besoin de programmes qui illustrent l'utilisation de settimer et des fonctions d'alarme dans GNU C

Quelqu'un peut-il illustrer l'utilisation de settimer ou la fonction d'alarme dans C de gnu , avec quelques des exemples de programmes ,s'il vous plaît ?

J'ai un programme qui ne cesse de traitement de certaines données , et j'ai besoin de mettre un timer /alarme qui se déclenche toutes les t secondes , à la suite de quoi , j'ai besoin de stocker les données traitées dans un fichier. Ce fichier a écrit asynchrone < c'est à dire le traitement des données et l'écriture de fichier ne doivent pas attendre les uns des autres > . Je suis passé par la Bibliothèque C de GNU pages , mais je ne pouvais pas comprendre beaucoup de choses..

[MODIFIER]

J'ai obtenu ce programme :

#include <stdio.h>
#include <signal.h>
#include <sys/time.h>

#define INTERVAL 1

int howmany = 0;

void alarm_wakeup (int i)
{
   struct itimerval tout_val;

   signal(SIGALRM,alarm_wakeup);

   howmany += INTERVAL;

   printf("\n%d sec up partner, Wakeup!!!\n",howmany);
   tout_val.it_interval.tv_sec = 0;
   tout_val.it_interval.tv_usec = 0;
   tout_val.it_value.tv_sec = INTERVAL; /* 10 seconds timer */
   tout_val.it_value.tv_usec = 0;

   setitimer(ITIMER_REAL, &tout_val,0);

}

void exit_func (int i)
{
    signal(SIGINT,exit_func);
    printf("\nBye Bye!!!\n");
    exit(0);
}

int main ()
{
  struct itimerval tout_val;

  tout_val.it_interval.tv_sec = 0;
  tout_val.it_interval.tv_usec = 0;
  tout_val.it_value.tv_sec = INTERVAL; /* 10 seconds timer */
  tout_val.it_value.tv_usec = 0;
  setitimer(ITIMER_REAL, &tout_val,0);

  signal(SIGALRM,alarm_wakeup); /* set the Alarm signal capture */
  signal(SIGINT,exit_func);

  while (1)
  {
    //printf("!");
  }

  return 0;

}

Mais il me semble que je ne peut rien faire pendant que la minuterie est sur..
Que dois-je modifier pour l'adapter à mes besoins ? Pl suggèrent..
[/EDIT]

OriginalL'auteur trinity | 2010-01-18

8

Voici un exemple de ici qui utilise setitimer() régulièrement appel DoStuff().

La clé ici est que l'appel à setitimer() résultats dans l'OS de la planification d'un SIGALRM à être envoyé à votre processus après le temps spécifié s'est écoulé, et il est de votre programme pour traiter le signal quand il s'agit. Vous gérer le signal par l'enregistrement d'un signal fonction de gestionnaire pour le type de signal (DoStufF() dans ce cas), après quoi le système d'exploitation ne sais d'appeler cette fonction lors de l'expiration de la minuterie.

Vous pouvez lire les setitimer() page de man à comprendre ce que les arguments sont et comment annuler la minuterie.

Remarque: si vous souhaitez que la minuterie pour déclencher qu'une seule fois, vous devrez appeler alarm() ou ualarm() au lieu de setitimer().
```
/*
 * setitimer.c - simple use of the interval timer
 */

#include <sys/time.h>       /* for setitimer */
#include <unistd.h>     /* for pause */
#include <signal.h>     /* for signal */

#define INTERVAL 500        /* number of milliseconds to go off */

/* function prototype */
void DoStuff(void);

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

  struct itimerval it_val;  /* for setting itimer */

  /* Upon SIGALRM, call DoStuff().
   * Set interval timer.  We want frequency in ms, 
   * but the setitimer call needs seconds and useconds. */
  if (signal(SIGALRM, (void (*)(int)) DoStuff) == SIG_ERR) {
    perror("Unable to catch SIGALRM");
    exit(1);
  }
  it_val.it_value.tv_sec =     INTERVAL/1000;
  it_val.it_value.tv_usec =    (INTERVAL*1000) % 1000000;   
  it_val.it_interval = it_val.it_value;
  if (setitimer(ITIMER_REAL, &it_val, NULL) == -1) {
    perror("error calling setitimer()");
    exit(1);
  }

  while (1) 
    pause();

}

/*
 * DoStuff
 */
void DoStuff(void) {

  printf("Timer went off.\n");

}
```
Merci pour qui , comment puis-je modifier cela si je veux que tout d'alarme cours d'exécution en arrière-plan , pendant ce temps je peux traiter des données.. et comme n lorsque l'alarme se déclenche , j'écris quelque chose dans un fichier.. comme je l'ai dit avant , ces deux c'est à dire la transformation et de l'écriture dans un fichier pour être un système..
Merci beaucoup , j'ai fait quelques changements à ce programme et j'ai presque eu ce que je voulais.. ( je vais l'essayer pour la capture de paquets projet sur lequel je travaille actuellement )
Dans votre code, vous finissent par tourner dans main(), donc au lieu de la vider de boucle que vous pourriez faire de votre traitement. Chaque fois que vous obtenez le SIGALRM votre code sera mis en pause et le gestionnaire de signal obtient le contrôle. Une fois que le gestionnaire de signal finitions, votre code continuera à nouveau. Vous pouvez utiliser le gestionnaire de signal pour définir un indicateur indiquant que vous devez écrire dans un fichier, puis vérifiez que l'indicateur dans votre boucle de traitement. Si elle est définie, vous allez écrire dans le fichier et de réinitialiser l'indicateur de faux. Mais cette solution n'est pas asynchrone, c'est à dire l'alarme / gestionnaire de signal ne définir un indicateur plutôt que d'écrire le fichier.
(J'ai couru hors de l'espace au-dessus de), Vous devez être prudent lors de l'écriture du fichier, de sorte que la structure de données que vous écrivez est dans un état cohérent plutôt que d'être modifiée par le processus principal. C'est pourquoi le drapeau-le réglage de la démarche est la bonne.

OriginalL'auteur liwp

Vous devez vous connecter pour publier un commentaire.