ForHoward

Version One:

#include <iostream>
#include <thread>
#include <chrono>
#include <vector>
#include <algorithm>

// g++ -std=c++11 -O3 -s -DNDEBUG chrono.cpp

int main()
{
    typedef std::chrono::high_resolution_clock Clock;
    typedef std::chrono::nanoseconds nanoseconds;

    std::vector<int> v;
    v.push_back(45); v.push_back(56); v.push_back(57); v.push_back(58); v.push_back(59); v.push_back(59);
    v.push_back(61); v.push_back(62); v.push_back(62); v.push_back(63); v.push_back(64); v.push_back(65);
    const int N = 100;

    Clock::time_point t0 = Clock::now();
    //Test area
    for (int j = 0; j < N; ++j)
    {
        v.push_back(j);
        std::sort(v.begin(), v.end());
    }
    //std::this_thread::sleep_for(nanoseconds(50));


    Clock::time_point t1 = Clock::now();

    nanoseconds ms = std::chrono::duration_cast<nanoseconds>(t1 - t0)/N;
    std::cout << ms.count() << " Nanoseconds\n";
}

Results(multiple runs):
1893 Nanoseconds

5025 Nanoseconds

5035 Nanoseconds

5039 Nanoseconds

1897 Nanoseconds


6961 Nanoseconds

5039 Nanoseconds

6046 Nanoseconds

----------------------------------------------------------------------------------------------------

Version 2:

#include <chrono>
#include <iostream>
#include <vector>
#include <algorithm>

namespace x
{

struct clock
{
    typedef unsigned long long                 rep;
    typedef std::ratio<1, 1600000000>          period; // My machine is 2.8 GHz
    typedef std::chrono::duration<rep, period> duration;
    typedef std::chrono::time_point<clock>     time_point;
    static const bool is_steady =              true;

    static time_point now() noexcept
    {
        unsigned lo, hi;
        asm volatile("rdtsc" : "=a" (lo), "=d" (hi));
        return time_point(duration(static_cast<rep>(hi) << 32 | lo));
    }
};

}  // x

template <class clock>
void
test_empty_loop()
{
    // Define real time units
    typedef std::chrono::duration<unsigned long long, std::pico> picoseconds;
    // or:
    // typedef std::chrono::nanoseconds nanoseconds;
    // Define double-based unit of clock tick
    typedef std::chrono::duration<double, typename clock::period> Cycle;
    using std::chrono::duration_cast;
    const int N = 100;
    // Do it


    std::vector<int> v;
    v.push_back(45); v.push_back(56); v.push_back(57); v.push_back(58); v.push_back(59); v.push_back(59);
    v.push_back(61); v.push_back(62); v.push_back(62); v.push_back(63); v.push_back(64); v.push_back(65);

    auto t0 = clock::now();

    /*Test area begins*/

    // for (int j = 0; j < N; ++j)
    //     asm volatile("");
    for (int j = 0; j < N; ++j)
    {
        v.push_back(j);
        std::sort(v.begin(), v.end());
    }
    /*Test area ends*/

    auto t1 = clock::now();
    // Get the clock ticks per iteration
    auto ticks_per_iter = Cycle(t1-t0)/N;
    std::cout << ticks_per_iter.count() << " clock ticks per iteration\n";
    // Convert to real time units
    std::cout << duration_cast<picoseconds>(ticks_per_iter).count()
              << "ps per iteration\n";
}

int main()
{
    std::cout << "Precision: "<<std::chrono::high_resolution_clock::period::den << std::endl;

    std::cout << "\nUsing rdtsc:\n";
    test_empty_loop<x::clock>();

    std::cout << "\nUsing std::chrono::high_resolution_clock:\n";
    test_empty_loop<std::chrono::high_resolution_clock>();

    std::cout << "\nUsing std::chrono::system_clock:\n";
    test_empty_loop<std::chrono::system_clock>();


}

Results:


Precision: 1000000000

Using rdtsc:
7862.72 clock ticks per iteration
4914200ps per iteration

Using std::chrono::high_resolution_clock:
4932.74 clock ticks per iteration
4932739ps per iteration

Using std::chrono::system_clock:
5665.97 clock ticks per iteration
5665970ps per iteration


Another run:

Precision: 1000000000

Using rdtsc:
11240.3 clock ticks per iteration
7025199ps per iteration

Using std::chrono::high_resolution_clock:
5014.35 clock ticks per iteration
5014350ps per iteration

Using std::chrono::system_clock:
7627.23 clock ticks per iteration
7627229ps per iteration

Another run:
Precision: 1000000000

Using rdtsc:
7875.04 clock ticks per iteration
4921899ps per iteration

Using std::chrono::high_resolution_clock:
5890.23 clock ticks per iteration
5890229ps per iteration

Using std::chrono::system_clock:
5641.11 clock ticks per iteration
5641109ps per iteration

Another run:

Using rdtsc:
3714.96 clock ticks per iteration
2321850ps per iteration

Using std::chrono::high_resolution_clock:
1874.76 clock ticks per iteration
1874759ps per iteration

Using std::chrono::system_clock:
1832.86 clock ticks per iteration
1832859ps per iteration