Question

Given a while loop and the function ordering as follows:

int k=0;
int total=100;
while(k<total){
   doSomething();
   if(approx. t milliseconds elapsed) { measure(); }
   ++k;
}

I want to perform ‘measure’ every t-th milliseconds. However, since ‘doSomething’ can be close to the t-th millisecond from the last execution, it is acceptable to perform the measure after approximately t milliseconds elapsed from the last measure.
My question is: how could this be achieved?

One solution would be to set timer to zero, and measure it after every ‘doSomething’. When it is withing the acceptable range, I perform measures, and reset. However, I’m not which c++ function I should use for such a task. As I can see, there are certain functions, but the debate on which one is the most appropriate is outside of my understanding. Note that some of the functions actually take into account the time taken by some other processes, but I want my timer to only measure the time of the execution of my c++ code (I hope that is clear). Another thing is the resolution of the measurements, as pointed out below. Suppose the medium option of those suggested.

Answer 1

High resolution timing is platform specific, and you have not specified in the question. The standard library clock() function returns a count that increments at CLOCKS_PER_SEC per second. On some platforms this may be fast enough to give you the resolution you need but you should check your system’s tick rate since it is implementation defined. However if you find it is high enough then:

#define SAMPLE_PERIOD_MS 100
#define SAMPLE_PERIOD_TICKS ((CLOCKS_PER_SEC * SAMPLE_PERIOD_MS) / 1000)

int k=0;
int total=100;
clock_t measure_time = clock() + SAMPLE_PERIOD_TICKS  ;
while(k<total)
{
   doSomething();
   if( clock() - measure_time > 0 )
   { 
        measure(); 
        measure_time += SAMPLE_PERIOD_TICKS ;
        ++k;
   }
}

You might replace clock() with some other high-resolution clock source if necessary.

However note a couple of issues. This method is a “busy-loop”; unless either doSomething() or measure() yield the CPU, the process will take all the cpu cycles it can. If this is the only code running on a target, that may not matter. On the other hand is this is running on a general purpose OS such as Windows or Linux which are not real-time, the process may be pre-empted by other processes, and this may affect the accuracy of the sampling periodicity. If you need accurate timing use of an RTOS and performing doSomething() and measure() in separate threads would be better. Even in a GPOS that would be better. For example a general pattern (using a made-up API in teh absence of any specification) would be:

int main()
{
    StartThread( measure_thread, HIGH_PRIORITY ) ;
    for(;;)
    {
        doSomething() ;
    }
}

void measure_thread()
{
    for(;;)
    {
        measure() ;
        sleep( SAMPLE_PERIOD_MS ) ;
    }
}

The code for measure_thread() is only accurate if measure() takes a negligible time to run. If it takes significant time you may need to account for that. If it is non-deterministic, you may even have to measure its execution time in order to subtract it the sleep period.