#include <iostream>
#include <fstream>
#include <sys/time.h>

using namespace std;

//filestream erstellen
fstream f;

int main(int argc, char *argv[]) 
{	
	//Textdatei zum schreiben öffnen
	f.open("TEST.txt", ios::out);											

	//Zeitvariablen erstellen
	timeval zeit1;
	timeval zeit2;

	//Schleifenzähler erstellen
	int i = 0;

	//Schleifendurchläufe festlegen
	int anzahl = 1000*1000*4;

	//Puffer erstellen
	unsigned char *puffer;
	puffer = new unsigned char[anzahl];

	//Dauerschleife
	while(true)
	{
		//Startzeit holen
		gettimeofday(&zeit1, NULL);

		//For-Schleife durchlaufen
		for(i = 0; i < (anzahl); i+=4)
		{
			//Puffer füllen
			puffer[i]   = 50;
			puffer[i+1] = 50;
			puffer[i+2] = 50;
			puffer[i+3] = 0;
		}
		//Endzeit holen
		gettimeofday(&zeit2, NULL);

		//Durchlaufzeit in Millisekunden berechnen und in Datei screiben
		f << ((zeit2.tv_sec - zeit1.tv_sec)*1000.0) + ((zeit2.tv_usec - zeit1.tv_usec)/1000.0) << endl;
	}

	//Puffer löschen
	delete[] puffer;

	//Datei schließen
	f.close();

	return 0;
}

Inhalt der .txt :

0
15.626
0
0
15.626
0
0
0
15.627
0
0
15.626
0
0
0
15.625
0
0
0
15.626
0
0
15.625
0
0
15.626
0
0
0
15.626
0
0
15.626
0
0
0
15.626
0
0
15.626
0
0
0
15.626
0
0
15.626
0
0
0
15.625
0
0
0
15.626
0
0
15.626
0
0
0
15.625
0
0
15.627
0
0
0
15.625
0
0
15.626
0
0
0
15.625
0

Der Rest des Programms: Ich hoffe mal, das ist zur Übung und nicht ganz ernst, oder?

Der Code dient nur dazu ein komplexeres Programm möglichst genau auf das Problem reduziert abzubilden, zB. wird der Puffer mit sinvollen Daten gefüllt.
Solltest du jedoch Verbesserungsvorschläge haben, die mir vielleicht auch für das komplexere Programm helfen könnten,würde ich mich darüber freuen.

Welche Möglichkeiten habe ich eine höhere Auflösung des Timers zu erreichen?
Spontan fällt mir nur der "QueryPerformanceCounter" ein.

Der Code dient nur dazu ein komplexeres Programm möglichst genau auf das Problem reduziert abzubilden, zB. wird der Puffer mit sinvollen Daten gefüllt.
Solltest du jedoch Verbesserungsvorschläge haben, die mir vielleicht auch für das komplexere Programm helfen könnten,würde ich mich darüber freuen.

• Warum fstream, statt einem der ofstream, wenn du nur schreibst?
• Warum den Stream global? Bei lokalem Streamobjekt bräuchtest du auch den open/close Quatsch nicht.
• Warum new für Arrays? Das ist in C++ immer falsch. Nimm std::vector.
• Warum Variablen nicht direkt initialisieren? Besonders putzig sind die Zeilen 26,27.
• Galt für den Filestream besonders, aber gilt auch für deine anderen Variablen: Variablen so lokal wie möglich halten.
• Warum endl (was '\n' und flush() ist), wenn du doch nur '\n' meinst?
• Warum return 0 aus main?

Welche Möglichkeiten habe ich eine höhere Auflösung des Timers zu erreichen?
Spontan fällt mir nur der "QueryPerformanceCounter" ein.

Betreibssystemabhängig. Aber ich bin jetzt verwirrt. Dein obiger Code war Unix, QueryPerformanceCounter ist Windows. clock_gettime wäre eine Möglichkeit in Linux. Ein systemunabhängiger Wrapper ist in der verbreiteten Boost-Bibliothek zu finden. gettimeofday ist auf jeden Fall ein Irrweg, das ist, wie der Name schon sagt, eher etwas um die aktuelle Uhrzeit zu bekommen.

Außerdem noch ganz wichtig ist der Unterschied zwischen der Uhrzeit und der CPU-Zeit eines Programms. Du bist vermutlich eher an der CPU-Zeit interessiert.

Welche Möglichkeiten habe ich eine höhere Auflösung des Timers zu erreichen?
Spontan fällt mir nur der "QueryPerformanceCounter" ein.

Was ist mit chrono aus C++11?

