Modifier variable périodiquement

Version imprimable

21/04/2008, 05h37
MarronSuisse

Modifier variable périodiquement

Bonjour,

J'aimerais incrémenter périodiquement une certaine variable au cours de l'exécution de mon programme.
Typiquement, le programme appelle régulièrement une certaine fonction, grâce à la fonction alarm() et l'utilisation d'un handler. Or j'aimerai compter le nombre de fois où cette fonction handler est appelée.
Or j'ai lu qu'il n'était pas bon de modifier des variables globales à partir du handler, et que celui-ci devait agir de manière confinée (pas d'interaction avec les variables du programme).

Alors, comment faire ? Existe-t-il une solution ?

Merci.
21/04/2008, 05h58
MarronSuisse

En fait mon problème est même d'ordre plus général :

comment effectuer, à intervalles de temps réguliers, un certain traitement, qui implique la lecture de variables du programme, et à moindre mesure l'écriture (uniquement incrémenter un compteur), et ce de manière asynchrone.
C'est à dire que le programme peut très bien être en train de calculer ou en attente de message, etc...
21/04/2008, 08h46
ram-0000

Lorsque 2 threads ou plus tentent d'accèder à une même variable, il faut protéger la variable.

Dans ton cas, tes 2 threads sont le programme principal et le handler de traitement des signaux

Pour protéger ta variable, il y a plein de possibilités, la plus simple étant probablement la section critique.
21/04/2008, 09h01
Emmanuel Delahaye

Citation:

Envoyé par MarronSuisse

En fait mon problème est même d'ordre plus général :

comment effectuer, à intervalles de temps réguliers, un certain traitement, qui implique la lecture de variables du programme, et à moindre mesure l'écriture (uniquement incrémenter un compteur), et ce de manière asynchrone.
C'est à dire que le programme peut très bien être en train de calculer ou en attente de message, etc...

http://emmanuel-delahaye.developpez.com/pthreads.htm
21/04/2008, 09h34
MarronSuisse

Arg, je pensais pouvoir éventuellement pouvoir me passer des threads puisque le traitement n'a pas nécessairement besoin d'être effectué en parallèle, mais apparemment y'a pas trop le choix :pleure:

Je sais ce qu'il me reste à faire..

Si tu peux te passer des threads :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
 
void handler (int);
 
static volatile sig_atomic_t var = 0;
 
int main (void)
{
   signal (SIGALRM, handler);
 
   for (int i = 0; i < 10000; i++)
   {
      var++;
      if (i % 1000 == 0)
         raise (SIGALRM);
   }
 
   printf ("resulat attendu : 10010\n"
           "resultat obtenu : %d\n"
           "%s\n", var, 10010 == var ? "success" : "fail");
   return 0;
}
 
void handler (int sig)
{
   var++;
   signal (SIGALRM, handler);
}

Citation:

Envoyé par nicolas.sitbon

Si tu peux te passer des threads :

Etait-il précisé 'sous unixoïde' ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
Project   : Forums
Compiler  : GNU GCC Compiler (called directly)
Directory : D:\dev\forums\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
main.c: In function `main':
main.c:11: error: `SIGALRM' undeclared (first use in this function)
main.c:11: error: (Each undeclared identifier is reported only once
main.c:11: error: for each function it appears in.)
main.c:13: error: 'for' loop initial declaration used outside C99 mode
main.c: In function `handler':
main.c:29: error: `SIGALRM' undeclared (first use in this function)
main.c: At top level:
main.c:26: warning: unused parameter 'sig'
Process terminated with status 1 (0 minutes, 1 seconds)

C'est marrant je m'attendais à une telle remarque, du moins pour le signal SIGALRM puisque le reste n'a rien à voir avec UNIX.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdio.h>
#include <signal.h>
 
void handler (int);
 
static volatile sig_atomic_t var = 0;
 
int main (void)
{
   signal (SIGINT, handler);
 
   for (int i = 0; i < 10000; i++)
   {
      var++;
      if (i % 1000 == 0)
         raise (SIGINT);
   }
 
   printf ("resulat attendu : 10010\n"
           "resultat obtenu : %d\n"
           "%s\n", var, 10010 == var ? "success" : "fail");
   return 0;
}
 
void handler (int dummy)
{
   var++;
   signal (SIGINT, handler);
}

21/04/2008, 13h51
valefor

Le "sig_atomic_t" et le pourquoi du volatile sont expliqués dans le manuel de la glibc par exemple.
21/04/2008, 14h03
nicolas.sitbon

Je dirais même mieux, tout cela est expliqué dans la norme (7.14 Signal handling <signal.h>).
22/04/2008, 04h08
MarronSuisse

Merci beaucoup pour vos infos, je vais piocher un peu partout!
J'ai toujours craint les threads mais ça a pas l'air si compliqué que ça finalement.

Bonne continuation à vous
22/04/2008, 07h56
MarronSuisse

J'ai découvert la fonction setitimer qui correspond exactement à ce dont j'avais besoin : elle permet l'envoi du signal SIGALRM à un intervalle de temps choisi, ce qui permet d'exécuter périodiquement une action en parallèle de l'exécution du programme.

