Cours GRF

prpa/cours.tex

@@ -169,3 +169,113 @@ sont pas respectées.
 \paragraph{Famine~:} un thread est en famine quand il attend indéfiniment une
 ressources.
 
+
+
+\chapter{Techniques de lock}
+
+\section{Comment locker~?}
+
+\subsection{Bloquer les interruptions et la mémoire}
+
+\subsubsection{Interruptions}
+
+Dans le code on déclenche des interruptions de temps en temps pour
+changer de thread.
+
+\subsubsection{Mémoire}
+
+On bloque un espace mémoire le temps de faire une série d'opération.
+
+
+\subsection{Test and set}
+
+On swap 1 avec le contenu d'une adresse mémoire. Ensuite on lit le
+contenu récupéré. S'il vaut 1, on continue de boucler. S'il vaut 0,
+tout autre thread obtiendrait un 1 du fait que l'opération de swap est
+atomique.
+
+\subsection{Compare and swap}
+
+On lui donne une adresse, une valeur de test, une nouvelle valeur.
+
+Exemple~: $+=$, $-=$, \ldots
+
+\subsection{Mutex}
+
+C'est un verrou que l'on utilise comme valeur abstraite qui correspond
+à une porte de toilette.
+
+C'est implémenté à base de compare and swap.
+\newline
+
+Pthread n'utilise pas des mutex équitables, ni implémentés sous forme
+de pile, ils sont réentrants et sont en attente passive.
+
+\newline
+
+L'attente passive c'est le fait de donner au kernel la charge de
+réveiller le thread lorsqu'un autre syscall indiquant qu'il a fini
+d'exécuter le code critique.
+
+Du fait du nombre de syscall, il est intéressant de garder un spin
+lock plutôt qu'un mutex.
+
+\subsection{Barrière}
+
+C'est un outil de synchronisation. Elle reste fermée tant qu'il n'y a
+pas assez de monde pour rentrer. La barrière se referme derrière le
+dernier.
+
+Peut utilisé, sauf avec Cuda sur les cartes graphiques.
+
+\subsection{Read/Write lock}
+
+Répond au problème du lecteur/rédacteur.
+
+Des thread lisent la zone mémoire et d'autre écrivent la zone
+mémoire.
+
+Lorsqu'il n'y a pas d'écriture, on peut lire sans gérer les
+locks. Mais lorsqu'il y a de l'écriture, il peut arriver que l'on lise
+le début de la réécriture puis l'ancien contenu écrit.
+
+On a donc deux mutex~: un pour la lecture, un autre pour
+l'écriture. Si le mutex d'écriture est actif, on attend systématique,
+si le mutex de lecture est actif, on autorise les autres lecteure,
+mais on attend pour faire les écritures.
+
+\subsection{Variable de condition}
+
+On associe une condition à un mutex. On boucle sur la condition, et on
+wait (sans oublier de libérer le mutex) tant que la condition n'est
+pas valide.
+
+
+\subsection{Sémaphores}
+
+On a un compteur protégé que l'on peut incrémenté ou
+décrémenter. Quand ce compteur est supérieur ou égal à 0~: le
+sémaphore est réveillé. Lorsqu'il est à 0 et qu'il est décrémenté, il
+se met en sommeil.
+
+Généralement, on utiliser les opérations P et V. P incrémente le
+compteur et V le décrémente. Par défaut, on a une notion de pile.
+
+\subsection{Moniteur}
+
+L'avantage des moniteurs est de cacher l'utilisation des wait
+Cela requiert d'avoir un langage objet.
+
+\section{Le diner des philosophes}
+
+On a 5 philosophes.
+
+\section{Structure de données}
+
+Les B-tree sont très adaptés au parallélisme.
+
+Les listes doublement chaînées sont à l'inverse, le pire choix
+possible.
+
+\subsection{Structures non bloquantes}
+