Performance

slapy

hm, ok, aber klärt das auch die Frage warum das "cout<<.." die Zeit vervielfacht?

int ch; // int nicht char!
while((ch=in.get()) != EOF)
{

}

- darf das wirklich funktionieren, in der Referenz steht nicht, dass .get() den Dateizeiger eins weitersetzt, also dachte ich dass ich mit seekg immernoch den Dateizeiger weitersetzen muss?!

Nochmal zu den Blockweise-Aufbau: Wie groß ist ein Block? ein Zeichen ist doch schon 1 Byte lang. mit welcher funktion wäre es sonst ratsam einen größeren Block auszulesen?
Vielen Dank soweit.
slapy

slapy

oh da hat während ich geschrieben habe, volkard schon die meisten meiner Fragen beantwortet, vielen Dank !!!

volkard schrieb:

if(in){
   do{
     int const BUFSIZE=1024;
     char buf[SIZE];
     int size=in.read(buf,BUFSIZE);
     for(int j=0;j<size;++j)
        tuwas(buf[j]);
     cout<<i<<'\r';
   }while(in);
}

oder so.
damit haste schonmal echt gute performance.

wenn man's noch schneller haben will sollte man noch die sich in der schleife befindenen variablen nach aussen verlegen bzw. weg lassen(size)

otze

oder man entledigt sich dieser sorgen und verlässt sich voll und ganz auf den compiler der das eh rausoptimiert

volkard

Cpt.Tanga schrieb:

wenn man's noch schneller haben will sollte man noch die sich in der schleife befindenen variablen nach aussen verlegen bzw. weg lassen(size)

nach außen legen kann der compiler generell aleine, wenns PODs sind. nach innen legen ist aber meist nicht möglich, weil man den wert des letzen schleifendurchlaufs haben muss.
also macht der mensch nach möglichkeit alles so lokal wie möglich und nach aussen legen darf der compiler, wie er lust hat.

schauen wir genauer:

if(in){
   do{
     int const BUFSIZE=1024;//kostenlos, da inline-ersetzung wie makro
     char buf[SIZE];//sollte kostenlos sein, da nach außen gelagert. 
        //schlimmstenfalls ADD SP,1024, also einen takt und am blockende noch einen
     int size=in.read(buf,BUFSIZE);//size landet ex in AX. behalten ist kostenlos.
     for(int j=0;j<size;++j)//j natürlich auch in ein register stecken und davon ausgehen, daß tuwas inline ist
        tuwas(buf[j]);
     cout<<i<<'\r';
   }while(in);
}

Cpt.Tanga schrieb:

volkard schrieb:
if(in){
   do{
     int const BUFSIZE=1024;
     char buf[SIZE];
     int size=in.read(buf,BUFSIZE);
     for(int j=0;j<size;++j)
        tuwas(buf[j]);
     cout<<i<<'\r';
   }while(in);
}
oder so.
damit haste schonmal echt gute performance.
wenn man's noch schneller haben will sollte man noch die sich in der schleife befindenen variablen nach aussen verlegen bzw. weg lassen(size)

Wenns richtig schnell sein soll läßt man das cout weg und benutzt was eigenes, das bestenfalls putchar aufruft

camper

edit: müll

hab die datei(release) mal im debugger betrachtet-musste sie allerdings noch ein wenig umschreiben da sie sonst nicht lauffaehig gewesen weare:

if(in)
	{
	do {
		int const BUFSIZE=1024;
		char buf[BUFSIZE]={0};
		in.read(buf,BUFSIZE);
		for(int j=0;buf[j];++j)
			tuwas(buf[j]);
		cout<<buf<<'\r';
		} while (in);
	endl(cout);
	};

nun gut allerdings hat dieser code auch nicht mehr so viel mit volkards gemein aber was solls :P.
heraus kam dass die variablen nicht nach aussen verlegt worden. wobei BUFSIZE durch eine konstante(0x400) ersetzt wurde(also keine eigene speicherzelle in anspruch nahm, und buf jedes mal neu belegt wurde(was allerdings auch an ...={0}; liegen koennte).

otze

compiler? optimierungslevel?

Konfusius

normalerweise haben streams einen eingebauten puffer von 4kb oder so. seek löscht jedoch den puffer und deshalb bringt die pufferung in deinem programm nichts. da die lesefunktionen aber sowieso den fileseekpointer um die gelesene zahl an bytes weiterschieben, kannst du seek auch weglassen. dann sollte es recht flott gehen.

allerdings haben dateioperationen von haus aus einen ziemlichen overhead. deshalb ist es immer deutlich schneller, ein paar kb auf einmal zu schreiben/lesen als jedes byte einzeln.

vc 6.0 einfache release optimiert auf geschwindigkeit.

slapy

Also danke für die ganzen Optimierungstipps, mit in.read geht das wirklich extrem viel schneller.
Ich habe aber noch ein Problem was die Blöcke angeht:
Ich will einfach mal mit diesem code eine Datei kopieren, das funktioniert ziemlich schnell aber eben nicht ganz. Ich habe eine 1,11KB große datei file1.dat und die kopierte Datei file2.dat ist aber leider nur 1KB groß. Warum?

ifstream in("file1.dat",ios::binary);
        ofstream out("file2.dat",ofstream::binary);

        in.seekg(0, ios::end);
        unsigned long file_size = in.tellg();
        in.seekg(0, ios::beg);                         

        char *buffer;
        buffer = new char [file_size];
        in.read(buffer,file_size);
        out.write(buffer,file_size);

Bin für jeden Hinweis bezüglich des Problems oder auch verbesserungswürdiger Performance dankbar!
slapy

kann eigentlich nicht passieren-der code sieht ok aus. -musst mal nachsehen was denn in der kopierten datei anders ist als in der original. zur not kannst du ja auch copy mal aus <algorithm> verwenden.