Pourquoi est-volatils pas jugé utile multithread programmation C ou C++?

Comme l'a démontré cette réponse j'ai posté, j'ai l'impression d'être confus au sujet de l'utilité (ou l'absence) de volatile en multi-thread contexte de programmation.

Ma compréhension est ceci: toutes les fois qu'une variable peut être modifiée à l'extérieur du flux de contrôle d'un morceau de code en y accédant, cette variable doit être déclarée volatile. Les gestionnaires de signaux I/O registres, et les variables modifiées par un autre thread constituent de telles situations.

Donc, si vous avez un mondial int foo, et foo est lu par un thread et de définir automatiquement par un autre thread (probablement à l'aide d'une instruction machine), le thread de lecture, voit dans cette situation de la même manière, il voit une variable tordu par un gestionnaire de signal ou modifié par un matériel externe condition et, par conséquent foo doit être déclarée volatile (ou, pour le multithread situations, accessible avec la mémoire clôturé la charge, ce qui est probablement une meilleure solution).

Comment et où ai-je tort?

Tous les volatiles n'est dire que le compilateur ne doit pas mettre en cache l'accès à une variable volatile. Il ne dit rien sur serialising un tel accès. Cela a été discuté ici, je ne sais pas combien de fois, et je ne pense pas que cette question va rien ajouter à ces discussions.
Et encore une fois, une question qui ne le mérite pas, et il a été demandé à de nombreuses reprises avant de obtient upvoted. Vous s'il vous plaît arrêter de faire cela.
J'ai cherché d'autres questions, et trouvé un, mais tout existant explication que j'ai vu en quelque sorte de ne pas déclencher ce dont j'avais besoin pour vraiment comprendre pourquoi j'ai eu tort. Cette question a suscité une telle réponse.
Pour une grande étude en profondeur sur ce que les Processeurs faire avec des données (par l'intermédiaire de leurs caches) départ: rdrop.com/users/paulmck/scalability/paper/whymb.2010.06.07c.pdf
En Java volatile crée une barrière de mémoire lorsqu'il est lu, de sorte qu'il peut être utilisé comme un des threads du pavillon qu'une méthode est terminée depuis qu'il applique un passe-avant relation avec le code avant que le drapeau a été défini. Ce n'est pas le cas en C.
Java volatile n'a rien à voir avec le C/C++ volatile: Java volatile est définie à l'intérieur du modèle de langage, peut être transformé, optimisé (écrire suivie par la lecture de Java volatiles peuvent être optimisés pour écrire) et de la volatilité complètement éliminé si la volatilité de la variable est prouvable pas partagées entre les threads. En C/C++ volatile est à l'extérieur du modèle de langage, les opérations à la volatilité des objets peuvent avoir des effets visible pour les autres appareils, par définition, pas de transformation de la volatilité est possible, pas même une lecture dont le résultat est ignoré peut être éliminé. Ils n'ont pas le même but.
C'est ce que je voulais dire par "pas le cas en C", où il peut être utilisé pour écrire dans les registres de matériel, etc., et n'est pas utilisé pour le multithreading, comme il est couramment utilisé dans Java.

InformationsquelleAutor Michael Ekstrand | 2010-03-20

c c++c++-faq multithreading volatile

205

Le problème avec volatile dans un contexte multithread est qu'il ne fournit pas tous les garanties dont nous avons besoin. Il possède quelques propriétés dont nous avons besoin, mais pas tous d'entre eux, de sorte que nous ne pouvons pas compter sur volatile seul.

Cependant, les primitives que nous aurions à utiliser pour le restant propriétés fournissent également ceux qui volatile fait, donc c'est effectivement inutile.

Thread-safe accès aux données partagées, nous avons besoin d'une garantie que:
- la lecture/écriture qui se passe réellement (que le compilateur ne sera pas seulement de stocker la valeur dans un registre, au lieu et à reporter la mise à jour de la mémoire principale jusqu'à ce que bien plus tard).
- qu'aucune réorganisation a lieu. Supposons que nous utilisons un volatile variable comme un drapeau pour indiquer si oui ou non certaines données est prêt à être lu. Dans notre code, nous avons tout simplement mis le drapeau après la préparation des données, de sorte que tous semble amende. Mais que faire si les instructions sont réorganisés de sorte que le drapeau est réglé première?
volatile ne garantit pas le premier point. Il garantit également qu'aucune réorganisation se produit entre les différents volatiles des lectures/écritures. Tous les volatile les accès à la mémoire se fera dans l'ordre dans lequel ils sont spécifiés. C'est tout ce dont nous avons besoin pour ce volatile est prévu pour: manipuler les I/O de registres ou de matériel mappé en mémoire, mais il ne nous aide pas dans le code multithread, où la volatile objet est souvent utilisé pour synchroniser l'accès à des données non volatile. Ces accès peuvent toujours être réorganisées par rapport à la volatile ceux.

La solution pour la prévention de la réorganisation est d'utiliser un barrière de mémoire, qui indique à la fois pour le compilateur et le CPU qui pas d'accès à la mémoire peuvent être réorganisées à l'échelle de ce point de. Placer ces barrières autour de notre volatile variable permet de garantir que même les non-volatile accède à ne pas être réorganisées à travers le volatil, ce qui nous permet d'écrire thread-safe code.

Cependant, les barrières de la mémoire aussi s'assurer que tous dans l'attente de lectures/écritures sont exécutés lorsque la barrière est atteinte, donc effectivement nous donne tout ce dont nous avons besoin par lui-même, en faisant volatile inutiles. On peut tout simplement supprimer le volatile qualifier entièrement.

Depuis C++11, atomique variables (std::atomic<T>) de nous donner toutes les garanties correspondantes.
- Merci. Le morceau qui me manquait dans ma compréhension, aussi loin que je peux dire, est que la volatilité ne pas garantir l'absence de réorganisation avec les pays voisins de la mémoire non volatile d'accès, ce qui est nécessaire pour la atomique drapeau-réglage de cas d'utilisation.
- Est-il vraiment de garantir l'ordre, et interdire l'utilisation de valeurs en cache ou ne le fait qu'au niveau du compilateur? Si l'ancien était vrai, vous pourriez peut-être écrire portable de synchronisation de thread, mais tout le code que j'ai vu utilise CPU-instructions spécifiques et suppose que le CPU va réorganiser tout.
- Qui "il" me demandez-vous environ? Volatiles ou les barrières de la mémoire? Dans tous les cas, la réponse est à peu près la même. Ils ont tous les deux de travailler à la fois au compilateur et de la CPU, car ils décrivent les comportements observables du programme --- donc, ils doivent s'assurer que le CPU n'est pas réorganiser tout, changer le comportement qu'ils garantissent. Mais vous ne pouvez pas écrire portable de synchronisation de thread, parce que les barrières de la mémoire ne font pas partie de la norme C++ (donc ils ne sont pas portables), et volatile n'est pas assez fort pour être utile.
- MSDN exemple de cela, et prétend que les instructions ne peuvent pas être réorganisées passé un volatile d'accès: msdn.microsoft.com/en-us/library/12a04hfd(v=vs. 80).aspx
- Mais Microsoft compilateur redéfinit volatile une véritable barrière de mémoire (prévention de la réorganisation). Qui ne fait pas partie de la norme, de sorte que vous ne pouvez pas compter sur ce problème dans un code portable.
- Alors, comment ne les barrières de la mémoire de l'aide quand il y a l'accès simultané de plusieurs Processeurs?
- En bref, le CPU et le compilateur de la magie (et oui, il vous faut les deux pour que cela fonctionne). Une barrière de mémoire est un PROCESSEUR d'instructions qui est conçu pour résoudre ce problème. Il interagit avec le bus mémoire, en s'assurant qu'aucune autre base peut lire/écrire la mémoire jusqu'à ce que la barrière a fini de faire sa chose, et le CPU ne sait pas pour réorganiser les accès à la mémoire à travers elle. Il ne peut pas vraiment faire des émules dans le logiciel.
- Mais vous auriez encore besoin de le mot clé volatile pour assurer la valeur perçue par le code de la valeur en mémoire. Sans elle, il ne pouvait pas l'optimiseur de cache de la valeur dans un registre? Le problème devient alors l'un des accès simultanés.
- non, c'est là que le compilateur de la magie" une partie de l'équation est en. Une barrière de mémoire doit être compris par les deux le CPU et le compilateur. Si le compilateur comprend la sémantique d'une barrière de mémoire, il sait éviter les trucs comme ça (ainsi que la réorganisation des lectures/écritures à travers la barrière). Et heureusement, le compilateur t comprendre la sémantique d'une barrière de mémoire, donc en fin de compte, tout fonctionne. 🙂
- Alors, comment avez-vous préciser quand une barrière de mémoire est nécessaire? Le compilateur n'a aucun moyen de savoir si le code doit être exécuté sur un seul core/thread ou plusieurs cores/threads. L'optimiseur serait registerise valeurs dans la mesure du possible, qui serait un échec si les deux noyaux ont été d'accéder aux données simultanément, étant donné que chaque thread/core a son propre registre stockées version de la valeur. Sans 'volatile' le compilateur va certainement se tromper.
- Je ne suis pas sûr de comprendre. Vous spécifiez une barrière de mémoire en utilisant selon la valeur intrinsèque le compilateur fournit pour la fin (ou en utilisant le C++11 équivalent). C'est quelque chose que vous avez à insérer manuellement; vous ne pouvez pas compter sur le compilateur de générer les barrières de la mémoire en cas de besoin pour vous.
- Je vois, c'était pas clair dans votre réponse que les barrières de la mémoire sont une extension du langage / C++11 fonctionnalité. Donc, si le compilateur n'a pas que de l'extension que vous êtes coincé avec le volatile. Je pensais qu'il y avait quelque chose en C/C++ (pré-11) que je n'était pas au courant de.
- Je vois. Désolé pour la confusion. Toutefois, si le compilateur n'a pas une telle extension, alors vous êtes hors de la chance de toute façon, parce que volatile n'est pas suffisante en elle-même.
- Les Threads sont eux-mêmes toujours une plate-forme dépendant de l'extension avant C++11 et C11. À ma connaissance, tous les C et C++ environnement qui fournit un filetage extension propose aussi une "barrière de mémoire" de l'extension. Peu importe, volatile est toujours inutile pour le multi-thread de programmation. (Sauf sous Visual Studio, où volatile est la barrière de la mémoire d'extension.)
- Comme vous l'avez dit, la volatilité est utile pour accéder à I/O registres. Le coût est beaucoup plus élevé si nous utilisons la barrière de mémoire pour mettre en œuvre une telle fonction (bloc potentiel de compilateur/optimisation matérielle)
- pouvez-vous développer? Pourquoi le coût sera plus élevé qu'avec volatile? volatile empêche optimisations trop.
- Si nous barrière de mémoire pour simuler/mettre en œuvre la fonction de la volatilité, serait-il la cause de beaucoup d'autres sans rapport lecture/écriture pour arriver réellement? Il bloque également compilateur pour réorganiser l'accès à toutes les variables indépendantes.
- Je ne vois pas pourquoi il serait la cause de "beaucoup d'autres sans rapport lecture/écriture". Le point sur la réorganisation peut couper en deux façons, selon l'usage. Une mémoire prévient tous lectures/écritures de réorganisation à travers elle, mais seulement à un point spécifique dans le temps (Lorsque la barrière de code est exécuté), tandis qu'une variable volatile seulement empêche la réorganisation à l'égard des autres volatiles des lectures/écritures, mais d'un autre côté, empêche ce pour tous accède à la variable, et pas seulement à un point spécifique dans le code.
- Selon ma compréhension, la volatilité va forcer la lecture de la valeur de toujours à partir de la mémoire au lieu de la cache. Supposons que nous, nous avons partagé variable (entre threads), un thread modifie et la variable est non-volatile. En supposant que nous soyons à l'aide de l'exclusion mutuelle verrous à chaque fois que nous avons accès à la variable partagée. Depuis la variable partagée est non-volatile, comment est-il garanti que la variable sera toujours lu à partir de la mémoire du cache?
- c'est implicite dans le mutex. Il implique une barrière de mémoire, de sorte que lorsqu'elle est exécutée, le compilateur est chargé de veiller à ce que toutes les écritures sur les variables qui peuvent être visibles par les autres threads doit être rincé à la mémoire.
- Mot clé Volatile est toujours nécessaire ici d'éviter complier à cache le drapeau à la place de la lecture de la valeur de la mémoire.
- Non, ce n'est pas le cas, la dépendance de données de l'analyse traite de la barrière de la mémoire comme une fonction externe qui pourrait avoir changé toute variable qui n'a jamais été un alias. (Registre de stockage des variables locales dont l'adresse n'est jamais prise à fait est tout à fait sûr). Même en single-threaded code, global_x = 5; extern_call(); cout << global_x; le compilateur ne peut pas le remplacer par cout << 5; parce que extern_call() peut avoir modifié la valeur.
- Dans ce cas, le traitement de volatile mondiale en tant que barrière à l'compilateur réorganisation posent un grave problème de performance? Si, dans un morceau de code tous les endroits qui ont besoin de barrières ont explicitement marqué, permettant un compilateur pour réorganiser les activités à l'échelle volatile peut avoir certains avantages, mais on a le code qui utilise volatile mais n'est pas configuré pour utiliser des barrières compris par le compilateur est d'utiliser, une option pour traiter volatile comme un compilateur-commande de la barrière permet au compilateur utile d'exécuter ce code.
- Vous dites volatiles n'est pas nécessaire - ce qui implique qu'une barrière de mémoire serait la force de lit à partir de la mémoire, et pas en mémoire cache une valeur de registre. Est-ce correct, que les barrières de la mémoire de la force de lit pour ne pas être mis en cache? Ou avez-vous dire cela pour le multi-thread utilisation de la volatilité, de ne pas s'inscrire/IO utiliser?
- Sur les Processeurs modernes (depuis une dizaine d'années), volatile n'a même pas la force d'une lecture ou d'écriture de mémoire. Il a juste provoque la CPU à se comporter comme si une opération de lecture ou d'écriture a été forcé de mémoire single-threaded code. Et c'est tout ce que la norme requise, car il n'ont pas multi-thread sémantique exigences.
- Les seuls avantages de volatile sur instrinsics à assumer les forces externes qui peuvent lire et/ou écrire n'importe quel objet à n'importe quel point dans le temps (1) du code existant qui ne comprend ni le volatile ni obstacles pourraient être fixé plus facilement, dans la plupart des cas, par l'ajout de volatile que par l'ajout de barrières; (2) certaines plates-formes peuvent exiger des instructions spéciales pour la volatilité des lectures/écritures qui sont différentes de faire la synchronisation, l'accès, et puis un autre de synchronisation. La seule saine d'esprit, raison pour laquelle je peux penser pour C89 de ne pas avoir inclus les obstacles (puisque la mise en œuvre devrait être en mesure d'obtenir les...
- ...de la sémantique, si oui ou non ils pourraient exiger l'utilisation de barrières à donc), c'est que les auteurs ont prévu que les implémentations où les programmeurs peuvent avoir besoin les obstacles à des fins diverses, ferait "volatile" les fournir). Même I/O registres, souvent, n'ont pas besoin de la sémantique d'autant plus précise que ce que volatile fournirait. Dans de nombreux cas, il sera important qu'un groupe d'opérations précède l'autre, mais l'ordre des opérations à l'intérieur de chaque groupe n'a pas d'importance.
InformationsquelleAutor jalf
47

Vous pouvez également envisager ce à partir de la Le Noyau Linux Documentation.
C programmeurs ont souvent pris des volatiles à dire que la variable
pourrait être modifié en dehors du thread en cours d'exécution; comme un
résultat, ils sont parfois tentés de l'utiliser dans le code du noyau lors de l'
partagé structures de données sont utilisées. En d'autres termes, ils ont été
connu pour traiter les volatiles types comme une sorte de simple variable atomique, qui
ils ne le sont pas. L'utilisation de la volatilité dans le code du noyau est presque jamais
correct; ce document explique pourquoi.

Le point essentiel à comprendre à l'égard de la volatilité, c'est que son
le but est de supprimer l'optimisation, ce qui n'est presque jamais ce que l'on
veut vraiment faire. Dans le noyau, il convient de protéger les données partagées
les structures contre les accès simultanés, ce qui est très bien d'un
tâche différente. La procédure de protection contre les
la simultanéité permettra également d'éviter presque tous les problèmes d'optimisation
d'une façon plus efficace.

Comme volatile, le noyau primitives qui font de l'accès simultané à
la sécurité des données (spinlocks, mutex, les barrières de la mémoire, etc.) sont conçus pour
empêcher les indésirables de l'optimisation. Si elles sont utilisées correctement, il n'
sera pas nécessaire d'utiliser volatils ainsi. Si volatile est encore
nécessaire, il s'agit certainement d'un bug dans le code quelque part. Dans
correctement écrit le code du noyau, la volatilité ne peut que ralentir les choses
vers le bas.

Envisager un bloc typique du code du noyau:
```
spin_lock(&the_lock);
do_something_on(&shared_data);
do_something_else_with(&shared_data);
spin_unlock(&the_lock);
```
Si tout le code qui suit le verrouillage des règles, la valeur de shared_data
ne peut pas changer de façon inattendue alors que the_lock est tenue. Tout autre code
qui pourrait vouloir jouer avec les données seront en attente sur la serrure.
Le spinlock primitives agissent comme des barrières de la mémoire - s'ils sont explicitement
écrit à le faire - ce qui signifie que l'accès de données ne sera pas optimisé
à travers eux. Ainsi, le compilateur pourrait penser qu'il sait ce qui va être dans
shared_data, mais le spin_lock() l'appel, puisqu'il agit comme une mémoire
barrière, va l'obliger à oublier tout ce qu'il sait. Il n'y aura pas
les problèmes d'optimisation avec des accès à ces données.

Si shared_data ont été déclarées volatile, le blocage serait encore
nécessaire. Mais le compilateur pourrait également être empêchée d'optimiser la
l'accès à shared_data dans la section critique, quand on sait que
personne d'autre ne peut être de travailler avec elle. Alors que le verrou est maintenu,
shared_data n'est pas volatile. Lorsque vous traitez avec des données partagées, bon
verrouillage rend volatile inutile et potentiellement dangereux.

De la volatilité de la classe de stockage était destiné à l'origine pour memory-mapped I/O
les registres. Dans le noyau, le registre accède, elle aussi, doit être
protégés par des verrous, mais on ne veut pas le compilateur
"l'optimisation" registre accède à l'intérieur d'une section critique. Mais, à l'intérieur de
le noyau, I/O les accès à la mémoire sont toujours fait par le biais de l'accesseur
fonctions; un accès à une mémoire des e/S directement par le biais de pointeurs est mal
et ne fonctionne pas sur toutes les architectures. Ces accesseurs sont
écrite pour empêcher les indésirables de l'optimisation, de sorte que, une fois de plus, la volatilité est
inutiles.

Une autre situation où l'on pourrait être tenté d'utiliser volatile, c'est quand
le processeur est occupé-en attente sur la valeur d'une variable. Le droit
pour effectuer une attente active est:
```
while (my_variable != what_i_want)
    cpu_relax();
```
La cpu_relax() l'appel peut réduire la consommation du PROCESSEUR ou de céder à un
hyperthread twin processeur; il arrive aussi de servir de mémoire
barrière, de sorte que, une fois de plus, la volatilité est inutile. Bien sûr,
occupé-attendre, est généralement un anti-sociale, loi sur pour commencer.

Il y a encore quelques rares cas où les volatiles de sens que dans
le noyau:
- Ci-dessus mentionné fonctions d'accesseur peut utiliser volatile sur
  les architectures où direct I/O accès à la mémoire fonctionne. Essentiellement,
  chaque accesseur appel devient un peu de la section critique sur son propre et
  s'assure que l'accès se passe comme prévu par le programmeur.
- Assembly en ligne de code qui change de la mémoire, mais qui n'a pas d'autres
  visible effets secondaires, risque d'être supprimé par la GCC. L'ajout de la volatilité de l'
  mot-clé à l'asm, les déclarations d'empêcher cette suppression.
- La jiffies variable est particulière en ce qu'elle peut avoir une valeur différente
  chaque fois qu'il est référencé, mais il peut être lu sans
  verrouillage. Donc jiffies peut être volatile, mais l'ajout d'autres
  les variables de ce type est fortement désapprouvée. Jiffies est considéré comme
  pour être un "stupide héritage" question (Linus de mots) à cet égard; en le fixant
  serait plus d'ennuis que cela vaut la peine.
- Des pointeurs vers des structures de données cohérente de la mémoire qui sont susceptibles d'être modifiés
  par des périphériques d'e/S peuvent, parfois, être légitimement volatile. Un anneau de la mémoire tampon
  utilisé par une carte réseau, où que l'adaptateur change de pointeurs vers
  indiquer les descripteurs ont été traitées, est un exemple de ce
  type de situation.
Pour la plupart de code, aucune de ces justifications, le volatile s'appliquent.
En conséquence, l'utilisation de la volatilité est susceptible d'être considérée comme un bug et
apportera un examen plus approfondi du code. Les développeurs qui sont
tentés d'utiliser les volatiles devraient prendre du recul et de réfléchir à ce
ils sont vraiment en train d'essayer d'accomplir.
- "En ajoutant le mot clé volatile à l'asm, les déclarations d'empêcher cette suppression." Vraiment?
- Oui. Voir aussi gcc.gnu.org/onlinedocs/gcc-4.0.4/gcc/Extended-Asm.html .
- Le spin_lock() ressemble régulière d'un appel de fonction. Quelle est la particularité que le compilateur va traiter spécialement de sorte que le code généré va "oublier" de toute valeur d'shared_data qui a été lu avant le spin_lock() et stockée dans un registre, de sorte que la valeur doit être lu à nouveau dans le do_something_on() après le spin_lock()?
- Je suis sûr que toute introduction de serrures/mutex/etc permettrait d'expliquer cela. Mais il suffit de dire les mots clés dans le texte: barrière de mémoire. En gros, les fonctions doivent contenir une plate-forme spécifique opcode ou d'autres déclencheur, ce qui le compilateur sait dire "vous ne pouvez absolument pas se déplacer toute opération entre cela et la prochaine barrière de mémoire en dehors de la région délimitée par les deux". Puis une fois dans le les barrières, les mutex assure qu'aucun autre thread ne peut accéder aux données et les opérations sur shared_data se produire dans leur ordre indiqué que la Norme définit qu'ils ont à faire.
- Mon point est que je ne peux pas dire le nom de la fonction spin_lock() qu'il fait quelque chose de spécial. Je ne sais pas ce qui est en elle. En particulier, je ne sais pas ce qui est dans la mise en œuvre qui empêche le compilateur à partir de l'optimisation de loin les lectures suivantes.
- Syncopés a un bon point. Essentiellement, cela signifie que le programmeur doit connaître les internes de mise en œuvre de ces "fonctions spéciales" ou au moins d'être très bien informés au sujet de leur comportement. Cela soulève des questions supplémentaires, tels que sont ces fonctions spéciales normalisés et garantis pour fonctionner de la même manière sur toutes les architectures et tous les compilateurs? Existe t il une liste de ces fonctions ou au moins est-il une convention pour l'emploi des commentaires de code de signal que les développeurs de la fonction en question protège le code contre le fait d'être "optimisé loin"?
- Ce n'est pas que le compilateur doit mettre en œuvre un traitement spécial, c'est que le compilateur a pour générer du code qui fonctionne correctement avec void spin_lock() { shared_data = 7; } et la seule façon de le faire est à la corbeille de la copie conservée dans un registre et relire la valeur de la mémoire. En fait, le compilateur a aussi de déversement qui enregistrent le retour de la mémoire de la première, de sorte que void spin_lock() { if (shared_data == 42) abort(); } voit la valeur. Donc, vous voyez, en le considérant comme régulièrement un appel de fonction ne fait exactement la bonne chose dans le compilateur.
- Supposons que shared_data est une private static. Le compilateur sait maintenant que spin_lock ne peut pas toucher. Donc, pas de barrière de mémoire. Et ce qui se passe si C99 restreindre est ajouté?
- Une private static peut être touché par un code, par l'intermédiaire d'un pointeur. Et son adresse est prise. Peut-être le flux des données l'analyse est capable de prouver que le pointeur n'échappe, mais qui est en général un problème très difficile, superlinear dans la taille du programme. Si vous avez un moyen de garantir qu'aucun alias existent, puis en déplaçant l'accès à travers un verrou de rotation devrait en fait être ok. Mais si aucun alias existent, volatile est inutile aussi. Dans tous les cas, l'appel à une fonction dont le corps ne peut pas être vu" comportement va être correct.
- Selon cette drdobbs.com/cpp/volatile-the-multithreaded-programmers-b/..., c'est bien pour le compilateur d'optimiser l'accès à toutes les variables dans la section critique protégée par un mutex ou de verrouillage, car une telle section critique est sérialisé et peut être considérée comme le seul contexte de thread.
- Cet article reconnaît le concept qu'un objet ne devrait pas être accessible à l'aide d'un volatile qualificatif à des moments où il est surveillé par un mutex. Pour un autoportant mise en œuvre, le plus simple type de mutex construire est un gage de passage de drapeau qui dit qui est propriétaire d'un groupe d'objets, et chaque contexte utilise le drapeau pour passer le jeton tout moment il veut de l'autre contexte d'utilisation de l'objet. Sur une mise en œuvre qui s'abstient de déplacement des autres opérations passé une écriture volatile ou l'avance d'un volatile lire, un seul volatile indicateur peut prendre soin de cela.
InformationsquelleAutor
11

Je ne pense pas que vous avez tort -- volatile est nécessaire pour garantir que le fil d'Une volonté de voir la variation de la valeur, si la valeur est modifiée par quelque chose d'autre que de fil A. si je comprends bien, la volatilité est essentiellement une façon de dire au compilateur "ne cache pas cette variable dans un registre, au lieu assurez-vous de toujours lire/écrire à partir de la mémoire RAM sur tous les accès".

La confusion est parce que la volatilité n'est pas suffisante pour mettre en œuvre un certain nombre de choses. En particulier, les systèmes modernes, l'utilisation de plusieurs niveaux de mise en cache, moderne, multi-core, faire un peu de fantaisie optimisations au moment de l'exécution, et les compilateurs modernes faire un peu de fantaisie optimisations au moment de la compilation, et tout peut entraîner divers effets secondaires montrant dans un ordre différent de celui que vous attendez si vous avez seulement regardé dans le code source.

Tellement volatile est très bien, aussi longtemps que vous gardez à l'esprit que les "observés" des changements dans la volatilité de la variable ne peut pas se produire au moment même où vous pensez qu'ils seront. Plus précisément, n'essayez pas d'utiliser des variables volatiles comme un moyen de synchroniser ou de l'ordre des opérations dans les threads, car il ne fonctionne pas de manière fiable.

Personnellement, ma principale (seule?) l'utilisation de la volatilité de l'indicateur est comme un "pleaseGoAwayNow" booléen. Si j'ai un thread qui tourne en permanence, je vais vérifier la volatilité des booléens à chaque itération de la boucle, et de sortie si le booléen est jamais vrai. Le thread principal peut alors en toute sécurité nettoyer le thread de travail en définissant le booléen à true, et puis l'appel de pthread_join() pour attendre jusqu'à ce que le thread de travail est allé.
- Votre drapeau Booléen est probablement dangereux. Comment pouvez-vous garantir que le travailleur accomplit son travail, et que le drapeau reste dans la portée jusqu'à ce qu'il est lu (si elle est lue)? C'est un travail pour les signaux. Volatile est bonne pour la mise en œuvre simple spinlocks si aucun mutex est impliqué, depuis alias, la sécurité, le compilateur suppose mutex_lock (et tous les autres de la bibliothèque de fonction) peut modifier l'état de la variable d'indicateur.
- Évidemment, il ne fonctionne que si la nature de la thread de travail de routine est tel qu'il est garanti pour vérifier le booléen périodiquement. La volatilité de l'-bool-drapeau est assuré de rester dans le champ d'application parce que le fil-séquence d'arrêt se produit toujours avant que l'objet qui détient la volatilité des booléens est détruit, et le fil d'arrêt de la séquence d'appels pthread_join() après le réglage de la bool. pthread_join() bloque jusqu'à ce que le thread de travail a disparu. Les signaux ont leurs propres problèmes, en particulier lorsqu'il est utilisé conjointement avec le multithreading.
- Désolé, je veux dire pthread signaux (les variables de condition), pas de signaux POSIX. Vous n'avez toujours pas expliquer comment le travailleur est garanti pour achever ses travaux avant le Booléen est vrai. Vraisemblablement, il doit recevoir des unités de travail dans une section critique, le reste des travaux pourra être demandée après le drapeau est réglé. Vous avez décrit un demi-spinlock, qui pourrait fonctionner pour vous, mais je n'appellerais pas cela un modèle de conception, et probablement il n'a pas d'avantages par rapport à un plus sûr, plus classiques, le mécanisme.
- Le thread de travail n'est pas garantie d'achever ses travaux avant le booléen est vrai, en fait, il est presque certainement va être au milieu d'une unité de travail lorsque le booléen est définie sur true. Mais il n'a pas d'importance lorsque le thread de travail a terminé son unité de travail, parce que le thread principal ne va pas faire quoi que ce soit à l'exception de blocage à l'intérieur de pthread_join() jusqu'à ce que le thread de sorties, en tout cas. De sorte que la séquence d'arrêt est ordonné, -- le volatile bool (et toutes les autres données partagées) ne sera pas libéré jusqu'à ce que après pthread_join() retourne, et pthread_join() ne retourne pas jusqu'à ce que le thread de travail est allé.
- vous avez raison, dans la pratique, mais théoriquement, il pourrait toujours l'équilibre. Sur l'un deux un système de base est constamment à l'exécution de votre thread de travail. Les autres jeux de bool true. Cependant il n'est pas garanti au travailleur le thread du noyau va jamais voir le changement, c'est à dire qu'il ne peut jamais s'arrêter, même si elle répète vérifie le type bool. Ce comportement est autorisé par le c++0x, java et c# modèles de mémoire. Dans la pratique, cela ne devrait jamais se produire comme occupé fil probablement insérer une barrière de mémoire quelque part, après quoi il sera de voir le changement de l'bool.
- merci pour cette info, c'est bon à savoir. J'avais pensé que le mot clé volatile de traiter avec multicœur-mémoire-problèmes de mise en cache.
- deux système de base un noyau est constamment à l'exécution de votre thread de travail." Et le système d'exploitation ne fait jamais rien?
- Vous ne pouvez pas faire d'hypothèses sur l'OS de faire quelque chose. Vous pourriez avoir un thread en cours d'exécution en temps réel sous sceduling de la politique et de la haute priorité et donc très rarement contexte changé à partir de l'un de vos cœurs (pensez à un 16 système de base qui est relativement parlant pas vert occupé et que votre thread de travail est en train de faire des calculs et jamais/rarement faire des appels système). OS parfois de faire quelque chose type de pensée est que vous penser en très compliqué façons de vous assurer que vous êtes raisonnablement correct dans votre cas particulier.
- Tu veux dire qu'un calcul de fil avec 0 syscalls pourrait obtenir le CPU à 100% du temps, avec des interruptions? En théorie Possible, mais pas très plausible. Si c'est le cas, vous avez besoin d'envoyer un signal asynchrone sur le fil.
- Prendre un système POSIX, l'utilisation en temps réel de la planification de la politique SCHED_FIFO, plus statique de priorité que les autres processus/threads dans le système, assez de cœurs, doit être parfaitement possible. Sous Linux, vous pouvez spécifier que les processus en temps réel peut utiliser 100% du temps CPU. Ils ne seront jamais de changement de contexte si il n'y a pas de priorité plus élevée thread/processus et de ne jamais bloquer par I/O. Mais le point est que le C/C++ volatile n'est pas destiné à l'application correcte des données de partage et de synchronisation de la sémantique. Je trouve la recherche pour les cas spéciaux de prouver que le code incorrect peut-être pourrait parfois le travail est inutile.
- exactement pourquoi pensez-vous que le thread de travail pourrait ne jamais voir le changement? Est-ce parce que le thread de ne pas lire la variable, ou parce que le superviseur thread ne pas écrire la variable? Le thread qui a besoin d'une barrière de mémoire?
InformationsquelleAutor Jeremy Friesner
6

Votre compréhension est vraiment mauvais.

La propriété, que la volatilité des variables, est de "lire et écrire à cette variable sont une partie de perceptible comportement du programme". Cela signifie que ce programme fonctionne (compte tenu de l'utilisation de matériel approprié):
```
int volatile* reg=IO_MAPPED_REGISTER_ADDRESS;
*reg=1; //turn the fuel on
*reg=2; //ignition
*reg=3; //release
int x=*reg; //fire missiles
```
Le problème est, ce n'est pas le bien que nous voulons "thread-safe" quoi que ce soit.

Par exemple, un thread-safe compteur serait juste (linux-kernel-comme le code, je ne sais pas le c++0x équivalent):
```
atomic_t counter;

...
atomic_inc(&counter);
```
C'est atomique, sans barrière de mémoire. Vous devez les ajouter si nécessaire. L'ajout de volatiles ne serait probablement pas aider, parce que cela ne concerne pas l'accès à la proximité de code (par exemple. l'ajout d'un élément à la liste le compteur compte). Certainement, vous n'avez pas besoin de voir le compteur incrémenté à l'extérieur de votre programme, et des optimisations sont encore souhaitables, par exemple.
```
atomic_inc(&counter);
atomic_inc(&counter);
```
peut encore être optimisé pour
```
atomically {
  counter+=2;
}
```
si l'optimiseur est assez intelligent (on ne change pas la sémantique du code).

InformationsquelleAutor jpalecek
6

volatile est utile (mais non suffisante) pour mettre en œuvre le concept de base d'un spinlock mutex, mais une fois que vous avez (ou quelque chose de supérieur), vous n'avez pas besoin d'un autre volatile.

La manière typique de la programmation multithread n'est pas de protéger chaque variable partagée au niveau de la machine, mais plutôt d'introduire de la garde des variables qui guide le flux du programme. Au lieu de volatile bool my_shared_flag; vous devriez avoir
```
pthread_mutex_t flag_guard_mutex; //contains something volatile
bool my_shared_flag;
```
Non seulement cette encapsuler le "dur", il est fondamentalement nécessaire: C ne comprend pas opérations atomiques nécessaires pour mettre en œuvre un mutex; il a seulement volatile de faire des garanties supplémentaires sur ordinaire opérations.

Maintenant vous avez quelque chose comme ceci:
```
pthread_mutex_lock( &flag_guard_mutex );
my_local_state = my_shared_flag; //critical section
pthread_mutex_unlock( &flag_guard_mutex );

pthread_mutex_lock( &flag_guard_mutex ); //may alter my_shared_flag
my_shared_flag = ! my_shared_flag; //critical section
pthread_mutex_unlock( &flag_guard_mutex );
```
my_shared_flag n'a pas besoin d'être volatile, en dépit d'être cache, parce que
1. Un autre thread a accès.
2. Sens d'une référence à elle doit avoir été prise quelque temps (avec la & opérateur).
  - (Ou une référence a été pris pour un contenant de structure)
3. pthread_mutex_lock est une fonction de la bibliothèque.
4. Sens le compilateur ne peut pas savoir si pthread_mutex_lock en quelque sorte acquiert cette référence.
5. Sens le compilateur doit assumer que pthread_mutex_lock transforme le drapeau commun!
6. Si la variable doit être rechargé à partir de la mémoire. volatile, tandis que de sens dans ce contexte, est étrangère.
InformationsquelleAutor Potatoswatter
6

Pour que vos données puissent être cohérent à un concurrent à l'environnement, vous avez besoin de deux conditions pour postuler:

1) Atomicité je.e si je lire ou écrire des données dans la mémoire alors que les données est en lecture/écrite en une seule passe, et ne peut être interrompu ou soutenu en raison de l'e.g un changement de contexte

2) la Cohérence-je.e l'ordre de lecture/écriture de l'ops doit être vu être le même entre simultané de plusieurs environnements - être que les fils, les machines etc

volatile s'inscrit ni de l'au-dessus - ou, plus particulièrement, le c ou le c++ standard de la volatilité devrait se comporter inclut ni de la ci-dessus.

C'est même pire dans la pratique que certains compilateurs ( comme intel Itanium compilateur ) tentent de mettre en œuvre certains éléments de l'accès simultané des comportements sécuritaires ( j'.e en s'assurant de la mémoire des clôtures ) cependant il n'y a pas de cohérence à l'échelle du compilateur de mise en œuvre et en outre la norme ne l'exige pas la mise en œuvre en premier lieu.

Marquage d'une variable, alors que la volatilité sera juste dire que vous êtes en forçant la valeur à être vidées vers et à partir de la mémoire à chaque fois dans de nombreux cas, juste ralentit votre code que vous avez soufflé votre cache de performance.

c# et java autant que je sache faire la réparation en faisant des volatiles adhérer aux 1) et 2) toutefois, le même ne peut pas être dit pour les compilateurs c/c++ donc, fondamentalement, faire avec elle que vous voyez l'ajustement.

Pour un peu plus en profondeur ( mais pas impartial ) discussion sur le sujet lire cette
- +1 - garantie de l'atomicité est un autre morceau de ce que j'étais en manque. J'ai été en supposant que le chargement d'un int est atomique, de sorte que la volatilité de prévenir la re-commande de la solution sur le côté lecture. Je pense que c'est un décent hypothèse sur la plupart des architectures, mais il n'est pas une garantie.
InformationsquelleAutor zebrabox
5

La comp.de la programmation.fils FAQ a un classique de l'explication par Dave Butenhof:

Q56: Pourquoi n'ai-je pas besoin de déclarer les variables partagées VOLATILE?

Je suis inquiète cependant des cas où le compilateur et le
fils de la bibliothèque de s'acquitter de leurs spécifications respectives. Conforme
C compilateur peut globalement allouer une part (non volatile) variable
un registre est sauvegardé et restauré en tant que le CPU est passée de
fil à fil. Chaque thread aura sa propre valeur pour
cette variable partagée, ce qui n'est pas ce que nous voulons, à partir d'un partage
variable.

Dans un certain sens, cela est vrai, si le compilateur sait assez sur les
les champs d'application respectifs de la variable et la pthread_cond_wait (ou
pthread_mutex_lock) de fonctions. Dans la pratique, la plupart des compilateurs ne pas essayer
de garder des copies de données globales à travers un appel à l'externe
fonction, parce que c'est trop dur de savoir si la routine peut
en quelque sorte avoir accès à l'adresse de la donnée.

Donc oui, c'est vrai qu'un compilateur qui se conforme strictement (mais très
d'une manière agressive) à la norme ANSI C peut ne pas fonctionner avec plusieurs threads sans
volatile. Mais quelqu'un avait de mieux le fixer. Parce que tout SYSTÈME (qui est,
de façon pragmatique, une combinaison de noyau, les bibliothèques, et le compilateur C) que
ne pas fournir la POSIX mémoire garantit la cohérence n'est pas CONFORME
à la norme POSIX. Période. Le système NE peut pas vous obliger à utiliser
volatiles sur des variables partagées pour corriger ce comportement, parce que POSIX
exige seulement que les POSIX fonctions de synchronisation sont nécessaires.

Donc, si votre programme est en pause parce que vous n'utilisez pas volatile, que c'est un BUG.
Il ne peut pas être un bug dans C, ou d'un bug dans les filets de la bibliothèque, ou un bug dans
le noyau. Mais c'est un SYSTÈME de bug, et un ou plusieurs de ces composants
vous avez à travailler pour le fixer.

Vous ne souhaitez pas utiliser volatile, parce que, dans tout système où il fait
toute la différence, elle sera beaucoup plus coûteuse que celle d'une bonne
non volatile de la variable. (C ANSI exige "une séquence de points de" volatile
les variables à chaque expression, tandis que POSIX exige qu'au
les opérations de synchronisation -- un calcul intensif filetée application
va voir beaucoup plus de l'activité de la mémoire à l'aide de volatiles, et, après
le tout, c'est l'activité de la mémoire que vraiment vous ralentit.)

/---[ Dave Butenhof ]-----------------------[ [email protected] ]---\

| Digital equipment Corporation 110 Cracher Brook Rd ZKO2-3/Q18 |

| 603.881.2218, FAX 603.881.0120 Nashua NH 03062-2698 |

-----------------[ Mieux Vivre Par Le Biais De Simultanéité ]----------------/

M. Butenhof couvre la plus grande partie de la même terre dans ce message usenet:

L'utilisation de "volatile" n'est pas suffisante pour assurer une bonne mémoire
la visibilité ou de la synchronisation entre les threads. L'utilisation d'un mutex est
suffisante, et, sauf par le recours à diverses organisations non-machine portable
code alternatives, (ou plus subtiles implications de la POSIX mémoire
des règles qui sont beaucoup plus difficiles à appliquer de manière générale, comme expliqué dans
mon post précédent), un mutex est NÉCESSAIRE.

Par conséquent, en tant que Bryan l'a expliqué, l'utilisation de la volatilité des accomplit
mais rien pour empêcher le compilateur de les rendre utiles et désirables
les optimisations, en fournissant aucune aide que ce soit dans la fabrication de code "thread
coffre-fort". Vous êtes les bienvenus, bien sûr, de déclarer tout ce que vous voulez que
"volatile", c'est un juridique en C ANSI attribut de stockage, après tout. Juste
ne vous attendez pas à résoudre tous les problèmes de synchronisation de thread pour vous.

Tout ce qui est tout aussi applicable à C++.
- Le lien est rompu; il ne semble plus au point à ce que tu voulais citer. Sans le texte, son genre d'une réponse vide de sens.
InformationsquelleAutor Tony Delroy
3

Selon mon ancienne norme C “Ce qui constitue un accès à un objet volatile qualifiés de type est la mise en œuvre définies par l'”. Donc le compilateur C écrivains pourrait ont choisi d'avoir "volatile" signifie "thread-safe d'accès dans un environnement multi-processus de l'environnement". Mais ils n'ont pas.

Au lieu de cela, les opérations à effectuer pour faire une section critique thread-safe dans un multi-core et multi-processus de la mémoire partagée de l'environnement ont été ajoutés en tant que nouveaux définis par l'implémentation de fonctionnalités. Et, libéré de l'obligation d' "volatile" permettrait atomique et l'accès de la commande dans un multi-processus de l'environnement, le compilateur écrivains prioritaires de code de réduction historique de la mise en œuvre dépendant de la "volatilité" de la sémantique.

Cela signifie que des choses comme "volatile" sémaphores autour de la critique des sections de code qui ne sont pas de travailler sur du nouveau matériel avec de nouveaux compilateurs, ont déjà travaillé avec les anciens compilateurs sur du vieux matériel, et des exemples anciens sont parfois pas mal, juste vieux.
- Les exemples anciens nécessaire que le programme sera traitée par la qualité des compilateurs qui sont appropriés pour la programmation de bas niveau. Malheureusement, "moderne" compilateurs ont pris le fait que la Norme n'exigent pas de processus de "volatile" utile à la mode comme une indication que le code qui les obligerait à faire est cassé, plutôt que de reconnaître que la Norme ne fait aucun effort pour interdire les implémentations qui sont conforme, mais de faible qualité comme inutiles, mais ne saurait en aucune manière tolérer de faible qualité-mais conforme compilateurs qui sont devenus très populaires
- Sur la plupart des plates-formes, il serait assez facile de reconnaître ce qui volatile aurait besoin de le faire, afin de permettre d'écrire un OS dans une manière qui est matériel, mais dépend du compilateur indépendant. En exigeant que les programmeurs utilisent dépend de l'implémentation des fonctionnalités plutôt que de faire volatile travail comme l'exige la sape le but d'avoir un standard.
InformationsquelleAutor david
2

C'est tout ce que "volatile" est en train de faire:
"Hey compilateur, cette variable peut changer À TOUT MOMENT (sur n'importe quel tic d'horloge), même si il n'y a PAS d'INSTRUCTIONS agissant sur elle. Ne PAS mettre en cache cette valeur dans un registre."

Qui est-IL. Il indique au compilateur que votre valeur est, bien volatiles, cette valeur peut être modifiée à tout moment par la logique externe (un autre fil, un autre processus, le Noyau, etc.). Il existe plus ou moins exclusivement pour supprimer les optimisations du compilateur qui va silencieusement cache une valeur dans un registre qu'il est intrinsèquement dangereux à JAMAIS cache.

Vous rencontrerez peut-être des articles comme "Dr Dobbs" que le ton volatile que certains panacée pour le multi-thread de programmation. Son approche n'est pas totalement dénuée de fondement, mais il a le défaut fondamental de la réalisation d'un objet, les utilisateurs de responsable de son fil de sécurité, ce qui a tendance à avoir les mêmes problèmes que d'autres violations de l'encapsulation.
- drdobbs.com/cpp/volatile-the-multithreaded-programmers-b/...
InformationsquelleAutor Zack Yezek

Vous devez vous connecter pour publier un commentaire.