Conception et programmation Programmation Parallèle

Présentation au sujet: "Conception et programmation Programmation Parallèle"— Transcription de la présentation:

1 Conception et programmation Programmation Parallèle
TC1- CPPOO 96h - 9 Ects Matière 2:4,5 Ects Conception et programmation Orientée-objet 12h cours -14h TD -12h TP Matière 1: 4,5 Ects Programmation Parallèle 16h cours -18h TD - 12h TP BE 12h TP CPOOP

2 TC1: Conception et programmation parallèle et orientée objet
Volume horaire: 96h Répartition: Cours: 28h TD: 32h TP: 24h BE: 12h Objectif: Ce cours a pour but de présenter les concepts de base de la programmation orientée objet et parallèle. Ils sont illustrés à travers une démarche de développement et des applications de synthèse. Plan: 1. Conception et Programmation Orientée Objets - Concepts fondamentaux de la POO Rappels et compléments sur les concepts de la POO (classes, objets, héritage, polymorphisme, ...) - Conception Orientée Objets - Introduction au langage de modélisation UML - Démarche d'analyse et de conception - Schémas de conception - Mise en œuvre - Modélisation d'une application - Implantation avec Java 2. Programmation Parallèle - Expression des activités parallèles: processus et threads - Modèles de parallélisme: synchrone, asynchrone - Mécanismes de communication et de synchronisation - variables partagées, envoi de messages - verrou, sémaphore, moniteur, rendez-vous - Problèmes et applications - Exclusion mutuelle - Allocation de ressources - Schéma producteur-consommateur, lecteur-rédacteur, Eléments de spécification et de vérification - Mise en œuvre (UNIX et Java) 3. Travaux de synthèse - Réalisation d'objets synchronisés - Etude et réalisation d'interfaces graphiques Cette partie sera assurée dans le cadre de bureaux d'études et travaux-pratiques. Elle doit permettre de faire le lien entre les deux premières parties.

3 Programmation Parallèle
Pourquoi ? Système complexe Exigence: Décomposition en activités « indépendantes » Matériel multiprocesseur réseaux monoprocesseur

4 Plateforme Centralisé Distribué Pseudo-parallélisme Parallélisme réel Monoprocesseur: UC réseaux Multiprocesseur: UC1..UCn S1 S2 S3 Sn P0 P1 ---- ---- ---- ---- ---- ---- MC Passage de contrôle

5 Expression du parallélisme
Processus Définition utilisateur Programme en cours d’exécution Processus Pile du processus _ : Ad_SDonnées Ad_Code Définition système S_Données _ Descripteur identité état pcontexte : Ad_Code _

6 PRÊT BLOQUÉ ACTIF TERMINÉ
États d’un processus Plusieurs processus Prêts attendent l’UC PRÊT BLOQUÉ ACTIF TERMINÉ Créé Allocation Préemption Attente Fin, destruction Le processus élu est choisit selon une politique de schedulling Selon implantations, sous-états possibles

7 Processus Unix S_Données_Père X 0 Pid Num_Fils S_Pile_Père S_Code Main() { int x, pid; x=0; pid = fork(); if (!pid) x=1; else x=2; } S_Données_fils X 0 Pid 0 S_Pile_Fils

8 Processus Unix S_Données_Père X 2 Pid Num_Fils S_Pile_Père S_Code Main() { int x, pid; x=0; pid = fork(); if (!pid) x=1; else x=2; } S_Données_fils X 1 Pid 0 S_Pile_Fils

9 Expression du parallélisme
Thread « processus léger » Permettre à une activité parallèle contrairement aux processus de partager l’espace d’adressage avec d’autres S_Données_processus _ processus t1 t2 t3 tn

10 Un thread est crée, seulement, par un processus
Un processus peut créer plusieurs threads Le processus père joue le rôle du processeur / à ses threads Les threads s’exécutent d’une façon général en multiprogrmmé Ils partagent le temps du processus père Le contrôle passe à un autre thread si le thread courant: se termine se bloque Lance une opération E/S D’autres politiques de schedulling sont possibles

