Freigeben über

_InterlockedAdd systeminternen Funktionen

  • Artikel

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

Summand
[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