Parallélisme. (Basé sur Concepts of Programming Languages, 8 th edition, by Robert W. Sebesta, 2007)

Transcription

1 Parallélisme (Basé sur Concepts of Programming Languages, 8 th edition, by Robert W. Sebesta, 2007) 1

2 Les différents types de Parallélisme Le Parallélisme dans l'exécution de logiciel peut se produire à quatre niveaux différents: Au Niveau des instructions de machines - exécutant deux ou plus instructions de machine simultanément. Au Niveau des instructions de code - exécutant deux instructions de codes sources ou plus simultanément. Au Niveau des Unités - exécutant deux unités ou plus de sous-programmes simultanément. Au Niveau des Programmes - exécutant deux programmes ou plus simultanément. Puisqu'aucune issue reliée à la conception de langages n'est impliquée dand le Parallélisme au niveau des instructions-machine et au niveau des programmes, ils ne sont pas discutés dans ce cours. 2

3 Les différents types d architectures a processeurs multiples Les deux catégories les plus communes d architectures à processeurs multiples sont: Single-Instruction Multiple-Data (SIMD) Architectures à processeurs multiples qui exécutent la même instruction simultanément, chacune sur des données différentes. Multiple-Instruction Multiple-Data (MIMD) Architectures à processeurs multiples qui opèrent indépendamment mais dont les opérations peuvent être synchronisés. 3

4 Les différentes catégories de Parallélisme Il y a deux catégories distinctes de control parallele d'unités : Le Parallélisme Physique Plusieures unités appartenant au même programme sont exécutées littéralement en parallèle sur différents processeurs. Le Parallélisme Logique - Plusieures unités appartenant au même programme semblent (au programmeur et a l'application) être exécutées en parallèle sur différents processeurs. En fait, l'exécution réelle des programmes à lieu de maniere intercalée sur un processeur simple. Pour le programmeur et le créateur de langage, les deux types de Parallélisme sont les mêmes. 4

5 Tâches I Une Tâche ou un processus est une unité de programme, semblable à un sous-programme qui peut être exécutée en parallèle avec d'autres unités du même programme. Il y a trois différences entre les tâches et les sousprogrammes: Une tâche peut commencer implicitement tandis qu'un sousprogramme doit être appelé explicitement. Quand une unité de programme appelle une tâche, elle n'a pas besoin d'attendre que la tâche à accomplir soit terminée avant de continuer la sienne. Quand l'exécution d'une tâche est accomplie, la commande peut ou peut ne pas retourner à l'unité qui l'a appelée. 5

6 Tâches II Il y a deux catégories de Tâches: Heavyweight Tâches tâches exécutées dans leur propre espace mémoire. Lightweight Tâches tâches qui fonctionnent toutes dans le même espace mémoire. Lightweight tâches sont plus faciles à mettre en application que les heavyweight tâches. Les tâches peuvent typiquement communiquer avec d autres tâches afin de partager le travail nécessaire pour accomplir le programme. Les tâches qui ne communiquent pas avec ou n'affectent pas l'exécution d'autres tâches s appellent des tâches disjointes. Typiquement, les tâches ne sont pas disjointes et doivent synchroniser leur exécution, partager les données, ou les deux à la fois. 6

7 Synchronisation La synchronisation est un mécanisme qui controle l'ordre dans lequel les tâches sont exécutées. Cela peut être réalisé par la coopération ou la compétition. La synchronisation de coopération est exigée entre une tâche A et une tâche B quand la tâche A doit attendre que la tâche B soit terminée pour continuer son exécution. La synchronisation de competition est exigée entre deux tâches quand toutes deux exigent l'utilisation d'une certaine ressource qui ne peut pas être employée simultanément. Pour la synchronisation de coopération, des tâches spécifiques doivent être accomplies avant qu une nouvelle tâche puisse être exécutée, alors que, pour la synchronisation de competition, certaines ressources doivent etre libérées avant qu une 7 nouvelle tâche s'exécute.

8 Un exemple de synchronisation de coopération Le Problème Du Producteur et du Consommateur mémoire tampon Programme 1 (Producteur) Programme 2 (Consommateur) Le programme 1 produit des données ; Le programme 2 emploie les données. La synchronisation est nécessaire: L'unité du consommateur ne doit pas prendre des données si la mémoire tampon est vide L'unité du producteur ne peut pas placer de nouvelles données dans la mémoire tampon si elle n'est pas vide 8

