_WriteBarrier

Spécifique à Microsoft

Écrit de force à la mémoire à effectuer au point de l'appel.

Attention
_ReadBarrier, _WriteBarrier, et les intrinsèques du compilateur de _ReadWriteBarrier empêchent uniquement retrier de compilateur.Pour empêcher l'UC de retrier plusieurs opérations de lecture et d'écriture, utilisez la macro de MemoryBarrier .

void _WriteBarrier(void);

Configuration requise

Fichier d'en-tête <intrin.h>

Notes

_ReadBarrier, _WriteBarrier, et l'aide de fonctions d' _ReadWriteBarrier vérifient que le bon fonctionnement des programmes multithread optimisées par le compilateur pour Visual C++ .Un programme correctement optimisé présente les mêmes résultats lorsqu'il s'exécute sur plusieurs threads comme lorsqu'il s'exécute sur un thread unique.

Pour garantir que le programme optimisé fonctionne correctement, la fonction d' _WriteBarrier force les écrit dans la mémoire pour s'exécuter au point de l'appel.Après l'appel, d'autres threads peuvent accéder à la mémoire sans crainte que le thread qui a provoqué l'appel peut avoir une écriture en attente à la mémoire.Pour plus d'informations, consultez les notes relatives à _ReadWriteBarrier.

[!REMARQUE]

Dans les versions précédentes du compilateur pour Visual C++ , _ReadWriteBarrier et fonctions d' _WriteBarrier ont été appliqués uniquement localement et n'ont pas affecté des fonctions en haut de l'arborescence des appels.Ces fonctions sont désormais appliquées complètement en haut de l'arborescence des appels.

Exemple

L'exemple suivant est similaire à celle de _ReadWriteBarrier.La fonction f fait deux assignations à la variable locale x.Sans _WriteBarrier le premier assignation est optimisé loin comme assignation inutile.Avec _WriteBarrier en place les deux assignations sont conservés et une violation d'accès se produit lorsque les premières assignation tente d'un pointeur non null.

// intrinsics_writebarrier.c
// compile with: /O2 -DNO_BARRIER
// This code contains an error--dereferencing a null pointer--
// which will be optimized away as a useless assignment.
// Omit the NO_BARRIER command line to activate the Write Barrier.
// With the barrier activated, the assignment is not optimized away
// and causes an access violation.

#include <windows.h> // for EXCEPTION_ACCESS_VIOLATION
#include <excpt.h>
#include <stdio.h>
#include <intrin.h>

#pragma intrinsic(_WriteBarrier)

int x = 0;

__declspec(noinline) int f(int* p)
{
    x = *p;
#ifndef NO_BARRIER
    _WriteBarrier();
#endif
    x = 7;
    return x;
}


// If code is EXCEPTION_ACCESS_VIOLATION it should be the
// attempt to read from the NULL pointer we passed in, so
// we handle the exception.
int filter(unsigned int code, struct _EXCEPTION_POINTERS *ep)
{
    if (code == EXCEPTION_ACCESS_VIOLATION)
    {
        printf_s("AV\n");
        return EXCEPTION_EXECUTE_HANDLER;
    }

    // If not what we were looking for, we don't want to handle it.
    return EXCEPTION_CONTINUE_SEARCH;
}

int main()
{
    __try
    {
        // Should return only if the first assignment is
        // optimized away.
        f(NULL);
        printf_s("Assignment was optimized away!\n");
    }
    __except(filter(GetExceptionCode(), GetExceptionInformation()))
    {
        // We get here if an Access violation occurred.
        printf_s("Access Violation: assignment was not optimized away.\n");
    }
}

Résultat de l'exemple

Sans /DNO_BARRIER :

AV
Access Violation: assignment was not optimized away.

Avec /DNO_BARRIER :

Assignment was optimized away!

Voir aussi

Référence

_ReadBarrier

_ReadWriteBarrier

Intrinsèques du compilateur