Quand doit-Win32 InterlockedExchange fonction?

Je suis tombé sur la fonction InterlockedExchange et je me demandais quand je dois utiliser cette fonction. À mon avis, la définition d'une valeur 32 Bits sur un processeur x86 devrait toujours être atomique?

Dans le cas où je veux utiliser la fonction, la nouvelle valeur ne dépend pas de l'ancienne valeur (ce n'est pas une opération d'incrémentation).
Pourriez-vous fournir un exemple où cette méthode est obligatoire (je ne suis pas à la recherche pour InterlockedCompareExchange)

InformationsquelleAutor EFrank | 2008-10-16

multithreading winapi

4

Dans un multi-processeur ou multi-core de la machine à chaque cœur possède son propre cache, de sorte que chaque de base a chaque propre potentiellement différent de "vue" de ce que le contenu de la mémoire système est.

De synchronisation de Thread mécanismes de prendre soin de la synchronisation entre les cœurs, pour plus d'informations regardez http://blogs.msdn.com/oldnewthing/archive/2008/10/03/8969397.aspx ou google pour acquérir et la libération de la sémantique
- Les Caches sont ici secondaire. Même si il n'y a pas de caches et les Processeurs étaient en train de parler de la mémoire directement normale de lecture / écriture de la séquence n'est pas atomique.
InformationsquelleAutor Nir
11

Ainsi que l'écriture de la nouvelle valeur, InterlockedExchange également de lire et renvoie la valeur précédente; cette opération atomique. Ceci est utile pour les algorithmes sans verrouillage.

