Funciones intrínsecas _InterlockedOr

Específicos de Microsoft

Realizar una operación OR bit a bit atómica en una variable compartida por varios subprocesos.

Sintaxis

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

Parámetros

Valor
[in, out] Puntero al primer operando, que lo sustituirá el resultado.

Mask
[in] El segundo operando.

Valor devuelto

El valor original al que apunta el primer parámetro.

Requisitos

Intrinsic	Architecture	Encabezado
_InterlockedOr, _InterlockedOr8, _InterlockedOr16	x86, ARM, x64, ARM64	<intrin.h>
_InterlockedOr64	ARM, x64, ARM64	<intrin.h>
_InterlockedOr_acq, _InterlockedOr_nf, _InterlockedOr_rel, _InterlockedOr8_acq, _InterlockedOr8_nf, _InterlockedOr8_rel, _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>

Comentarios

El número en el nombre de cada función especifica el tamaño en bits de los argumentos.

En plataformas ARM, utilice los intrínsecos con sufijos _acq y _rel si necesita adquirir y liberar semántica, como al principio y al final de una sección crítica. Los intrínsecos de ARM con un sufijo _nf ("sin barrera") no actúan como una barrera de memoria.

Los intrínsecos con un sufijo _np ("sin captura previa") impiden que el compilador inserte una posible operación de captura previa.

En las plataformas de Intel que admiten instrucciones de Elisión de bloqueo de Hardware (HLE), los intrínsecos con sufijos _HLEAcquire y _HLERelease incluyen una sugerencia para el procesador que puede acelerar el rendimiento mediante la eliminación de un paso de escritura de bloqueo en el hardware. Si se llama a estos intrínsecos en plataformas que no son compatibles con HLE, se omite la sugerencia.

Ejemplo

// _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 Específicos de Microsoft

Consulte también

Intrínsecos del compilador
Conflictos con el compilador de x86