Forum Programmation.c petite question....

Posté par angsthase le 12 mai 2005 à 11:26.

Étiquettes : aucune

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 Roger Rabbit le 12 mai 2005 à 11:31. Évalué à -5.

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

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

kikoolol
# explication sommaire

Posté par galactikboulay le 12 mai 2005 à 11:58. É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 abgech le 12 mai 2005 à 13:39. É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 galactikboulay le 12 mai 2005 à 13:53. É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 popopo333 le 12 mai 2005 à 19:37. É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 galactikboulay le 13 mai 2005 à 08:43. É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 popopo333 le 13 mai 2005 à 19:39. É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 galactikboulay le 15 mai 2005 à 22:47. É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 alberthier (site web personnel) le 12 mai 2005 à 15:44. É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 angsthase le 18 mai 2005 à 10:03. É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 à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.