Forum Programmation.c petite question....

Posté par  .
Étiquettes : aucune
0
12
mai
2005
Salut à tous!!!

Je voudrais savoir qu'est ce qu'une variable volatile ?????
Je ne sais pas si j'ai bien compris car je ne vois pas l'intérêt !!!!!

Ce que j'ai compris c'est que c'et une variable qui peut être modifier par autre que le programme lui-même !

Parce que les autres variable ne peuvent pas ???
Le compilateur ne sais pas quel valeur il y a dans la zone mémoire. Il va et prends les valeurs.
Ou c'est une histoire de permission d'accès à la mémoire.

Bref, je ne vois pas là. Si quelqu'un avait la réponse......
Merci
  • # ?????????? !!!!!!!!!!!!!!!!!!

    Posté par  . Évalué à -5.

    ???????????????

    !!!!!!!!!!!!!!!!!!!!!!!

    kikoolol
  • # explication sommaire

    Posté par  . Évalué à 9.

    Cela indique au compilateur qu'à chaque fois qu'il doit faire un accès
    à la variable, il doit aller y accéder réellement en mémoire (et donc
    ne pas utiliser un registre pour la manipuler).

    Par exemple, suppose que tu aies un thread exécutant ce type
    de traitement:


    volatile int running = 1;

    void thread_1(void)
    {
    while(running)
    {
    /* ... */
    }
    }



    Et tu as un 2ème thread qui va modifier la variable "running", en la
    mettant à 0.

    Si la variable "running" n'est pas marquée "volatile", le compilo va
    utiliser un registre dans la fonction thread_1 pour la stocker, et
    ne reconsultera pas la donnée elle-même en mémoire. Ce qui fait
    que si le 2ème thread modifie cette variable, cela n'est pas pris
    en compte.

    Le "volatile" indique donc au compilo que cette valeur peut être
    modifiée de manière "extérieure".
    • [^] # Re: explication sommaire

      Posté par  . Évalué à 3.

      Explication sommaire, en effet.

      Dans l'exemple que tu donnes, il faudrait mieux monter un verrou (ou un sémaphore) pour protéger running.

      L'attribut volatile est plutôt utilisé en contrôle de processus, pour qualifier une variable qui peut être modifiée par du matériel, par exemple, le registre d'un capteur de température. Le compilateur va s'empêcher certaines optimisations dans le but de garantir l'intégrité séquentielle du contenu de la variable, effectivement, la plupart du temps, en rechargeant ystèmatiquement la variable à partir de la mémoire, cela au détriment de la vitesse d'exécution. C'est un attribut qui n'interesse, en principe, que les développement d'applications temps réel ou la réalisation de driver de périphériques. À moins qu'il y ait d'autres domaines d'application, mais je le les connais pas.
      • [^] # Re: explication sommaire

        Posté par  . Évalué à 3.


        Dans l'exemple que tu donnes, il faudrait mieux monter un verrou (ou un sémaphore) pour protéger running.


        Le but de mon exemple était de montrer de manière simple comment
        le comportement optimisant d'un compilateur peut être pénalisant
        lorsqu'une variable est modifiée de manière extérieure.

        Le but n'était pas de faire une démonstration de programmation
        multi-thread super bien ficelée (encore que, je ne vois pas trop ce
        qu'on peut reprocher à cet exemple, et en quoi un verrou réglerait
        le problème).

        Cela dit, tu as tout à fait raison de signaler que "volatile" est très
        utile pour gérer le matériel.

        En cherchant rapidement sur google, j'ai trouvé ceci:

        http://www.programmersheaven.com/articles/pathak/article1.htm(...)

        Cela résume assez bien les différents cas que l'on peut rencontrer
        (programmation multithread, traitement d'interruptions, devices
        utilisant du "memory-mapped I/O", ...)
        • [^] # Re: explication sommaire

          Posté par  . Évalué à 2.

          (encore que, je ne vois pas trop ce qu'on peut reprocher à cet exemple

          je crois que c'est surtout que dans ton exemple le volatile apporte pas grand chose.
          ca marche en gros aussi bien sans.
          • [^] # Re: explication sommaire

            Posté par  . Évalué à 1.

            Essaie sans, tu verras bien si ça marche ou non.

            J'ai donné cet exemple parce que j'y ai été confronté dans la vie réelle.
            Et "volatile" a bien réglé mon problème.
            • [^] # Re: explication sommaire

              Posté par  . Évalué à 1.

              je viens d'essayer :
              #include <pthread.h>
              
              int running = 1;
              
              void* thread_1(void* p) 
              {
              	while(running) {
              		printf("thread : salut\n");
              		sleep(2);
              	}
              	printf("thread : ok d'accord...\n");
              }
              
              int main() 
              {
              	pthread_t* t;
              	t = (pthread_t*)malloc(sizeof(pthread_t));;
              	pthread_create(t,NULL,thread_1,NULL);
              	sleep(10);
              	printf("main : bon tu t'arretes maintenant!\n");
              	running=0;
              	sleep(100);
              }
              
              
              le resultat :
              $ ./test
              thread : salut
              thread : salut
              thread : salut
              thread : salut
              thread : salut
              main : bon tu t'arretes maintenant!
              thread : ok d'accord...
              
              
              ca me parait bien.
              • [^] # Re: explication sommaire

                Posté par  . Évalué à 3.

                Ok, et cet exemple là ça marche aussi: ?


                #include <pthread.h>

                int running = 1;

                void* thread_1(void* p)
                {
                int a = 0,c = 1;

                while(running) {
                //printf("thread : salut\n");
                //sleep(2);
                a++;
                c = a * c * c;
                }
                printf("thread : ok d'accord, c = %d...\n",c);
                }

                int main()
                {
                pthread_t* t;
                t = (pthread_t*)malloc(sizeof(pthread_t));;
                pthread_create(t,NULL,thread_1,NULL);
                sleep(10);
                printf("main : bon tu t'arretes maintenant!\n");
                running=0;
                sleep(100);
                }


                Compilé avec -O3.

                Extrait du code assembleur généré (rajouter l'option -S sur la
                ligne de commande de gcc):


                .globl thread_1
                .type thread_1, @function
                thread_1:
                pushl %ebp
                xorl %ecx, %ecx
                movl %esp, %ebp
                pushl %ebx
                movl $1, %edx
                subl $20, %esp
                movl running, %ebx
                testl %ebx, %ebx
                je .L8
                .p2align 4,,15
                .L6:
                incl %ecx
                movl %ecx, %eax
                imull %edx, %eax
                imull %eax, %edx
                testl %ebx, %ebx
                jne .L6
                .L8:
                movl %edx, 4(%esp)
                movl $.LC1, (%esp)
                call printf
                addl $20, %esp
                popl %ebx
                popl %ebp
                ret


                On voit ici que la boucle, située entre .L6 et .L8 ne recharge PAS
                le contenu de la variable running.

                Donc, ne pas faire de généralisation abusive à partir d'un seul
                exemple.
  • # Programmation de microcontrôleurs

    Posté par  (site Web personnel) . Évalué à 2.

    J'ai vu ce mot clé utilisé pour la programmation de microcontrôleurs :
    Un microcontrôleurs possède des ports = pattes du composant. Ces ports peuvent être configurés en entrée.
    Ces ports sont souvent des groupes de 8 pattes et sont mappées en mémoire, cad les bits de l'octet à cette adresse mémoire représente l'état logique de chaque patte du port.

    Nous sommes donc dans un cas où le contenu d'une adresse mémoire peut être modifiée par autre chose que le programme.

    Pour programmer ces microcontrôleurs en C, on utilise donc le mot clé volatile.
    • [^] # Merci

      Posté par  . Évalué à 1.

      Merci pour vos réponse.

      On m'avais conseiller sur internet d'utiliser ces variables, car je veut communiquer avec le port série....

      Alors merci à tous pour vos réponse...

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n’en sommes pas responsables.