Appel d'une fonction pendant un certain temps

Question

Je souhaite passer un appel - soit un appel de fonction, soit une condition pendant une PÉRIODE de temps ... en général 10 - 20 secondes.

J'obtenir des commentaires d'utilisateur pour la quantité de temps et faire ...

Quelle est la fonction propre à utiliser sur les systèmes Linux/Unix? Gettimeofday semble être le chemin à parcourir ... ou peut-être time_t time (time_t * t) ... semble simple. Qu'est-ce qui est préféré?

Answer 1

Cela peut être fait comme si

#include <ctime> 
/* 
your function here 
*/ 

    int main() 
    { 
     double TimeToRunInSecs = ...; 
     clock_t c = clock(); 
     while(double(clock()-c)/CLOCKS_PER_SEC < TimeToRunInSecs) 
     { 
      myFunc(); 
     } 
    } 

la fonction horloge standard() retourne le nombre de quelque chose dès le début du processus. En une seconde il y a CLOCK_PER_SEC Somethings :)

HTH

Answer 2

je pouvais faire un

time_t current_time = time(0);

et la mesure hors de ... mais est-il un moyen préféré ... surtout cette est une des meilleures pratiques genre de question ....

x

Answer 3

Ainsi est-il quelque chose comme ça que vous voulez? Cela appellera à plusieurs reprises myfunc() pour les 20 prochaines secondes. Alors, pourrait faire 1 appel (si myfunc prend au moins 20 secondes pour exécuter) ou des centaines d'appels (de myfunc() prend quelques millisecondes pour compléter):

#include <time.h> 

void myfunc() 
{ 
    /* do something */ 
}  

int main() 
{ 
    time_t start = time(NULL); 
    time_t now = time(NULL); 
    while ((now - start) <= 20) { 
     myfunc(); 
     time_t now = time(NULL); 
    } 
} 

Il est probablement utile de se demander ce que vous finalement essayer atteindre. Si c'est pour le profilage (par exemple, quel est le temps moyen que la fonction f prend pour exécuter), alors vous pouvez regarder d'autres solutions - par exemple, en utilisant le profilage intégré que gcc vous donne (lors de la construction du code avec le -pg "option), et l'analyse avec gprof.

Answer 4

Couple de choses ..

Si vous voulez vous assurer que la fonction prend un temps X pour terminer, quelle que soit la durée du code réel au sein de la fonction a, quelque chose comme ça (code très pseudo)

class Delay 
{ 
    public: 
    Delay(long long delay) : _delay(delay) // in microseconds 
    { 
     ::gettimeofday(_start, NULL); // grab the start time... 
    } 

    ~Delay() 
    { 
     struct timeval end; 

     ::gettimeofday(end, NULL); // grab the end time 
     long long ts = _start.tv_sec * 1000000 + _start.tv_usec; 
     long long tse = end.tv_sec * 1000000 + end.tv_usec; 

     long long diff = tse - ts; 
     if (diff < _delay) 
     { 
     // need to sleep for the difference... 
     // do this using select; 
     // construct a struct timeval (same as required for gettimeofday) 
     fd_set rfds; 
     struct timeval tv; 
     int retval; 

     FD_ZERO(&rfds); 

     diff = _delay - diff; // calculate the time to sleep 

     tv.tv_sec = diff/1000000; 
     tv.tv_usec = diff % 1000000; 

     retval = select(0, &rfds, NULL, NULL, &tv); 
     // should only get here when this times out... 
     } 
    } 
    private: 
    struct timeval _start; 
}; 

Définissez ensuite une instance de cette classe de retard dans la partie supérieure de votre fonction de retarder - devrait faire l'affaire ... (ce code est non testé et pourrait avoir des bugs en elle, je viens dactylographié pour vous donner une idée ..)