4. _SECURE_SCL wirklich so langsam?

_SECURE_SCL wirklich so langsam?

  • P

    Hiho,

    hatte momentan wieder einie Probs mit einer Fremdbibliothek, bis ich bemerkt habe, das dort _SECURE_SCL=0 gesetzt wurde und es deswegen zu Abstürzen kann, wenn ich diese Lib gegen mein Programm gelinkt habe.
    In der Doku steht, dass diese secured Iteratoren der MS-STL in einigen Fällen bis 100x langsamer sein sollen??
    Ist das wirklich so schlimm? Hat da jemand Erfahrungen. Also sollte man die in der Release-Version generell deaktivieren?

    MfG Pellaeon

    0
  • P

    Ach ja udn noch eine andere Frage dazu: in der Lib ist folgendes definiert:

    _HAS_ITERATOR_DEBUGGING=0
    _SECURE_SCL=0

    Das steht in den Projektoptionen bei "Vererbte Werte" unter Präprozessor.
    Wo kann ich die deaktivieren??? Ich hab schon in der gesamten Projektmappe gesucht, ich finde die Stelle nicht, wo die defines gesetzt werden.

    0

  • Die musst du mit Hand bei den Präprozessor-Optionen reinschreiben.

    0
  • P

    hustbaer schrieb:

    Die musst du mit Hand bei den Präprozessor-Optionen reinschreiben.

    Hiho,

    nein ich meinet das andersherum, die waren definiert uind ich wollte sie weg haben. habs aber inzwischen gefunden. Es gab eine externe Projektdatei, wo die definiert waren und im eigentlichen Projekt wurde diese Projektdatei als Abhängigkeit definiert. Deswegen waren sie in der eigentlich Bibliothek nicht definiert, sondern wurden durch diese exterene Datei reingezogen.

    Naja tortzdem würde mich noch das aus der ersten Frage interessieren: ziehen die wirklich so viel Performance im Release Mode?

    0
  • P

    *push*

    0
  • V

    Mehr als 100% langsmaer habe ich noch nicht gemessen.

    // iter2.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.
//

#include "stdafx.h"
#define _SECURE_SCL 0
#include <vector>
#include <iostream>
using namespace std;

typedef unsigned __int64 UInt64;
UInt64 rdtsc() {
   __asm rdtsc;
}

template<typename F>
UInt64 measure(F f){
	UInt64 minTime=UInt64(-1);
	int count=100;
	while(count--){
		UInt64 elapsed=0-rdtsc();
		int cum=f();
		elapsed+=rdtsc();
		if(elapsed<minTime){
			minTime=elapsed;
			count=100;
			cout<<minTime<<'\n';
			if(UInt64(cum)==minTime)
				++count;
		}
	}
	return minTime;
}

vector<int>& cf(){
	static vector<int> vec;
	if(vec.empty())
		for(int i=0;i!=10000000;++i)
			vec.push_back(i*i);
	return vec;
}

int foo(){
	vector<int>& vec=cf();
	int sum=0;
	for(int i=0;i!=10000000;++i)
		sum+=vec[i];
	return sum;
}

int _tmain(int argc, _TCHAR* argv[])
{
	cout<<measure(foo)<<'\n';
	return 0;
}
    0

  • Pellaeon schrieb:

    Naja tortzdem würde mich noch das aus der ersten Frage interessieren: ziehen die wirklich so viel Performance im Release Mode?

    Musst du ausprobieren, kommt sehr stark auf das Programm an. Normalerweise merkt man wenig. Vielleicht mal 5 oder 10%.
    Wenn ein Programm natürlich sehr viele Iteratoren in engen Schleifen verwendet, wo auch pro Element kaum was gerechnet wird, kann es schon mehr ausmachen.

    0
Anmelden zum Antworten