La lecture-modification-écriture atomique est-elle une opération atomique unique ou séparable ?

La lecture-modification-écriture atomique est-elle une opération atomique ou séparable ?

Les opérations de lecture-modification-écriture atomique (RMW), telles que x.exchange(), sont des opérations atomiques qui lisent et écrivent un emplacement mémoire et garantissent que les opérations de lecture et d'écriture sont exécutées dans l'ordre. Cependant, il n'est pas explicitement défini si ces opérations sont considérées comme une opération atomique unique ou une combinaison d'une charge d'acquisition et d'un magasin de libération.

Point de vue de la norme

Du point de vue de Du point de vue de la norme C, une opération RMW est considérée comme une opération unique. Cela ressort clairement du fait qu’il porte un nom unique (RMW) et qu’il est désigné par la norme comme une opération unique. Par exemple, [N4860](https://isocpp.org/files/papers/n4860.pdf) (Draft Working Paper std::memory_order) déclare :

"Une opération de lecture-modification-écriture avec ceci L'ordre de la mémoire est à la fois une opération d'acquisition et une opération de libération. Aucune lecture ou écriture de mémoire dans le thread actuel ne peut être réorganisée avant ou après cela. store."

Opérations atomiques ou séparables

La distinction entre les opérations atomiques et séparables est importante car elle détermine la manière dont les autres opérations interagissent avec elles. Si une opération RMW est traitée comme atomique, cela signifie qu'elle ne peut pas être réorganisée par rapport aux autres accès mémoire. Cependant, s'il est traité comme séparable, cela ouvre la possibilité de réorganiser entre les composants de chargement et de stockage de l'opération.

Exemple de code

Considérez l'exemple de code suivant , qui utilise x.exchange() et y.store() pour définir les valeurs de deux variables atomiques, x et y.

std::atomic<int> x, y;

void thread_A() {
    x.exchange(1, std::memory_order_acq_rel);
    y.store(1, std::memory_order_relaxed);
}

void thread_B() {
    int yy = y.load(std::memory_order_acquire);
    int xx = x.load(std::memory_order_acquire);
    std::cout << xx << ", " << yy << std::endl;
}

Si x.exchange() est traité comme une seule opération atomique, cela signifie que les composants de chargement et de stockage de l'opération ne peuvent pas être réorganisés. Par conséquent, le thread B observera toujours que les valeurs de x et y sont toutes deux égales à 1 ou toutes deux égales à 0.

Cependant, si x.exchange() est traité comme séparable, cela laisse ouverte la possibilité que le chargement et le stockage les éléments de l’opération pourraient être réorganisés. Dans ce cas, le thread B pourrait potentiellement observer que les valeurs de x et y sont 0, 1, car la charge de x pourrait être réorganisée avant le magasin vers y.

Implémentation du compilateur et interprétation standard

Du point de vue de la norme, il semblerait que le thread B ne devrait pas observer 0, 1. Cependant, l'implémentation ARM64 du code suggère que l'opération RMW est traitée comme séparable, ce qui permet la possibilité de réorganiser entre les composants de chargement et de stockage.

Cet écart apparent soulève la question de savoir si la citation de référence est incorrecte ou s'il s'agit simplement d'une mauvaise compréhension de la norme. Bien qu'il soit possible que la citation cppreference ne soit pas parfaitement exacte, elle correspond au traitement général de la norme des opérations RMW comme des opérations atomiques uniques.

Il est important de noter que la norme ne définit pas explicitement le comportement des opérations RMW sous toutes circonstances. En particulier, il ne fournit pas d'indications claires sur la manière dont les relations de synchronisation s'appliquent aux opérations RMW. En tant que tel, il peut y avoir place pour différentes interprétations et mises en œuvre des opérations RMW.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!