fonctions intrinsèques _InterlockedOr

Article
08/04/2024

Section spécifique à Microsoft

Effectuer une opération OR atomique au niveau du bit sur une variable partagée par plusieurs threads.

Syntaxe

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

Paramètres

Valeur
[in, out] Pointeur vers le premier opérande, à remplacer par le résultat.

Masque
[in] Deuxième opérande.

Valeur retournée

Valeur d'origine vers laquelle pointe le premier paramètre.

Spécifications

Intrinsic	Architecture	En-tête
`_InterlockedOr`, , `_InterlockedOr8_InterlockedOr16`	x86, ARM, x64, ARM64	<intrin.h>
`_InterlockedOr64`	ARM, x64, ARM64	<intrin.h>
`_InterlockedOr_acq`, , `_InterlockedOr_nf`, `_InterlockedOr8_acq`, , `_InterlockedOr8_rel_InterlockedOr64_acq_InterlockedOr64_nf_InterlockedOr16_acq_InterlockedOr16_rel_InterlockedOr16_nf_InterlockedOr8_nf_InterlockedOr_rel_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>

Notes

Le nombre dans le nom de chaque fonction spécifie la taille en bits des arguments.

Sur les plateformes ARM, utilisez les fonctions intrinsèques avec des suffixes _acq et _rel si vous devez acquérir et libérer des éléments de la sémantique, comme le début et la fin d’une section critique. Les intrinsèques ARM avec un _nf suffixe (« sans clôture ») ne font pas office de barrière de mémoire.

Les fonctions intrinsèques avec un suffixe _np (pour « no prefetch », « pas de prérécupération ») empêchent l'insertion par le compilateur d'une possible opération de prérécupération.

Sur les plateformes Intel qui prennent en charge les instructions HLE (Hardware Lock Elision), les fonctions intrinsèques avec les suffixes _HLEAcquire et _HLERelease comprennent une indication pour le processeur qui peut accélérer les performances en éliminant une étape d'écriture de verrou dans le matériel. Si ces intrinsèques sont appelées sur des plateformes qui ne prennent pas en charge HLE, l’indicateur est ignoré.

Exemple

// _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

FIN de la section spécifique à Microsoft

Voir aussi

Intrinsèques du compilateur
Conflits avec le compilateur x86

Partager via