Spinlock

Un article de Wikipédia, l'encyclopédie libre.

En programmation informatique et plus particulièrement en programmation concurrente, le spinlock ou verrou tournant est un mécanisme simple de synchronisation basé sur l'attente active.[1]

Le spinlock base son principe sur l'attente active. En attendant leur tour, les threads l'utilisant vont le tester de manière répétée jusqu'à ce qu'il se libère. Pour ce faire, les threads doivent impérativement utiliser une opération atomique afin de garder le principe de l'exclusion mutuelle.

Quand utiliser le spinlock ?[modifier | modifier le code]

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.

Variantes[modifier | modifier le code]

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.

Exemple[modifier | modifier le code]

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

Références[modifier | modifier le code]

  1. (en) Maurice Herlihy, Nir Shavit, Victor Luchangco et Michael Spear, The art of multiprocessor programming, Morgan Kaufmann, 2e éd. (ISBN 978-0-12-415950-1), p. 147