(Soit dit en passant, 32-bit écrit ne sont pas garantis pour être atomique. Considérons le cas où l'écriture est non alignés et chevauche un cache de limite, par exemple.)
- Il serait atomique du point de vue du logiciel en cours d'exécution sur le processeur, mais pas du point de vue du matériel, assis sur le bus.
- Serait-il atomique du POV de logiciel en cours d'exécution sur une autre base? Quid d'une écriture qui est à cheval sur une frontière de page et déclenche une faute? Ça fait des années que je n'ai tout de bas niveau x86 codage, suppose que je suis peut-être le mensonge :/
InformationsquelleAutor moonshadow
10

InterlockedExchange est à la fois une écriture et une lecture -- elle renvoie la valeur précédente.

Cela est nécessaire pour assurer un autre thread n'a pas écrit une valeur différente juste après que vous avez fait. Par exemple, disons que vous essayez d'incrémenter une variable. Vous pouvez lire la valeur, ajouter 1, puis de définir la nouvelle valeur avec InterlockedExchange. La valeur retournée par InterlockedExchange doit correspondre à la valeur d'origine que vous avez lu, sinon un autre thread probablement incrémentée dans le même temps, et vous avez besoin pour faire une boucle autour de vous et essayez de nouveau.
- Dans ce cas, je voudrais utiliser InterlockedCompareExchange, car le vérifier si la valeur est toujours celui d'origine est effectuée par la méthode déjà.
- Ou tout simplement InterlockedIncrement
InformationsquelleAutor Jason Cohen
3

Réglage d'une valeur de 32 bits est atomique, mais seulement si vous êtes à la définition d'un littéral.

b = a est 2 opérations:
```
mov         eax,dword ptr [a] 
mov         dword ptr [b],eax 
```
Théoriquement, il pourrait y avoir d'interruption entre la première et la deuxième opération.
- Et si il y aurait une certaine interruption, alors qu'est - ce- qu'il va prendre un peu de temps, mais la valeur de eax ne changera pas. Le véritable point de InterlockedExchange est qu'il est atomique lire et à écrire.
- Alors quoi? L'enfer. L'interruption peut provoquer un appel système, le système d'appel d'un changement de contexte, puis un autre thread modifie la valeur. Puis EAX est restauré et la valeur est de nouveau changé. Des conditions de course sont particulièrement mortels lorsque le comptage de références. Un thread peut incrémenter la valeur, tandis qu'un autre thread décrémente la valeur, ou les deux threads peuvent augmenter en même temps. Que EAX est restauré n'est pas la solution à son problème.
- Et c'est encore pire quand il y a plus d'un CPU/core.
- Rien de grave dans ce cas. b sera écrit avec une seule instruction, indépendamment de sa valeur précédente.
InformationsquelleAutor Gerald
3

L'écriture d'une valeur n'est jamais atomique par défaut. Lorsque vous écrivez une valeur à une variable, plusieurs instructions machine sont générés. Moderne, de préemption en Os, l'OS peut passer à un autre thread entre les opérations individuelles de l'écriture.

C'est même plus un problème sur les ordinateurs multi-processeurs, où plusieurs threads peuvent s'exécuter en même temps, et d'essayer d'écrire dans un seul emplacement de mémoire simultanément.

Opérations verrouillées éviter cela en utilisant les instructions spéciales pour rendre l'écriture (x86 a consacré des instructions pour ce genre de situation), qui font la lecture-modification-écriture dans une instruction. Ces consignes sont également verrouiller le bus mémoire de tous les processeurs, pour s'assurer qu'aucun autre thread qui s'exécute pourrait être écrit de la valeur en même temps.
- -1, Incorrect plaine aligné écrit sont atomiques sur x86.
InformationsquelleAutor Mathieu Garstecki
2

InterlockedExchange permet de s'assurer que le changement d'une variable et le retour de sa valeur d'origine ne sont pas interrompus par d'autres threads.

Donc, si " je "est un int, ces appels (prises individuellement) n'ont pas besoin InterlockedExchange autour de "i":
```
a = i;
i = 9;
i = a;
i = a + 9;
a = i + 9;
if(0 == i)
```
Aucun de ces énoncés se fondent à la FOIS sur les valeurs initiale ET finale du "je". Mais ces appels NE doivent InterlockedExchange autour de "i":
```
a = i++;  //a = InterlockedExchange(&i, i + 1);
```
Sans elle, les deux threads s'exécutant à travers ce même code peut obtenir la même valeur de " i " attribué à 'a' ou 'a' peut inattendue sauter deux ou plusieurs nombres.
```
if(0 == i++) //if(0 == InterlockedExchange(&i, i + 1))
```
Deux threads peuvent exécuter le code qui est supposé se produire une fois.

etc.
- Exemple Incorrect a = InterlockedExchange(&i, i + 1);. Votre i peut être changé par l'autre CPU entre i + 1 et InterlockedExchange.
InformationsquelleAutor helmk
-1

wow, donc beaucoup des réponses contradictoires. Difficile à parcourir, qui a raison, qui a tort, et que l'information est trompeuse.

Je ne suis pas sûr de la réponse, étant donné ci-dessus des demi-réponses, mais je pense que ça fonctionne comme ça, j'ai peut-être tort, et il sera intéressant de savoir si je suis:
1. 32-bit lire & les écritures SONT atomiques, mais en fonction de votre code, qui ne peut pas dire grand-chose.
2. ne vous inquiétez pas au sujet de la non-alignés de lecture/écriture. TOUS les 32-bit écrit à une variable de 32 bits doivent être alignées ou de la machine de la page défauts.
3. ne vous inquiétez pas à propos de l'écriture d'habillage autour de la fin d'une page en cache, qui ne peut pas se produire.
4. Si vous avez besoin d'écrire puis lire sur un fil, et que vous écrivez sur un autre thread, alors vous devez utiliser InterlockedExchange. Si vous êtes tout simplement la lecture de la valeur sur un fil, et de l'écrire sur un autre, alors vous n'avez pas besoin de l'utiliser, mais ces valeurs peuvent être ondulée en raison de multithreading.
- -1 32-bits vars n'a pas besoin d'être alignés sur les architectures x86. Et 32 bits des écritures atomique sur x86, mais pas sur d'autres architectures.
InformationsquelleAutor Ericf.

Vous devez vous connecter pour publier un commentaire.