Unterschied zwischen std :: system_clock und std :: stetiger_takt?

Was ist der Unterschied zwischen std::system_clockund std::steady_clock? (Ein Beispielfall, der unterschiedliche Ergebnisse / Verhaltensweisen veranschaulicht, wäre großartig).

Wenn mein Ziel genau zu Ausführungszeit von Funktionen (wie ein Benchmark) zu messen, was wäre die beste Wahl zwischen std::system_clock, std::steady_clockund std::high_resolution_clock?

Von N3376:

20.11.7.1 [time.clock.system] / 1:

Klassenobjekte system_clockrepräsentieren die Wanduhrzeit von der systemweiten Echtzeituhr.

20.11.7.2 [time.clock.steady] / 1:

Klassenobjekte steady_clockstellen Uhren dar, für die die Werte von time_pointniemals mit fortschreitender physikalischer Zeit abnehmen und für die Werte von time_pointfortschreitender Geschwindigkeit relativ zur Echtzeit. Das heißt, die Uhr kann möglicherweise nicht eingestellt werden.

20.11.7.3 [time.clock.hires] / 1:

Klassenobjekte high_resolution_clockrepräsentieren Uhren mit der kürzesten Tick-Periode. high_resolution_clockkann ein Synonym für system_clockoder sein steady_clock.

Beispielsweise kann die systemweite Uhr von einer Sommerzeit beeinflusst werden. Zu diesem Zeitpunkt kann die zu einem späteren Zeitpunkt angegebene tatsächliche Zeit tatsächlich eine Zeit in der Vergangenheit sein. (ZB in den USA bewegt sich die Herbstzeit um eine Stunde zurück, so dass dieselbe Stunde "zweimal" erlebt wird.) Es steady_clockist jedoch nicht gestattet, von solchen Dingen betroffen zu sein.

Eine andere Art, in diesem Fall über "stetig" nachzudenken, sind die Anforderungen, die in der Tabelle vom 20.11.3 [time.clock.req] / 2 definiert sind:

In Tabelle 59 C1und C2bezeichnen Uhrentypen. t1und t2sind Werte, die zurückgegeben werden, C1::now()wenn die Rückgabe des Anrufs t1vor der Rückgabe des Anrufs erfolgt t2und diese beiden Anrufe zuvor erfolgen C1::time_point::max(). [Hinweis: Dies bedeutet, C1dass nicht zwischen t1und umbrochen wurde t2. - Endnote]

Ausdruck: C1::is_steady
Rückgabe: const bool
Operative Semantik: trueWenn dies t1 <= t2immer der Fall ist und die Zeit zwischen den Ticks der Uhr konstant ist, ist dies ansonsten konstant false.

Das ist alles, was der Standard über ihre Unterschiede hat.

Wenn Sie Benchmarking durchführen möchten, ist dies wahrscheinlich die beste Wahl std::high_resolution_clock, da Ihre Plattform wahrscheinlich einen hochauflösenden Timer (z. B. QueryPerformanceCounterunter Windows) für diese Uhr verwendet. Wenn Sie jedoch ein Benchmarking durchführen, sollten Sie wirklich in Betracht ziehen, plattformspezifische Timer für Ihren Benchmark zu verwenden, da verschiedene Plattformen dies unterschiedlich handhaben. Auf einigen Plattformen können Sie beispielsweise die tatsächliche Anzahl der für das Programm erforderlichen Takt-Ticks ermitteln (unabhängig von anderen Prozessen, die auf derselben CPU ausgeführt werden). Besser noch, besorgen Sie sich einen echten Profiler und nutzen Sie diesen.

Billy gab eine großartige Antwort basierend auf dem ISO C ++ - Standard, dem ich voll und ganz zustimme. Es gibt jedoch eine andere Seite der Geschichte - das wirkliche Leben. Es scheint, dass es im Moment wirklich keinen Unterschied zwischen diesen Uhren bei der Implementierung populärer Compiler gibt:

gcc 4.8:

#ifdef _GLIBCXX_USE_CLOCK_MONOTONIC
   ...
#else
  typedef system_clock steady_clock;
#endif
  typedef system_clock high_resolution_clock;

Visual Studio 2012:

class steady_clock : public system_clock
{   // wraps monotonic clock
public:
  static const bool is_monotonic = true;    // retained
  static const bool is_steady = true;
};

typedef system_clock high_resolution_clock;

Im Falle von gcc können Sie überprüfen, ob Sie mit einer stabilen Uhr umgehen, indem Sie einfach prüfen is_steadyund sich entsprechend verhalten. Allerdings scheint VS2012 hier ein bisschen zu schummeln :-)

Wenn Sie eine hochpräzise Uhr benötigen, empfehle ich Ihnen, zunächst eine eigene Uhr zu schreiben, die der offiziellen C ++ 11-Uhrschnittstelle entspricht, und zu warten, bis die Implementierungen aufholen. Dies ist ein viel besserer Ansatz als die Verwendung einer betriebssystemspezifischen API direkt in Ihrem Code. Für Windows können Sie dies folgendermaßen tun:

// Self-made Windows QueryPerformanceCounter based C++11 API compatible clock
struct qpc_clock {
  typedef std::chrono::nanoseconds                       duration;      // nanoseconds resolution
  typedef duration::rep                                  rep;
  typedef duration::period                               period;
  typedef std::chrono::time_point<qpc_clock, duration>   time_point;
  static bool is_steady;                                                // = true
  static time_point now()
  {
    if(!is_inited) {
      init();
      is_inited = true;
    }
    LARGE_INTEGER counter;
    QueryPerformanceCounter(&counter);
    return time_point(duration(static_cast<rep>((double)counter.QuadPart / frequency.QuadPart *
                                                period::den / period::num)));
  }

private:
  static bool is_inited;                                                // = false
  static LARGE_INTEGER frequency;
  static void init()
  {
    if(QueryPerformanceFrequency(&frequency) == 0)
      throw std::logic_error("QueryPerformanceCounter not supported: " + std::to_string(GetLastError()));
  }
};

Für Linux ist es noch einfacher. Lesen Sie einfach die Manpage von clock_gettimeund ändern Sie den obigen Code.

Implementierung von GCC 5.3.0

C ++ stdlib befindet sich in der GCC-Quelle:

• high_resolution_clock ist ein Alias ​​für system_clock
• system_clock leitet an die erste der folgenden Optionen weiter, die verfügbar sind:
  • clock_gettime(CLOCK_REALTIME, ...)
  • gettimeofday
  • time
• steady_clock leitet an die erste der folgenden Optionen weiter, die verfügbar sind:
  • clock_gettime(CLOCK_MONOTONIC, ...)
  • system_clock

Dann wird CLOCK_REALTIMEvs CLOCK_MONOTONICerklärt unter: Unterschied zwischen CLOCK_REALTIME und CLOCK_MONOTONIC?

Der vielleicht bedeutendste Unterschied ist die Tatsache, dass der Ausgangspunkt std::chrono:system_clockder 1.1.1970, der sogenannten UNIX-Epoche, ist. Auf der anderen Seite ist dies std::chrono::steady_clocknormalerweise die Startzeit Ihres PCs und eignet sich am besten zum Messen von Intervallen.