11 PRÊT BLOQUÉ ACTIF TERMINÉ
États d’un thread les threads Prêts attendent dans le processus PRÊT BLOQUÉ ACTIF TERMINÉ Créé Allocation Préemption Attente Fin, destruction Le thread élu est choisit selon une politique de schedulling. Il s’exécute quand le processus est actif Selon implantations, sous-états possibles

12 S_Code int x; /* */ void *traitementThread () { /* */ int i; x++; printf(…) x++; } main() { int etat; int numThreads; pthread_t idThread; pthread_attr_t attribut; /* Creation d’un thread */ x = 1; etat = pthread_create(&idThreads, &attribut, traitementThread, &numThreads); Printf (…..); X--; X == 1

13 S_Code int x; /* */ void *traitementThread () { /* */ int i; x++; printf(…) x++; } main() { int etat; int numThreads; pthread_t idThread; pthread_attr_t attribut; /* Creation d’un thread */ x = 1; etat = pthread_create(&idThreads, &attribut, traitementThread, &numThreads); Printf (…..); X--; X == 2

14 S_Code int x; /* */ void *traitementThread () { /* */ int i; x++; printf(…) x++; } main() { int etat; int numThreads; pthread_t idThread; pthread_attr_t attribut; /* Creation d’un thread */ x = 1; etat = pthread_create(&idThreads, &attribut, traitementThread, &numThreads); Printf (…..); X--; X == 1

15 S_Code int x; /* */ void *traitementThread () { /* */ int i; x++; printf(…) x++; } main() { int etat; int numThreads; pthread_t idThread; pthread_attr_t attribut; /* Creation d’un thread */ x = 1; etat = pthread_create(&idThreads, &attribut, traitementThread, &numThreads); Printf (…..); X--; X == 2

16 Exemple: Thread Unix Créer un thread
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg); start_routine = fonction exécutée par le thread arg = argument de cette fonction attr = attributs optionnels de création thread = identificateur Toutes les ressources nécessaires au thread doivent avoir été initialisées. Erreurs possibles : EINVAL : attributs invalide EAGAIN : ressources insuffisantes

17 Autres opérations sur un thread
int pthread_detach(pthread_t thread); Détacher un thread Erreurs : (EINVAL : thread non « joignable » ESRCH : thread invalide) pthread_t pthread_self(void); Retourne l’identificateur de l’appelant int pthread_yield(void); <sched.h>, TR Rend prêt l’appelant, élection nouveau thread Erreur : Retour -1 + errno ENOSYS : non supporté

18 Terminer un thread void pthread_exit(void *value_ptr); Terminaison de l’appelant value_ptr = valeur (non adr) de retour pour jointure int pthread_join(pthread_t thread, void **value_ptr); Attente de la terminaison d’un thread non détaché thread = identificateur du thread concerné value_ptr = valeur retournée (si non NULL) Erreurs : EINVAL : thread non « joignable » ESRCH : thread invalide (EDEADLK : join avec self) Exemple : create, exit/join

19 2 Modèles du parallélisme
I- Modèle Synchrone Lustre Esterel Une seule horloge Flot de données A chaque top tous les processus s’activent Flot de contrôle exécution // entre 2 top Horloge interaction 0 P0 ---- P1 ---- Pn ---- t0 t1 t2 t3 t4

20 2 Modèles du parallélisme
II- Modèle Asynchrone H0 H1 H2 ……. Hn Indépendance interaction 0

21 Quelques Problèmes Causes coopération Partage de ressources Synchrone Variables partagées Communication & Synchronisation Asynchrone Envoie de messages

22 Quelques Problèmes Propriétés Comportementales Sûreté Section Critique Exclusion Mutuelle Communication Synchrone Non Inter blocage Communication Asynchrone Attendre & Signaler un événement Diffuser un événement Allocation de Ressources Fichier Partagé Vivacité Pilote d’Entrée /Sortie Non Famine :::::::: Équité