Kurze Frage zu C-Programm: Zeitmessung

[hayabusa1300]

Hallo zusammen,

ich habe ein C-Programm geschrieben das eigentlich nur aus einer while-Schleife (i<=1000000000) besteht. Jetzt würde ich gerne vom PC messen lassen, wie lange es dauert, bis die Bedingung erfüllt ist. Gibt es die Möglichkeit das einfach einzubinden oder ist das sehr kompliziert?

Vielen Dank im vorraus

 

[Kasn]

Zeit in eine Variable speichern, schleife laufen lassen, variable von der aktuellen Zeit abziehen und fertig.

 

[hayabusa1300]

Stimmt, auf die einfachste Lösung kommt man manchmal gar nicht.

Aber gibt es das auch mit Millisekunden? (Die kleinste Einheit die ich kenne ist Sekunden)

 

[W@sserleiche]

Tja, standardmäßig kennt C nur minimal Sekunden (ctime).

Unter Linux kannst du aber gettimeofday() nutzen, die liefert sogar Microsekunden (auch wenn die Genauigkeit von der Hardware abhängt).
Unter Windows weiß ich es jetzt nicht genau, aber dort gibt es sicher äquivalente Funktionen.

Einfach mal googlen, dann findest du schon das richtige.

 

[tbird]

wenn du die möglichkeit hast, auf c++ zu wechseln, dann geht das hier:

//----------------------------------------------------------------------
//
//    Zeitmessung im µs-Bereich
//    TESTANWENDUNG
//    Author: tbird
//    Date: 20.11.2007
//
//----------------------------------------------------------------------

//#include "stdafx.h"
#include "windows.h"
#include "stdio.h"
#include <string>
#include <iostream>
#include "math.h"

using namespace std;

int main(int argc, char* argv[])
{
	//Variablen
    LONGLONG g_Frequency, g_FirstNullCount, g_LastNullCount, g_FirstCount, g_LastCount;

    //Frequenz holen
    if (!QueryPerformanceFrequency((LARGE_INTEGER*)&g_Frequency))
        printf("Performance Counter nicht vorhanden");

	double resolution = 1000000 / ((double)g_Frequency);
	
	printf("Frequenz des Counters:  %lld kHz\n", g_Frequency/1000);  //lld -> LONGLONG darstellung
	printf("Dadurch maximale Aufloesung: %4.5f us\n", resolution);

	//null-messung
	QueryPerformanceCounter((LARGE_INTEGER*)&g_FirstNullCount);
	QueryPerformanceCounter((LARGE_INTEGER*)&g_LastNullCount);
	double nulltime = (((double)(g_LastNullCount-g_FirstNullCount))/((double)g_Frequency)); 

	printf("Null-Zeit: %4.5f us\n", nulltime * 1000000);

	
	//beginn messung
	QueryPerformanceCounter((LARGE_INTEGER*)&g_FirstCount);
	
	//hier das rein was zeit braucht
	long j=0;
	for(long i=0; i<10000; i++)
	{
		j++;
	}
	
	//2. Messung
    	QueryPerformanceCounter((LARGE_INTEGER*)&g_LastCount);

    	double dTimeDiff = (((double)(g_LastCount-g_FirstCount))/((double)g_Frequency)); 

	//Von der gemessenen Zeit die "Null-Zeit" abziehen, um genauer zu werden
	double time = (dTimeDiff - nulltime) * 1000000; //mikro-sekunden
	
	printf("Zeit: %4.5f us\n" ,time);
	
	//warten auf tastendruck
	string dummy;
	getline(cin, dummy);

	return 0;
}

(getestet mit MS Visual C++ 6.0)

Das Proggi hat halt den vorteil dass du extrem kleine Zeitspannen messen kannst.

Die For-Schleife braucht auf meinem 3GHz-Rechner etwa 20µs

 

[B.XP]

Tja, standardmäßig kennt C nur minimal Sekunden (ctime).

Unter Linux kannst du aber gettimeofday() nutzen, die liefert sogar Microsekunden (auch wenn die Genauigkeit von der Hardware abhängt).
Unter Windows weiß ich es jetzt nicht genau, aber dort gibt es sicher äquivalente Funktionen.

Einfach mal googlen, dann findest du schon das richtige.

"minimal sekunden" !?

Ich hätte ein "artverwandtes" Problem, ich möchte die Zeit zwischen zwei Keyboard-Tastenanschlägen messen, die bei Maximal 10 anschlägen/sek liegt, also brauche ich etwas mehr als 100ms Auflösung.
Nun bleibt halt die frage, wie man das am sinnvollsten Programmiert, denn der Code von tbird ist schon fast zu viel des Guten.

 

[tbird]

ich hatte angenommen man braucht eine extrem genaue zeitmessung.

für weniger anspruchsvolle messungen, wo der windows-timer genügt, kann man das hier einsetzen:

#include <time.h>

int main(void) {
int time1, time2, thou, sec;

time1 = clock(); // Set clock.

//hier methode rein, die gemessen werden soll
yyparse();   //aufruf des parsers (als beispiel, hier kann stehen was will)

time2 = clock (); // Get elapsed time.
   
thou  = (time2-time1) * 1000 / CLOCKS_PER_SEC;
sec   = thou / 1000;
thou -= sec * 1000;

printf ("%ld.%03ld sec.\n\n", sec, thou);
}

sollte laufen ... glaub ich *g*

 

[hostile]

kein return-wert.. ^^

gruß
hostile

ps. hab's eben kompiliert. macht dem nix aus. aber er kennt printf nicht.. also stdio.h "includen".

 

[phubong]

WIN API
==========

GetTickCount gibt die Anzahl der Millisekunden zurück, die seite dem letzten Windowsstart vergangen sind.
Im allgemeinen berechnet die Funktion die Zeit zwischen zwei verschiedenen Aufrufen vergangen sind.

DWORD t1 = GetTickCount();
// irgendwas ...
DWORD t2 = GetTickCount();

DWORD ms = t2 - t1;

 

[tbird]

Im allgemeinen berechnet die Funktion die Zeit zwischen zwei verschiedenen Aufrufen vergangen sind.

öööhm...ne. das macht nicht die funktion an sich, denn die gibt immer nur eine zahl zurück (eben die ms seit windows-start). die differenz muss man sich noch selbst berechnen.

@hostile: ja sry, hatte das ding ned geprüft und so nebenbei (hock ja auffer arbeit) hingehackt *ggg*

 

[B.XP]

Ich hab meins über zeit1 = clock() usw. realisiert. Funktioniert für meine Anwendung super!

 

[phubong]

öööhm...ne. das macht nicht die funktion an sich, denn die gibt immer nur eine zahl zurück (eben die ms seit windows-start). die differenz muss man sich noch selbst berechnen.

Genau! Ich habe da falsch beschrieben.