L'exécution d'une fonction à intervalles spécifiques

La tâche est d'exécuter une fonction (dire Processfunction()) tous les x (par exemple x=10) secondes.

Avec le code ci-dessous, je suis en mesure d'appeler Processfunction() toutes les x secondes.

Question: Comment gérer le cas où la fonction prend plus de 10 secondes à la fin de l'exécution?

Un autre moyen serait d'avoir un drapeau pour indiquer la fin de Processfunction() d'exécution et de les vérifier avant d'appeler Processfunction().
Est-il une meilleure façon de le faire ?

#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
}
vous ne voulez pas avoir deux Processfunction() cours d'exécution en même temps? Préférez-vous voulez retarder l'invocation ou de passer un appel dans le cas d'un temps d'exécution plus long de temps que la durée de l'intervalle normalement permettrait?
Oui,je ne veux pas le faire fonctionner en même temps. Je veux sauter/en cas de retard de plus de temps d'exécution.

OriginalL'auteur m4n07 | 2013-03-17

  1. 4

    Pourquoi avez-vous besoin d'une minuterie pour cela?

    Vous pourrait il suffit de mesurer le temps d'exécution et de prendre un sommeil selon la relation de temps écoulé jusqu'à la durée de l'intervalle.

    Exemple:

    #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;
}

    De sortie:

    $ 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
    +1 - oui, c'est la façon dont je le ferais. Les minuteries sont souvent utilisées de façon inappropriée 🙁
    Cela peut être fait sans linux code spécifique (boost ou c++11) et sans dort-il? Le programme a d'autres choses à faire en attendant.
    Vous pouvez utiliser Boost.Asio de la date limite des minuteries de manière asynchrone attendre un moment précis. Vous pourriez avoir besoin de restructurer votre code un peu à cause de l'asynchrone flux de programme (si ce n'est pas déjà le cas).
    ouais c'est une bonne façon d'aller à ce sujet aussi, j'ai utilisé avant. Cependant, je voulais mettre le code dans un très petit exemple et je trouve que le typique développeur a du mal à saisir asio immédiatement donc je voulais éviter une trop grande complexité. J'ai mis la solution je suis allé dans une autre réponse ci-dessous au cas où quelqu'un d'autre vient à travers ce qui ne peuvent pas utiliser la accepté de répondre à ses dépendances.

    OriginalL'auteur moooeeeep

  2. 1

    J'ai eu presque le même cas d'utilisation sauf que moi j'ai besoin de la croix-plate-forme de C++11 et besoin de faire d'autres tâches en attendant, plutôt que de dormir. Voici mon code au cas où il est utile à quelqu'un:

    #include <iostream>
#include <chrono>

///Tracks the time since execution() was called, and only
///Calls the passed function if the minimum time interval has elapsed
///@see https://stackoverflow.com/questions/2808398/easily-measure-elapsed-time for the code I based this on
template<typename TimeT = std::chrono::milliseconds>
struct periodic
{
    periodic(TimeT duration = TimeT(1)):
    start(std::chrono::system_clock::now()),
    period_duration(duration),
    previous_duration(TimeT::zero())
    {};

    template<typename F, typename ...Args>
    TimeT execution(F func, Args&&... args)
    {
        auto duration = std::chrono::duration_cast< TimeT>
                            (std::chrono::system_clock::now() - start);
        if(duration > previous_duration + period_duration)
        {
            std::forward<decltype(func)>(func)(std::forward<Args>(args)...);
            previous_duration = duration;
        }
        return duration;
    }

    std::chrono::time_point<std::chrono::system_clock> start;
    //The minimum duration to wait before the function can be called again
    TimeT period_duration;
    //The duration between startup and the last time the function was called
    TimeT previous_duration;
};

    Voici un exemple d'utilisation:

    int main(int argc, char* argv[])
{

     periodic<> callIfMinPeriodPassed(std::chrono::milliseconds(1));
     std::size_t num_periods;

     while(true)
     {
          callIfMinPeriodPassed.execution( [&num_periods]()
          {
                  std::cout << ++num_periods << "timesteps have passed\n"
          });
          //do other stuff here, this example will work
          //but spins at 100% CPU without the sleep
          std::this_thread::sleep_for(std::chrono::milliseconds(1));
     }

}

    Cette mise en œuvre est basée sur une modification de cette stackoverflow question à propos de la mesure du temps écoulé.

    OriginalL'auteur Andrew Hundt