Pourquoi le volatile est-il nécessaire en c ?

Question

Pourquoi est-ce que volatile nécessaire en C ? A quoi sert-il ? Que fera-t-il ?

Answer 1

Volatile indique au compilateur de ne pas optimiser tout ce qui a trait à la variable volatile.

Il n'y a qu'une seule raison de l'utiliser : Quand vous vous interfacez avec le matériel.

Disons que vous avez un petit morceau de matériel qui est mappé dans la RAM quelque part et qui a deux adresses : un port de commande et un port de données :

typedef struct
{
  int command;
  int data;
  int isbusy;
} MyHardwareGadget;

Maintenant, vous voulez envoyer une commande :

void SendCommand (MyHardwareGadget * gadget, int command, int data)
{
  // wait while the gadget is busy:
  while (gadget->isbusy)
  {
    // do nothing here.
  }
  // set data first:
  gadget->data    = data;
  // writing the command starts the action:
  gadget->command = command;
}

Cela semble facile, mais cela peut échouer car le compilateur est libre de changer l'ordre dans lequel les données et les commandes sont écrites. Ainsi, notre petit gadget émettrait des commandes avec la valeur de données précédente. Jetez également un coup d'œil à la boucle wait while busy. Celle-ci sera optimisée. Le compilateur essaiera d'être malin, de lire la valeur de isbusy une seule fois et ensuite d'entrer dans une boucle infinie. Ce n'est pas ce que vous voulez.

Le moyen de contourner ce problème est de déclarer le gadget pointeur comme volatile. De cette façon, le compilateur est obligé de faire ce que vous avez écrit. Il ne peut pas supprimer les affectations de mémoire, il ne peut pas mettre en cache les variables dans les registres et il ne peut pas non plus changer l'ordre des affectations :

C'est la version correcte :

   void SendCommand (volatile MyHardwareGadget * gadget, int command, int data)
    {
      // wait while the gadget is busy:
      while (gadget->isbusy)
      {
        // do nothing here.
      }
      // set data first:
      gadget->data    = data;
      // writing the command starts the action:
      gadget->command = command;
    }

Answer 2

volatile en C est en fait apparu dans le but de ne pas mettre automatiquement en cache les valeurs de la variable. Il va dire à la machine de ne pas mettre en cache la valeur de cette variable. Elle prendra donc la valeur de la variable volatile de la mémoire principale à chaque fois qu'il la rencontre. Ce mécanisme est utilisé car à tout moment, la valeur peut être modifiée par le système d'exploitation ou par une interruption. Ainsi, en utilisant volatile nous aidera à accéder à la valeur à chaque fois.

Answer 3

Une autre utilisation de volatile est le traitement des signaux. Si vous avez un code comme celui-ci :

quit = 0;
while (!quit)
{
    /* very small loop which is completely visible to the compiler */
}

Le compilateur est autorisé à remarquer que le corps de la boucle ne touche pas à l'élément quit et convertir la boucle en une while (true) boucle. Même si le quit est définie dans le gestionnaire de signaux pour SIGINT et SIGTERM ; le compilateur n'a aucun moyen de le savoir.

Toutefois, si le quit la variable est déclarée volatile le compilateur est obligé de le charger à chaque fois, car il peut être modifié ailleurs. C'est exactement ce que vous voulez dans cette situation.

Answer 4

volatile indique au compilateur que votre variable peut être modifiée par d'autres moyens que le code qui y accède. Par exemple, il peut s'agir d'un emplacement mémoire mappé en entrée/sortie. Si cela n'est pas spécifié dans de tels cas, certains accès aux variables peuvent être optimisés, par exemple, son contenu peut être maintenu dans un registre, et l'emplacement mémoire n'est pas relu à nouveau.

Answer 5

Voir cet article d'Andrei Alexandrescu, " volatile - le meilleur ami du programmeur multithreadé "

Le site volatile mot-clé a été pour empêcher les optimisations du compilateur compilateur qui pourraient rendre le code incorrect en présence de certains événements asynchrones. Par exemple, si vous déclarez une variable primitive comme volatile le compilateur n'est pas autorisé à le mettre en cache dans un registre -- une optimisation commune qui serait désastreuse si cette variable était partagée entre plusieurs threads. Ainsi, la règle générale est que, si vous avez des variables de type primitif qui doivent être partagées entre plusieurs threads, déclarez ces variables volatile . Mais vous pouvez faire beaucoup plus avec ce mot-clé : vous pouvez l'utiliser pour attraper du code qui n'est pas thread safe, et vous pouvez le faire au moment de la compilation. Cet article montre comment faire ; la solution implique un simple pointeur intelligent qui qui permet également de sérialiser facilement sections critiques du code.

L'article s'applique à la fois C et C++ .

Voir aussi l'article " C++ et les dangers du verrouillage à double vérification " par Scott Meyers et Andrei Alexandrescu :

Ainsi, lorsque l'on traite certains emplacements de mémoire (par exemple, les ports mappés en mémoire ou la mémoire référencée par les ISR [ Interrupt Service Routines ] ), certaines optimisations doivent être suspendues. volatile existe pour spécifier un traitement spécial pour de tels emplacements, en particulier : (1) le contenu d'une variable volatile est "instable" (peut changer par des moyens inconnus du compilateur), (2) toutes les écritures sur les données volatiles sont "observables", elles doivent donc être exécutées religieusement, et (3) toutes les opérations sur les données volatiles sont exécutées dans l'ordre dans lequel elles apparaissent dans le code source. Les deux premières règles garantissent une lecture et une écriture correctes. La dernière permet la mise en œuvre de protocoles d'E/S qui mélangent entrée et sortie. C'est de manière informelle ce que garantit la volatilité du C et du C++.