9 Exemple de synchronisation de compétition I Nous avons deux tâches (A et B) et une variable partagée (TOTAL) La tâche A doit additionner 1 à TOTAL La tâche B doit multiplier TOTAL par 2. Chaque tâche accomplit son opération en utilisant le processus suivant: Chercher la valeur dans TOTAL Effectuer l'opération arithmétique Remettre la nouvelle valeur dans TOTAL TOTAL a une valeur originale de 3. 9

10 Exemple de synchronisation de compétition II Sans synchronisation de compétition, 4 valeurs peuvent résulter de l'exécution des deux tâches: Si A s accomplit avant que B ne commence 8 Si A et B cherchent le TOTAL avant que l'un ou l'autre remette la nouvelle valeur dedans, alors nous avons: Si A remet la nouvelle valeur dans TOTAL en premier 6 Si B remet la nouvelle valeur dans TOTAL en premier 4 Si B s accomplit avant qu'a ne commence 7 Ce genre de situation s'appelle un état de course ou compétition parce que deux taches ou plus font la course pour utiliser les ressources partagées et le résultat dépend de quelle tache arrive la premiere. 10

11 Permission d accés mutuellement exclusif à une ressource partagée? I Une méthode générale consiste à considérer la ressource en tant qu entité qu une tâche peut posséder et ne permettre qu à une seule tâche de la posséder à la fois. Pour posséder une ressource partagée, une tâche doit demander la permission d y accéder. Quand une tâche a fini d utiliser une ressource partagée qu'elle possède, elle doit la relacher pour qu elle puisse être disponible à d'autres tâches. 11

12 Permission d accés d accés mutuellement exclusif à une ressource partagée? II Pour que cet arrangement général marche, nous devons poser deux conditions: Il doit y avoir une manière de retarder l'exécution des tâches L'exécution des tâches doit être controllée L'exécution de tâches est controllée par le scheduleur qui contrôle le partage des processeurs parmi les tâches en créant des créneaux de temps et en les distribuant tour a tour. Le travail du scheduleur, cependant, n'est pas aussi simple que cela en raison des délais de taches qui sont nécessaires pour la synchronisation et l attente pendant les opérations d'entrée-sortie. 12

13 États des tâches Afin de simplifier l implantation d attentes de la synchronisation, les tâches peuvent être dans différents états: Nouvelle : la tâche a été créée mais n'a pas encore commencé son exécution Prête : la tâche est prête à exécuter mais elle n exécute pas en ce moment. Elle se trouve dans la file d'attente des tâches prêtes. En execution : la tâche est exécutée en ce moment Bloquée : la tâche n est pas présentement en exécution parce qu'elle a été interrompue par un de plusieurs événements (habituellement une opération d'i/o). Morte : Une tâche meurt une fois son exécution terminée ou lorsqu elle est explicitement tuée par le programme. 13

14 Perte de Vie Supposez que les tâches A et B aient besoin des ressources X et Y pour terminer leurs travaux. Supposez que la tâche A gagne la possession de X et la tâche B gagne la possession de Y. Après une certaine exécution, la tâche A a besoin de gagner possession de Y, mais doit attendre que la tâche B la libère. De même la tâche B doit gagner possession de X mais doit attendre que la tâche A la libère. Ni l'une ni l'autre des tâches n'abandonne la ressource qu elle possède, et en conséquence, toutes les deux perdent leur vie. Ce genre de perte de vie s'appelle un inter blocage ou deadlock. Les inter blocages sont des menaces sérieuses à la fiabilité d'un programme et doivent être évitées. 14

15 Issues de conception du Parallélisme : Mécanismes de synchronisation Discutons maintenant de trois méthodes qui permettent l accés mutuellement exclusif aux ressources: Les Sémaphores Les Moniteurs Le passage de Messages Dans chaque cas, nous discuterons de la maniere dont la méthode peut être employée pour implanter la synchronisation de coopération et la synchronisation de competition. 15

