Threads et Lightweight Processes

1. Threads et Lightweight Processes Chapitre 5 En français on utilise parfois ‘flots’ ou ‘fils’ pour ‘threads’. Votre manuel préfère le mot anglais thread: terminologie Java http://w3.uqo.ca/luigi/

2. Concepts importants du Chap. 5 • Threads et processus: différence • Threads de noyau et d’usager: relations • LWP: lightweight processes, threads légers Ch.5

3. Flots = threads = lightweight processes • 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 • Les différents threads d’un processus partagent les variables et les ressources d’un processus • lorsqu’un thread modifie unevariable (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) Ch.5

4. Processus à un thread et à plusieurs threads En commun Séparés Ch.5

5. 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 Ch.5

6. Threads et processus [Stallings] Ch.5

7. Processus • Possède sa mémoire, ses fichiers, ses ressources, etc. • Accès protégé à la mémoire, fichiers, ressources d’autres processus Ch.5

8. Thread • Possède un état d’exécution (prêt, bloqué…) • Possède sa pile et un espace privé pour variables locales • A accès à l’espace adressable, fichiers et ressources du processus auquel il appartient • En commun avec les autres threads du même proc Ch.5

9. 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 Ch.5

10. La commutation entre threads est moins dispendieuse que 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 • 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 vars locales du thread Ch.5

11. 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 Ch.5

12. 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 Ch.5

13. Threads de noyau (kernel) et d’utilisateur • Où implémenter les threads: • Dans les bibliothèques d’usager • contrôlés par l’usager • Dans le noyau du SE: • contrôlés par le noyau • Solutions mixtes Ch.5

14. Threads d’utilisateur et de noyau (kernel) • 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 • 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 Ch.5

15. 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) Ch.5

16. Plusieurs threads utilisateur pour un thread noyau:l’usager contrôle les threads usager • Le SE ne connaît pas les threads utilisateur • v. avantages et désavantages mentionnés avant noyau Ch.5

17. 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 Ch.5

18. Plusieurs à plusieurs: solution mixte usager • 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 noyau Ch.5

19. Threads dans Solaris 2 (une version de Unix) Tâche = processus Plusieurs à plusieurs, usager et noyau Ch.5

20. 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 • 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 UCT Ch.5

21. Revenons aux deux méthodes d’E/S • 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 Ch.5

22. Plutôt génial … • 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 Ch.5

23. 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 • 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éé Ch.5

24. 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éé • Si un LWP devient bloqué, l’UCT qui l’exécute peut être affectée à un autre thread Ch.5

25. 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 Ch.5

26. Dans les sessions exercices, vous verrez comment Java implémente les threads vous cachant tous ces mécanismes Ch.5

27. Concepts importants du Chap. 5 • threads et processus: différence • threads de noyau et d’usager: relations • LWP: lightweight processes, processus légers • Implémentation utilisant UCT physiques Ch.5

28. Quoi étudier dans le manuel • En classe, nous avons vu seulement 5.1- 5.2 et 5.3.6 • 5.3.1 jusqu’à 5.3.5 sont utiles pour mieux comprendre mais pas matière d’examen • 5.4 et 5.5 sont intéressants mais ils ne sont pas matière d’examen • Pendant les sessions exercices vous verrez 5.6 et suivants Ch.5