c++ bekommen Millisekunden seit ein paar Tag

Ich brauche eine Möglichkeit in c++ zu verfolgen die Anzahl der Millisekunden seit der Ausführung des Programms. Und ich brauche die Genauigkeit in Millisekunden. (In meinem googeln habe ich gefunden, dass viele Leute, die gesagt gehören Zeit.h und multiplizieren der Ausgabe des time() von 1000 ... das wird nicht funktionieren.)

Ich denke, wir müssen wissen, über das Betriebssystem, das Sie interessiert; ich bin ziemlich sicher, dass es keine portable Möglichkeit, diese zu bekommen.
Es scheint, dass die Zeit.h clock () - Lösung unten funktioniert Prima. Ist es ein Problem, dass ich hier nicht gedacht haben?
gut, ich persönlich benutze clock (), um zu sehen, wie lange es dauert, zu lösen euler Probleme.. Es ist perfekt für meinen Fall, so dass es hängt wirklich davon ab, wie spezifisch Sie sein möchten.
ja -- clock gibt die Zeit mit einer Auflösung von CLOCKS_PER_SEC, die könnte überall sein von Millisekunden bis ganze Sekunden. CLOCKS_PER_SEC können Sie konvertieren, um Sekunden, aber es kann nicht gleich die richtige Auflösung. Zum Beispiel, VC++ liefert ein Ergebnis in Millisekunden -- aber die tatsächliche Schrittweite ist in der Regel rund 10 ms. I. e., erhalten Sie eine Zeit von 0, dann 10, dann 20, und so weiter.
guter Punkt (+1). Obwohl für meine aktuellen mock-up I hohe Auflösung erfordern eher als Genauigkeit. Albern, nicht wahr?
clock() hat nicht zählen zu den Uhren. Es zählt Uhren Sie das Programm ausgeführt wurde, eine feine, aber wichtige Unterscheidung. Der Bemerkenswerte Unterschied ist, dass clock() nicht weiter zu zählen, während das Programm schläft oder blockiert I/O (dist/Netzwerk).
außer, wenn es funktioniert. Wie bereits in meiner Antwort, verschiedene Implementierungen funktionieren anders in dieser Hinsicht. Während ich damit einverstanden, dass die Absicht ist, dass clock zählen nur CPU-Zeit, ist es nicht immer umgesetzt werden, dass Art und Weise.

InformationsquelleAutor JnBrymn | 2010-07-19

c++time

1

Sehen std::clock()
- Ich Liebe das Beispielprogramm in diesen link, vor allem die while-Schleife.
- CLOCKS_PER_SEC ist nicht garantiert werden, in Millisekunden.
- Ja, wäre Es OS abhängig.
- mcnamara: es soll garantieren, um die Expansion in die Anzahl der Taktzyklen pro Sekunde. So ist es vielleicht nicht in Millisekunden, aber es erhalten Sie Sekunden, und es sollte nicht allzu schwer zu bekommen Millisekunden aus, dass...
- Ich denke, was Jim meint ist, dass es in Runde Sekunden - das es nicht unbedingt sein. Wenn es (random zahlen entschieden aus der Luft) werden 15.000 Uhren eine Sekunde, und Ihr Programm genommen hat 45 Uhren, nehmen Sie 45, teilen Sie es von 15000 und bekommen von 0,003 Sekunden. Dann multiplizieren Sie durch 1000 um die 3 Millisekunden. Getan. Es sei denn, ich habe versagt Mathematik. Die möglich ist.
- -1 Uhr zählt nur die Zeit, während Sie das Programm aktiv ist. Alle blockierten Anrufe werden nicht gezählt ( Dateisystem-Zugriff, Netzwerk, schlafen, etc).
- Dies ist keine gute Lösung.. Uhr ist gut, aber es wird Probleme haben, für die zukünftige Verwendung, wie andere gesagt haben
- clock() ist nicht real-time-clock. Es ist die CPU-time-clock, das kann schneller laufen, wenn multi-threading verwendet wird, und langsamer (gestoppt), wenn Sie blockiert wird, die von einigen IO.
InformationsquelleAutor cpx
8

clock wurde vorgeschlagen, eine Anzahl von Zeiten. Dies hat zwei Probleme. Zuerst von allen, ist es oft nicht eine Auflösung haben, die einmal in die Nähe einer Millisekunde (10-20 ms ist wohl eher üblich ist). Zweitens, einige Implementierungen (z.B., Unix und ähnliche) Rückkehr CPU-Zeit, während andere (E. g., Windows) return-Wand Zeit.

