Middleware Notions de programmation OO concurrente et distribuée

Transcription

Middleware Notions de programmation OO concurrente et distribuée
Middleware
Plan
Notions de programmation OO
1. Introduction
2. Concepts liés à l’approche objet
concurrente et distribuée
3. Concurrence
4. Répartition
Lionel Seinturier
5. Bibliographie
Université Pierre & Marie Curie
Middleware / OO - concur - rép
1
Lionel Seinturier
Middleware / OO - concur - rép
1. Introduction
2
Lionel Seinturier
1. Introduction
Introduction de la notion d’objet dans un environnement réparti
Ö Mieux structurer les applications
Ö Simplifier la conception, le développement, la maintenance
Ö Uniformiser l’accès au système au travers d’un
Quelques notions
• Encapsulation : l’objet protège les données en ne les rendant visibles
qu’au travers des méthodes
• Instanciation : les objets sont créés à partir de moules (les classes)
• Héritage : les classes peuvent être définies en dérivant des classes existantes
Langage OO concurrent et réparti
Objet = données + méthodes
données ≈ variables
méthodes ≈ traitements
Middleware / OO - concur - rép
d1
M1
données et méthodes sont appelées
les membres de la classe
3
Classification (P. Wegner)
Données
d2
M2
• Langage basé objet : langage avec un mécanisme d’encapsulation (Ada)
• Langage basé classe : avec en plus un mécanisme d’instanciation (Simula)
• Langage orienté objet : avec en plus un mécanisme d’héritage
(Smalltalk, C++, Java)
M3
Méthodes
Lionel Seinturier
Middleware / OO - concur - rép
4
Lionel Seinturier
2. Concepts objet
2.1 Interface
Définir les services rendus par un objet
2.1 Interface
• ensemble des méthodes accessibles par les utilisateurs de l’interface
2.2 Classe
• définition des identifiants de méthodes (ex. : empile, depile)
• définition des profils d’appel (synonyme signatures) des méthodes
= ensembles des paramètres (type + identifiant)
• définition des paramètres de retour des méthodes
• pas de code (simple déclaration)
2.3 Polymorphisme
2.4 Héritage
2.5 Conversion d’objets
interface Pile {
void empile( int element );
int depile();
}
Middleware / OO - concur - rép
5
Lionel Seinturier
Middleware / OO - concur - rép
2.2 Classe
Opérations sur les classes
• définition des données de la classe
• définition du code des méthodes de la classe
• instanciation : opération new
obj = new maClasse();
- création d’un objet ( = instance, = représentant de la classe )
- appel d’une méthode dite «constructeur»
pour initialiser les données de l’objet
- les classes abstraites ne peuvent pas être instanciées
(classes partiellement implantées i.e. certaines méthodes n’ont pas de code)
• une classe peut implanter 0, 1 ou plusieurs interfaces
• une même interface peut être implantée par plusieurs classes
interface Trieuse { int[] trier( int[] tableau ); }
class TriBulle implements Trieuse { ... }
class TriFusion implements Trieuse { ... }
• destruction
interface Total { int sigma( int[] tableau ); }
class Tri implements Trieuse, Total {
int[] donneesIntermediaire;
int[] trier( int[] tableau ) { ... }
int sigma( int[] tableau ) { ... }
}
class TriBis implements Trieuse, Total { ... }
7
Lionel Seinturier
2.2 Classe
Définir l’implantation d’un service
Middleware / OO - concur - rép
6
- destruction de l’objet ( = libération de la mémoire occupée par ses données)
- soit explicitement (C++)
: opérateur delete obj
- soit implicitement (Java)
: lorsque l’objet n’est plus utilisé
Lionel Seinturier
Middleware / OO - concur - rép
8
Lionel Seinturier
2.2 Classe
2.2 Classe
Résumé
Accessibilité des membres
3 niveaux principaux pour chaque membre (donnée ou méthode)
interface
• public : toutes les classes peuvent accéder au membre
• protected : seules les sous-classes peuvent y accéder
• private : le membre n’est accessible que par sa classe
interface
est implan
tée par 0,n
implante
0,n
classe
est instan
ciée en 0,n
objet
classe
est mem
bre d’ 1
objet
Membres d’objets / membres de classes
Remarque : selon les langages, les classes sont
• par défaut les membres sont accessibles via un objet
• certains peuvent l’être via une classe
public class Thread { public static void sleep(long time); ... }
appel par
et non par
Thread.sleep(1000);
obj = new Thread(); obj.sleep(1000);
Middleware / OO - concur - rép
9
Lionel Seinturier
- statiques
déclarées une fois pour toutes à la compilation (C++, Java)
- dynamiques
considérées comme des objets pouvant être instanciés (Smalltalk)
Middleware / OO - concur - rép
10
2.3 Polymorphisme
Lionel Seinturier
2.4 Héritage
Définir de nouveaux éléments à partir d’éléments existants
Associer plusieurs formes aux éléments d’un langage
• héritage de classe
• héritage d’interface
• Polymorphisme de méthode
une même méthode possède ≠ signatures
membres (données + méthodes) de la sur-classe
} les
(resp. interf.) sont repris dans la sous-classe (resp. interf.)
Héritage simple
void empiler( int element );
void empiler( float element );
void empiler( float element, int nombreDeFois );
Héritage multiple
Personne
• Polymorphisme de classe
une même classe se décline sous ≠ formes
par exemple en fonction d’un paramètre de généricité (C++)
Enfant
template <class T> class List { ... };
Pile
Parent
Le graphe d’héritage est un arbre
Tableau
PileFixe
Le graphe d’héritage doit être acyclique
C++ : pas d’interface, héritage simple & multiple
Java : interface, héritage simple, pas d’héritage multiple
Middleware / OO - concur - rép
11
Lionel Seinturier
Middleware / OO - concur - rép
12
Lionel Seinturier
2.5 Conversion d’objets
3. Concurrence
Convertir le type des objets
• Tout objet issu d’une hiérarchie d’héritage peut être converti
en un objet d’une classe parente,
mais pas d’une classe fille, ni d’une classe quelconque
3.1 Degrés de concurrence
3.2 Association objet/activité
• Les objets dont la classe a été «affaiblie» peuvent être
reconverti vers leur classe d’origine
C0
Ex : C2
C1
obj = new C2();
(C0) obj
(C4) obj
3.3 Effets de bord de l’invocation de méthodes
3.4 Synchronisation
valide
interdit (erreur de conversion de type)
C2
une instance de C2 peut être convertie vers C0 ou C1,
mais pas vers C4 ou C3
Middleware / OO - concur - rép
13
C3
C4
Lionel Seinturier
Middleware / OO - concur - rép
3.1 Degrés de concurrence
Deux types d’objets concurrents
Objet passif
Rq: le terme parallélisme est lié aux machines multi-processeurs
4 degrés de concurrence (adapté de P. Wegner, J.P. Briot et al.)
• séquentiel : une seule méthode est exécutée à la fois par l’objet
• quasi-concurrent : plusieurs activations de méthodes coexistent,
mais au plus une seule n’est pas suspendue
• complètement concurrent : concurrence sans aucune restriction
ne s’applique qu’aux objets sans état
(i.e. sans données)
• concurrent : plusieurs activités peuvent s’exécuter, mais le programmeur
peut restreindre le degré de concurrence pour :
garantir la cohérence des données, limiter la charge, ...
15
Lionel Seinturier
3.2 Association objet/activité
Concurrence : possibilité d’exécuter +sieurs activités simultanément
Middleware / OO - concur - rép
14
Lionel Seinturier
Objet actif
L’activité
• manipulée de façon explicite
• orthogonal à l’objet
• se «plaque» sur les méthodes
Une (+sieurs) activité dédiée
à l’objet exécutent les méthodes
appelant
appelant
Ex :
thread Java
Middleware / OO - concur - rép
16
Lionel Seinturier
3.3 Effets de bord de l’invocation
3.4 Synchronisation
Restreindre la concurrence
Modes d’invocation de méthodes
Client
Serveur
Client
Synchrone
{
Concur
rence
Serveur
Client
Asynchrone
Serveur
Semi-synchrone
Synchrone : le client attend la réponse pour continuer son exécution
Asynchrone : le client n’attend pas de réponse et continue tout de suite
Semi-synchrone : le client continue son exécution après l’envoi et
pourra récupérer le résultat ultérieurement
Semi-sync. futur explicite
(boîte à lettres)
Semi-sync. futur implicite
(via les variables résultats)
factorielle << maBAL << n;
...
maBAL >> res;
k = factorielle(n);
...
printf(«%d\n»,k);
Middleware / OO - concur - rép
17
Lionel Seinturier
But : garantir la cohérence, limiter la charge
Ex : exclusion mutuelle, lecteurs/écrivain, transaction
Ö Restriction des méthodes exécutables pour un objet
en fonction de l’état
des données de l’objet
en fonction de l’état
d’exécution de l’objet
ex : Pile avec empile et depile
vide : empile
1/2 : empile et depile
plein : depile
ex : Fichier avec lire et écrire
soit +sieurs lire simultanément
soit 1 seul ecrire
Middleware / OO - concur - rép
3.4 Synchronisation
sémaphores
objets avec méthodes P et V
moniteurs
objet avec méthodes synchronized,
wait et notify (ex Java)
expressions
de chemin
opérateurs , * | // pour spécifier
les séquences valides de méthodes
gardes
chaque méthode est associée
à une condition booléenne
remplacements
de comportements
graphes
états/transitions
Middleware / OO - concur - rép
18
Lionel Seinturier
4. Répartition
4.1 Communication
4.2 Nommage
4.3 Sécurité d’accès
4.4 Durée de vie des objets
4.5 Synchronisation inter-objets
chaque objet a +sieurs «comportements»
chacun correspond à l’exécution d’une méthode
on spécifie avec la primitive become le cpment suivant
4.6 Migration
chaque objet est associé à un ensemble d’états
chaque état est associé à un sous-ensemble de
méthodes pouvant être exécutées
4.8 Ramasse-miettes
19
synchro. intra-objet
synchro. comportementale
Lionel Seinturier
4.7 Réplication
Middleware / OO - concur - rép
20
Lionel Seinturier
4.1 Communication
4.2 Nommage
Solution la plus simple : l’invocation de méthode distante est réalisée par un RPC
Client
1
opération
Serveur
10
6
Souche
client
2
Souche
serveur
9
Transport
client
5
7
8
4
Transport
serveur
1. Appel local
2. Préparation du
message d’appel
3. Envoi
4. «Upcall» vers
la souche serveur
5. Décodage du message
6..10 : Chemin inverse
• Deux objets ≠ sur le même site ou sur des sites ≠
ne doivent pas avoir la même identité (on parle de référence)
• La référence sert à «retrouver» l’objet pour pouvoir invoquer ses méthodes
• Généralisation de la notion de pointeur à un environnement réparti
Deux techniques principales
• un ID sans rapport avec la localisation généré par une fonction mathématique
+ une table de translation entre l’ID et la localisation de l’objet
• un ID en deux parties : son site de création + un numéro local unique
Recherche d’un objet à partir de sa référence
3
Eventuellement d’autres messages en cas de sémantiques + complexes
(détection de pannes client, serveur, réseau)
Middleware / OO - concur - rép
Identifier les objets dans un environnement réparti
21
Lionel Seinturier
• annuaires de localisation centralisés ou répartis, ou diffusion
• interrogation du site contenu dans la référence + liens de poursuite
Middleware / OO - concur - rép
4.3 Sécurité d’accès
22
Lionel Seinturier
4.4 Durée de vie
Gérer le partage des objets dans un environnement réparti
Gérer la durée de vie des objets
Pour des raisons de sécurité, l’accès à certains objets peut être restreint
• Objets temporaires : leur durée de vie correspond à celle de leur créateur
- en fonction de l’identité de l’objet appelant
ex : seuls les accès en provenance de l’intranet sont autorisés
- à partir d’une liste de contrôle d’accès
ex : mot de passe, mécanismes de clés de session, ...
• Objets persistants
- l’objet reste présent en mémoire tant qu’il n’est pas détruit
- la persistance peut être limitée par la durée de vie du système
ou s’étendre au delà des redémarrages
La restriction peut
- interdire complètement l’accès à l’objet
- fournir une vue «dégradée»
ex : autoriser les méthodes qui fournissent un service de consultation
mais interdire celles qui modifient l’état de l’objet
Plusieurs possibilités
Ö Nombreuses informations à ajouter aux objets
Middleware / OO - concur - rép
23
Lionel Seinturier
- tous les objets sont persistants ou non
- un objet est crée persistant ou non
- un objet temporaire peut devenir persistant et vice-versa
- un objet référencé par un objet persistant est persistant ou non
Middleware / OO - concur - rép
24
Lionel Seinturier
4.5 Synchonisation inter-objets
4.6 Migration
Gérer les dépendances entre objets
Déplacer des objets
Ö mécanismes de synchronisation pour en préserver la cohérence
• d’un espace d’adressage à un autre
• d’une zone de stockage à une autre (mémoire, disque)
• d’un site à un autre
Exemple : un transfert entre deux objets comptes bancaires
Assurer qu’un ensemble de 2 ou +sieurs invocations de méthodes
compte1.depot(50);
compte2.retrait(50);
s’effectuent complètement ou pas du tout ( + propriétés ACID /* cf. BD */ )
Problématique de la théorie de la sérialisatibilité et des moniteurs transactionnels
Ö intégration du moniteur dans le système réparti objet avec un
- protocole de validation (2PC ou 3PC)
- mécanisme de verrouillage des ressources
- mécanisme de détection et de traitement des conflits
Middleware / OO - concur - rép
25
Lionel Seinturier
4.7 Réplication
Objectifs
- réduire les coûts de communication entre objets «bavards»
- répartir la charge vers les sites inutilisés
- augmenter la disponibilité d’un service en le rapprochant de ses clients
Nombreux problèmes à résoudre
- interrompre ? attendre la fin ? des traitements en cours avant de migrer
- impact de la migration sur la référence ?
Middleware / OO - concur - rép
26
Lionel Seinturier
4.8 Ramasse-miettes
Dupliquer des objets sur +sieurs sites
Détruire les objets qui ne sont référencés par aucun autre
Objectif principal : tolérance aux fautes
Objectif : récupérer les ressources (mémoire, CPU, disque) inutilisées
Difficulté / aux systèmes centralisés : suivre les références entre sites distants
Active
Passive
(primary-backups)
Deux techniques
• comptage de références : on associe un compteur à chaque objet
+1 lorsque la référence est acquise
-1 lorsque elle est libérée
• traçage : périodiquement on parcourt le graphe des objets à partir d’une racine
à la fin, les objets non marqués peuvent être détruits
client
client
réplique 1
réplique
primaire
Comparaison
• Inconv. : utilisation mémoire / Avant. : simple
• Inconv. : temps CPU pour le traçage / Avant. : pas de modification des objets
réplique 2
réplique 2
réplique 3
réplique 3
Middleware / OO - concur - rép
27
Lionel Seinturier
Middleware / OO - concur - rép
28
Lionel Seinturier
5. Bibliographie
• Numéro spécial, Concurrent Object Oriented Programming, Communications of the
ACM 36(9), Sept. 1993.
• C. Atkinson, Object-Oriented Reuse, Concurrency and Distribution,
Addison Wesley, 1992.
• R. Balter, J.P. Banâtre, S. Krakowiak editeurs, Constructions des systèmes
d’exploitation répartis, 1991.
• B. Meyer, Object-Oriented Software Construction, Prentice Hall, 1997.
• J.P. Briot, R. Guerraoui, Objets pour la Programmation Parallèle et Répartie :
Intérêts, Evolutions et Tendances, TSI 15(6):765-800, Juin 1996.
• A. Tanenbaum, Distributed Operating Systems, Prentice-Hall, 1994.
Middleware / OO - concur - rép
29
Lionel Seinturier