_InterlockedAdd systeminternen Funktionen

Microsoft-spezifisch

Diese Funktionen führen eine Atomzugabe durch, wodurch sichergestellt wird, dass der Vorgang erfolgreich abgeschlossen wird, wenn mehr als ein Thread Zugriff auf eine freigegebene Variable hat.

Syntax

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
);

Parameter

Addend
[in, out] Zeiger auf die ganze Zahl, der hinzugefügt werden soll; durch das Ergebnis des Zusatzs ersetzt.

Wert
[in] Der hinzuzufügende Wert.

Rückgabewert

Beide Funktionen geben das Ergebnis der Addition zurück.

Anforderungen

Intrinsic	Aufbau
_InterlockedAdd	ARM, ARM64
_InterlockedAdd_acq	ARM, ARM64
_InterlockedAdd_nf	ARM, ARM64
_InterlockedAdd_rel	ARM, ARM64
_InterlockedAdd64	ARM, ARM64
_InterlockedAdd64_acq	ARM, ARM64
_InterlockedAdd64_nf	ARM, ARM64
_InterlockedAdd64_rel	ARM, ARM64

Headerdatei<intrin.h>

Hinweise

Die Versionen dieser Funktionen mit den Suffixen _acq oder _rel führen eine ineinander greifende Addition gemäß der Semantiken zum Abrufen oder Freigeben durch. "Semantik abrufen" bedeutet, dass das Ergebnis des Vorgangs für alle Threads und Prozessoren sichtbar gemacht wird, bevor später Speicherlese- und Schreibvorgänge vorgenommen werden. „Acquire“ ist bei der Eingabe eines kritischen Abschnitts nützlich. Freigabesemantik bedeutet, dass alle Speicherlese- und Schreibvorgänge für alle Threads und Prozessoren sichtbar gemacht werden müssen, bevor das Ergebnis des Vorgangs selbst sichtbar gemacht wird. „Release“ ist beim Verlassen eines kritischen Abschnitts nützlich. Die Systeminternen mit einem _nf Suffix ("kein Zaun") wirken nicht als Speicherbarriere.

Diese Routinen sind nur als systeminterne Funktionen verfügbar.

Beispiel: _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);
}

Ausgabe: _InterlockedAdd

0xffffff00 0xff0000 0xffffff00

Beispiel: _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;
}

Ausgabe: _InterlockedAdd64

ff0000000000 + ff0000ffffffff = ffff00ffffffff
Return value: ffff00ffffffff

Ende Microsoft-spezifisch

Siehe auch

Systeminterne Compiler
Konflikt mit dem x86-Compiler