16 Sémaphores I Un sémaphore est une structure de données se composant d'un nombre entier et d'une file d'attente qui stocke des descripteurs de tâche. Un descripteur de tâche est une structure de données qui stocke toutes les informations appropriées sur l'état d'exécution d'une tâche. Le concept d'une sémaphore est que, pour fournir l'accès limité à une structure de données, des gardes sont placées autour du code qui accède à la structure. 16

17 Sémaphores II Un garde permet au code gardé d'être exécuté seulement quand une condition particulière est vraie. Un garde peut être employé pour permettre à une seule tâche à la fois d'accéder à une structure de données partagée. Un sémaphore est l implantation d'un garde. Les demandes d'accès à la structure de données qui ne peuvent pas être honorées sont stockées dans la file d'attente du descripteur de tâches du sémaphore jusqu'à ce que l'accès puisse être accordé. Il y a deux opérations liées à un sémaphore : attendre et libérer 17

18 Sémaphores : Opérations d Attente et de Libération Wait(Sem) If Sem s counter > 0 then Decrement Sem s counter else Put the caller in Sem s queue Attempt to transfer control to some ready task (if the task queue is empty, deadlocks occur) Release(Sem) If Sem s queue is empty (no task is waiting) then Increment Sem s counter else Put the calling task in the task-ready queue Transfer control to a task from Sem s queue. 18

19 Synchronisation de Coopération: Le Problème du Producteur Consommateur défini à l'aide des sémaphores semaphore fullspots, emptyspots; fullspot.count = 0 Emptyspot.count = BUFLEN task producer loop -- produce VALUE -- wait(emptyspots); DEPOSIT(VALUE); release(fullspots); end loop end producer task consummer loop wait(fullspots); FETCH(VALUE); release(emptyspots); -- consume VALUE -- end loop end consumer 19

20 Synchronization de compétition Exécution partagée de la mémoire tampon implementation avec sémaphores semaphore access, fullspots, emptyspots; Access.count = 1; fullspot.count = 0; Emptyspot.count = BUFLEN; task producer loop -- produce VALUE -- wait(emptyspots); wait(access); DEPOSIT(VALUE); release(access); release(fullspots); end loop end producer task consummer loop wait(fullspots); wait(access); FETCH(VALUE); release(access); release(emptyspots); -- consume VALUE -- end loop end consumer 20

21 Inconvénients des sémaphores L'utilisation des sémaphores pour la synchronisation crée un environnement peu sûr. Dans La Synchronisation de Coopération: L oubli de l'instruction wait(emptyspots) causerait un débordement de la mémoire tampon. L oubli de l'instruction wait(fullspots) causerait un underflow de la mémoire tampon Dans La Synchronisation de Compétition : L oubli de l'instruction wait(access) de l'une ou l'autre des tâches peut causer un accès peu sûr à la mémoire tampon L oubli de l'instruction release(access) de l'une ou l'autre des tâche peut causer un interblocage. Aucune de ces erreurs ne peut être vérifiée au moment de la compilation puisqu'elles dépendent de la sémantique du programme. 21

22 Moniteurs Les moniteurs résolvent les problèmes des sémaphores en encapsulant les structures de données partagées avec leurs opérations et en cachant leur exécution. Monitor Processus Sub 1 Processus Sub 2 Processus Sub 3 Insérer Supprimer Mémoire Tampon Processus Sub 4 22

23 Synchronisation de compétition et de coopération à l aide de moniteurs Synchronisation de compétition : Puisque tous les accès résident dans le moniteur, l implantation du moniteur peut garantir l'accès synchronisé en permettant seulement un accès à la fois. Synchronisation de coopération : La coopération entre les processus demeure la responsabilbité du programmeur qui doit s'assurer qu'une memoire tampon partagée ne subisse pas d underflow (sous-écoulement) ou de débordement. Évaluation : Les moniteurs sont un meilleur outil de synchronisation que les sémaphores, bien que certains des problèmes des sémaphores dans l'exécution de la synchronisation de coopération s y retrouvent. 23

24 Passage de messages synchronisé Supposez que les tâche A et B sont toutes deux en exécution, et que A souhaite envoyer un message à B. Si B est occupé, il n'est pas souhaitable de permettre à une autre tâche de l'interrompre. Au lieu de cela, B peut signaler à d'autres tâches le moment où il est prêt à recevoir des messages. A ce moment la, la tâche A peut envoyer un message. Quand la transmission a enfin lieu, nous parlons d un rendezvous. Le passage de messages (synchronisé ou pas) est disponible en Ada. La Synchronisation de compétition et de coopération peuvent être toutes deux mises en application en utilisant ce paradigme. 24

