Executing a function at specific intervals

Question

The task is to execute a function (say Processfunction()) every x (say x=10) seconds.

With below code, I'm able to call Processfunction() every x seconds.

Question: How to handle the case where the function takes more than 10 seconds to finish execution?

One way would be to have a flag to indicate the end of Processfunction() execution and check for it before calling Processfunction(). Is there a better way to do this ?

---

#include <pthread.h>
#include <unistd.h> // for sleep() and usleep()

void *timerthread(void *timer_parms) {  

  struct itimerspec new_value;
  int max_exp, fd;
  struct timespec now;
  uint64_t exp;
  ssize_t s;

  struct timer_params *p =(struct timer_params*)timer_parms;

  printf("starttimer Start\n");
  /* Create a CLOCK_REALTIME absolute timer with initial
     expiration and interval as specified in command line */
  if (clock_gettime(CLOCK_REALTIME, &now) == -1)
    handle_error("clock_gettime");

  new_value.it_value.tv_sec = now.tv_sec;
  new_value.it_value.tv_nsec = now.tv_nsec + p->tv_nsec;
  new_value.it_interval.tv_sec = p->tv_sec;
  new_value.it_interval.tv_nsec = p->tv_nsec;
  //max_exp = 5; //No of times

  fd = timerfd_create( CLOCK_REALTIME , 0);
  if (fd == -1)
    handle_error("timerfd_create");

  if (timerfd_settime(fd, TFD_TIMER_ABSTIME, &new_value, NULL) == -1)
    handle_error("timerfd_settime");

  printf("timer started\n");

  while(1) // keep checking
  {
    s = read(fd, &exp, sizeof(uint64_t));
    if (s != sizeof(uint64_t))
      handle_error("read");
    Processfunction(); // Say after X seconds call this function
  }
  return NULL;
}

int main() {

  struct timer_params timer_params_obj;
  int res;void *thread_result;
  timer_params_obj.tv_sec = 10; 
  //timer_params_obj.tv_nsec = 10000000  ; //10ms
  timer_params_obj.tv_nsec = 0  ; 

  pthread_t pt;
  pthread_create(&pt, NULL, timerthread, &timer_params_obj);
  // thread is running and will call Processfunction() every 10 sec
}

Answer 1

Why do you need a timer for this?

You could just measure the execution time and take a sleep according to the relation of elapsed time to desired interval duration.

Example:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>

int main() {
    srand(1);
    for (;;) {
        double interval = 10; /* seconds */

        /* start time */
        time_t start = time(NULL);

        /* do something */
        int duration = rand() % 13;
        printf("%2d seconds of work started at %s", duration, ctime(&start));
        sleep(duration);

        /* end time */
        time_t end = time(NULL);

        /* compute remaining time to sleep and sleep */
        double elapsed = difftime(end, start);
        int seconds_to_sleep = (int)(interval - elapsed);
        if (seconds_to_sleep > 0) { /* don't sleep if we're already late */
            sleep(seconds_to_sleep);
        }
    }
    return 0;
}

Output:

$ gcc test.c && ./a.out
 0 seconds of work started at Sun Mar 17 21:20:28 2013
 9 seconds of work started at Sun Mar 17 21:20:38 2013
11 seconds of work started at Sun Mar 17 21:20:48 2013
 4 seconds of work started at Sun Mar 17 21:20:59 2013
 1 seconds of work started at Sun Mar 17 21:21:09 2013
^C