Hast du nicht wirklich gesagt, ob Sie möchten, Wand, Zeit oder CPU-Zeit, was es schwierig macht, zu geben eine wirklich gute Antwort. Auf Windows könnten Sie GetProcessTimes. Geben Sie die kernel-und user-CPU-Zeit, direkt. Es wird auch Ihnen sagen, Wann der Prozess erstellt wurde, wenn Sie so wollen Millisekunden der Wand Zeit, da der Prozess der Schöpfung, Sie können abziehen, die Prozess-Erstellung Zeit von der aktuellen Zeit (GetSystemTime). QueryPerformanceCounter wurde auch erwähnt. Dieser hat ein paar Merkwürdigkeiten seiner eigenen-zum Beispiel, in einigen Implementierungen, es ruft die Zeit aus den CPUs Zyklus-Zähler, so dass deren Frequenz variiert, wenn/falls die CPU-Geschwindigkeit ändert. Andere Implementierungen Lesen von der Hauptplatine 1.024 MHz timer, die nicht nicht variieren mit der CPU-Geschwindigkeit (und die Bedingungen, unter denen jede verwendet werden, sind nicht völlig offensichtlich ist).

Unter Unix verwenden, können Sie GetTimeOfDay zu bekommen, die Wand der Zeit mit (zumindest die Möglichkeit) relativ hohe Genauigkeit. Wenn Sie möchten-Zeit für einen Prozess, die Sie verwenden können, mal oder getrusage (letzteres ist neuer und bietet mehr vollständige Informationen, kann auch nicht mehr so genau).