25 Le Parallèlisme en Java: Threads Les unités concourantes en Java sont des méthodes appelées run dont le code peut être exécuté en parallèle avec d'autres méthodes du même type (appartenant à d'autres objets) et avec la méthode principale. Le processus dans lequel la méthode run est exécutée s'appelle un thread. Les threads du Java sont des tâches lightweight, ce qui signifie qu elles sont toutes exécutées dans le même espace de mémoire. Pour définir une classe contenant une méthode de type run, on peut définir une sous-classe de la classe prédéfinie thread et remplacer sa méthode run par une nouvelle méthode. 25

26 Le Classe Thread Dans la classe Thread, il y a deux méthodes prédéfinies run et start. Le code de la méthode run décrit les actions de Thread. La méthode start commence son thread comme une unité concourante en appelant sa méthode run. Quand un programme a des threads multiples, un scheduleur doit déterminer quels threads s exécuteront à quel moment. La classe Thread fournit plusieurs méthodes pour controler l'exécution des threads: yield : demande à un thread en exécution de rendre le processeur sleep : bloque un thread pendant un nombre specifié de millisecondes join : force une méthode à retarder son exécution jusqu'à ce qu'une autre thread ait accompli son exécution interrupt : envoie un message à un thread, le forçant à terminer. 26

27 Priorité des Threads Les threads peuvent avoir différentes priorités. La priorité par défaut d'un thread est la même que celle du thread qui l'a créée. La priorité d'un thread peut être changée en utilisant la méthode setpriority. getpriority retourne la priorité actuelle d'un thread. Quand il y a des threads avec différentes priorités, le comportement du scheduleur est imposé par ces priorités. Un thread à priorité inférieure sera exécuté que s il n y a pas de thread à priorité plus élevée dans la file d'attente quand l opportunité se présente. 27

28 Synchronisation de compétition en Java I En Java, la synchronisation de compétition est réalisé en indiquant qu une méthode ayant accès à des données partagées doit avoir finie son exécution avant qu'une autre méthode soit exécutée sur le même objet. Cela est fait en ajoutant le modificateur synchronized à la définition de la méthode. Class ManageBuf{ Private int [100] buf; Public synchronized void deposit (int item) { } Public synchronized void fetch (int item) { } } Un objet dont les méthodes sont toutes synchronisées 28 correspond à un moniteur.

29 Synchronisation de compétition en Java II Un objet peut avoir plus d une méthode synchronisée, et avoir une ou plusieurs méthodes non synchronisées. Si dans une méthode particulière, seule une petite partie des instructions emploient la structure de données partagée, on peut employer une instruction synchronisée seulement pour la partie du code qui emploie la structure de données partagée : Synchronize (expression) instructions(s) Remarque: l'expression évaluée correspond à un objet Un objet à méthodes synchronisées doit avoir une file d'attente qui lui sont liées pour stocker les méthodes synchronisées qui ont essayé de s exécuter sur lui. 29

30 Synchronisation de coopération en Java La synchronisation de coopération en Java emploie trois méthodes définies dans Object, la classe souche du Java. Ce sont les méthodes suivantes: wait(): chaque objet à une liste d'attente contenant tous les threads qui ont appelé wait() sur l'objet. notify(): est employé pour dire à un thread en attente que l'événement qu'il attendait s'est produit. notifyall(): réveille tous les threads de la liste d'attente de l'objet, pour commençer leur exécution juste aprés leur appel a wait(). Notifyall est souvent employé à la place de notify. Ces trois méthodes peuvent seulement être appelées de l interieur d'une méthode synchronisée car elles utilisent la serrure placée sur un objet par une telle méthode 30

31 Évaluation du Parallélisme en Java Le Parallélisme en Java est relativement simple mais efficace. Cependant, puisque les threads de Java sont lightweight, elles ne permettent pas aux tâches d'être distribuées sur des processeurs dotés de mémoires différentes, qui pourraient même se trouver sur des ordinateurs différents localisés a différents endroits. C'est la que l implementation du Parallélisme plus compliquée de l'ada a des avantages par rapport à celui de Java. 31