fonctions intrinsèques _InterlockedAdd

Section spécifique à Microsoft

Ces fonctions effectuent un ajout atomique, ce qui garantit que l’opération se termine correctement lorsque plusieurs threads ont accès à une variable partagée.

Syntaxe

long _InterlockedAdd(
   long volatile * Addend,
   long Value
);
long _InterlockedAdd_acq(
   long volatile * Addend,
   long Value
);
long _InterlockedAdd_nf(
   long volatile * Addend,
   long Value
);
long _InterlockedAdd_rel(
   long volatile * Addend,
   long Value
);
__int64 _InterlockedAdd64(
   __int64 volatile * Addend,
   __int64 Value
);
__int64 _InterlockedAdd64_acq(
   __int64 volatile * Addend,
   __int64 Value
);
__int64 _InterlockedAdd64_nf (
   __int64 volatile * Addend,
   __int64 Value
);
__int64 _InterlockedAdd64_rel(
   __int64 volatile * Addend,
   __int64 Value
);

Paramètres

Addend
[in, out] Pointeur vers l’entier à ajouter ; remplacé par le résultat de l’ajout.

Valeur
[in] Valeur à ajouter.

Valeur retournée

Ces deux fonctions renvoient le résultat de l'addition.

Spécifications

Fichier<d’en-tête intrin.h>

Notes

Les versions de ces fonctions avec le suffixe _acq ou _rel effectuent une addition verrouillée respectant la sémantique acquire ou release. Acquérir la sémantique signifie que le résultat de l’opération est rendu visible par tous les threads et processeurs avant toute lecture et écriture de mémoire ultérieure. Elle est utile lors de l'entrée d'une section critique. La sémantique de mise en production signifie que toutes les lectures et écritures de mémoire sont forcées d’être rendues visibles par tous les threads et processeurs avant que le résultat de l’opération soit rendu visible lui-même. Elle est utile quand vous quittez une section critique. Les intrinsèques avec un _nf suffixe (« sans clôture ») ne font pas office de barrière de mémoire.

Ces routines sont disponibles seulement comme fonctions intrinsèques.

Exemple : _InterlockedAdd

// interlockedadd.cpp
// Compile with: /Oi /EHsc
// processor: ARM
#include <stdio.h>
#include <intrin.h>

#pragma intrinsic(_InterlockedAdd)

int main()
{
        long data1 = 0xFF00FF00;
        long data2 = 0x00FF0000;
        long retval;
        retval = _InterlockedAdd(&data1, data2);
        printf("0x%x 0x%x 0x%x", data1, data2, retval);
}

Sortie : _InterlockedAdd

0xffffff00 0xff0000 0xffffff00

Exemple : _InterlockedAdd64

// interlockedadd64.cpp
// compile with: /Oi /EHsc
// processor: ARM
#include <iostream>
#include <intrin.h>
using namespace std;

#pragma intrinsic(_InterlockedAdd64)

int main()
{
        __int64 data1 = 0x0000FF0000000000;
        __int64 data2 = 0x00FF0000FFFFFFFF;
        __int64 retval;
        cout << hex << data1 << " + " << data2 << " = " ;
        retval = _InterlockedAdd64(&data1, data2);
        cout << data1 << endl;
        cout << "Return value: " << retval << endl;
}

Sortie : _InterlockedAdd64

ff0000000000 + ff0000ffffffff = ffff00ffffffff
Return value: ffff00ffffffff

FIN de la section spécifique à Microsoft

Voir aussi

Intrinsèques du compilateur
Conflits avec le compilateur x86