Bottom line: wie ich sagte, in meinem Kommentar, es gibt keine Möglichkeit, das zu bekommen, was Sie wollen Mobil. Da du noch nicht gesagt, ob Sie möchten, CPU-Zeit oder an der Wand Zeit, auch für ein bestimmtes system, es gibt nicht die eine richtige Antwort. Die von Ihnen "akzeptiert" (clock()) hat die Tugend, dass verfügbar auf nahezu jedem system, aber was, es gibt auch variiert nur über die am weitesten verbreitete.
- Er will ein Zeit-delta, die ist weder Wand, noch cpu-Zeit.
- Was er wirklich tun muss, ist einfach notieren Sie die Zeit, wenn sein Programm beginnt und, wenn er braucht, um zu wissen, wie lange es schon läuft, nur um die aktuelle Zeit wieder und subtrahieren Sie die beiden Werte. Das wird ungefähr so präzise, wie Sie bekommen können.
- Zuerst Frage ich mich, ob seine Frage ausreichend klar zu sagen, es ist ein delta mit Bestimmtheit sagen. Zweitens, selbst wenn es ein delta, es hat immer noch ein delta von Wand-oder CPU-Zeit (d.h., "Wie lange seit der Prozess gestartet werden?", oder "wie viel CPU-Zeit hat der Prozess eingesetzt?"
- Oh mein Gott, dies ist nur für Windows!
InformationsquelleAutor Jerry Coffin
1

Zeit.h, und verwenden Sie dann die clock () - Funktion. Es gibt die Anzahl von Uhr-ticks vergangen sind, seit das Programm gestartet wurde. Nur dividieren Sie durch "CLOCKS_PER_SEC", um die Anzahl der Sekunden, können Sie multiplizieren Sie mit 1000, um die Anzahl der Millisekunden.
- Sicherlich meinen Sie vermehren sich durch 1000?
- die Frage, die sagten, er braucht die Genauigkeit nicht die Division durch 1000 Lösungen 🙂
- Ich meinte Multiplizieren btw 😛
- haha, wurde mir schlecht 😉 danke
- Auch, sicherlich meinst du dividieren durch CLOCKS_PER_SECOND? Oder sind meine Mathe-Kenntnisse im Stich gelassen hatte? (Meine im-Kopf-Beispiel war: "ich Laufe 10m/s. Ich habe für 2 Meter. Daher hat es gedauert, 0,2 s").
- NÖ, MEINE mathematischen Fähigkeiten sind nicht mir.. -_- danke, wieder 🙂
InformationsquelleAutor Jesse Emond

Einige cross-Plattform-Lösung. Dieser code verwendet wurde, für irgendeine Art von benchmarking:

#ifdef WIN32
  LARGE_INTEGER g_llFrequency = {0};
  BOOL g_bQueryResult = QueryPerformanceFrequency(&g_llFrequency);
#endif

//...

long long osQueryPerfomance()
{
#ifdef WIN32
  LARGE_INTEGER llPerf = {0};
  QueryPerformanceCounter(&llPerf);
  return llPerf.QuadPart * 1000ll / ( g_llFrequency.QuadPart / 1000ll);
#else
  struct timeval stTimeVal;
  gettimeofday(&stTimeVal, NULL);
  return stTimeVal.tv_sec * 1000000ll + stTimeVal.tv_usec;
#endif
}

gettimeofday() ist unter windows nicht unterstützt. Beim kompilieren von code in windows QueryPerformanceCounter verwendet werden. Ist nicht ein high-resolution-timer. Diese Methode ist sehr schnell und präzise.

InformationsquelleAutor loentar

1

Den meisten tragbaren Weg ist mit dem Uhr Funktion.Es in der Regel berichten die Zeit, die Ihr Programm wurde mit dem Prozessor, oder eine Annäherung davon. Beachten Sie jedoch die folgenden:
- Die Auflösung ist nicht sehr gut für GNU-Systeme. Das ist wirklich schade.
- Kümmern casting alles zu Doppel - vor Spaltungen und Rendezvous.
- Den Zähler gehalten wird als 32-bit-Zahl in GNU 32 bits, das kann ziemlich ärgerlich für lange laufende Programme.
Gibt es alternativen mit "Mauer-Zeit", die bessere Auflösung in Windows und in Linux. Aber wie das libc-Handbuch sagt: Wenn Sie versuchen, optimieren Sie Ihr Programm, oder Messen Sie Ihre Effizienz, ist es sehr nützlich zu wissen, wie viel Prozessor-Zeit, die es verwendet. Für, die, Kalender, Uhrzeit und verstrichene Zeiten sind nutzlos, denn ein Prozess kann zu verbringen Zeit mit dem warten auf I/O oder für andere Prozesse auf die CPU.

InformationsquelleAutor dsign

Hier ist eine C++0x-Lösung und ein Beispiel, warum clock() könnte nicht tun, was Sie denken, es tut.

#include <chrono>
#include <iostream>
#include <cstdlib>
#include <ctime>

int main()
{
   auto start1 = std::chrono::monotonic_clock::now();
   auto start2 = std::clock();

   sleep(1);

   for( int i=0; i<100000000; ++i);

   auto end1 = std::chrono::monotonic_clock::now();
   auto end2 = std::clock();

   auto delta1 = end1-start1;
   auto delta2 = end2-start2;

   std::cout << "chrono: " << std::chrono::duration_cast<std::chrono::duration<float>>(delta1).count() << std::endl;

   std::cout << "clock: " << static_cast<float>(delta2)/CLOCKS_PER_SEC << std::endl;
}

Auf meinem system Ausgänge:

chrono: 1.36839
clock: 0.36

Werden Sie feststellen, die clock() - Methode fehlt ein zweites. Eine aufmerksame Beobachter können auch feststellen, dass clock() sieht weniger Auflösung. Auf meinem system ist es das ticken von in 12 Millisekunde Schritten, schreckliche Auflösung.

Wenn Sie nicht in der Lage oder nicht Willens ist, die C++0x, werfen Sie einen Blick auf Boost.DateTime's ptime microsec_clock::universal_time().

InformationsquelleAutor deft_code

0

Dies ist nicht C++ - spezifisch (noch tragbare), aber Sie tun können:
```
SYSTEMTIME systemDT;
```
In Windows.

Von dort aus können Sie auf jedes Mitglied des systemDT struct.

Können Sie erfassen die Zeit, als das Programm begann, und vergleichen Sie die aktuelle Zeit auf die Zeit aufgezeichnet (systemDT versus systemDTtemp zum Beispiel).

Zu aktualisieren, rufen Sie GetLocalTime(&systemDT);

Zugang zu jedem Mitglied, Sie würde tun systemDT.wHour, systemDT.wMinute, systemDT.wMilliseconds.

Um mehr Informationen zu bekommen SYSTEMTIME.

InformationsquelleAutor
0

Wollen Sie die wall clock time, CPU-Zeit, oder eine andere Messung? Auch, welche Plattform ist das? Es gibt keine universell tragbare Weg, um mehr Präzision als time() und clock() Ihnen, aber...
- auf den meisten Unix-Systemen, die Sie verwenden können, gettimeofday() und/oder clock_gettime(), die mindestens Mikrosekunden-Präzision und Zugang zu einer Vielzahl von Timern;
- Ich bin nicht so vertraut mit Windows, aber ein diese Funktionen vermutlich tut Sie das, was Sie wollen.
InformationsquelleAutor zwol

Können Sie versuchen, diesen code (erhalten Sie von Stockfisch Schach-engine, source-code (GPL)):

#include <iostream>
#include <stdio>

#if !defined(_WIN32) && !defined(_WIN64) //Linux - Unix
    #  include <sys/time.h>
    typedef timeval sys_time_t;
    inline void system_time(sys_time_t* t) {
        gettimeofday(t, NULL);
    }
    inline long long time_to_msec(const sys_time_t& t) {
        return t.tv_sec * 1000LL + t.tv_usec / 1000;
    }
    #else //Windows and MinGW
    #  include <sys/timeb.h>
    typedef _timeb sys_time_t;
    inline void system_time(sys_time_t* t) { _ftime(t); }
    inline long long time_to_msec(const sys_time_t& t) {
        return t.time * 1000LL + t.millitm;
    }
#endif

struct Time {
    void restart() { system_time(&t); }
    uint64_t msec() const { return time_to_msec(t); }
    long long elapsed() const {
        return long long(current_time().msec() - time_to_msec(t));
    }
    static Time current_time() { Time t; t.restart(); return t; }
private:
    sys_time_t t;
};

int main() {
    sys_time_t t;
    system_time(&t);
    long long currentTimeMs = time_to_msec(t);
    std::cout << "currentTimeMs:" << currentTimeMs << std::endl;

    Time time = Time::current_time();
    for (int i = 0; i < 1000000; i++) {
        //Do something
    }
    long long e = time.elapsed();
    std::cout << "time elapsed:" << e << std::endl;

    getchar();  //wait for keyboard input
}

InformationsquelleAutor TrungTN

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.