c++ 11 get timestamp

¿Cómo obtener la precisión de high_resolution_clock?

Question

C ++ 11 define high_resolution_clock y tiene los tipos de miembros period y rep . Pero no puedo entender cómo puedo obtener la precisión de ese reloj.

O, si no puedo llegar a la precisión, ¿puedo al menos obtener un recuento en nanosegundos de la duración mínima del tiempo representable entre tic-pies? probablemente usando el period ?

#include <iostream>
#include <chrono>
void printPrec() {
    std::chrono::high_resolution_clock::rep x = 1;
    // this is not the correct way to initialize ''period'':
    //high_resolution_clock::period y = 1;

    std::cout << "The smallest period is "
              << /* what to do with ''x'' or ''y'' here? */
              << " nanos/n";
}

Answer 1

La duración mínima representable es high_resolution_clock::period::num / high_resolution_clock::period::den second. Puedes imprimirlo así:

std::cout << (double) std::chrono::high_resolution_clock::period::num
             / std::chrono::high_resolution_clock::period::den;

¿Por qué es esto? El miembro del ::period un reloj se define como "El período de marca del reloj en segundos". Es una especialización de std::ratio que es una plantilla para representar ratios en tiempo de compilación. Proporciona dos constantes integrales: num y den , el numerador y el denominador de una fracción, respectivamente.

Answer 2

Un tipo std::ratio representa el período de tictac del reloj, en segundos. Definido en el espacio de nombres std::chrono

template<intmax_t Num, intmax_t Denom = 1 > class ratio;

Answer 3

Yo subestimé la respuesta de R. Martinho Fernandes porque creo que ofrece la respuesta más clara y directa a la pregunta. Sin embargo, quería agregar un pequeño código que mostrara un poco más de funcionalidad <chrono> y que abordara esta parte de la pregunta del OP:

¿De alguna manera puedo al menos obtener un recuento en nanosegundos de la duración mínima del tiempo representable entre tics?

Y no es práctico poner tanta información en un comentario. Pero de otra manera considero esta respuesta como un comentario de apoyo a la respuesta de R. Martinho Fernandes.

Primero el código, y luego la explicación:

#include <iostream>
#include <chrono>

template <class Clock>
void
display_precision()
{
    typedef std::chrono::duration<double, std::nano> NS;
    NS ns = typename Clock::duration(1);
    std::cout << ns.count() << " ns/n";
}

int main()
{
    display_precision<std::chrono::high_resolution_clock>();
    display_precision<std::chrono::system_clock>();
}

Primero creé un nanosecond que utiliza un double como representación ( NS ). Utilicé el double en caso de que tuviera que mostrar fracciones de un nanosegundo (por ejemplo, 0.5 ns ).

A continuación, cada reloj tiene un tipo anidado llamado duration . Este es un chrono::duration que tendrá la misma std::ratio , y por lo tanto el mismo num y den como se señala en la respuesta de R. Martinho Fernandes. Una de esas duration , convertida a NS , nos dará la cantidad de nanosegundos en un reloj de Clock . Y ese valor se puede extraer de la duration con la función de miembro count() .

Para mí este programa imprime:

1 ns
1000 ns