hier der Main-Teil:

*main(int argc, char *argv[])
{
unsigned int t1,t2;
double Wert;
unsigned int Anzahl_Threads=atoi(argv[1]);

t1=clock(); // Stoppuhr an

threadstart(Anzahl_Threads);

t2=clock(); // Stoppuhr aus

Wert=(double)(t2-t1)/CLOCKS_PER_SEC;

printf("%f ",(double) Wert);

return 0;
}
*

Wie man sieht, habe ich bereits hier eine Lösung unter Verwendung der Zeitfunktion <time.h> (fettgedruckt). Allerdings bekomme ich für eine große Anzahl von Threads (>150) sehr stakr fallende Werte heraus(0,01 sec) und diese stimmen keinesfalls, da die Zeit, in der ich auf eine Programmantowrt warte mit steigender Anzahl von Threads immer länger wird (ca 20 sec).

Über eine zuverlässigere Funktion als Stoppuhr für mein Programm wäre ich sehr dankbar. Ich bitte darum Antworten leicht verständlich zu halten, da ich relativ neu unter den Programmierern bin.

Das sähe dann so aus:

#include <windows.h>

long long frequency;
long long startTime;
long long endTime;
double timeInSeconds;

//Frequenz abfragen, gibt Ticks pro Sekunde, muß nur einmal abgefragt werden Wert ist konstant
QueryPerformanceFrequency(reinterpret_cast<LARGE_INTEGER*>(&frequency));

//startzeit holen
QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER*>(&startTime));

//hier arbeiten erledigen

//endzeit holen
QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER*>(&endTime));

timeInSeconds=static_cast<double>(endTime-startTime)/static_cast<double>(frequency);

Der Counter is sehr genau. Weitere Infos kanst du dem MSDN und der Suchmaschine deines Vertrauens entnehmen.

Die Frage wieso du als Programmieranfänger mit Threads arbeitest und davon 150 brauchst spare ich mir.

@jesus: Danke, werd ich heut mal ausprobieren.

Mit folgender Funktion bekomme ich richtige Werte, die allerdings sehr ungenau sind(+/- 1 sec):

*time_t start,end;

time (&start);
threadstart(Anzahl_Threads);
time (&end);

dif = difftime (end,start);

printf("%f ",(double) dif);*

Problem hierbei ist, dass ich gerne Werte haben würde die auf die Millisekunde genau sind. Eine Lösung über clock() und CLOCKS_PER_SEC funktioniert jedenfalls nicht. Ich habe in anderen Foren auch schon gelesen, dass dies wahscheinlich daran liegt dass ich auf einem Mehrprozessorsystem arbeite.

Für weiter Hilfe wäre ich sehr dankbar.

double Erstellungszeit = clock();
std::cout << Erstellungszeit << std::endl;

Leider kommt immer null raus
Soweit ich das verstanden habe zählt clock doch die CPU Ticks die seit Programmstart vergangen sind. Da sollte also doch ein Wert rauskommen! Außerdem können doch keine zwei Objekte zur gleichen Zeit erstellt werden, es liegen immer ein paar Ticks dazwischen. Kann ich also diese Erstellungszeit als eindeutige ID benutzen?

#include <sys/time.h>  

    timeval start, end;

    gettimeofday(&start, NULL);

   /* Mach irgendwas tolles */

    gettimeofday(&end, NULL);

    long seconds  = end.tv_sec  - start.tv_sec;
    long useconds = end.tv_usec - start.tv_usec;

    long utime = ((seconds) * 1000000 + useconds); // vergangene Zeit in Mikrosekunden

edit: Man beachte, dass die Auflösung des Zeitgebers nicht standardmäßig eine Mikrosekunde sein muss. Wie genau er tatsächlich ist, hängt von deinem System ab.

edit2: Im Linux-Unterforum hier gibt es bestimmt Leute, die noch genauere Methoden kennen, falls es diese gibt. Das was ich hier zeige hat mir persönlich immer gereicht und ich war froh, dafür nicht zu tief in die Systemprogrammierung einsteigen zu müssen.

http://de.kontron.com/unternehmen/news-events/jrexce+der+erste+intel+celeron+35sbc+mit+usb+20.72.html

Kann man den zufällig zur genauen Zeitmessung brauchen?

Keine Ahnung, ich will jetzt nicht das gesamte datenblatt durchlesen, aber Zeitmessung unter Linux allgemein habe ich ja schon weiter oben erklärt.

aber Zeitmessung unter Linux allgemein habe ich ja schon weiter oben erklärt.

Hab ich grad ausprobiert, funktioniert wunderbar! Vieles Danke

unsigned long HIRN::gibuZeitstempel2(void)
{
  boost::posix_time::ptime Urzeitpunkt = boost::posix_time::from_iso_string("19700101T000000"); 
  boost::posix_time::ptime AktuelleZeit = boost::posix_time::microsec_clock::local_time();
  boost::posix_time::time_duration VergangeneZeit = AktuelleZeit - Urzeitpunkt;
  return (unsigned long) VergangeneZeit.total_milliseconds();

};

Weiß zufällig jemand warum?

Außerdem würde ich gerne microseconds machen, aber leider passt das anscheinend nicht in eine long

leider passt das anscheinend nicht in eine long

Mit uint64_t oder int64_t aus stdint.h (oder aber cstdint) hast du garantierte 64 Bit breite Integer.