Puis-je incrémenter de manière atomique un compteur de 16 bits sur x86/x86_64?

Question

Je veux économiser de la mémoire en convertissant un compteur 32 bits existant en un compteur 16 bits. Ce compteur est incrémenté/décrémenté de manière atomique. Si je fais ceci:

1. Quelles instructions dois-je utiliser pour atomic_inc (uint16_t x) sur x86/x86_64?
2. Est-ce fiable sur les machines x86/x86_64 multi-processeurs?
3. Existe-t-il une pénalité de performance à payer sur l'une de ces architectures pour cela?
4. Si oui pour (3), quelle est la pénalité de performance attendue?

Merci pour vos commentaires!

Answer 1

est ici celui qui utilise des extensions d'assemblage du CCG, comme une alternative à la réponse Delphi Steve:

uint16_t atomic_inc(uint16_t volatile* ptr) 
{ 
    uint16_t value(1); 
    __asm__("lock xadd %w0, %w1" : "+r" (value) : "m" (*ptr)); 
    return ++value; 
} 

Modifier le 1 avec -1, et le ++ avec --, pour diminuer la valeur.

Answer 2

Voici une fonction Delphi qui fonctionne:

function LockedInc(var Target :WORD) :WORD; 
asm 
     mov  ecx, eax 
     mov  ax, 1 
    Lock xadd [ecx], ax 
     Inc  eax 
end; 

Je suppose que vous pouvez convertir en la langue que vous avez besoin.

Answer 3

Pour répondre aux trois autres questions:

1. n'a pas trouvé un moyen de faire une liste numérotée en commençant par 2
2. Oui, cela est fiable dans un environnement multiprocesseur
3. Oui, il y a une pénalité de performance
4. Le préfixe "lock" verrouille les bus, non seulement pour le processeur, mais pour tout matériel externe, qui peut vouloir accéder au bus via DMA (stockage de masse, graphiques ...). Il est donc lent, typiquement ~ 100 cycles d'horloge, mais il peut être plus coûteux. Mais si vous avez "mégaoctets" de compteurs, il y a de fortes chances que vous fassiez face à un cache manquant, et dans ce cas vous devrez attendre environ 100 horloges (le temps d'accès à la mémoire), en cas de manque de mémoire, cent, de sorte que les frais généraux de verrouillage pourraient ne pas avoir d'importance.

Answer 4

La façon la plus simple d'effectuer une augmentation atomique est la suivante (ce qui est en ligne ASM):

asm 
    lock inc dword ptr Counter; 
end; 

où J est un entier. Cela augmentera directement Counter dans son emplacement mémoire.

J'ai testé cela avec force brute et cela fonctionne à 100%.