Difference in nanosecond precision between JVM and C++

Question

When measuring time on the JVM with System.nanoTime() you get a higher precision than with the std::chrono::high_resolution_clock. How can that be and is there a cross platform way to get the same precision in C++ as on the JVM.

Examples:

Kotlin (JVM):

fun main(args: Array<String>) {
    for (i in 0..10)
        test() // warmup

    println("Average resolution: ${test()}ns")
}

fun test(): Double {
    val timeList = mutableListOf<Long>()

    for (i in 0 until 10_000_000) {
        val time = System.nanoTime()
        if (timeList.isEmpty() || time != timeList.last())
            timeList.add(time)
    }

    return timeList
            .mapIndexed { i, l -> if (i > 0) l - timeList[i - 1] else null }
            .filterNotNull()
            .average()
}

Output: Average resolution: 433.37ns

C++:

#include <iostream>
#include <chrono>
#include <numeric>
#include <vector>

int main() {
    using namespace std;
    using namespace chrono;

    vector<long long int> time_list;

    for(int i = 0; i < 10'000'000; ++i) {
        auto time = duration_cast<nanoseconds>(high_resolution_clock::now().time_since_epoch()).count();
        if(time_list.empty() || time != time_list[time_list.size() - 1])
            time_list.push_back(time);
    }

    adjacent_difference(time_list.begin(), time_list.end(), time_list.begin());
    auto result = accumulate(time_list.begin() + 1, time_list.end(), 0.0) / (time_list.size() - 1);

    printf("Average resolution: %.2fns", result);

    return 0;
}

Output: Average resolution: 15625657.89ns Edit: (MinGW g++) Edit: Output: Average resolution: 444.88ns (MSVC)

This was done on Windows, but on Linux I get similar results.

Edit:

Alright the original C++ was computed with MinGW and g++ after switching to MSVC I got on par results with the JVM (444.88ns).

`(...) / time_list.size() - 1`should be `(...) / (time_list.size() - 1)` — Alan Birtles, Apr 27 '18 at 14:04
You are aware that you cannot measure exact times in nanoseconds? — Jerome Reinländer, Apr 27 '18 at 14:04
I get 64ns on my mac with your code. Did you compile with optimisations? — Alan Birtles, Apr 27 '18 at 14:09
I know, but that is the question about. How has the JVM a higher precision than the C++ implementation? @AlanBirtles thank you fixed it and adjusted output. — Jhonny007, Apr 27 '18 at 14:09
[No problems with Visual Studio](http://rextester.com/CUFO63792) and no problems [here](https://ideone.com/WxxGQh) — PaulMcKenzie, Apr 27 '18 at 14:11
*but on Linux I get similar results.* -- Linux is not a C++ compiler. What compiler and compilation settings are you using? — PaulMcKenzie, Apr 27 '18 at 14:14
Have you tried printing out the values in time list to see if they are sensible? there could be a single large difference which is skewing the average — Alan Birtles, Apr 27 '18 at 14:14
I used MinGW with g++ above. I now tried with MSVC and got 446ns. — Jhonny007, Apr 27 '18 at 14:17
Your output for Java is meaningless, since you've written an incorrect microbenchmark for Java. Read https://stackoverflow.com/questions/504103/how-do-i-write-a-correct-micro-benchmark-in-java If I repeat your test multiple times, to at least warm op the HotSpot compiler, I get averages from 45ns to 200ns on my 2015 MacBookPro — Erwin Bolwidt, Apr 27 '18 at 14:17
Thanks I added warmup even though it didn't really matter for this example since the JVM was more precise even without warmup. — Jhonny007, Apr 27 '18 at 14:28
On macOS using -O3 I'm getting results on the order of 74.67ns for the C++ experiment. — Howard Hinnant, Apr 27 '18 at 14:39

Erwin Bolwidt · Answer 1 · 2018-04-28T10:35:31.600

Your Java (Kotlin) example is not measuring nanosecond granularity; it is mostly measuring how long it takes to garbage collect a list of Long objects. (or expand the heap, or allocate the objects and object headers - if you only run the test once, it may attempt to garbage collect but it won't succeed for as long as the loop is running)

Java is pretty fast with memory allocation, usually faster than the standard memory allocators libraries for C/C++.

For C++, it's possible at least that a significant percentage of the perceived precision of the nanosecond clock comes from call push_back 10 million times on a vector, which involves a number of reallocations.

A better test would be (Kotlin, but the same can be done for C++) - there is no need to remember the timestamps in a list in order to calculate the average difference between them.

fun main(args: Array<String>) {
    for (i in 0 until 10) {
        runTest();
    }
}

fun runTest() {
    var lastTime = System.nanoTime()
    var count = 0;
    var total = 0L;
    for (i in 0 until 50_000_000) {
        val time = System.nanoTime()
        if (time > lastTime) {
            count++;
            total += time - lastTime;
            lastTime = time;
        }
    }

    val result = total / count;

    println("Average resolution: ${result}ns")
}

Note: this gives me a pretty consistent 32-35ns precision in Java, much better than the 45-200 ns that your original code gave me.

As for your C++ code, your original code running on my MacBookPro gives me 68-78ns (when run in a loop that runs it 10 times)

I've also removed the unnecessary vector from your code and then it gives a 50-51ns result, which gives a decent indication that the real granularity is 50ns.

The JVM does somewhat better than that with 32-35ns (38% better than 50ns), but the margin is not by far as big as what you mentioned.

Please try again and post the output with code that doesn't store the results in a list unnecessarily, as this greatly influences the results.

#include <iostream>
#include <chrono>
#include <numeric>
#include <vector>


int main1() {
    using namespace std;
    using namespace chrono;

    vector<long long int> time_list;

    long long total = 0;
    int count = 0;
    auto lastTime = duration_cast<nanoseconds>(high_resolution_clock::now().time_since_epoch()).count();
    for(int i = 0; i < 50000000; ++i) {
        auto time = duration_cast<nanoseconds>(high_resolution_clock::now().time_since_epoch()).count();
        if (time > lastTime) {
            count++;
            total += time - lastTime;
            lastTime = time; 
        }
    }

    long long result = total / count;

    printf("Average resolution: %.2lld ns\n", result);

    return 0;
}

int main() {
    for (int i = 0; i < 10; i++) {
        main1();
    }
}

@marko neither does the original. It’s the same as the original without the list — Erwin Bolwidt, Apr 28 '18 at 05:38

score 0 · Answer 2 · answered Apr 27 '18 at 14:04

0

The resolution in c++ is platform-dependent, but you may be able to get better accuracy using platform-specific calls (e.g. clock_gettime from time.h on Linux)

answered Apr 27 '18 at 14:04

apetranzilla

5,331
27
34

Difference in nanosecond precision between JVM and C++

Examples:

Kotlin (JVM):

C++:

Edit:

2 Answers2