Compartilhar via

Funções intrínsecas _InterlockedAdd

  • Artigo

Seção específica da Microsoft

Essas funções executam uma adição atômica, que garante que a operação seja concluída com êxito quando mais de um thread tiver acesso a uma variável compartilhada.

Sintaxe

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

Parâmetros

Addend
[in, out] Ponteiro para o inteiro ao qual adicionar; substituído pelo resultado da adição.

Valor
[in] O valor a ser adicionado.

Valor retornado

Ambas as funções retornam o resultado da adição.

Requisitos

Intrinsic Arquitetura
_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

Arquivo de cabeçalho<intrin.h>

Comentários

As versões dessas funções com os sufixos _acq ou _rel executam uma adição sincronizada após a semântica de aquisição ou liberação. Semântica de aquisição significa que o resultado da operação fica visível para todos os threads e processadores antes de qualquer leitura e gravação. A semântica de aquisição é útil ao inserir uma seção crítica. Semântica de liberação significa que todas as leituras e gravações na memória precisam ficar visíveis para todos os threads e processadores antes que o resultado da operação fique visível. A liberação é útil ao sair de uma seção crítica. Os intrínsecos com um sufixo _nf ("no fence") não funcionam como uma barreira de memória.

Essas rotinas somente estão disponíveis como intrínsecos.

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

Saída: _InterlockedAdd

0xffffff00 0xff0000 0xffffff00

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

Saída: _InterlockedAdd64

ff0000000000 + ff0000ffffffff = ffff00ffffffff
Return value: ffff00ffffffff

Fim da seção específica da Microsoft

Confira também

Intrínsecos do compilador
conflitos com o compilador x86