Function consuming wall time for specific amount of time

Question

I have a function which has a factor that needs to be adjusted according to the load on the machine to consume exactly the wall time passed to the function. The factor can vary according to the load of the machine.

void execute_for_wallTime(int factor, int wallTime) 
{
   double d = 0;
   for (int n = 0; n<factor; ++n)
      for (int m = 0; wall_time; ++m)
        d += d * n*m;
}

Is there a way to dynamically check the load on the machine and adjust the factor accordingly in order to consume the exact wall time passed to the function?

The wall time is read from the file and passed to this function. The values are in micro seconds, e.g:

73
21
44

Answer 1

According to OP comment:

#include <sys/time.h>

int deltaTime(struct timeval *tv1, struct timeval *tv2){
    return ((tv2->tv_sec - tv1->tv_sec)*1000000)+ tv2->tv_usec - tv1->tv_usec;
}
//might require longs anyway. this is time in microseconds between the 2 timevals

void execute_for_wallTime(int wallTime) 
{
    struct timeval  tvStart, tvNow;
    gettimeofday(&tvStart, NULL);

    double d = 0;
    for (int m = 0; wall_time; ++m){
      gettimeofday(&tvNow, NULL);
      if(deltaTime(tvStart,tvNow) >=wall_time) { // if timeWall is 1000 microseconds,
                                                 // this function returns after
                                                 // 1000 microseconds (and a
                                                 // little more due to overhead)
           return;
      }
      d += d*m;
   }
}

Now deal with timeWall by increasing or decreasing it in a logic outside this function depending on your performance calculations. This function simply runs for timeWall microseconds.

For C++ style, you can use std::chrono.

I must comment that I would handle things differently, for example by calling nanosleep(). The operations make no sense unless in actual code you plan to substitute these "fillers" with actual operations. In that case you might consider threads and schedulers. Besides the clock calls add overhead.