如何在 C++ 中测量指令执行时间（使用时钟周期单元）而不是秒？

Question

My question is I'm not sure if my function calcClock() is correct and I'm not sure if the function name is correct too, and "What is the exact Formula for measuring the execution time with Clock Cycle Unit?". I was reading http://www0.cs.ucl.ac.uk/teaching/B261/Slides/lecture2/tsld015.htm but I don't understand, because it doesn't have an example and difficult to be understood.

The reason I ask such question is I will measure many functions execution time such as _multiply() and once the measurements are placed, they must not be changed anymore.

Edit after answers: I renamed calcClock to calcClockCycles, and totalPerformedInstructions to totalPerformedExpressions, because an expression can have multiple instructions.

#include <chrono>
struct Chrono {
    // Referenced from:
    // - https://en.cppreference.com/w/cpp/chrono/high_resolution_clock/now
    // - https://levelup.gitconnected.com/8-ways-to-measure-execution-time-in-c-c-48634458d0f9

private:
    std::chrono::high_resolution_clock::time_point _start, _end;

public:
    void start() {
        _start = std::chrono::high_resolution_clock::now();
    }
    void end() {
        _end = std::chrono::high_resolution_clock::now();
    }
    double elapsed() {
        std::chrono::duration<double> diff = _end - _start;
    }
    double calcClockCycles(int totalPerformedExpressions, float GHz) { // I set GHz to 2.4 with "Intel(R) Core(TM) i7-5500U CPU @ 2.40GHz (4 CPUs), ~2.4GHz".
        return elapsed() / totalPerformedExpressions * GHz*1000*1000*1000;
    }
};

Example of application in main.cpp

Chrono g_ch;
int g_iterations = 2*1000*1000;
float g_GHz = 2.4f;

#define ITERx100_EXPRESSIONS(X) \
    for (int i = 0; i < g_iterations; i++) { \
        X; X; X; X; X; X; X; X; X; X; \
        X; X; X; X; X; X; X; X; X; X; \
        X; X; X; X; X; X; X; X; X; X; \
        X; X; X; X; X; X; X; X; X; X; \
        X; X; X; X; X; X; X; X; X; X; \
        X; X; X; X; X; X; X; X; X; X; \
        X; X; X; X; X; X; X; X; X; X; \
        X; X; X; X; X; X; X; X; X; X; \
        X; X; X; X; X; X; X; X; X; X; \
        X; X; X; X; X; X; X; X; X; X; \
    }

inline vec2 _multiply(const vec2 &_v, const mat2x2 &_M) {
    // |6|T   |2 3|T   |6*2+4*3|   |24|
    // |4|  * |7 5|  = |6*7+4*5| = |62|
    
    #if defined(__GNUC__)
        // M = {[0],[1],
        //      [2],[3]}
        v4sf o;
        v4sf &v = *(v4sf *)&_v;
        v4sf &M = *(v4sf *)&_M;
        #if 0
            o[0] = v[0]*M[0] + v[1]*M[1];
            o[1] = v[0]*M[2] + v[1]*M[3];
        #elif 1
            // v4sf a = __builtin_shuffle(v, v4si{0,1,0,1}) * M;
            // o[0] = a[0] + a[1];
            // o[1] = a[2] + a[3];
            //
            // v4sf a = __builtin_shuffle(v, v4si{0,1,0,1}) * M;
            // o = __builtin_shuffle(a, v4si{0,2}) + __builtin_shuffle(a, v4si{1,3});
            
            v4sf a = __builtin_shuffle(v, v4si{0,0,1,1}) * __builtin_shuffle(M, v4si{0,2,1,3});
            o = a + __builtin_shuffle(a, v4si{2,3});
        #endif
        return *(vec2 *)&o;
    #else
        return _multiply_slow(_v, _M);
    #endif
}

void mat2x2_vxM() {
    mat2x2 M = v4sf{
        2,3,
        7,5,
    };
    vec2 v(6,4);
    vec2 V;

    g_ch.start();
    ITERx100_EXPRESSIONS(V = _multiply(v, M));
    g_ch.end();
    printf("%s: %s, %g\n", __func__, to_string(V).c_str(), g_ch.calcClockCycles(100 * g_iterations, g_GHz));
}

int main() {
    mat2x2_vxM();
    return 0;
}

Example of measurements, where "v1 = v2;" has 1 clock unit, but "I'm not sure if it's right", nobody told me it's exact, it has 2 instructions ( movaps and another movaps ).

Edit: There is no optimizations, it's [Debug] It's almost impossible for me to build an estimation measurement calculation because I'm building a programming language that needs to estimate the Clock Cycles of an expression.

Answer 1

What I think you want is not easy task at all.

• There is no builtin support for counting clock cycles in C++.
• We are long past time=cycles*frequency era of CPUs, especially with something like Intel's i7.
• If you really want to measure how many clocks a sequence of instructions takes, you cannot do it from an ordinary user-space program because you are at mercy of the scheduler and the many interrupts running there.
• Cache will have huge impact on any memory loads/stores so the context in which the function is called matters a lot.
• Simply running a function in a for loop and averaging the runtime is not guaranteed to work at all. First, the cache can really skew the results compared to a real benchmark. On the other hand, hot paths are likely cached in the benchmark too. Second, you better ensure that ITERx100_EXPRESSIONS is not optimized away by the compiler because as it is written, it absolutely will be if the compiler can prove the repeated X are useless. Since the compiler sees inside _multiply - it touches no globals and takes args by const ref - making it pure, yep that is prime candidate for throwing away not only the repeated X but the loop itself too.

I see no problems* with Chrono itself but due to reasons stated above calcClock is not really meaningful. My advice would be to focus on program design, correctness, and proper encapsulation. Leave performance for the compiler.

*Maybe add a compile check for std::high_resolution_clock::is_steady so you are not surprised later.

Then you should construct a real-world benchmark (or as close as possible) only after that, you can play with changing the implementation and seeing how it impacts the benchmark. Those will be the most important measurements you should care about. You should then look at disassembly and try to explain/learn from those numbers.

I guess you could always look at the disassembly first and refer to instruction latencies and throughputs and calculate a guestimate from that. They should be found in the reference manual for the CPU but that calculation is likely really non-trivial too.