• Warum fstream, statt einem der ofstream, wenn du nur schreibst?
• Warum den Stream global? Bei lokalem Streamobjekt bräuchtest du auch den open/close Quatsch nicht.
• Warum new für Arrays? Das ist in C++ immer falsch. Nimm std::vector.
• Warum Variablen nicht direkt initialisieren? Besonders putzig sind die Zeilen 26,27.
• Galt für den Filestream besonders, aber gilt auch für deine anderen Variablen: Variablen so lokal wie möglich halten.
• Warum endl (was '\n' und flush() ist), wenn du doch nur '\n' meinst?
• Warum return 0 aus main?

• Nicht drüber nachgedacht, hab ich mal geändert.
• Weil der nur zum Debuggen gedacht ist, wird hinterher noch, im richtigen Projekt, eine eigene Klasse für geschrieben.
• Hatte in letzter Zeit nur in reinem C programmiert, und deswegen std::vector vergesssen, jedoch kann es sein dass ich aufgrund von Geschwindigkeit trotzdem ein Array verwenden muss.
• Wie gesagt, hab ich den Code recht schnell hingeklatscht, habe ich jetzt auch mal geändert.
• In dem Projekt stehen die Variablen in einer Klasse, wollte das ganze nur mögichst schnell abbilden und hab mir darüber keine Gedanken gemacht.
• Weil ich das Programm zu jeder zeit abbrechen möchte, ohne flush() ist nicht gesichert, dass die komplette Ausgabe in der Datei steht.
• Warum nicht?

Das Projekt läuft unter Windows, jedoch wollte ich an allen Stellen an denen es möglich ist es Systemunabhängig zu halten.
Weiterhin bin ich nicht an der Systemzeit interessiert, sondern an der reellen Zeit.

Vielen dank an dieser Stelle für deine Hilfe :).

Gugelmoser schrieb:

Was ist mit chrono aus C++11?

Danke, habe chrono bisher noch nicht gekannt. Aber sehr schön, dass es mittlerweile einen standarisierten präzisen Timer gibt.

Im folgenden nochmal der neue Code:

#include <iostream>
#include <fstream>
#include <stdlib.h>
#include <chrono>
#include <vector>

using namespace std;

int main(int argc, char *argv[]) 
{	
	srand(time(NULL));
	//Textdatei zum schreiben öffnen
	ofstream f ("TEST.txt");			

	//Schleifendurchläufe festlegen
	int anzahl = 2000*1000*40;

	//Puffer erstellen
	unsigned char *puffer = new unsigned char[anzahl];

	vector<unsigned char> buffer(anzahl, 0);

	//Dauerschleife
	while(true)
	{
		//Startzeit holen
		auto t1 = chrono::high_resolution_clock::now();

		//For-Schleife durchlaufen
		for(int i = 0; i < (anzahl); i+=4)
		{
			//Puffer füllen
			buffer.at(i)   = 50;
			buffer.at(i+1) = 50;
			buffer.at(i+2) = 50;
		}
		//Endzeit holen
		auto t2 = chrono::high_resolution_clock::now();

		//Durchlaufzeit in Millisekunden berechnen und in Datei screiben
		f << "Vector safe: " << chrono::duration_cast<chrono::milliseconds>(t2-t1).count() << "ms."<< "\n";

		//Startzeit holen
		t1 = chrono::high_resolution_clock::now();

		//For-Schleife durchlaufen
		for(int i = 0; i < (anzahl); i+=4)
		{
			//Puffer füllen
			buffer[i]   = 50;
			buffer[i+1] = 50;
			buffer[i+2] = 50;
		}
		//Endzeit holen
		t2 = chrono::high_resolution_clock::now();

		//Durchlaufzeit in Millisekunden berechnen und in Datei screiben
		f << "Vector:      " << chrono::duration_cast<chrono::milliseconds>(t2-t1).count() << "ms."<< "\n";

		//Startzeit holen
		t1 = chrono::high_resolution_clock::now();

		//For-Schleife durchlaufen
		for(int i = 0; i < (anzahl); i+=4)
		{
			//Puffer füllen
			puffer[i]   = 50;
			puffer[i+1] = 50;
			puffer[i+2] = 50;
		}
		//Endzeit holen
		t2 = chrono::high_resolution_clock::now();

		//Durchlaufzeit in Millisekunden berechnen und in Datei screiben
		f << "Array:      " << chrono::duration_cast<chrono::milliseconds>(t2-t1).count() << "ms."<< "\n" << endl;

	}
}

Und der Inhalt der TEST.txt:

Vector safe: 750ms.
Vector:      156ms.
Array:      93ms.

Vector safe: 750ms.
Vector:      140ms.
Array:      78ms.

Vector safe: 750ms.
Vector:      156ms.
Array:      78ms.

Vector safe: 734ms.
Vector:      156ms.
Array:      78ms.

Vector safe: 734ms.
Vector:      156ms.
Array:      78ms.

