Question

I was thinking about doing a take_timing function that would take the timing of any function passed to it. By any function it means that the arguments this callback takes is unknown by the caller. It would take too the arguments for the callback. But as it doesn’t know how to call it, it would take another callback function, the caller of the callback, written by the function user. The stub would be something like this:

void take_timing(
    void (*callback)(),
    void (*caller(void (*callback)(),void* args_struct),
    void* args_struct
)
{
    // Start timer

    caller(callback,args_struct);

    // Stop timer, read timings, record...
}

void some_caller(void (*callback)(),void* args_struct)
{
    // Cast "callback" to function signature
    // Cast args_struct to some struct with args
    // Call the callback with correct args signature
}

So comes my questions:

1. Is it possible?
2. Can it use variable arguments list to make it simples? How? I am helpless on this…
3. Is there a better way of doing it? Or is it just better to do a take_timing for every specific case?
4. Is there a OOP Design Pattern for this for use with C++?

I myself gave up on this, but put it here out of curiosity, maybe some very useful insights.

Answer 1

Just take a functor as a template argument. Something like:

template<typename F>
nanoseconds take_timing(F f) {

    auto start = high_resolution_clock::now();
    f();
    auto end = high_resolution_clock::now();
    return end - start;
}

long long factorial(int i);

take_timing( [](){factorial(20);} ); // wrap call to function taking arguments in zero-argument lambda