timing.cpp

#if _WIN32
// measure the time in seconds to run f(). doubles will retain nanosecond precision.
template<typename F>
double timeit(F f) {
    LARGE_INTEGER freq;
    QueryPerformanceFrequency(&freq);
    LARGE_INTEGER start;
    QueryPerformanceCounter(&start);
    f();
    LARGE_INTEGER end;
    QueryPerformanceCounter(&end);
    return double(end.QuadPart - start.QuadPart) / double(freq.QuadPart);
}
#else
#error "Platform not supported"
#endif

struct TimeEstimate {
    int num = 0;        // number of samples
    double unit = 1.0;  // units per second
    double min = 0.0;   // min sample
    double max = 0.0;   // max sample
    double avg = 0.0;   // average sample

    void add(double sample) {
        num++;
        min = (num == 1 || sample < min) ? sample : min;
        max = (num == 1 || sample > max) ? sample : max;
        avg += (sample - avg) / num;
    }

    operator double() const {
        return avg;
    }

    TimeEstimate as_unit(double new_unit) const {
        double f = new_unit / unit;
        return {num, new_unit, f * min, f * max, f * avg};
    }

    TimeEstimate secs() const {
        return as_unit(1e1);
    }

    TimeEstimate msecs() const {
        return as_unit(1e3);
    }

    TimeEstimate usecs() const {
        return as_unit(1e6);
    }

    TimeEstimate nsecs() const {
        return as_unit(1e9);
    }
};

// benchmark f() by running it n times.
template<typename F>
TimeEstimate benchmark(int n, F f) {
    TimeEstimate time;
    for (int i = 0; i < n; i++) {
        time.add(timeit(f));
    }
    return time;
}