Laufzeitmessung unter windows

Hallo,

Ich habe ein Problem mit der Laufzeitmessung in VC++. Zwar kenne ich Mittel und Wege die Laufzeit zu messen (QueryPerformanceCounter, clock() etc.), diese messen jedoch jeweils die "elapsed" oder "wall clock" time. Ich bin allerdings an der reinen cpu-time für mein Programm interessiert. Hat jemand eine Idee, wie das funktionieren könnte? Unter Linux geht das ja, für VC++ habe ich allerdings noch keine Lösung gefunden.

MfG Andreas

Mmacher

In welcher Größenordnung sollen die Messungen durchgeführt werden?

Bis wenige ms bietet sich meines Wissens nur der QueryPerformanceCounter() an. Auflösung ist abhängig von der Hardware, bei heutigen Systeme liegt sie im Sub-µs (also ca. Hunderter ns) Bereich.

Ab einige ms bietet sich der Multimedia-Timer an (Auflösung 1ms).

Für Langzeitmessungen (Sekunden, Minuten, Tage, ... ) eignet sich der Standard Timer GetTickCount() oder GetTickCount64().

Fast immer mußt Du wohl oder über die Zeitdifferenz herausrechnen, also "Verstrichene Zeit" = "Zeitpunkt Ende" minus "Zeitpunkt Start".

Zwei Fallstricke solltest Du beachten:
- QueryPerformanceCounter() eignet sich wegen der Ungenauigkeit NICHT für genaue Langzeitmessungen ab mehreren Minuten!
- GetTickCount() läuft nach ca. 45 Tagen über -> stattdessen wenns geht GetTickCount64() verwenden

Martin
P.S.: Oder meinst Du mit "cpu-time" die CPU-Last? Da könnte Dir die PSAPI-Funktionen (PSAPI.DLL) weiterhelfen.

Hallo,

Erstmal danke für die Antwort. Mit "cpu-time" meinte ich die Zeit, die das System dafür verwendet, nur mein Programm auszuführen. Also eine Zeit, die unabhängig davon ist, was gerade sonst noch auf dem System ausgeführt wird.

Toa

Du willst wissen wie lang eine Konsole zb offen war ?

Ich hab dir ma eben schnell was gecodet, weiß ja net wie weit du dich auskennst deswegen hab ichs komplett geschrieben:

#include <stdio.h>
#include <time.h>
#include <fstream>
#include <iostream>
#include <string>
using namespace std;

void umrechnen_und_ausgeben();
int start_zeit();
int ende_zeit();

int main()
{
     int warten;
     double differenz;   // Var in der die Diff gespeichert wird
     int start_time=start_zeit();
     cout <<"Lass dir Zeit: ";
     cin >>warten;
     int ende_time=ende_zeit();
     differenz = difftime (ende_time,start_time);    //diff wird ausgerechnet
     ofstream fout ( "Player_time.txt" );
     fout << differenz ;
     fout.close();
     umrechnen_und_ausgeben();

}

int start_zeit()
{
     time_t start;
     time (&start);
     return start;
}

int ende_zeit()
{
     time_t end;
     time (&end);
     return end;
}

void umrechnen_und_ausgeben()
{
     ifstream file("Player_time.txt");
     char line[100];
     file.get( line, 100);
     file.close();
     int zeit;
     zeit = atoi( line );
     int stunden = zeit / 3600;
     zeit = zeit % 3600;
     int minuten =  zeit / 60;
     zeit = zeit % 60;
     int sekunden = zeit;
     cout <<stunden <<"   Stunden   " << minuten <<"   Minuten  " << sekunden <<" Sekunden " <<"\n";

     system("pause");
}

Das ganze Stützt sich auf eine Player_time.txt wo die zeit in sekunden reingeschrieben wird. Das einzigste was du jetzt noch machen kannst ist Das ganze in einen Thread auszulagern dann wird dein Programmablauf nicht behindert ^.

MFG TOa

Danke für die Mühe. Was ich aber meinte ist eine Zeitmessung, die für mein Programm die Zeit misst, unabhängig davon was sonst gerade noch auf dem System läuft. Quasi eine bereinigte Zeitmessung. Ich kann das irgendwie schwer erklären. Mal ein Beispiel: Ich führe also mein Programm aus.

Situation 1:

Auf dem Rechner finden gerade keine weiteren aufwendigen Prozesse statt.
Als Laufzeit meines Programms werden (z.B.) 23,938 sec angezeigt.

Situation 2:

Auf dem Rechner finden gerade weitere zeitraubende Prozesse statt.
Nun wird die Laufzeit meines Programms womöglich höher sein, selbst wenn es mit den gleichen Input-Daten gefüttert wird wie in Situation 1.

Was ich nun gerne hätte, ist eine Zeitmessmethode, die in Situation 2 genau die gleiche Laufzeit ausgibt wie in Situation 1 (bzw. eine von den weiteren gerade laufenden Prozessen unabhängige Zeit). Gibt es da unter Visual C++ eine Möglichkeit? Vielleicht mit GetProcessTimes? Das wurde mir in einem anderen Forum empfohlen.

Mmacher

Anschnei schrieb:

Was ich nun gerne hätte, ist eine Zeitmessmethode, die in Situation 2 genau die gleiche Laufzeit ausgibt wie in Situation 1 (bzw. eine von den weiteren gerade laufenden Prozessen unabhängige Zeit). Gibt es da unter Visual C++ eine Möglichkeit? Vielleicht mit GetProcessTimes? Das wurde mir in einem anderen Forum empfohlen.

Hmmm, jetzt verstehe ichs was Du möchtest.
Da ich so eine Form der Zeitmessung noch nie gemacht habe, kann ich Dir nur Hinweise ohne Gewähr geben.

Ich unterstelle Dir mal, daß Du weißt wie Windows mit den Prozessen (und den zugehörigen Threads) in Form von Zeitscheiben handhabt.
Dazu kommen noch der Einfluß von Mehr-Kern-CPUs (egal ob virtuelle wie "Hyperthreading HT" oder reale) und damit verbunden die Prozessoer-Affinitäten.
Deine Form von Zeitmessung müßte also zwangsläufig auf Kernel-Ebene erfolgen.

Die API-Funktion GetProcessTimes() http://msdn2.microsoft.com/en-us/library/ms683223.aspx dürfte wohl richtig sein. Der Rückgabewert lpKernelTime dürfte genau das liefern was Du brauchst.
Natürlich der Endwert minus Startwert ist gleich die verstrichene tatsächliche CPU-Zeit.

Martin

P.S.: Bin neugierig, was man mit einer solchen "tatsächlich verbratenen CPU-Zeit" anfangen kann? Mir fällt spontan nicht ein für was das gut ist.

Bloops

Mmacher schrieb:

P.S.: Bin neugierig, was man mit einer solchen "tatsächlich verbratenen CPU-Zeit" anfangen kann? Mir fällt spontan nicht ein für was das gut ist.

Objektive Performance-Messung?