Licence Informatique

2021-2022
FILS (THREADS)
 Concepts importants
 Threads et processus: différence

 Threads de noyau et d’usager: relations

 LWP: lightweight processes, threads légers

 Flots = threads = lightweight processes
(Processus léger)
 Processus: programme en exécution
 Chaque processus a ses variables et fichiers
indépendants des autres processus

 Un thread est une subdivision d’un processus

 Un fil de contrôle dans un processus
Flots = threads = lightweight processes

 Les différents threads d’un processus partagent

les variables et les ressources d’un processus
 lorsqu’un thread modifie une variable (non
locale à lui), tous les autres threads voient la
modification

 un fichier ouvert par un thread est accessible aux

autres threads (du même processus)
Processus à deux threads
Processus à un thread et à plusieurs
threads
En commun

Séparés
 Exemple
 Le processus MS-Word peut impliquer plusieurs
threads:
 Interaction avec le clavier
 Rangement de caractères sur la page
 Sauvegarde régulière du travail fait
 Contrôle orthographe
 Etc.
 Ces threads partagent tous le même fichier .doc et
autres données
Threads et processus
 Processus
 Possède sa mémoire, ses fichiers, ses
ressources, etc.

 Accès protégé à la mémoire, fichiers,

ressources d’autres processus
 Thread

 Possède un état d’exécution (prêt, bloqué…)

 Possède sa pile et un espace privé pour

variables locales

 Accès à l’espace adressable, fichiers et

ressources du processus auquel il appartient

 En commun avec les autres threads du même proc
 Pourquoi les threads
 Reactivité: un processus peut être subdivisé en
plusieurs threads,
 L’un peut exécuter tant que l’autre est bloqué

 Utilisation de multiprocesseurs: les threads peuvent

exécuter en parallèle sur des UCT différentes
 Pourquoi les threads
 Les threads ont été surtout conçus pour faciliter la
programmation parallèle.
 Dans ce type de programmation, on distingue deux
types de parallélisme :
 parallélisme réel pour les systèmes multiprocesseurs où
plusieurs processus sont exécutés en même temps,
 parallélisme virtuel (ou concurrence) sur les
systèmes monoprocesseurs multitâches où plusieurs
processus s'exécutent concurremment.
Pourquoi les threads
 La commutation entre processus
 Un processus possède mémoire, fichiers,
autres ressources

 Changer d’un processus à un autre implique

sauvegarder et rétablir l’état de tout ça
La commutation entre threads
 Changer d’un thread à un autre dans le
même proc est bien plus simple,
implique sauvegarder seulement:
 les registres de l’UCT,
 la pile du thread,
 les var locales du thread
 La commutation entre threads est moins
dispendieuse que la commutation entre
processus
 La communication aussi est moins
dispendieuse entre threads qu’entre processus

 Étant donné que les threads partagent leur

mémoire,

 la communication entre threads dans un

même processus est plus efficace que la
communication entre processus

 elle utilise les variables qui sont en commun

entre threads
 La création et terminaison sont moins
dispendieuses

 La création et terminaison de nouveaux

threads dans un processus existant sont
aussi moins dispendieuses que la création ou
terminaison d’un processus
 Processus monoprogrammé
 Un processus lourd classique, ne contenant qu'un
seul fil d'exécution, est dit monoprogrammé :
 l'exécution du code du processus est réalisée de manière
séquentielle par un fil de contrôle (thread of control).

Processus monoprogrammé
 Processus multiprogrammé
 Un processus lourd contenant plusieurs fils
d'exécution est dit multiprogrammé : l'exécution du
code est réalisée par les différents fils d'exécution.

Processus multiprogrammé
 Threads de noyau (kernel) et
d’utilisateur
 Où implémenter les threads:

 Dans les bibliothèques d’usager

 contrôlés par l’usager (utilisateur)

 Dans le noyau du SE:

 contrôlés par le noyau

 Solutions mixtes
Threads de noyau (kernel) et
d’utilisateur
 Threads de noyau
 Threads de noyau: supportés directement par le noyau du SE
(Windows, Solaris)
 les ops sur les threads sont des appels au système
 le noyau est capable de gérer directement les états des threads
 Il peut affecter différents threads à différentes UCTs
 Exemples
 Windows XP/2000
 Solaris
 Linux
 Tru64 UNIX
 Mac OS X
 Threads d’utilisateur
 Threads d’utilisateur: supportés par des bibliothèques
