spinlock x86 en utilisant cmpxchg

Je suis nouveau à l'aide de gcc assembly en ligne, et je me demandais si, sur un système x86 multi-core de la machine, un spinlock (sans conditions de course) pourrait être mis en œuvre en tant que (AT&T syntaxe):

spin_lock: 
mov eax 0 
verrouillage cmpxchg 1 [lock_addr] 
jnz spin_lock 
ret 

spin_unlock: 
verrouillage mov 0 [lock_addr] 
ret

source d'informationauteur ManRow

  1. 22

    Vous avez la bonne idée, mais votre asm est cassé:

    cmpxchg ne peut pas travailler avec un opérande immédiat, seuls les registres.

    lock n'est pas un préfixe valide pour mov. mov à une adresse alignée est atomique sur x86, de sorte que vous n'avez pas besoin lock de toute façon.

    Il a été un certain temps depuis que je l'ai utilisé AT&T de la syntaxe, de l'espoir, je me suis souvenu de tout:

    spin_lock:
    xorl   %ecx, %ecx
    incl   %ecx            # newVal = 1
spin_lock_retry:
    xorl   %eax, %eax      # expected = 0
    lock; cmpxchgl %ecx, (lock_addr)
    jnz    spin_lock_retry
    ret

spin_unlock:
    movl   $0,  (lock_addr)    # atomic release-store
    ret

    Noter que la GCC a atomique objets internes, de sorte que vous n'avez pas besoin d'utiliser inline asm pour ce faire:

    void spin_lock(int *p)
{
    while(!__sync_bool_compare_and_swap(p, 0, 1));
}

void spin_unlock(int volatile *p)
{
    asm volatile ("":::"memory"); //acts as a memory barrier.
    *p = 0;
}

    Comme dit Bo ci-dessous, le verrouillage des instructions encourir un coût: chaque vous utilisez doit acquérir un accès exclusif à la ligne de cache et de verrouillage vers le bas tandis que verrouillage cmpxchg s'exécutece qui peut retarder le thread de déverrouillage surtout si plusieurs threads sont en attente pour prendre le verrou. Même sans beaucoup de Cpu, c'est toujours facile et il vaut la peine d'optimiser autour de:

    void spin_lock(int volatile *p)
{
    while(!__sync_bool_compare_and_swap(p, 0, 1))
    {
        //spin read-only until a cmpxchg might succeed
        while(*p) _mm_pause();  //or maybe do{}while(*p) to pause first
    }
}

    La pause instruction est essentiel pour la performance sur l'HyperThreading Cpu quand vous avez un code qui tourne comme celle-ci, elle permet à la deuxième thread exécute alors que le premier thread qui tourne. Sur les Processeurs qui ne le supportent pas pauseil est traité comme un nop.

    pause empêche également de la mémoire afin de sig-la spéculation lors de la sortie du spin-boucle, quand il est enfin temps de faire un réel travail de nouveau.

    Noter que réel spinlock implémentations ne tournent pas toujours; ils retombent à un OS assistée de sommeil et d'informer mécanisme. Ils peuvent également prendre des mesures pour améliorer l'équité, et beaucoup d'autres choses de la cmpxchg /pause boucle de ne pas le faire.

  2. 2

    Cela permettra de réduire la contention sur le bus mémoire:

    void spin_lock(int *p)
{
    while(!__sync_bool_compare_and_swap(p, 0, 1)) while(*p);
}