• [^] # Re: Instructions atomiques

    Posté par . En réponse à la dépêche IBM lance la mémoire transactionnelle dans le matériel. Évalué à 2.

    Si tu as besoin de protéger l'affectation

    Non, ça ne sert à rien. Si tu protège l'affectation newNode->... par un CAS, ça veut dire que tu connais sa valeur précédente, et que tu souhaite vérifier qu'un thread concurrent ne l'a pas modifié en même temps que toi. Ce qui n'arrivera pas tant que t'aura pas inséré le nœud.

    Soit node→next=A. [...] node→next devient B. [...] Affectation de node→next à newNode.

    Ce n'est pas qu'une affectation, c'est un Compare And Swap. Donc c'est "Affectation de node->next à newNode et node->next->prev à newNode si node->next vaut A et node->next->prev vaut node sinon rien faire et indiquer l'echec" (dans notre cas, on peut récupérer A à partir de newNode->next, si on ne l'a pas stocké dans une autre variable temporaire)

    Donc dans ton cas le CAS échoue, la modification concurrente est détéctée, et on refait les affectations depuis le début. Heureusement, parce que sinon les CAS ne serviraient strictement à rien si ça n'étaient que des affectations.

    Voila du code si t'en a envie :

    do {
 NodeType* old_node_next = node->next;
 NodeType* old_node_next_prev = node->next->prev;
 newNode->next = old_node_next;
 newNode->prev = old_node_next_prev;
// en supposant que __sync_bool_compare_and_swap2 existe.
} while ( faise == __sync_bool_compare_and_swap2(&node->next, old_node_next, newNode,
 &node->next->prev, old_node_next_prev, newNode));