Vector safe: 734ms.
Vector:      156ms.
Array:      78ms.

Ist er bei mir auch:

Vector safe: 56ms.
Vector:      40ms.
Array:      79ms.

Vector safe: 55ms.
Vector:      39ms.
Array:      39ms.

Vector safe: 54ms.
Vector:      39ms.
Array:      39ms.

Vector safe: 55ms.
Vector:      39ms.
Array:      39ms.

Vector safe: 55ms.
Vector:      39ms.
Array:      39ms.

Der massive Zeitunterschied zwischen at und operator[] bei dir deutet ebenfalls auf Unsinn beim compilieren hin. So teuer ist ein Rangecheck nun auch nicht, wie du an meinen Zahlen siehst.

Vector safe: 88ms.
Vector:      86ms.
Array:       85ms.

Vector safe: 88ms.
Vector:      86ms.
Array:       38ms.

Vector safe: 88ms.
Vector:      86ms.
Array:       39ms.

Vector safe: 88ms.
Vector:      86ms.
Array:       38ms.

Vector safe: 88ms.
Vector:      86ms.
Array:       38ms.

Was mache ich jetzt falsch?

Was mache ich jetzt falsch?

Du nimmst an, dass ideone optimieren würde. Probier mal bei dir zuhause.

Gibt es einen Grund, warum ideone nicht optimiert?

Gibt es einen Grund, warum ideone nicht optimiert?

Es ist eine Codeplattform, kein Rechenzentrum.

Sobald ich den Compiler jedoch optimieren lasse ("-O1") komme ich auch auf vernünftige Ergebnisse.
Dankeschön an dieser Stelle nochmal.

TEST.txt :

Vector safe: 30ms.
Vector:      27ms.
Array:      40ms.

Vector safe: 32ms.
Vector:      25ms.
Array:      26ms.

Vector safe: 29ms.
Vector:      25ms.
Array:      25ms.

Vector safe: 30ms.
Vector:      27ms.
Array:      25ms.

Vector safe: 31ms.
Vector:      33ms.
Array:      25ms.

Vector safe: 30ms.
Vector:      24ms.
Array:      29ms.

Vector safe: 30ms.
Vector:      26ms.
Array:      26ms.

Du hattest noch ein paar Fragen weiter oben:

frmimue schrieb:

SeppJ schrieb:

• Warum return 0 aus main?

• Warum nicht?

Du zeigst damit, dass du nicht alle Feinheiten der Sprache beherrscht. Was anscheinend auch der Fall ist. Aber nun hast du eine weitere Feinheit gelernt: In main (und nur in main!) ist return 0; implizit, sofern die Funktion nicht explizit anders verlassen wird.

frmimue schrieb:

SeppJ schrieb:

Warum return 0 aus main?

Warum nicht?

Du zeigst damit, dass du nicht alle Feinheiten der Sprache beherrscht. Was anscheinend auch der Fall ist. Aber nun hast du eine weitere Feinheit gelernt: In main (und nur in main!) ist return 0; implizit, sofern die Funktion nicht explizit anders verlassen wird.

Ich sehe das genau andersherum als du. Wie viele Leute hab ich bei mir an der Uni schon gesehen, die einfach bei jeder Funktion einen int als Rückgabetyp definieren, und nie etwas zurückgeben. Ich finde, jede Funktion, die nicht void als Rückgabetyp hat, hat eine return-Anweisung zu haben.

frmimue schrieb:

SeppJ schrieb:

• Warum return 0 aus main?

• Warum nicht?

Du zeigst damit, dass du nicht alle Feinheiten der Sprache beherrscht. Was anscheinend auch der Fall ist. Aber nun hast du eine weitere Feinheit gelernt: In main (und nur in main!) ist return 0; implizit, sofern die Funktion nicht explizit anders verlassen wird.

Because we can? Wirklich? Das findest du ein gutes Argument?

Also ob main() mit oder ohne return 0 ist mMn. sowas von vollkommen egal. Ich würde es grundsätzlich eher hinschreiben, weil es mMn. kaum einen guten Grund gibt überhaupt zu wissen dass return 0 implizit ist.

#include <chrono>
#include <iostream>
using namespace std;

int main()
{
	auto t1 = chrono::high_resolution_clock::now();
	auto t2 = chrono::high_resolution_clock::now();

	while(t1==t2) t2 = chrono::high_resolution_clock::now();

	cout << chrono::duration_cast<chrono::nanoseconds>(t2-t1).count() << " ns.\n";
	cout << chrono::duration_cast<chrono::microseconds>(t2-t1).count() << " us.\n";
	cout << chrono::duration_cast<chrono::milliseconds>(t2-t1).count() << " ms.\n";
	cout << endl;
}