Différence entre std :: system_clock et std :: stabil_clock?

Quelle est la différence entre std::system_clocket std::steady_clock? (Un exemple de cas illustrant différents résultats / comportements serait formidable).

Si mon objectif est de mesurer précisément le temps d'exécution des fonctions (comme un benchmark), quel serait le meilleur choix entre std::system_clock, std::steady_clocket std::high_resolution_clock?

Depuis N3376:

20.11.7.1 [time.clock.system] / 1:

Les objets de classe system_clockreprésentent l'heure de l'horloge murale à partir de l'horloge temps réel du système.

20.11.7.2 [heure.horloge.steady] / 1:

Les objets de classe steady_clockreprésentent des horloges pour lesquelles les valeurs de time_pointne diminuent jamais à mesure que le temps physique avance et pour lesquelles des valeurs d' time_pointavance à un rythme constant par rapport au temps réel. Autrement dit, l'horloge peut ne pas être ajustée.

20.11.7.3 [time.clock.hires] / 1:

Les objets de classe high_resolution_clockreprésentent les horloges avec la période de graduation la plus courte. high_resolution_clockpeut être un synonyme de system_clockou steady_clock.

Par exemple, l'horloge à l'échelle du système peut être affectée par quelque chose comme l'heure d'été, auquel moment l'heure réelle indiquée à un moment donné dans le futur peut en fait être une heure du passé. (Par exemple aux États-Unis, à l'automne, le temps recule d'une heure, de sorte que la même heure est vécue "deux fois") Cependant, il steady_clockn'est pas autorisé à être affecté par de telles choses.

Une autre façon de penser "stable" dans ce cas est dans les exigences définies dans le tableau du 20.11.3 [time.clock.req] / 2:

Dans le tableau 59 C1, C2notez les types d'horloge. t1et t2sont des valeurs renvoyées par C1::now()où l'appel de retour t1se produit avant le retour de l'appel t2et ces deux appels se produisent avant C1::time_point::max(). [Remarque: cela signifie C1que ne s'est pas enroulé entre t1et t2. —End note]

Expression: C1::is_steady
Renvoie: const bool
Sémantique opérationnelle: truesi t1 <= t2est toujours vrai et le temps entre les tics d'horloge est constant, sinon false.

C'est tout ce que la norme a sur leurs différences.

Si vous voulez faire un benchmarking, votre meilleur pari sera probablement std::high_resolution_clock, car il est probable que votre plate-forme utilise une minuterie haute résolution (par exemple QueryPerformanceCountersous Windows) pour cette horloge. Cependant, si vous effectuez une analyse comparative, vous devriez vraiment envisager d'utiliser des minuteries spécifiques à la plate-forme pour votre référence, car différentes plates-formes gèrent cela différemment. Par exemple, certaines plates-formes peuvent vous donner des moyens de déterminer le nombre réel de cycles d'horloge requis par le programme (indépendamment des autres processus exécutés sur le même processeur). Mieux encore, mettez la main sur un véritable profileur et utilisez-le.

Billy a fourni une excellente réponse basée sur la norme ISO C ++ avec laquelle je suis entièrement d'accord. Cependant, il y a un autre aspect de l'histoire - la vraie vie. Il semble que pour le moment, il n'y ait vraiment aucune différence entre ces horloges dans la mise en œuvre des compilateurs populaires:

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;

Dans le cas de gcc, vous pouvez vérifier si vous gérez une horloge régulière simplement en vérifiant is_steadyet en vous comportant en conséquence. Cependant VS2012 semble tricher un peu ici :-)

Si vous avez besoin d'une horloge haute précision, je vous recommande pour l'instant d'écrire votre propre horloge conforme à l'interface d'horloge officielle C ++ 11 et d'attendre que les implémentations rattrapent leur retard. Ce sera une bien meilleure approche que d'utiliser une API spécifique au système d'exploitation directement dans votre code. Pour Windows, vous pouvez le faire comme ça:

// 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()));
  }
};

Pour Linux, c'est encore plus facile. Lisez simplement la page de manuel clock_gettimeet modifiez le code ci-dessus.

Implémentation de GCC 5.3.0

C ++ stdlib est à l'intérieur de la source GCC:

• high_resolution_clock est un alias pour system_clock
• system_clock transfère au premier des éléments suivants disponibles:
  • clock_gettime(CLOCK_REALTIME, ...)
  • gettimeofday
  • time
• steady_clock transfère au premier des éléments suivants disponibles:
  • clock_gettime(CLOCK_MONOTONIC, ...)
  • system_clock

Alors CLOCK_REALTIMEvs CLOCK_MONOTONICest expliqué à: Différence entre CLOCK_REALTIME et CLOCK_MONOTONIC?

Peut-être, la différence la plus significative est le fait que le point de départ de std::chrono:system_clockest le 1.1.1970, soi-disant époque UNIX. De l'autre côté, pour std::chrono::steady_clockgénéralement le temps de démarrage de votre PC et il est le plus approprié pour mesurer les intervalles.