High Resolution Clock in VS2013

Question

I'm looking for a cross-platform clock with high resolution, high precision, and relatively low performance impact (in order of importance).

I've tried:

//using namespace std::chrono;
//typedef std::chrono::high_resolution_clock Clock;

using namespace boost::chrono;
typedef boost::chrono::high_resolution_clock Clock;
auto now = Clock::now().time_since_epoch();
std::size_t secs = duration_cast<seconds>(now).count();
std::size_t nanos = duration_cast<nanoseconds>(now).count() % 1000000000;
std::time_t tp = (std::time_t) secs;
std::string mode;
char timestamp[] = "yyyymmdd HH:MM:SS";
char format[] = "%Y%m%d %H:%M:%S";

strftime(timestamp, 80, format, std::localtime(&tp)); // Takes 12 microseconds
std::string output = timestamp + "." + std::to_string(nanos);

After some trials and testing: The original std::chrono::high_resolution_clock is typedef to system_clock and has precision of roughly 1 millisecond. The boost::chrono::high_resolution_clock uses the Query_Performance_Counter on Windows and has high resolution and precision. Unfortunately, Clock::now() returns time since boot and now().time_since_epoch() does not return epoch time (also returns time since boot).

Don't mind using guards for different solutions on different platforms (want VS2013 and Linux). Will likely store the now and do the processing in a separate/low priority thread.

Does a cross-platform, high-resolution, high-precision, performance-friendly timer exist?

Is boost::chrono::high_resolution_clock::now().time_since_epoch() working as intended? It does not give a time since the last epoch. It only gives a time since last boot. Is there a way to convert this now() into seconds since the epoch.

Answer 1

I think the nicest way to do it is to implement a new clock type that models the Clock requirement in the c++11/14 standard.

The windows function GetSystemTimePreciseAsFileTime can be used as the basis of the windows clock. I believe this function returns the time in units of 100 nano-seconds since the start of the windows epoch. If I'm wrong about that, just alter the definition of period to suit.

struct windows_highres_clock
{
    // implement Clock concept
    using rep = ULONGLONG;
    using period = std::ratio<1, 10000000>;
    using duration = std::chrono::duration<rep, period>;
    using time_point = std::chrono::time_point<windows_highres_clock, duration>;

    static constexpr const bool is_steady = true;

    static time_point now() noexcept {
        FILETIME ft = { 0, 0 };
        GetSystemTimePreciseAsFileTime(&ft);
        ULARGE_INTEGER stamp { { ft.dwLowDateTime, ft.dwHighDateTime } };
        return time_point { duration { stamp.QuadPart } };
    }
};

If you want to go ahead and implement the TrivalClock concept on top of it, that should work. Just follow the instructions at http://cppreference.com

Providing from_time_t and to_time_t member functions will complete the picture and allow you to use this clock for both timing and datetime representation.

example of use:

windows_highres_clock clock;
auto t0 = clock.now();
sleep(1);
auto t1 = clock.now();
auto diff = t1 - t0;
auto ms = std::chrono::duration_cast<chrono::milliseconds>(diff);
cout << "waited for " << ms.count() << " milliseconds\n";

example output:

waited for 1005 milliseconds

for non-windows systems the system_clock usually suffices, but you can write a similar per-system clock using the appropriate native timing mechanisms.

FYI:

Here's a portable piece of code you can use to check clock resolutions. The class any_clock is a polymorphic container that can hold any Clock-like object. It always returns its time stamps as microseconds since the epoch.

// create some syntax to help specialise the any_clock
template<class Clock> struct of_type {};

// polymorphic clock container
struct any_clock
{

    template<class Clock>
    any_clock(of_type<Clock>)
    : _ptr { new model<Clock> {} }
    {}

    std::chrono::microseconds now() const {
        return _ptr->now();
    }

    using duration = std::chrono::microseconds;

private:
    struct concept {
        virtual ~concept() = default;
        virtual duration now() const noexcept = 0;
    };
    template<class Clock>
    struct model final : concept {
        duration now() const noexcept final {
            return std::chrono::duration_cast<std::chrono::microseconds>(Clock::now().time_since_epoch());
        }
    };
    unique_ptr<concept> _ptr;
};

int main(int argc, const char * argv[])
{
    any_clock clocks[] = {
         { of_type<windows_highres_clock>() },
         { of_type<std::chrono::high_resolution_clock>() },
         { of_type<std::chrono::system_clock>() }
    };

    static constexpr size_t nof_clocks = std::extent<decltype(clocks)>::value;
    any_clock::duration t0[nof_clocks];
    any_clock::duration t1[nof_clocks];

    for (size_t i = 0 ; i < nof_clocks ; ++i) {
        t0[i] = clocks[i].now();
    }
    sleep(1);
    for (size_t i = 0 ; i < nof_clocks ; ++i) {
        t1[i] = clocks[i].now();
    }
    for (size_t i = 0 ; i < nof_clocks ; ++i) {
        auto diff = t1[i] - t0[i];
        auto ms = std::chrono::duration_cast<chrono::microseconds>(diff);
        cout << "waited for " << ms.count() << " microseconds\n";
    }
    return 0;
}