Comment comparer les deux horodateurs en C?

Je suis en train d'écrire un socket programme qui gère les files d'attente FIFO pour deux prises d'entrée. Lorsque vous décidez de la file d'attente de service, le programme tire la plus récente d'horodatage de chaque file d'attente.

J'ai besoin d'une méthode fiable pour la comparaison de deux timeval des structures. J'ai essayé d'utiliser timercmp(), mais ma version de gcc ne le supporte pas, et la documentation indique que la fonction n'est pas conforme à POSIX.

Que dois-je faire?

OriginalL'auteur Vishal Kotcherlakota | 2009-12-07

  1. 5

    googler timeval donner ce premier résultat. À partir de cette page:

    Il est souvent nécessaire de soustraire deux valeurs de type struct timeval ou struct timespec. Ici est la meilleure façon de le faire. Il fonctionne même sur certaines particulier les systèmes d'exploitation où le tv_sec membre a un type non signé.

     /* Subtract the `struct timeval' values X and Y,
    storing the result in RESULT.
    Return 1 if the difference is negative, otherwise 0.  */

 int
 timeval_subtract (result, x, y)
      struct timeval *result, *x, *y;
 {
   /* Perform the carry for the later subtraction by updating y. */
   if (x->tv_usec < y->tv_usec) {
     int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
     y->tv_usec -= 1000000 * nsec;
     y->tv_sec += nsec;
   }
   if (x->tv_usec - y->tv_usec > 1000000) {
     int nsec = (x->tv_usec - y->tv_usec) / 1000000;
     y->tv_usec += 1000000 * nsec;
     y->tv_sec -= nsec;
   }

   /* Compute the time remaining to wait.
      tv_usec is certainly positive. */
   result->tv_sec = x->tv_sec - y->tv_sec;
   result->tv_usec = x->tv_usec - y->tv_usec;

   /* Return 1 if result is negative. */
   return x->tv_sec < y->tv_sec;
 }
    Merci pour l'astuce, mais je suis déjà en utilisant le code. Comme une question de fait, je viens de réaliser que mon problème était. Merci pour le contrôle de Google, c'est probablement la première chose que j'aurais posté une réponse. =)
    Pour clarifier, j'ai réalisé que la timevals ont été initialisés pour avoir tv_sec et tv_usec valeurs de 0. À l'aide de gettimeofday() d'initialiser correctement les files d'attente fixe le problème. Merci pour le soutien. =)
    2AShelly, je voudrais ajouter que, à mon humble avis il est préférable de modifier la deuxième condition, la façon suivante x->tv_usec - y->tv_usec >= 1000000 afin de convertir le temps comme 5/1000000 à 6/0.
    Juste pour que les autres ne pas se faire frapper par le même bug que j'ai fait, sachez que l'appel de cette fonction a une 50-50 chance de modifier le paramètre y, causant la timeval passée dans être modifié.
    Wudn pas de ` int ns = (y->tv_usec - x->tv_usec) / 1000000 + 1;` cette opération toujours mettre nsec = 1 depuis deux y->tv_usec et x->tv_usec sont moins de 1 e6

    OriginalL'auteur AShelly

  2. 11

    timercmp() est juste une macro dans la libc (sys/time.h):

    # define timercmp(a, b, CMP)                                                  \
  (((a)->tv_sec == (b)->tv_sec) ?                                             \
   ((a)->tv_usec CMP (b)->tv_usec) :                                          \
   ((a)->tv_sec CMP (b)->tv_sec))

    Si vous avez besoin d' timersub():

    # define timersub(a, b, result)                                               \
  do {                                                                        \
    (result)->tv_sec = (a)->tv_sec - (b)->tv_sec;                             \
    (result)->tv_usec = (a)->tv_usec - (b)->tv_usec;                          \
    if ((result)->tv_usec < 0) {                                              \
      --(result)->tv_sec;                                                     \
      (result)->tv_usec += 1000000;                                           \
    }                                                                         \
  } while (0)
    Les besoins de la définition de _BSD_SOURCE macro si la compilation sous Linux.

    OriginalL'auteur Gonzalo

  3. 0

    C'est un peu différent, mais je pense que l'illustre clairement la logique.
    Je travaille sur quelques MSP430 code en C, et l'horodatage structure très similaire à timeval, mais avec nsecs au lieu de usecs.

    Ce code permet de tout positif, alors unsigned ints va fonctionner très bien, et évite les débordements (je pense). Il également ne pas modifier le timestamp/timevals être transmis, sauf le résultat bien sûr.

    typedef struct timestamp {
int32_t secs;
int32_t nsecs;
} timestamp_t;
int timestamp_sub(timestamp_t * x, timestamp_t * y, timestamp_t * result){
//returns 1 if difference is negative, 0 otherwise
//result is the absolute value of the difference between x and y
negative = 0;
if( x->secs > y->secs ){
if( x->nsecs > y->nsecs ){
result->secs = x->secs - y->secs;
result->nsecs = x->nsecs - y->nsecs;
}else{
result->secs = x->secs - y->secs - 1;
result->nsecs = (1000*1000*1000) - y->nsecs + x->nsecs;
}
}else{
if( x->secs == y->secs ){
result->secs = 0;
if( x->nsecs > y->nsecs ){
result->nsecs = x->nsecs - y->nsecs;
}else{
negative = 1;
result->nsecs = y->nsecs - x->nsecs;
}
}else{
negative = 1;
if( x->nsecs > y->nsecs ){
result->secs = y->secs - x->secs - 1;
result->nsecs = (1000*1000*1000) - x->nsecs + y->nsecs;
}else{
result->secs = y->secs - x->secs;
result->nsecs = y->nsecs - x->nsecs;
}
}
}
return negative;
}
    Il est préférable d'utiliser entier 1000000000 (ou 1000*1000*1000 si vous préférez) plutôt qu'à virgule flottante 1e9, que l'ancien est susceptible d'être plus efficace.

    OriginalL'auteur travc