d’usager ou le langage de prog (p.ex Java)
 les ops sur les threads ne demandent pas des appels du
système
 sont gérées par le système d’exécution du langage de
programmation (p.ex. Java)
 le noyau ne peut pas les gérer directement
 Exemple:
 Pthreads
 Threads Java
 Threads Win32
 Avantages des threads utilisateur
 pas d’appels système pour leur gestion
 commutation rapide
 on peut fixer l’ordonnancement (ex : bien avec
un gc)
 Inconvénients des threads utilisateur

 les appels systèmes bloquants bloquent tout le

monde
⇒ utiliser des appels non bloquants.
 Problème du défaut de page.
Solutions mixtes: threads utilisateur et
noyau
 Relation entre threads utilisateur et threads noyau
 plusieurs à un
 un à un
 plusieurs à plusieurs

 Nous devons prendre en considération plusieurs niveaux:

 Processus
 Thread usager
 Thread noyau
 Processeur (UCT)
Plusieurs threads utilisateur pour un thread
noyau: l’usager contrôle les threads

usager

noyau

 Le SE ne connaît pas les threads utilisateur

 v. avantages et désavantages mentionnés avant
Un vers un: le SE contrôle les threads

usager

noyau

 Les ops sur les threads sont des appels du système

 Permet à un autre thread d’exécuter lorsqu’un thread
exécute un appel de système bloquant
 Plusieurs à plusieurs: solution
mixte

usager

noyau

 Flexibilité pour l’usager d’utiliser la technique qu’il préfère

 Si un thread utilisateur bloque, son thread noyau peut être affecté à
un autre utilisateur
 Si plus. UCT sont disponibles, plus. threads noyau peuvent exécuter
en même temps
Threads dans Solaris 2 (une version
de Unix)
Tâche = processus

Plusieurs à plusieurs, usager et noyau

Processus légers (lightweight, LWP)
 Implémentent le concept d’UCT virtuelle,
pouvant exécuter des threads niveau usager

 Il y a un thread noyau pour chaque LWP,

chaque LWP est lié à son propre thread
noyau
Processus légers (lightweight, LWP)
 Si un thread noyau bloque, ses LWPs et ses threads usagers
bloquent aussi
 Chaque processus doit être affecté au moins à un LWP
 La bibliothèque des threads exécute les threads utilisateur
sur les LWP disponibles
 Seulement les threads usager qui sont associés à un LWP
peuvent exécuter, les autres sont bloqués
 similarité avec ordonnancement UCT
 La méthode (a) d’attente sur
E/S est conceptuellement la
plus simple
 Nous pouvons travailler avec
la méthode (a) si nous avons
assez d’UCT, qui peuvent
rester bloquées dans les E/S
 Le SE peut créer un nombre
arbitraire de LWP
 Par rapport aux LWP, nous utilisons ici la méthode d’E/S (a):
 Le LWP attend le complètement de l’E/S
 Mais par rapport à l’UCT réelle, nous utilisons la méthode (b)
 Dans l’attente l’UCT est allouée à un autre LWP, s’il y en a
 Utilisation des LWP
 Quand un thread usager fait un appel au SE, p.ex. E/S, on
crée un nouveau LWP pour s’occuper de cette opération
 le premier LWP peut continuer l’exécution du thread
 Utilisation des LWP
 Il y a besoin d’un LWP pour chaque thread qui peut devenir
bloqué pour un appel de système
 un programme qui ne fait qu’exécuter sur l’UCT a besoin d’un
seul thread
 s ’il y a 5 demandes d’E/S en même temps, 5 LWP nous
permettent de les lancer (virtuellement) en même temps
 s`il y a seul. 4 LWP, une des demandes d ’E/S doit attendre
qu’un LWP devienne libre ou soit créé
 Exécution des LWP
 Les threads de noyau qui implémentent les LWP exécutent sur les UCT
qui deviennent disponibles
 Si un thread noyau se bloque, son LWP se bloque aussi,
 mais un processus (tâche) peut en obtenir un autre, ou un nouveau
LWP peut être créé
 Exécution des LWP
 Si un LWP devient bloqué, l’UCT qui l’exécute peut
être affectée à un autre thread
Structures de données: Solaris
 Une tâche=processus Solaris peut être associée à
plusieurs LWP
 Un LWP contient un ensemble de registres, les vars
locales etc

PCB du proc

Données pour chaque LWP dans le proc principal