Matière 2:4,5 EctsConception et programmation
Orientée-objet 12h cours -14h TD -12h TP
Matière 1: 4,5 EctsProgrammation Parallèle
16h cours -18h TD - 12h TP
TC1- CPPOO 96h - 9 Ects
BE 12h TPCPOOP
TC1: Conception et programmation parallèle et orientée objetVolume horaire: 96hRépartition:
Cours: 28hTD: 32hTP: 24hBE: 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.
Programmation Parallèle
Pourquoi ?
Systèmecomplexe
Exigence:Décomposition en activités « indépendantes »
Matériel
multiprocesseur
réseaux
monoprocesseur
Plateforme
Centralisé Distribué
Pseudo-parallélisme Parallélisme réel
----------------
----------------
Multiprocesseur: UC1..UCn
Monoprocesseur: UCréseaux
MC
P0 P1
Passage de contrôle
S1 S2 S3 Sn
----------------
----------------
----------------
----------------
Expression du parallélisme
Processus
Définition utilisateur
Programme en cours d’exécution
Définition système
Descripteuridentitéétatpcontexte:
Pile du processus__:_Ad_SDonnéesAd_Code
S_Données__
Ad_Code__
Processus
États d’un processus
• Selon implantations, sous-états possibles
PRÊT BLOQUÉ
ACTIF
TERMINÉ
Créé
AllocationPréemption
Attente
Fin, destruction
Plusieurs processusPrêts attendent l’UC
Le processus élu est choisit selon une politique de schedulling
Processus UnixS_Données_PèreX 0Pid Num_Fils
S_Code
S_Pile_Père
Main(){ int x, pid;
x=0; pid = fork();if (!pid) x=1;else x=2;
}
S_Données_filsX 0Pid 0
S_Pile_Fils
Processus Unix
S_Code
S_Pile_Père
Main(){ int x, pid;
x=0; pid = fork();if (!pid) x=1;else x=2;
}
S_Pile_FilsS_Données_filsX 1Pid 0
S_Données_PèreX 2Pid Num_Fils
Thread « processus léger »
Expression du parallélisme
de partager l’espace d’adressage avec d’autres
Permettre à une activité parallèle
contrairement aux processus
processus
t1 t2 t3 tn
S_Données_processus
_
Un thread est crée, seulement, par un processus
Un processus peut créer plusieurs 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
Le processus père joue le rôle du processeur / à ses threads
États d’un thread
• Selon implantations, sous-états possibles
PRÊT BLOQUÉ
ACTIF
TERMINÉ
Créé
AllocationPréemption
Attente
Fin, destruction
les threads Prêts attendent dans le processus
Le thread élu est choisit selon une politique de schedulling.Il s’exécute quand le processus est actif
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
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
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
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
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
Exemple: Thread Unix
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é
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
2 Modèles du parallélisme
I- Modèle Synchrone
Flot de données
Flot de contrôle
P0--------------------------------
P1--------------------------------
Pn--------------------------------
Horloge
t0
t1
t2
t3
t4
• Une seule horloge
• A chaque top tous les processus s’activent
• exécution // entre 2 top
• interaction 0
Lustre
Esterel
2 Modèles du parallélisme
II- Modèle Asynchrone
H0 H1 H2 ……. Hn
• Indépendance
• interaction 0
Quelques Problèmes Causes
coopération Partage de ressources
Communication&
Synchronisation
Synchrone
Asynchrone
Variables partagées
Envoie de messages
Quelques Problèmes
Exclusion MutuelleCommunication Synchrone
Communication Asynchrone
Attendre & Signaler un événement
Diffuser un événement
Allocation de Ressources
Fichier Partagé
Pilote d’Entrée /Sortie
::::::::
Propriétés Comportementales
SûretéSection Critique
Non Inter blocage
VivacitéNon Famine
Équité