Разница между std :: system_clock и std :: stable_clock?

В чем разница между std::system_clockи std::steady_clock? (Примерный случай, иллюстрирующий разные результаты / поведение, был бы отличным).

Если моя цель - точно измерить время выполнения функций (например, эталонный тест), что будет лучшим выбором между std::system_clock, std::steady_clockи std::high_resolution_clock?

С N3376:

20.11.7.1 [time.clock.system] / 1:

Объекты класса system_clockпредставляют время настенных часов из общесистемных часов реального времени.

20.11.7.2 [time.clock.steady] / 1:

Объекты класса steady_clockпредставляют собой часы, для которых значения time_pointникогда не уменьшаются по мере продвижения физического времени и для которых значения time_pointпродвигаются с постоянной скоростью относительно реального времени. То есть часы можно не настраивать.

20.11.7.3 [time.clock.hires] / 1:

Объекты класса high_resolution_clockпредставляют собой часы с наименьшим периодом тика. high_resolution_clockможет быть синонимом system_clockили steady_clock.

Например, на общесистемные часы может влиять что-то вроде перехода на летнее время, когда фактическое время, указанное в какой-то момент в будущем, может фактически быть временем в прошлом. (Например, в США осеннее время сдвигается на один час назад, поэтому один и тот же час переживается "дважды") Однако steady_clockтакие вещи не могут повлиять на это.

Другой способ думать о «стабильном» в этом случае - это требования, определенные в таблице 20.11.3 [time.clock.req] / 2:

В Таблице 59 C1и C2обозначены типы часов. t1и t2являются значениями, возвращаемыми тем C1::now()местом, где t1происходит возврат вызова до возврата вызова, t2и оба этих вызова происходят раньше C1::time_point::max(). [Примечание: это означает C1отсутствие перехода между t1и t2. - конец примечания]

Выражение: C1::is_steady
Возвращает: const bool
Операционная семантика: trueif t1 <= t2всегда истинно, а время между тактами часов постоянно, в противном случае false.

Это все, что в стандарте говорится об их различиях.

Если вы хотите провести сравнительный анализ, вам, вероятно, будет лучше всего std::high_resolution_clock, потому что вполне вероятно, что ваша платформа использует таймер высокого разрешения (например, QueryPerformanceCounterв Windows) для этих часов. Однако, если вы проводите тестирование, вам действительно следует подумать об использовании таймеров для конкретной платформы для вашего теста, потому что разные платформы обрабатывают это по-разному. Например, некоторые платформы могут предоставить вам некоторые средства определения фактического количества тактов часов, которое требуется программе (независимо от других процессов, работающих на том же процессоре). А еще лучше, возьмите в руки настоящий профилировщик и используйте его.

Билли дал отличный ответ на основе стандарта ISO C ++, с которым я полностью согласен. Однако есть и другая сторона истории - реальная жизнь. Кажется, что сейчас действительно нет разницы между этими часами в реализации популярных компиляторов:

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;

В случае gcc вы можете проверить, имеете ли вы дело с постоянными часами, просто проверив is_steadyи действуя соответствующим образом. Однако VS2012, похоже, здесь немного обманывает :-)

Если вам нужны часы с высокой точностью, я рекомендую сейчас написать свои собственные часы, которые соответствуют официальному интерфейсу часов C ++ 11, и дождаться, пока реализации наверстают упущенное. Это будет намного лучше, чем использование API для конкретной ОС непосредственно в вашем коде. Для Windows это можно сделать так:

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

Для Linux это еще проще. Просто прочтите страницу руководства clock_gettimeи измените приведенный выше код.

Реализация GCC 5.3.0

C ++ stdlib находится внутри источника GCC:

• high_resolution_clock это псевдоним для system_clock
• system_clock пересылает на первое из следующих доступных:
  • clock_gettime(CLOCK_REALTIME, ...)
  • gettimeofday
  • time
• steady_clock пересылает на первое из следующих доступных:
  • clock_gettime(CLOCK_MONOTONIC, ...)
  • system_clock

Затем объясняется CLOCK_REALTIMEvs CLOCK_MONOTONIC: Разница между CLOCK_REALTIME и CLOCK_MONOTONIC?

Пожалуй, самое существенное отличие состоит в том, что отправной точкой std::chrono:system_clockявляется 1.1.1970, так называемая UNIX-эпоха. С другой стороны, std::chrono::steady_clockобычно это время загрузки вашего ПК, и это лучше всего подходит для измерения интервалов.