Sauf que j'aimerais exécuter plusieurs traitements périodiques (de période différente). Or setitimer ne permet que d'envoyer le signal SIGALRM, donc il n'y a pas moyen de distinguer quel traitement appliquer lors de la réception du signal. Existe-t-il une fonction qui permettrait d'envoyer périodiquement un autre type de signal, pour pouvoir associer un traitement différent à chaque signal périodique ?
22/04/2008, 08h05
nicolas.sitbon

timer_create() + signaux temps réels, feront ce que tu demandes.
22/04/2008, 12h19
souviron34

bah sinon setitimer ou SIGALRM et tu gères dans un petit tableau les différents cas.. Pas si compliqué que ça..
:D
23/04/2008, 03h28
MarronSuisse

Je me suis renseigné, la plateforme vers laquelle sera porté le code ne supporte pas les signaux temps réels...

Citation:

bah sinon setitimer ou SIGALRM et tu gères dans un petit tableau les différents cas.. Pas si compliqué que ça..

Au risque de paraître totalement stupide... : je ne vois pas comment !
Puisqu'on ne peut définir qu'une seule alarme avec setitimer. Lorsqu'on rappelle setitimer, la nouvelle alarme périodique remplacera la première.
De plus, quand bien même on pourrait définir plusieurs alarmes de périodes différentes, comment savoir dans le handler de quelle alarme le signal provient ? Puisque l'alarme ne peut transporter aucune information avec elle !

:?

facile..

Tu fais un petit tableau de structures dans lequel tu stockes tes infos :

Intervalle
Fonction à appeler
Data à passer

Du style

Code:

1
2
3
4
5
6
typedef struct pMyTimer {
       int Intervalle ;
       int NextCall ; 
       int *Fct ;
       void *Data ;
}  MyTimer ;

(dans ce cas les fonctions à appeler sont du style

Code:

int Fonction(void *Data)

)

Puis tu déclares dans ton module :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
MyTimer *MyTimers ;
int          NTimers=0 ;

....

RegisterTimer ( int intervalle, int FirstCall, (int *)&MaFonction, (void *)MyData )
{
    /* Reallocation de la structure */
 
    MyTimers[NTimers].Intervalle = intervalle ;
     ......

    /* Et ici tu appelles une routine qui re-calcule le nouveau prochain
     *  declenchement, en passant à travers tous les timers, calculant le
     * plus proche , settant le setitimer avec ce chiffre. et calculant la 
     * date du prochain appel pour chacun (NextCall). 
     */ 
    RecomputeTimer ();
}

void RecomputeTimer ( void )
{
  int i, MinTime=INT_MAX;
  time_t now ;

  now = time(NULL); /* Pour une precision a la seconde */
   /* Pour une précision à la micro, voir ma fonction dans les sources */

   for ( i = 0 ; i < NTimers ; i++ )
    {
       if ( Timers[i].NextCall <= now ) /* Voir remarque plus haut */
         {
             /* Appelle la fonction pour ce timer */ 
            .........

           /* Calcule le prochain appel */
          Timers[i].NextCall  =  Timers[i].NextCall + Timers[i].Intervalle ;

           /* Verifie si ce sera le prochain a appeler */
           if ( Timers[i].NextCall < MinTime )
              MinTime = Timers[i].NextCall ;
         }
        else
        {
            /* Pour ceux qui n'ont pas expire, verifie aussi si c'est le prochain */
           if ( Timers[i].NextCall < MinTime )
              MinTime = Timers[i].NextCall ;
        }
    }

   /* Et la reset le timer general */
    setitimer ( ....);
}

pas compliqué :D

et ton signal-handler ne fait qu'appeller cette routine RecomputeTimer();

23/04/2008, 05h15
MarronSuisse

Hmm ok ça commence à rentrer !

Merci pour ton aide, je n'aurais sans doute pas pensé à cette astuce de moi-même...

Bonne continuation.

Citation:
Envoyé par souviron34
Code:

1 2 3 4 5 6 typedef struct pMyTimer { int Intervalle ; int NextCall ; int *Fct ; void *Data ; } MyTimer ;
(dans ce cas les fonctions à appeler sont du style

Code:

int Fonction(void *Data)

)
Il me semble que le comportement est indéterminé dans ce cas là souviron34. Il faudrait plutôt faire :
Code:

1 2 3 4 5 6 typedef struct pMyTimer { int Intervalle ; int NextCall ; int (*Fct)(void*) ; void *Data ; } MyTimer ;
Qu'en penses tu?

23/04/2008, 12h52
souviron34
Citation:
Envoyé par nicolas.sitbon

Il me semble que le comportement est indéterminé dans ce cas là souviron34. Il faudrait plutôt faire :

Code:

1 2 3 4 5 6 typedef struct pMyTimer { int Intervalle ; int NextCall ; int (*Fct)(void*) ; void *Data ; } MyTimer ;

Qu'en penses tu?
bah c'était un exemple..

En général j'aurais fait un typedef d'une fonction, et j'aurais mis cette définition dans la structure..

Mais je voulais pas compliquer inutilement.

Sinon oui ta solution est bonne :D
23/04/2008, 13h05
nicolas.sitbon

Citation:

Envoyé par souviron34

bah c'était un exemple..

Ah ok.

Citation:

Envoyé par souviron34

En général j'aurais fait un typedef d'une fonction, et j'aurais mis cette définition dans la structure..

J'aurais fais la même chose (plus lisible dans la plupart des cas). +1