Spinlock

L'attente active rend le spinlock gourmand en ressources. C'est pourquoi il ne faut l'utiliser que dans une des situations suivantes :

• lorsque le changement de contexte est impossible (par exemple en l'absence de système d'exploitation) ;
• lorsque le changement de contexte est plus long que le temps d'attente moyen (contrainte temps réel souple) ou maximum (contrainte temps réel dur). Ce n'est en général le cas que dans les systèmes à multiprocesseurs. En effet, le verrou tournant est souvent utilisé pour synchroniser le noyau Linux sur des systèmes SMP (il est même souvent couplé avec une autre méthode de synchronisation).
• Le spinlock n'a d’intérêt que pour les systèmes multiprocesseur pour exécuter des tâches pseudo-atomiques. Sur un monoprocesseur le principe est le suivant : [taskLock - ma tâche - taskUnlock]. Comme avec plusieurs cœurs on ne contrôle pas les autres processeurs il faut se prévenir de leur intrusion avec le spinlock en plus : [taskLock - spinLock - ma tâche - spinUnlock - taskUnlock]. Si les interruptions peuvent interférer dans le processus il faut remplacer le taskLock par un intLock. Si on oublie de verrouiller le scheduler, un changement de tâche peut amener une autre tâche à utiliser 100 % du CPU sur la prise du spinLock jusqu'au prochain schedulling et si elle est prioritaire à un deadlock.

Il existe des variantes du verrou tournant visant à le rendre plus efficace :

• Le verrou tournant lecture/écriture qui est formé de 2 verrous : un pour la lecture et l'autre pour l'écriture. L'amélioration vient du fait que le verrou de lecture bloque seulement les accès en écriture et non les tentatives de lectures.
• Le verrou séquentiel.

 TestAndSet(*s, v) {
   s<-v
   return prev(s)
 } //Instruction Atomique (ie non interruptible)

 init(s) {
   TestAndSet(&s,1)
 }

 wait(s) {
   while(TestAndSet(&s,1))
   {
     //Attente active
   }
 }

 signal(s) {
   TestAndSet(&s,0)
 }