_InterlockedOr systeminternen Funktionen

Artikel
08/04/2024

Microsoft-spezifisch

Führen Sie eine atomarische bitweise OR-Operation für eine Variable durch, die von mehreren Threads genutzt wird.

Syntax

long _InterlockedOr(
   long volatile * Value,
   long Mask
);
long _InterlockedOr_acq(
   long volatile * Value,
   long Mask
);
long _InterlockedOr_HLEAcquire(
   long volatile * Value,
   long Mask
);
long _InterlockedOr_HLERelease(
   long volatile * Value,
   long Mask
);
long _InterlockedOr_nf(
   long volatile * Value,
   long Mask
);
long _InterlockedOr_np(
   long volatile * Value,
   long Mask
);
long _InterlockedOr_rel(
   long volatile * Value,
   long Mask
);
char _InterlockedOr8(
   char volatile * Value,
   char Mask
);
char _InterlockedOr8_acq(
   char volatile * Value,
   char Mask
);
char _InterlockedOr8_nf(
   char volatile * Value,
   char Mask
);
char _InterlockedOr8_np(
   char volatile * Value,
   char Mask
);
char _InterlockedOr8_rel(
   char volatile * Value,
   char Mask
);
short _InterlockedOr16(
   short volatile * Value,
   short Mask
);
short _InterlockedOr16_acq(
   short volatile * Value,
   short Mask
);
short _InterlockedOr16_nf(
   short volatile * Value,
   short Mask
);
short _InterlockedOr16_np(
   short volatile * Value,
   short Mask
);
short _InterlockedOr16_rel(
   short volatile * Value,
   short Mask
);
__int64 _InterlockedOr64(
   __int64 volatile * Value,
   __int64 Mask
);
__int64 _InterlockedOr64_acq(
   __int64 volatile * Value,
   __int64 Mask
);
__int64 _InterlockedOr64_HLEAcquire(
   __int64 volatile * Value,
   __int64 Mask
);
__int64 _InterlockedOr64_HLERelease(
   __int64 volatile * Value,
   __int64 Mask
);
__int64 _InterlockedOr64_nf(
   __int64 volatile * Value,
   __int64 Mask
);
__int64 _InterlockedOr64_np(
   __int64 volatile * Value,
   __int64 Mask
);
__int64 _InterlockedOr64_rel(
   __int64 volatile * Value,
   __int64 Mask
);

Parameter

Wert
[in, out] Ein Zeiger auf den ersten Operanden, der durch das Ergebnis ersetzt werden soll.

Maske
[in] Der zweite Operand.

Rückgabewert

Der ursprüngliche Wert, auf den der erste Parameter zeigt.

Anforderungen

Intrinsic	Aufbau	Header
`_InterlockedOr`, `_InterlockedOr8_InterlockedOr16`	x86, ARM, x64, ARM64	<intrin.h>
`_InterlockedOr64`	ARM, x64, ARM64	<intrin.h>
`_InterlockedOr_acq`, `_InterlockedOr_nf`, , `_InterlockedOr_rel`, `_InterlockedOr8_acq`, `_InterlockedOr8_rel_InterlockedOr8_nf`, `_InterlockedOr16_acq`, `_InterlockedOr16_nf`, , `_InterlockedOr16_rel`, `_InterlockedOr64_acq`, , `_InterlockedOr64_nf_InterlockedOr64_rel`	ARM, ARM64	<intrin.h>
`_InterlockedOr_np`, , `_InterlockedOr8_np_InterlockedOr16_np_InterlockedOr64_np`	x64	<intrin.h>
`_InterlockedOr_HLEAcquire`, `_InterlockedOr_HLERelease`	x86, x64	<immintrin.h>
`_InterlockedOr64_HLEAcquire`, `_InterlockedOr64_HLERelease`	x64	<immintrin.h>

Hinweise

Die Nummer im Namen jeder einzelnen Funktion gibt die Bitgröße der Argumente an.

Verwenden Sie auf ARM-Plattformen die systeminternen Funktionen mit den Suffixen _acq und _rel, wenn Sie Semantiken zum Abrufen bzw. Freigeben benötigen, wie am Anfang und Ende eines kritischen Abschnitts. Die systeminternen ARM-Dateien mit einem _nf Suffix ("kein Zaun") wirken nicht als Speicherbarriere.

Die systeminternen Funktionen mit dem Suffix _np („no prefetch“) verhindern, dass ein möglicher Vorabrufvorgang vom Compiler eingefügt wird.

Auf Intel-Plattformen, die Hardware Lock Elision (HLE)-Anweisungen unterstützen, enthalten die systeminternen Funktionen mit den Suffixen _HLEAcquire und _HLERelease einen Hinweis für den Prozessor, wie die Leistung durch den Wegfall der Schreibsperre in der Hardware beschleunigt werden kann. Wenn diese systeminternen Elemente auf Plattformen aufgerufen werden, die HLE nicht unterstützen, wird der Hinweis ignoriert.

Beispiel

// _InterlockedOr.cpp
#include <stdio.h>
#include <intrin.h>

#pragma intrinsic(_InterlockedOr)

int main()
{
        long data1 = 0xFF00FF00;
        long data2 = 0x00FFFF00;
        long retval;
        retval = _InterlockedOr(&data1, data2);
        printf_s("0x%x 0x%x 0x%x", data1, data2, retval);
}

0xffffff00 0xffff00 0xff00ff00

Ende Microsoft-spezifisch

Siehe auch

Intrinsische Compilerfunktionen
Konflikt mit dem x86-Compiler

Freigeben über