Mobilité de threads dans l`environnement JAVA

Université de Bretagne Occidentale
Faculté des Sciences et Techniques
Maîtrise d’Informatique
Option
Système Réactif & Intelligent
Juin 2001
Mobilité de
threads dans
l’environnement
Réalisé par
Encadré par
Mr. Karim
Mr. Daliane
JAVA
FILALI &
MOHAMED
Mr. Frank Singhoff
----------------------------------------------------------------------------------------------------------------------------------Faculté des Sciences et Techniques
6, Avenue Le Gorgeu, B.P.809 29285 BREST Cedex – Tel. 02.98.01.61.23
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
DEDICACES
Nous dédions ce travail
J
A nos chers parents pour leurs sacrifices et encouragements
J
Au corps administratif et professoral de l’UBO
J
A tous les étudiants de département Informatique
J
A tous nos amis.
----------------------------------------------------------------------------------------------------------------------------2
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
Je tiens à remercier profondément
` Mr Bernard POTTIER le Responsable
de la maîtrise
`
Mr Frank SINGHOFF notre encadrant qui
a été toujours à notre aide durant toute
la période de la réalisation de ce travail
` Le corps administratif et professoral de
l’Université de Bretagne Occidentale
`
et tous ceux qui ont pu nous aider de prés ou de
loin à réaliser ce travail.
----------------------------------------------------------------------------------------------------------------------------3
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
SOMMAIRE
I
INTRODUCTION ………………….…….…….…….…………………………. 7
II
L’ENVIRONNEMENT JAVA ………………….…….…….…….………...8
1- Définition du langage Java ………………….…….…….…….……….………….. 8
2- Compilation et Interprètation ………………….…….…….…….……….……... 9
a) Compilation ………………….…….…….…….…………………….….…….. ..9
b) Interprétation ………………….…….…….…….……………………………..10
3- Exemples de programmes java ………………….…….…….…….……….……..10
a) Premier exemple ………………….…….…….…….………….……...………..10
b) Deuxième exemple ………………….…….…….…….…………….……. …. 12
4- Machine Virtuelle Java (JVM) ………………….…….…….…….……….……. 13
5- Pourquoi l’environnement Java ? ………………….…….…….…….………….. 15
III
LA MOBILITE DES THREADS (La Mobilité Des Agents) …………………. 16
1- Définition de threads et sa syntaxe ………………….…….…….…….………… 16
2- Définition de la mobilité ( Les agents mobiles) ………………….…….………....18
3- Une petite comparaison entre deux paradigmes ………………….…….…….. 19
a) client/serveur ………………….…….…….…….……….……………………..19
b) agents mobiles …………………………….…….…….…….……….………...20
4- Caractéristiques des Agents Mobiles ……………….…….…….…….………… 20
5- Synopsis de Fonctionement ………………….…….…….…….……….………. 21
6- Les mécanismes de la mobilité des threads ………………….…….…….…….…22
6-1 Les mécanismes pour la migrations ……………….…….…….…….……….. 22
6-2 Les mécanismes pour le clonage ……………….…….…….…….…………. 23
6-3 Mécanisme de Sérialisation/Désérialisation du contexte d’exécution …...…… 23
7- Contexte d’exécution ………………….…….…….…….……….………………. 23
8- Les langages utilisés pour l’implantation ………………….…….…….………... 25
----------------------------------------------------------------------------------------------------------------------------4
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
IV
PRINCIPES DU MECANISME DE MIGRATION …….……..……. 26
1- Etat d’un thread Java
…….…….………………….…….…….…….……….……. 26
2- Mécanisme de migration ……………………………………………………………… 28
3- Mécanisme d’extraction du contexte d’execution d’un thread .………………….… 28
3-1 Traitement utilisant la Pile JAVA …….…….…….…….…….…….…….….. 29
3-2 Traitement utilisant le Tas d’objets …….…….…….…….…….………….. 30
3-3 Traitement utilisant la Zone de méthodes …….…….…….…….…….…….. 30
4- Mécanisme de transfert d’un contexte d’execution ……………………………… 30
4-1 Traitement utilisant la Pile JAVA …….…….…….…….…….…….……….. 30
4-2 Traitement utilisant le Tas d’objets …….…….…….…….…….…….…… 31
4-3 Traitement utilisant la Zone de méthodes …….…….…….…….…….…….. 31
5- Mécanisme d’intégration d'un contexte d’exécution à un nouveau Thread …… 31
5-1 Traitement utilisant la Pile JAVA …….…….…….…….…….……………. 31
5-2 Traitement utilisant le Tas d’objets …….…….…….…….…….…….………31
5-3 Traitement utilisant la Zone de méthodes .…….…….…….…….…..…..…... 32
5-4 Lancement de l'
exécution du nouveau Thread …….…….…………….……32
V REALISATION DU MECANISME DE MIGRATION ………………… 33
1- Extension de la JVM
……………………………………………………………… 33
2- Problèmes rencontrés
………………………………………………………………. 36
3- Domaines d’utilisation ……………………………………………………………… 37
3.1 Les agents mobiles ….…….…….…….…...….…….…….…….…..….……. 38
3.2 La tolérance aux fautes……………………….………………………….……. 38
VI
CONCLUSION……………………….……………………………...…40
GLOSSAIRE ………………………………………………….……………………....41
ANNEXES ………………….…………………………………..……………………42
BIBLIOGRAPHIE …………………………………………………….………….…49
----------------------------------------------------------------------------------------------------------------------------5
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
RESUME
Le succès croissant des environnements multithreads distribués s’accompagne
d’exigences de plus en plus grandes concernant leur portabilité et leur efficacité.
Les processus légers, ou threads, ont longtemps connu une exploitation presque
exclusivement destinée à la mise en œuvre de politique d’équilibrage ou de tolérance aux
pannes. Aujourd’hui leur évolution dû en grande partie à la maturité des environnements
multithreads distribués leur vaut d’être l’objet d’un intérêt croissant. En effet, dans ces
environnements, les performances d’une application dépendent grandement des performances
du réseau. Le transfert d’un processus peut alors apparaître comme un outil de coût
raisonnable permettant à un programme de s’adapter à son environnement. Le problème de
l’hétérogénéité sont partiellement résolus grâce à l’utilisation de langages interprétés tels que
Java, Tcl, Telescript.
Dans ce rapport nous avons étudié les différentes solutions proposées pour la migration de
threads en particulier dans l’environnement Java.
----------------------------------------------------------------------------------------------------------------------------6
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
I
INTRODUCTION
La nécessité d’équilibrer la charge de calcul et de permettre à une application de résister
aux pannes a conduit des équipes de recherches universitaires et industrielles à s’intéresser
aux mécanismes permettant de déplacer un programme en cours d’exécution d’un site à un
autre. Ces travaux ont abouti à la mise en œuvre de mécanismes de mobilité permettant à des
processus de migrer. Cependant la mobilité est difficile à implanter, elle est coûteuse, peu
compatible et pose des problèmes de sécurité. Pour ces raisons, ces techniques de migration
ont longtemps été délaissées d’autant plus qu’ils ne sont pas une nécessité des applications
réparties.
La Machine Virtuelle Java est actuellement portée sur la plupart des systèmes courants et
fournit des services facilitant le développement d’applications distribuées. La mobilité y est
un aspect très important. En effet, Java fournit un mécanisme de sérialisation d’objets
permettant le capture et la restauration de l’état des objets Java ainsi que le déplacement entre
différents sites de ces objets. En revanche, Java ne fournit pas de services permettant la
capture et la restauration de l’état d’un thread.
Nous présentons dans ce rapport une brève présentation du langage Java, tout en
expliquant le choix de ce langage pour le développement de tels mécanismes. Nous abordons
ensuite les différents mécanismes utilisés pour la migration des threads ainsi que les
problèmes rencontrés, en nous concentrons sur les expérimentations et les résultats obtenus
par le laboratoire SIRAC. Nous finissons par un exposé des différentes solutions
universitaires et industrielles pour la migration des threads et nous concluons par les
différentes perspectives ouvertes par ces services.
----------------------------------------------------------------------------------------------------------------------------7
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
II
L’ENVIRONNEMENT JAVA
Dans cette partie, nous allons
définir le langage Java, ses propriétés ainsi que ses
avantages, puis nous expliquerons les étapes de compilation, interprétation et exécution;
ensuite, nous donnerons des exemples pour mettre ce que nous allons dire en pratique avec
une description détaillé, ainsi que le fonctionnement de la Machine Virtuelle Java; et enfin,
nous invoquerons quelques avantages et les motifs pour l’utilisation de ce langage.
1- Définition du langage Java :
C’est un langage très récent, puisqu’il a été introduit par Sun en 1995. Son immense
succès est dû au fait qu’il possède de nombreux caractéristiques intéressantes.
C’est un langage orienté objet inspiré de :
- Smalltalk, C (utilisation des références d’objet, polymorphisme dynamique,
bibliothèques de classes, garbage collector, …) .
- Ada (paquetage, exception …) dans sa sémantique.
- C + + dans sa syntaxe.
C’est une architecture distribuée qui offre une solution au problème de la distribution
d’objets entre plates-formes hétérogènes grâce aux applets. Le langage Java offre la
possibilité de charger du code (applet) et des composants(Java Beans) pour les exécuter sur le
poste client.
Java est indépendant des architectures, ce qui nous permet de dire qu’il est portable :
- Les UNIX
- MacOS
- Windows 95, NT
Il permet d’écrire des programmes orientés objets puissants et il fournit des API pour les
interfaces graphiques, le son, le multithreading, la programmation réseau, base de données,
calcul scientifique, etc …
Il existe deux type de programme en Java :
- un programme à interpréter sans le Web : application autonome (standalone).
- un programme chargeable par Internet à l’aide d’un client Web et exécuté en local à
l’aide de l’interpréteur intégré dans le client Web : les applets.
L’Applet est une application écrite en Java et compilée en bytecode. Ce bytecode est
interprété par une machine virtuelle Java.
----------------------------------------------------------------------------------------------------------------------------8
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
Résumé :
A partir de ce qui est dit précédemment on peut résumer les atouts de java, qu’il est un
langage de programmation
-
Orienté Objet,
Portable,
Multithread,
Simple,
Gérant la mémoire et Sécurisé.
et proposant plusieurs classes d'
objets, en particulier, la classe Thread à laquelle nous nous
intéresserons plus particulièrement.
2-
Compilation et Interprétation :
a) Compilation :
L’opération de compilation consiste à convertir les instructions données à l’ordinateuren
un langage qu’il comprend instantanément .
Pour compiler un fichier Program.java on exécute la commande :
javac Program.java (il faut mettre l’extension .java et respecter la casse du nom du fichier).
Le programme javac est le compilateur Java, il produit un fichier Program.class (en bytecode) qui pourra être exécuté par la suite par :
Java Program (il ne faut pas mettre l’extension .class)
Program.java
Javac Program.java
Program.class
Class program…
001011011
(code source)
(byte code )
Figure 1 : Compilation d’un programme Java
----------------------------------------------------------------------------------------------------------------------------9
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
b) Interprétation :
Le programme java est une machine virtuelle Java (JVM pour Java Virtuelle Machine) qui
interprète le code généré par le compilateur (byte-code) et l’exécute par la commande :
% java Program
Program.class
001011011
(byte code )
Figure 2 : Interprétation d’un bytecode
3-
Exemples de programmes Java :
a) Premier exemple :
Fichier HelloWorld.java
class HelloWorld
// Déclaration de la classe
{
// Début de bloc
public static void main ( String args[] )
// Déclaration de la méthode principale
{
// Début de bloc
System.out.println(" Programme plus simple ") ; // Ecriture de la chaîne de caractère
}
// Fin de bloc
}
// Fin de bloc
Figure 3 : Exemple d’un programme Java
----------------------------------------------------------------------------------------------------------------------------10
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
On compile :
%javac HelloWorld.java
// commande pour la compilation
On exécute :
%java HelloWorld
// commande pour l’inteprétation
Programme plus simple
// résultat affiché
Figure 4 : Trace de compilation et d’interprétation
Le langage JAVA est un langage interprété. La compilation d'un programme source Java
génère du code à interpréter (byte-code). Ce code interprété étant un format intermédiaire
entre le format source Java et le format binaire executable. De ce fait, un programme Java
compilé est indépendant de la machine, il peut s'exécuter sur tout type de machine, pourvu
qu'il y ait un interprète Java sur cette machine. Et avec le déploiment du Web, cette
caractéristique a rendu Java plus populaire, permettant de déplacer un même code Java
compilé d'une machine à une autre à travers l'Internet, ce qui nous permet de parler de la
Machine Virtuelle Java (JVM) que nous verrons dans la section suivante.
----------------------------------------------------------------------------------------------------------------------------11
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
b) Deuxième exemple :
Le programme suivant est un programme plus compliqué que le premier, il présente la
structure du programme Java, avec une description détaillée des différentes instructions.
Autre exemple plus serieux :
class Incrementer {
// déclaration de la classe Incrementer
int val;
public Incrementer (int val_init){
this.val=val_init;
}
// déclaration d’une variable val, type entier
// méthode d’initialisation de la variable
public int plus(){
this.val++;
}
// méthode plus() effectue l’opération d’incrementation
public static void main( String args[])
// fonction principale
{
Incrementer v;
// déclaration d’objet de type Incrementer
v = new Incrementer (4);
// création d’une nouvelle instance
v.plus();
// invocation de la méthode plus()
System.out.println(" valeur = "+val); // affichage du résultat
}
}
Figure 5 : Deuxième exemple d’un programme Java
Description du programme:
Le programme suivant commence par la déclaration de la classe Incrementer qui dérive de
la classe mère Objet, puis une déclaration d’une variable val de type entier, ensuite une méthode
qui permet d’initialiser la variable lors de la création d’une nouvelle instance de cette classe, et
une méthode plus() se charge de l’opération d’incrémentation de l’attribut val, et la méthode
principale main qui s’exécute lors du lancement de ce programme. Cette méthode déclare un
objet de type Incrementer, crée une nouvelle instance en initialisant val à 4 et appelle la
méthode plus() sur cette instance, et en fin l’affichage.
----------------------------------------------------------------------------------------------------------------------------12
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
4-
Machine Virtuelle Java (JVM) :
La Machine Virtuelle Java est un processeur logiciel dont le langage est le byte-code . Elle
possède, de ce fait, un ensemble d’instructions de byte code et manipule un ensemble de
registres lors de l’exécution d’un code.
Code source Java
compilation
Byte code Java
JVM
JVM
Archi.1
Archi.2
…..
JVM
Archi.n
Figure 6 : Principe d’homogénéisation de la JVM
Le byte code est un format de code indépendant de l’architecture de la machine sousjacente; il en résulte qu’une même suite d’instructions de byte code peut être exécutée par des
machines virtuelles Java installées sur différentes architectures. De ce fait la machine virtuelle
Java fournit l’abstraction d’une seule et même machine, indépendante de l’architecture sousjacente ; et permet ainsi de considérer un ensemble de machines hétérogènes comme un
système homogène.
Prog.source Java
compilation
Byte code Java
Machine Virtuelle Java
Une instruction de byte code
Interprète Java
Une suite d’instruction machine
Machine physique
Exécution des instructions machine
Figure 7 : Illustration détaillé de l’Interprète Java
----------------------------------------------------------------------------------------------------------------------------13
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
La compilation d’un programme source Java produit une suite d’instructions de byte code
stockées dans un fichier particulier ayant pour nom celui du fichier contenant le programme
source auquel est ajouté le suffixe .class. Le lancement de l’exécution d’un fichier .class
provoque la création d’un processus dont le rôle est de parcourir la suite d’instructions de
byte code stockées dans le fichier .class et interpréter, au fur et à mesure, chacune de ces
instructions.
Démarrage de la Machine Virtuelle Java :
Dés que la méthode principale main d’une classe est appelé, la machine virtuelle
commence son exécution et passe par 3 étapes :
a) Le chargement :
Lors de l’exécution d’un programme Java, la méthode principale main invoque la
machine virtuelle afin de charger la classe spécifié en utilisant un chargeur de classe le
ClassLoader .
b) La liaison :
Après le chargement de la classe, une opération de liaison s’effectue entre cette classe
et les autres classes et interfaces utilisés par cette classe, et cette opération passe par 3 étapes :
1. La vérification : consiste à vérifier que la classe respecte bien la sémantique de la
machine virtuelle Java.
2. La préparation : consiste à allouer certaines structures de données nécessaires à la
machine virtuelle.
3. La résolution : cette étape se charge de la traduction des références symboliques
utilisés dans la classe, en références directes.
c) L’initialisation :
Après avoir réalisé les opérations de chargement et de liaison de la classe, on effectue
l’étape d’initialisation des entités partagés par toutes les instances de la classe.
----------------------------------------------------------------------------------------------------------------------------14
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
5-
Pourquoi l’environnement Java ?
La technologie Java convient particulièrement bien au développement de plate-formes
et d'applications basées sur les objets distribués et mobiles. Voici quelques raisons :
•
Java est un langage de programmation passionnant. Il permet d’ajouter une animation
et du son à une page Web, d’écrire des jeux et des utilitaires très pratiques, de créer
des programmes avec une interface graphique et de concevoir des logiciels destinés à
l’Internet.
•
Java est portable. La portabilité de Java en fait un langage de choix pour les systèmes
distribués devant être déployés sur des réseaux hétérogènes.
•
Java est sécuritaire. La vérification dynamique des classes lors du chargement,
l'absence de pointeurs ainsi que les nombreuses fonctionnalités offertes par le langage
au niveau de la sécurité (security managers, encryption, etc.) font de Java un langage
très sécuritaire, et donc bien adapté aux systèmes distribués modernes.
•
Java offre beaucoup de support pour la programmation réseau. De nombreux outils
sont disponibles dans l’API standard de Java en ce qui concerne la programmation de
systèmes distribués: input/output streams, sockets, TCP/IP, RMI, etc.
•
Java supporte la sérialisation d'objets. La sérialisation consiste à transformer un objet
en une série d'octets. Si cela permet de stocker des instances d'objet sur disque pour
assurer leur persistence, cela permet aussi de transférer dynamiquement des objets (ou
des classes) entre deux machines Java via un réseau.
•
Java est un langage Orienté Objet moderne. Le langage Java est entièrement orienté
objet, il supporte le multithreading, offre un service de nettoyage automatique de la
mémoire (garbage collection), permet le chargement dynamique de classes, etc. Ces
aspects sont particulièrement utiles dans le contexte d'applications distribuées de haut
niveau.
----------------------------------------------------------------------------------------------------------------------------15
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
III
LA MOBILITE DES THREADS (La Mobilité Des Agents)
1-
Définition de threads et syntaxe :
Un thread aussi appelé processus léger ou activité est une suite d’instructions à
l’intérieur d’un processus. Les programmes qui utilisent plusieurs threads sont dits
multithreadés. Les threads peuvent être crées comme instance d’une classe dérivée de la
classe Thread. ils sont lancés par la méthode start(), qui demande à l’ordonanceur de
thread de lancer la méthode run() du thread. Cette méthode run() doit être implantée
dans le programme.
EXEMPLE DeuxThread.java
class DeuxThread
{
public static void main (String args[]) {
new UneThread (" La Thread 1 " ).start() ;
new UneThread (" La seconde Thread " ).start() ;
}
}
class UneThread extends Thread
{
Public UneThread( String str ) {
super(str) ;
}
public void run() {
for(int i=0 ; i<5 ; i++) {
System.out.println(i + " " + getName()) ;
Try {
sleep( (int)Math.random()*10 ) ;
}
catch( InterruptedException e ){
}
}
System.out.println( getName() + " est finie " ) ;
}
}
Figure 8 : Exemple de code d’un thread
----------------------------------------------------------------------------------------------------------------------------16
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
Trace d’exécution :
EXECUTION
Compilation :
% javac DeuxThread.java
Interprétation :
% java DeuxThread
Trace :
0 La Thread 1
0 La seconde Thread
1 La Thread 1
2 La Thread 1
1 La seconde Thread
3 La Thread 1
4 La Thread 1
2 La seconde Thread
3 La seconde Thread
4 La seconde Thread
La seconde Thread est finie
La Thread 1 est finie
Figure 9 : Trace de compilation et d’interprétation
Dans le domaine des systèmes répartis, on parle souvent des agents plutôt que threads. Le
terme agent est très utilisé actuellement. Bien qu'il n'existe pas encore une définition standard,
les chercheurs sont d'accord sur le fait qu'un agent est un programme autonome, capable d'agir
seul, même si l'utilisateur est absent, et dont le but est d’effectuer un ensemble de taches sur
des machines distantes et différentes lors de son déplacement, et de récupérer les résultats sur
la machine locale.
----------------------------------------------------------------------------------------------------------------------------17
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
2-
Définition de la mobilité ( Les agents mobiles) :
Un agent mobile est un agent qui peut se déplacer sur un réseau hétérogène sous son
propre contrôle. Ce type d'agent est très utile pour surpasser les faiblesses de la connexion,
mais des problèmes de sécurité reste à résoudre.
L’illustration suivante représente un agent mobile qui se déplace dans le réseau en
transportant un message. Au début l’agent migre vers le router puis le récipient pour s’assurer
que le message arrive à la boite destinataire spécifique.
Figure 10 : Illustration d’un agent mobile
Les agents mobiles se présentent comme une alternative au modèle client/serveur, qui est à
la base de la quasi- totalité des services proposés sur l'Internet d'aujourd'hui, pour certaines
applications qui nécessitent une plus grande flexibilité et une certaine mobilité.
Ces agents, s'ils permettent d'effectuer des taches qui auraient été nettement plus difficiles
à réaliser en utilisant d'autres techniques, ne vont pas sans poser un certain nombre de
problèmes relatifs à la sécurité en général et, en particulier, à l'intégrité, la confidentialité des
données transportées, mais aussi des hôtes exécutant ces agents.
----------------------------------------------------------------------------------------------------------------------------18
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
3-
Une petite comparaison entre deux paradigmes client/serveur et agents mobiles :
Apres que le modèle client/serveur ait montré ses limites pour certaines applications, les
chercheurs ont proposé une solution et celle des agents mobiles, vu ses avantages.
- Programmes spécialisés pouvant se déplacer dans un réseau afin d'exécuter une tache de
façon autonome .
- Réduction du trafic réseau, flexibilité, possibilité de collaboration entre agents, etc.
a)
client/serveur :
client/serveur
Client
Serveur
Requête
Service
Réponse
Figure 11 : Illustration du mécanisme de client/serveur
Dans ce paradigme, on a la notion de client, service et serveur; c’est à dire un client
demande un service auprès du serveur ( ex : service d’impression, de base de données ) d’une
façon interactive et synchrone entre le client et le serveur, ceci signifie que le client est
bloqué tant que le serveur n’a pas répondu. Et dans le cas où le serveur répond, cette
opération se fait par diffusion de flot de données (voir page 40 : Annexe 1 : Client / Serveur ).
----------------------------------------------------------------------------------------------------------------------------19
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
b)
agents mobiles :
agents mobiles
Site B
Site de création
Migration
Migration
Agent
Site A
Figure 12 : Illustration du mécanisme d’un agent mobile
Dans ce modèle, on a la notion d’agents qui se déplacent d’une façon autonome entre les
machines d’un réseau pour réaliser certaines tâches en disposant des états au cours de leurs
exécutions. Ces agents s’exécutent d’une façon asynchrone ce qui nous permet de dire que ce
paradigme est mieux adapté que le client/serveur à des traitement longs (Voir page 43 :
Annexe 2 : Thread Mobile ).
Ce modèle est souvent utilisé dans le domaine de la Recherche dans le Web,
Administration réseau, le commerce électronique, la gestion de la mobilité et les services
évolués de télécommunications etc..
4-
Caractéristiques des Agents Mobiles :
Un agent est généralement défini comme un système informatique logiciel qui répond
aux propriétés suivantes :
©
La mobilité : la capacité d'un agent à se déplacer dans un réseau informatique
entre les machines .
©
La véracité : la conjecture selon laquelle un agent ne communique pas de
mauvaises informations sans le savoir.
©
Le bénévolat : la conjecture selon laquelle les agents n’ont pas de buts
incompatibles, et que chaque agent essaiera de faire ce qu’on attend de lui.
----------------------------------------------------------------------------------------------------------------------------20
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
5-
©
La rationnalité : la conjecture selon laquelle un agent agira de sorte à atteindre ses
objectifs, au moins dans la limite de ses convictions.
©
Autonomie : les agents opèrent sans intervention directe d'être humain ou autre,
et ont un certain contrôle sur leurs actions et leur état interne.
©
Comportement social : les agents interagissent avec d'autres agents (éventuellement
humains) via une sorte de langage de communication agent.
©
Réactivité : les agents perçoivent leurs environnements qui peuvent être le monde
physique, un utilisateur via une interface graphique, une collection d'autres agents,
l'Internet ou même tous à la fois ; et répondent aux changements qui apparaissent.
©
Comportement intentionnel : les agents n'agissent pas simplement en réponse à
leur environnement, ils sont capables d'avoir un comportement dirigé vers un but et
de prendre des initiatives.
Synopsis de Fonctionnement :
Il y a une liste d’ Hôtes permettant l’accueil et la réception des agents migrants.
Un agent part d’un Hôte Initiateur, puis migre vers d’autres Hôtes tout en effectuant un
certain traitement spécifié à chaque fois qu’il y débarque, jusqu’à ce qu’il revienne sur l’Hôte
de départ, en ramenant ses résultats et les affiche.
Migre (Agent)
Migre (Agent)
Agent
Agent
Agent
Prod1 : Prix1
Prod2 : Prix2
Prod3 : Prix3
Prod1 : Prix1’
Prod2 : Prix2’
Prod3 : Prix3’
Migre (Agent)
Réseau
Site initiateur
Hote
Hote
Figure 13 : Schéma d’un Agent Mobile
----------------------------------------------------------------------------------------------------------------------------21
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
Le Schéma présente un exemple d’un agent mobile qui se déplace d’un système à un
autre, de façon à exécuter un certain nombre de taches définies par l’utilisateur. Cet agent a la
particularité de transporter avec lui des données et programmes. Par exemple, cet agent
mobile pourrait déterminer le meilleur prix pour un produit proposé par les serveurs de
plusieurs fournisseurs, en les consultant successivement, les uns après les autres, puis en
revenant sur l’ordinateur de l’utilisateur avec la meilleure offre.
6- Les mécanismes de la mobilité des threads :
Dans cette partie, nous allons invoquer les mécanismes de la mobilité des threads tels que
la migration, le clonage et la sérialisation/désérialisation . Nous détaillerons chaqu’un de ces
mécanismes ultérieurement.
6-1
Les mécanismes pour la migrations :
La migration d’un thread, est le déplacement de son exécution d’une machine source vers
une autre machine destination. On peut distinguer deux type de migrations, faible et forte. La
première est lorsqu’un thread interrompe son exécution à un moment donné, puis se déplace
vers une machine destinataire en reprenant l’exécution depuis le début. La deuxième
migration est lorsque le déplacement se fait de telle sorte que l’exécution du flot sur la
machine destination reprenne au point où elle a été interrompue sur la machine source; et
nous nous intéresserons qu’au modèle de migration forte. On peut représenter ce paradigme
en 3 principales étapes :
a) L’extraction du contexte d’exécution d’un thread :
Cette étape a pour rôle d’interrompre l’exécution d’un flot de contrôle (thread Java) et
d’extraire l’image de son exécution. Ce contexte d’exécution est une structure de
données contenant les informations nécessaire à la restitution de ce contexte.
b) Le transfert de contexte d’exécution de la machine source vers la machine destination :
Cette étape a pour rôle de transférer le contexte d’exécution extrait au cours de l’étape
d’extraction, d’une machine virtuelle Java source vers une machine virtuelle
destination.
c) L’intégration du contexte d’exécution reçu :
L’étape de l’intégration du contexte d’exécution reçu, a pour rôle de créer un nouveau
thread, de lui attribuer les informations constituant le contexte d’exécution, puis de
lancer ce thread pour s’exécuter tout en reprenant l’exécution au point où elle a été
interrompue.
----------------------------------------------------------------------------------------------------------------------------22
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
6-2
Les mécanismes pour le clonage :
Le mécanisme de clonage est quasi identique de ce lui de la migration, la différence
vient du fait que, le thread poursuit son exécution après interruption et extraction du contexte
d’exécution. Ce mécanisme, on peut le définir comme suit :
a) L’extraction du contexte d’exécution d’un thread .
b) Le transfert de contexte d’exécution de la machine source vers la machine destination.
c) L’intégration du contexte d’exécution reçu .
d) Poursuite d’exécution du thread sur la machine source.
Ce mécanisme a pour objectif de dupliquer l’exécution d’une application sur plusieurs
machines afin de tolérer les pannes.
6-3
Mécanisme de Sérialisation / Désérialisation du contexte d’exécution :
Le mécanisme de Sérialisation / Désérialisation (Sauvegarde / Reprise) consiste à extraire
le contexte d’exécution d’un thread au cours de son exécution après chaque interruption, et de
sauvegarder ce contexte qui est l’état du flot Java dans un fichier qui sera crée. Cette
opération est appelé l’opération de Sérialisation. Puis, dans le cas du besoin de ce contexte,
on le restaure et on le récupère à partir de ce fichier. Cette opération est appelé l’opération de
Désérialisation. Les interruptions momentanées n’arrêtent pas l’exécution du thread
définitives, mais après chaque interruption, le thread reprend son exécution normal.
7-
Le contexte d’exécution :
Le contexte d’exécution d’un thread Java est composé de plusieurs structures de données
qui peuvent être résumés en 3 organes :
La pile Java :
C’est une pile qui est associé à chaque thread. Cette pile décrit l’état d’avancement de
l’exécution du thread, et elle contient des zones qui seront crées à chaque appel à une
méthode Java, et chaque zone contient un ensemble d’informations comme les variables
locales de la méthode ainsi que les résultats intermédiaires .
----------------------------------------------------------------------------------------------------------------------------23
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
Le tas d’objets :
C’est une zone partagée par tous les threads, elle contient l’ensemble des objets Java
utilisés par ces threads.
La zone des méthodes :
C’est aussi une zone partagée par les threads, elle contient l’ensemble des méthodes
utilisées par les flots de contrôle de la JVM (Java Virtuelle Machine)
D’après cette description, on peut dire que ces données représentent le contexte
d’exécution comme étant des structures de données manipulés par les threads, ces structures
peuvent être schématiser comme suit :
Objet Java
Class Java
La zone des méthodes
La pile Java
Le tas d’objets
Figure 14 : Schéma de contexte d’exécution d’un thread Java
----------------------------------------------------------------------------------------------------------------------------24
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
8-
Les différents langages utilisés pour l’implantation d’agents mobiles :
Cette section présente les principaux langages de programmation qui peuvent être utilisés
pour implanter des agents mobiles.
TeleScript de General Magic: C'est le premier langage des agents mobiles destiné pour le
commerce électronique.
Java de Sun: Java est le langage portable par excellence (un programme écrit dans ce langage
peut être exécuté sur différentes machines).
TCL de Sun: Tool Command Language, c'est un langage script et un interprèteur . Son
utilisation est facile et très sollicitée pour relier différentes composantes logiciels.
Obliq de Digital: C'est un langage interprété, à typage faible, qui supporte les calculs
distribués orientés objets.
Python de Guido van Rossum: C'est un langage orienté objet, extensible, interprété et
interactif. Il est disponible sur différents systèmes.
Phantom de Anthony Courtney: C'est un langage interprété pour la programmation distribuée.
OScheme de INRIA: C'est un interpréteur dont l'implantation se ressemble à celle de Scheme
mais qui offre plus d'extensions.
Résumé :
Après tout ce qui a été vu précédemment on peut résumer la définition d’un thread mobile
ou bien d’un agent mobile comme étant une entité informatique qui réalise de manière
autonome une ou plusieurs tâches déléguées par un individu, sur des machines distantes grâce
à sa propriété de migration avec son contexte d’exécution afin qu’il puisse reprendre son
exécution sur la machine destinataire au moment où il s’est interrompu sur la machine
source, ensuite il récupère les informations résultantes pour les afficher localement .
----------------------------------------------------------------------------------------------------------------------------25
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
IV
PRINCIPES DU MECANISME DE MIGRATION
Le service de capture/restauration d’état des flots de contrôle Java a été intégré à la
machine virtuelle Java. Avant de présenter les principes et les choix du service
capture/restauration d’état, nous décrirons d'
abord la structure de l’état d'
un flot dans la
machine virtuelle.
1- Etat d’un thread Java :
La structure du contexte d'exécution d'un thread Java, ou l'état d'un thread Java, est
constituée de trois structures de données principales:
. La pile Java : Tout thread de la machine virtuelle Java possède sa propre pile Java, crée lors
de la création de ce thread. Cette pile décrit l’état d'avancement de l'exécution du flot de
contrôle, c'est le composant principal du contexte d'exécution d'un thread.
La pile Java contient des régions crées à chaque appel d'une méthode Java. Ces régions,
également appelées frames, contiennent des informations sur les variables locales à la
méthode et les résultats des calculs intermédiaires, des registres tels que le registre de sommet
de pile ou le registre compteur ordinal indiquant la prochaine instruction de code
intermédiaire, ou byte code.
. Le tas d’objets : La machine virtuelle Java possède une zone mémoire partagée par tous les
threads, appelé tas d'objets. Ce tas d'objets regroupe l'ensemble des objets Java crées et
utilisées par les threads de la machine virtuelle.
. La zone des méthodes : La machine virtuelle Java possède une zone de méthodes partagée
par tous les threads. Cette zone regroupe l'ensemble des classes Java utilisées par les threads
de la machine virtuelle; elle contient, pour chaque classe, le code de ses méthodes et de ses
constructeurs.
----------------------------------------------------------------------------------------------------------------------------26
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
la figure suivant, permet de mieux visualiser la structure du contexte d'exécution d'un thread
Java. Cette structure est constituée des trois ensembles d'informations suivants: une pile Java,
un tas d'objets de l'ensemble des objets manipule par le thread et une zone de méthodes
constituée des classes utilisées par ce thread. Les références de classe et les références d'objet
sont stockés dans la pile.
Figure 15 : la structure du contexte d'exécution d'un thread Java
. Les Frames : les frames de la machine virtuelle Java sont des zones mémoire servant à
stocker des données, des résultats partiels, des valeurs de retour de méthodes et à effectuer des
liaisons dynamiques.
A chaque appel de méthode un nouveau frame est crée et il est détruit lorsque la méthode se
termine. Ce frame est alloué dans la pile Java du thread qui l'a crée. Il contient deux zones
mémoires particulières, la table des variables locales de cette méthode et la pile d'opérandes
qui sert a stocker les résultats intermédiaires calculés.
----------------------------------------------------------------------------------------------------------------------------27
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
Figure 16 : La structure des Frames d’une Pile Java
2- Mécanisme de migration :
Nous allons décrire dans ce chapitre les services nécessaires à la migration des threads Java.
Pour permettre la migration de threads Java, des mécanismes supplémentaires doivent être
ajoutés à la machine virtuelle Java. Cette extension est due au fait que la migration de threads
nécessite des informations et des traitements que la machine virtuelle Java ne procure pas.
Le service qui a été proposé par le laboratoire SIRAC fournit deux fonctions: la capture de
l'état courant de l'exécution d'un thread Java et la restauration de cet état.
Les extensions apportées visent principalement l'ajout de mécanismes permettant tout d'abord
d'interrompre un thread Java en cours d'exécution, d'extraire son contexte d'exécution, de
transférer ce contexte vers une machine distante et de créer un nouveau thread Java en y
intégrant le contexte reçu pour qu'il reprenne l'exécution au point même ou elle avait été
interrompu.
3- Mécanisme d’extraction du contexte d’exécution d’un thread :
La capture du contexte d’un thread Java revient à construire une structure de données qui
contient toutes les informations permettant de restaurer ce contexte. Cette structure doit donc
contenir toutes les informations nécessaires à la reconstitution de la pile du thread Java, de
son tas d'objets et de sa zone de méthodes.
----------------------------------------------------------------------------------------------------------------------------28
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
Pour extraire l'état d'exécution du thread Java, il faut capturer la pile qui lui est associée. Il
faut ensuite identifier l'ensemble des objets et des classes Java qui sont utilisés; ceci est fait en
parcourant la pile Java du flot pour y récupérer les références vers les objets et les classes
Java. Finalement un nouvelle structure de données, contenant toute ces informations, est
construite.
Nous allons maintenant décrire les traitements nécessaires à l'extraction du contexte
d'exécution d'un thread Java, préalablement interrompu, en étudiant les traitements effectués
autour de chacune des trois structures de données constituant ce contexte, càd la pile Java, le
tas d'objets et la zone de méthodes.
3-1 Traitement utilisant la Pile JAVA:
Le mécanisme d'extraction de contexte doit effectuer une copie des frames contenus dans
la pile Java. En effet, c'est dans la pile Java que se situe toutes les références vers les objets et
les classes manipulés par le thread. Une liste des références vers les objets et les classes
manipulés par le thread doit être construite.
Certaines informations complémentaires et nécessaires à la restitution du contexte doivent
être calculées à partir de la pile Java. Ces informations concernent la transformation de
certaines valeurs absolues en valeur relatives. La valeur du registre pc d'un frame, par
exemple, est une valeur absolue. Elle représente l'adresse de la prochaine instruction à
exécuter. Apres migration, cette instruction n'est plus à la même adresse. Il faut donc calculer
la valeur relative correspondante pour pouvoir ainsi restituer la bonne valeur absolue lors de
la restitution du contexte.
. Liste des objets et des classes Java manipules : Il faut construire une listes des références
des objets et des classes Java utilisés. Toutes ces références sont contenues dans la pile Java,
elles peuvent être récupérées à partir de tables de variables et des piles d'opérandes contenues
dans les frames de la pile Java. Mais une table de variables ou une pile d'opérandes peut
contenir des valeurs de types différents (entier, réel, références Java...). Comme aucune
information donne le type de ces valeurs, il faut effectuer un traitement lors de l'interprétation
des instructions de byte code.
. Transformation des valeurs absolues en valeur relatives : Cette transformation est faite
en trouvant pour chacune de ces valeurs un point de référence. Il est ainsi possible de calculer
une valeur de décalage et donc d’obtenir une valeur relative.
Dans la structure d'un frame, il existe un champ particulier qui est une adresse vers le frame
précédent. Pour traduire une telle valeur absolue en valeur relative, il faut prendre comme
point de référence l'adresse du premier frame.
----------------------------------------------------------------------------------------------------------------------------29
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
3-2 Traitement utilisant le Tas d’objets :
Grâce à la liste des références d'objets Java, l'identification d'objets Java utilisé par le
thread est possible. Une des étapes d'extraction de contexte est la récupération des objets.
Tous les objets manipulés par le thread sont recopiés et intégrés au contexte d'exécution.
Un objet Java peut référencer d'autre objet pour ainsi former une structure de graphe. La
recopie des objets se fait donc en parcourant les graphes et en les stockant dans une structure
qui permet leur acheminement vers une autre machine et leur reconstitution. L'opération de
sérialisation de Java permet d'effectuer un tel traitement.
3-3 Traitement utilisant la Zone de méthodes :
L’identification, dans la zone de méthodes, des classes Java manipulées par le thread peut
être faite grâce à la liste des références. Le code des méthodes appelés par ce thread peut être
ainsi identifié. Un des rôles du mécanisme d'extraction du contexte d'exécution d'un thread est
de fournir les informations nécessaires à la restitution ultérieure du code.
Grâce à cette liste des classes, un chargement peut être fait sur une machine distante en
utilisant le mécanisme ClassLoader, chargeur de classe, fournit par Java. Ces classes doivent
absolument être chargées avant l'étape d'intégration du contexte puisqu'elles sont référencées
dans le contexte d'exécution du thread et qu'elles seront utilisées par le nouveau thread.
4- Mécanisme de transfert d’un contexte d’exécution :
Ce mécanisme a pour objectif de transférer le contexte d'exécution d'un thread d'une
machine virtuelle Java source vers une autre. Les informations transférées sont les structures
de données construites lors de l'extraction du contexte d'exécution du thread. Ces structures
regroupent les copies de la pile Java, des objets manipulés par le thread, de la liste des
références des objets et des classes Java.
Nous allons maintenant décrire ce mécanisme de transfert d'un contexte en étudiant les
traitement autour des trois structures de données qui constituent le contexte d'exécution.
4-1 Traitement utilisant la Pile JAVA:
Le mécanisme de transfert du contexte d'exécution doit transférer la copie de la pile Java et
la liste de valeurs relatives.
----------------------------------------------------------------------------------------------------------------------------30
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
4-2 Traitement utilisant le Tas d’objets :
Le mécanisme de transfert doit envoyer la liste des références d'objets et la structures de
graphes d'objets d'une machine virtuelle Java source vers une autre. Une fois à destination, il
faut reconstruire à partir de la structure de graphes d'objets reçue, de nouveaux graphes
d'objets équivalent à l'original. Ceci se fait grâce à l'opération de desérialisation de Java.
Une correspondance entre les références aux objets initiaux et aux objets nouvellement crées
est faite.
4-3 Traitement utilisant la Zone de méthodes:
Le mécanisme de transfert doit fournir a la machine virtuelle distante, la liste des noms de
classes a charger. Le code de ces classes peut être charge en utilisant le ClassLoader, un
chargeur de classes.
5- Mécanisme d’intégration d'un contexte d’exécution à un nouveau Thread :
Le mécanisme d'intégration consiste à créer un nouveau thread, à l'initialiser, et à lancer
son exécution pour que celle-ci reprenne au point même ou elle avait été interrompue sur la
machine virtuelle Java source.
Nous décrivons, dans ce qui suit, tous les traitements nécessaires.
5-1 Traitement utilisant la Pile JAVA:
Le mécanisme d’intégration doit restaurer un contexte d’exécution à un nouveau thread
crée avec une pile vide allouée. La pile Java du contexte doit donc être recopiée dans la pile
vide, et les valeurs absolues sont ensuite recalculées à partir de la liste des valeurs relatives
contenues dans le contexte.
5-2 Traitement utilisant le Tasd’objets :
Le mécanisme d’intégration est chargé de rattacher les nouveaux objets Java, construits lors
du transfert, au thread nouvellement créé. Les anciennes références d'
objets doivent être
remplacées par des références vers les nouveaux objets créés. Ceci est fait grâce à la
correspondance établie lors du mécanisme de transfert.
----------------------------------------------------------------------------------------------------------------------------31
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
5-3 Traitement utilisant la Zone de méthodes:
Après le chargement des classes, ayant lieu lors du transfert du contexte, le mécanisme
d’intégration obtient la liste des références vers ces classes ainsi chargées. Ceci permettra de
mettre à jour les références vers les classes contenues dans la pile Java.
5-4 Lancement de l'exécution du nouveau Thread :
Le thread est maintenant initialisé avec le contexte d’exécution qui a été capturé, et peut
donc ainsi reprendre son exécution ou point même ou il avait été interrompu. Il suffit
maintenant de le lancer pour qu'
il exécute la suite du code.
----------------------------------------------------------------------------------------------------------------------------32
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
V
1-
REALISATION DU MECANISME DE MIGRATION
Extension de la JVM :
L'état d’exécution d'un thread Java est interne à la machine virtuelle Java. Cet état n'est pas
accessible par les programmes et ne peut donc pas être directement capturé. Pour faire face à
ce problème, le laboratoire SIRAC a étendu la machine virtuelle pour en extraire l’état
d’exécution des threads et ainsi leur capture.
Le service de capture/restauration de l’état d'un thread propose un nouveau package:
java.lang.threadpack.
----------------------------------------------------------------------------------------------------------------------------33
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
Ce package fournit plusieurs classes, telles que la classe ThreadState, dont les instances
représentent l’état d’exécution d'
un thread Java, et la classe ThreadStateManagement qui
fournit les services de bases au mécanisme de capture et de restauration.
La figure suivante illustre
ThreadStateManagement:
une
partie
de
l'
interface
fournie
par
la
classe
Figure 17 : Interface du service de capture/restauration
. La méthode capture permet de capturer l’état courant d'
un flot Java et de l'
affecter à un
objet ThreadState qui sera retourné en résultat.
. La méthode restaure sert à créer un nouveau flot Java, à initialiser son état avec l'
objet
ThreadState donné en paramètre puis à lancer son exécution au point même ou elle a été
interrompue; ce nouveau flot sera retourné en résultat.
. La méthode captureAndSend permet en plus de la capture, de spécifier le traitement à
effectuer à l’état capture. Cette spécialisation est possible grâce au paramètre de type
SendInterface. Un objet qui implante l'
interface SendInterface fournit une méthode SendState
dans laquelle sera spécifie le traitement relatif a l'
envoi. Le troisième paramètre permet de
spécifier soit l’arrêt du flot dont l’état vient d’être capturé, soit sa reprise.
----------------------------------------------------------------------------------------------------------------------------34
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
. La méthode receiveAndRestore permet de spécifier le traitement à effectuer pour recevoir
l’état d'
un flot. Cette spécialisation est possible grâce au paramètre de type receiveInterface.
Un objet qui implante l'
interface ReceiveInterface fournit la méthode receiveState qui permet
de spécifier le traitement relatif à la réception de l’état à restaurer. Une fois l’état obtenu,
celui-ci sera restauré dans un nouveau flot Java.
La classe MobileThreadManagement, appartenant au package java.lang.threadpack,
fournit les services nécessaires à la mobilité des flots de contrôles Java.
La figure suivante illustre une partie de son interface:
Figure 18 : Service de mobilité des threads Java
. La méthode go permet de transférer le contexte d’exécution du thread vers une machine
distante, dont l'
adresse est donnée en paramètre par les variables targetHost et targetPort.
. La méthode arrive permet de recevoir un nouveau flot à partir d'
une machine dont l’adresse
est donnée en paramètre par sourceHost et sourcePort.
Les primitives go et arrive ont été mis en œuvre grâce aux méthodes génériques de la
classe ThreadStateManagement: captureAndSend et receiveAndRestore.
figure 19.1 : Réalisation du service de mobilité
----------------------------------------------------------------------------------------------------------------------------35
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
captureAndSend et receiveAndRestore ont été appellés en utilisant des instances des classes
MySender et MyReceiver.
La classe MySender implante l'interface sendInterface, qui fournit la méthode sendState.
La classe MyReceiver implante l'interface receiveInterface, qui fournit la méthode
receiveState.
Figure 19.2 : Réalisation de service de mobilité
. La méthode sendState établit une connexion vers la machine distante puis envoie l'objet
ThreadState en utilisant la serialisation Java. L'objet ThreadState fait référence aux objets
Java utilises par le thread, ces objets feront donc partie du graphe d'objets serialisés.
. La méthode receiveState accepte une connexion à partir de la machine source puis reçoit
l'objet ThreadState en utilisant la de-serialisation Java. Les objets utilisés par le thread feront
partie du graphe reçu. Les classes utilisées par le thread et auxquelles l'objet ThreadState fait
référence, sont reçues en utilisant le chargement dynamique des classes.
2- Problèmes rencontrés :
L’hétérogénéité du système, le maintien des canaux ouverts, le maintient des
communications entre processus sont les principaux problèmes rencontrés pour le mécanisme
de migration.
La migration de processus dans un système de machines hétérogènes est un problème car
la représentation du code et des données du processus est dépendante de la machine sur
laquelle il s’exécute. Dans le cas de machines avec des architectures différentes l’état d'
un
thread risque de ne pas être compris.
Les solutions proposées sont soit la traduction de l’état du thread de la représentation source à
la représentation finale, ce qui implique autant de traducteurs que de couples d'
architectures
différentes, soit la représentation de '
état dans un format standard intermédiaire, indépendante
de la machine et compris par toutes les machines. Le mécanisme de migration du système
Emerald utilise un format intermédiaire pour représenter l’état du processus à déplacer.
----------------------------------------------------------------------------------------------------------------------------36
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
Un canal ouvert est une entité qui est dépendante du système et qui n'est plus valide dans
un autre système; cela peut être un descripteur de fichier, un socket, un sémaphore, une zone
mémoire...
Que se passe-t-il alors quand un processus qui accède à un fichier locale est déplacé sur une
autre machine? Le descripteur de fichier n'a plus de valeur sur la nouvelle machine. Une
solution serait de créer un lien de poursuite entre le nouveau site et le site source. Ce lien
permettra au processus d’accéder à distance au canal ouvert. Mais cette solution ne devient
plus efficace lors d'une panne sur la machine source.
Une autre solution serait de fournir une identification standard des canaux ouverts qui
auraient le même identificateur sur toutes les machines. Certains systèmes comme le système
Charlotte fournit ce genre de mécanisme.
Le maintien des communications entre processus est un autre problème rencontré lors de la
migration de processus. En effet, que se passe-t-il lorsqu'un message arrive a un processus en
cours de migration?
Une solution est de considérer l’état du processus en cours de migration est un état particulier
dans lequel il ne peut recevoir de messages. Dans ce cas il devra prévenir les autres processus
communicant de ne pas envoyer de messages.
Une autre solution serait de retarder l'envoi du message au processus, le temps que celui-ci ait
fini de migrer.
La sécurité d'un système est un problème important, elle peut être défini autour de trois axes:
. la non-occurence de défaillance catastrophique
. la préservation de la confidentialité et de l’intégrité des informations
. le temps s’écoulant jusqu’à la survenance d'une défaillance.
Des développements et des extensions récents ont été apportés à Java pour effacer certains
problèmes de sécurité. La notion de domaine, par exemple, est maintenant associé aux droits
sur les ressources. Des primitives de contrôle ont été rajoutées: check_privilege(domaine,
droits) et enable_privilege(domaine, droits).
Le byte code des programmes mobiles est maintenant vérifié pour éviter les conversions
illégales, les débordements de pile...
3- Domaines d’utilisation :
La migration de processus est utilisé dans différents domaines, comme la mobilité des
agents, la répartition de charge, la tolérance aux fautes, la sauvegarde de l’état d’exécution
d'
un thread après une panne...
On peut citer des exemples qui interviennent dans la vie de tous les jours:
. administration, pour apporter des changements a toutes les machines
. virus, programme espion...
. courrier actif, les messages contient des programmes exécutables.
----------------------------------------------------------------------------------------------------------------------------37
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
3-1
Les agents mobiles :
Un agent est un programme doté d'un certain degré d'autonomie, qui réalise des tâches pour
le compte d'un utilisateur ou d'une application. Un agent peut éventuellement se déplacer
entre les sites d'un réseau et coopérer avec d'autres agents pour réaliser ses tâches.
Le développement des agents est né de la conjonction de deux voies de recherche:
les ``agents intelligents'', domaine issu de l'intelligence artificielle, visant à étudier les
capacités d'apprentissage et de prise de décision d'entités autonomes coopérantes ; les
techniques de code mobile, permettant à des programmes de migrer d'une machine à une
autre, en préservant leur environnement d'exécution. Ce dernier domaine connaît une
évolution rapide en raison du développement de langages interprétés tels que Tcl et Java, et
de leur environnement d'exécution portable.
Les domaines potentiels d'application des agents sont nombreux : administration de
systèmes et de réseaux, gestion et filtrage du courrier, commerce électronique, recherche
sélective d'information. La conception d'environnements de développement et d'exécution
pour les agents est un domaine de recherche très actif.
. Aglets Software Dévelopment Kit est un environnement pour la programmation d'agents
mobiles Internet en Java développé par IBM Research. La perspective d'IBM est d'utiliser les
agents mobiles pour effectuer différentes tâches sur le net, comme la réservation de places de
cinéma ou la planification d'un voyage autour du monde.
Les Aglets, sont des objets Java qui peuvent migrer d'un hôte source à un autre hôte sur
Internet. Ils peuvent stopper leur exécution courante sur un hôte, se déplacer sur un autre hôte
distant et reprendre leur exécution. En se déplaçant un Aglet emporte le code de son
programme et ses données.
. Concordia est un cadre pour le développement et la gestion des applications d'agents mobiles
sur un réseau. Ces agents mobiles peuvent accéder, à tout moment et en n'importe quel lieu,
aux informations sur toute les machines supportant Java reliées au réseau.
Développé par le laboratoire MEITCA, Mitsubishi Electric Information Technology Center
America, Concordia permet la création de programmes d'agents mobiles en Java.
3-2 La tolérance aux fautes :
Le placement de processus et la répartition de charge sont des problèmes importants dans
le domaine des systèmes répartis. Les résoudre permet d'optimiser l'utilisation des ressources
disponibles et d'accélérer le traitement des applications parallèles qui s'y déroulent.
----------------------------------------------------------------------------------------------------------------------------38
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
Les réseaux à large échelle permettent l'accès à un grand nombre de ressources.
Cependant, leurs caractéristiques en terme de débits variables, de taux de fautes élevés, de
temps de latence implique la conception de nouveaux algorithmes de tolérance aux fautes. En
effet, les hypothèses sur les délais de transmission bornés qui étaient appropriées pour les
réseaux locaux ne sont plus applicables. La plupart des algorithmes de tolérance aux fautes
n'ont pas de solutions dans ce type de réseaux asynchrones.
Ces algorithmes seront mis en oeuvre par un ensemble d'agents mobiles coopérant. Les
agents permettent d'exploiter au mieux les potentialités des grands réseaux. Leur mobilité en
environnement hétérogène leur permet de s'adapter aux changements dynamiques fréquents
dans ce type de réseau.
----------------------------------------------------------------------------------------------------------------------------39
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
VI
CONCLUSION
Un service de capture et de restauration de threads a été ajouté à l’environnement Java. Ce
service est générique et peut être utilisé pour différents usages comme la mise en œuvre
d’agents mobiles, la création de processus clones à distance ou encore la sauvegarde de l’état
d’exécution d’un processus pour une éventuelle reprise après une panne. Ces services
pourront même être portés sur des machines virtuelles embarquées pour pouvoir bénéficier de
la mobilité entre des machines telles que les téléphones ou les PDA…
Les Threads et leur migration ainsi que le langage Java étaient des sujets que nous ne
maîtrisions pas. Le développement de l’Internet et le succès que rencontre le langage Java
nous obligeaient à nous y intéresser ne serait-ce que pour élargir nos connaissances et ainsi
nous assurer de meilleurs conditions pour notre entrée dans la vie active.
Le sujet de ce TER a été proposé par M. Franck Singhoff. Il s’est effectué à la faculté
d’informatique de Brest et fût essentiellement bibliographique. Notre démarche de travail a
été de récolter le maximum d’informations sur les threads, le langage Java et les services de
mobilité. Toutes les références sont notées dans la partie bibliographie.
----------------------------------------------------------------------------------------------------------------------------40
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
GLOSSAIRE
Applet : Programme Java conçu pour tourner sur une page Web.
Byte : Type de données dont la valeur est comprises entre -127 et 128.
Class : Extension des fichiers de classe Java.
Compilateur : Programme qui transforme un fichier source en programme informatique en
interprétant l’ensemble des fichier et en produisant un fichier compilé qui pourra être lu par
l’ordinateur.
Constructeur : Méthode spéciale utilisée uniquement pour la création d’un objet.
Echange de données : Transfert de fichier entre applications.
HTML : (HyperText Markup Language) Langage de marquage hypertext servant à encoder
les pages Web.
Interopérabilité : Deux systèmes sont interopérables entre deux environnements X et Y
hétérogènes si ils peuvent communiquer entre eux à travers l’envoi et la réception de requêtes
d’un environnement à l’autre.
Javac : Compilateur inclus au JDK
Multithreading : Capacité d’un programme ou d’un système d’exploitation à faire tourner
plusieurs programmes simultanément. On parle aussi de programme multitâche.
Multi-plate-forme : Qualité d’un logiciel à tourner sur plusieurs types de plates-formes sans
avoir besoin d’être adapté.
Partage de données : Accès de manière simultanée et concurrente à un même groupe de
données stockées sur une BD.
Plate-forme : Système d’exploitation et unité centrale d’un ordinateur.
Portabilité : Un système est portable entre deux environnements X et Y hétérogènes si il
peut être déplacé de l’environnement X à l’environnement Y et vice versa sans aucune
modification.
Répartition et Distribution : Distribution des traitements sur des données réparties.
: Notre fameux agent mobile qui se déplace entre les sites pour effectuer certains
traitement.
----------------------------------------------------------------------------------------------------------------------------41
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
Annexe 1 : Client / Serveur
import java.io.*;
import java.net.*;
import java.util.*;
/* Cette exemple représente l’utilisation des sockets et la
* sérialisation pour envoyer et recevoir des objets
*/
public class Client {
public static void main(String args[]){
System.out.println(" je suis le Client : ");
System.out.println(" je vais envoyer la date et un message au Serveur ");
try {
// Create a socket
Socket soc = new Socket(InetAddress.getLocalHost(), 8020);
// Serialize today’s date to a outputstream associated to the socket
OutputStream o = soc.getOutputStream();
ObjectOutput s = new ObjectOutputStream(o);
s.writeObject("Today’s date");
s.writeObject(new Date());
System.out.println(" le message est envoyé avec succes:) \n ");
s.flush();
s.close();
} catch (Exception e) {
System.out.println(e.getMessage());
System.out.println("Error during serialization");
System.exit(1);
}
}
}
----------------------------------------------------------------------------------------------------------------------------42
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
import java.io.*;
import java.net.*;
import java.util.*;
import java.lang.*;
import java.lang.ClassNotFoundException;
/* Cette exemple représente l’utilisation des sockets et la
* sérialisation pour envoyer et recevoir des objets
* cette classe est chargé de la réception de l’objet
*/
public class Server {
public static void main(String args[]) {
ServerSocket ser = null;
Socket soc = null;
String str = null;
Date d = null;
System.out.println(" je suis le Server et j’attends un message du Client :");
try {
ser = new ServerSocket(8020);
// This will wait for a connection to be made to this socket.
soc = ser.accept();
InputStream o = soc.getInputStream();
ObjectInput s = new ObjectInputStream(o);
str = (String) s.readObject();
d = (Date) s.readObject();
s.close();
// print out what we just received
System.out.println(str);
System.out.println(d);
System.out.println(" le message est bien recu. ");
} catch (Exception e) {
System.out.println(e.getMessage());
System.out.println("Error during serialization");
System.exit(1);
}
}
}
----------------------------------------------------------------------------------------------------------------------------43
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
Execution
Serveur :
Sur le Serveur
linux408.univ-brest.fr[26]% source ~filali/corba.tcsh
linux408.univ-brest.fr[27]% javac Server.java
linux408.univ-brest.fr[27]% java Server
je suis le Server et j’attends un message du Client :
Today’s date
Tue Jun 12 20:10:26 GMT+02:00 2001
le message est bien recu.
linux408.univ-brest.fr[28]%
Client :
Sur le Client
linux408.univ-brest.fr[24]%
linux408.univ-brest.fr[25]%
linux408.univ-brest.fr[25]%
je suis le Client :
je vais envoyer la date et
le message est envoyé avec
linux408.univ-brest.fr[26]%
source ~filali/corba.tcsh
javac Client.java
java Client
un message au Serveur
succes:)
----------------------------------------------------------------------------------------------------------------------------44
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
Annexe 2 : Thread Mobile
import java.lang.threadpack.*;
class Source {
/*
* Ce programme a pour rôle la creation du Thread
* puis l’envoyer vers la destination.
* Commande de lancement sur la destination :
* java Source <target host name> <taget port number>
*/
public static void main(String[] args) {
String host; // Host name of target
int
port; // Port of target machine
MyThread myThr; // Migrating thread
try {
System.out.println("Source: Begin");
if (args.length != 2) {
usage();
return;
}
host = args[0];
port = Integer.parseInt(args[1]);
//
Creating the migrating thread
myThr = new MyThread();
myThr.start();
// Effectively starting the MyThread thread
Thread.currentThread().yield();
// Moving the MyThread thread
MobileThreadManagement.goAndStop(myThr, host, port);
System.out.println("Source: End");
}
catch (Exception ex) {
System.err.println("Source: Exception = " + ex);
}
}
private static void usage() {
System.out.println("\nUsage:");
System.out.println(" java Source <target host name> <taget port>");
}
}
----------------------------------------------------------------------------------------------------------------------------45
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
import java.lang.threadpack.*;
class Target {
/*
* Ce programme a pour rôle de recevoir le
* Thread mobile et reprendre son exécution.
* Commande de lancement sur la source:
* java Target <local host name> <local port number>
*/
public static void main(String[] args) {
String host;
int port;
Thread thr;
try {
System.out.println("Target: Begin");
// Teste d’arguments
if (args.length != 2) {
usage();
return;
}
host = args[0];
port = Integer.parseInt(args[1]);
// attente de l’arrivée de Thread.
System.out.println(" ---> Waiting for an incoming thread...");
thr = MobileThreadManagement.arrive(host, port);
System.out.println(" <--- Arrived thread = " + thr);
System.out.println("Target: End");
}
catch (Exception ex) {
System.err.println("Target: Exception = " + ex);
return;
}
}
private static void usage() {
System.out.println("\nUsage:");
System.out.println(" java Target <local host name>
}
<local port>");
}
----------------------------------------------------------------------------------------------------------------------------46
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
import java.lang.threadpack.*;
/*
* Cette classe représente l’objet Thread à partir duquelle
* on crée une nouvelle instance qui migre du site source
* vers le site destination .
*/
public class MyThread extends CapturableThread implements java.io.Serializable
{
public void run() {
int i, cpt;
System.out.println("MyThread: Begin ===> thread = " + Thread.currentThread());
for (i = 0, cpt = 7; i < 1000000; i++) {
cpt += 3;
}
System.out.println("MyThread: End ===> thread = " + Thread.currentThread());
}
}
Execution
Source :
Sur la JVM source
% java Source <host name> <port number>
Source: Begin
MyThread: Begin ===> thread = Thread[Thread0,5,main]
Source: End
%
Destination :
Sur la JVM destination
% java Target <host name> <port number>
Target: Begin
---> Waiting for an incoming thread...
<--- Arrived thread = Thread[Thread-0,5,main]
Target: End
MyThread: End ===> thread = Thread[Thread-0,5,main]
%
----------------------------------------------------------------------------------------------------------------------------47
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
ANNEXE DES FIGURES
Figure 1 : Compilation d’un programme Java …………………………………………… 8
Figure 2 : Interprétation d’un bytecode ………………………………………………….. 9
Figure 3 : Exemple d’un programme Java ……………………………………………….. 9
Figure 4 : Trace de compilation et d’interpétation ……………………………………… 10
Figure 5 : Deuxième exemple d’un programme Java …………………………………… 11
Figure 6 : Principe d’homogénéisation de la JVM ……………………………………… 12
Figure 7 : Illustration détaillé de l’Interprète Java ……………………………… ……… 12
Figure 8 : Exemple de code d’un thread …………………………………………………. 15
Figure 9 : Trace de compilation et d’interprétation ……………………………………... 16
Figure 10 : Illustration d’un agent mobile …………………………………………..…… 17
Figure 11 : Illustration du mécanisme de client/serveur …………………………………. 18
Figure 12 : Illustration du mécanisme d’un agent mobile …………………………….…. 19
Figure 13 : Schéma d’un Agent Mobile …………………………………………………. 20
Figure 14 : Schéma de contexte d’exécution d’un thread Java …………………..…… 23
Figure 15 : La structure de contexte d’exécution d’un thread Java …………………… 26
Figure 16 : La structure des Frames d’une Pile Java …………………………………..… 27
Figure 17 : Interface du service de capture/restauration …………………………………. 33
Figure 18 : Service de mobilité des threads Java ………………………………………… 34
Figure 19.1 : Réalisation de service de mobilité …………………………………………. 34
Figure 19.2 : Réalisation de service de mobilité …………………………………………. 35
----------------------------------------------------------------------------------------------------------------------------48
Réalisé par MOHAMED & FILALI
Juin 2001
TER Maîtrise Informatique
Mobilité de threads dans l’environnement JAVA
----------------------------------------------------------------------------------------------------------------------------
BIBLIOGRAPHIE
*
JAVA ET INTERNET
Concepts et programmation
Auteur : Gilles Roussel et Etienne Duris
*
Mécanismes pour la migration de processus
Extension de la machine virtuelle java
Auteur : Sara Bouchenak-khelladi
*
Capture et restauration du contexte d’exécution
d’un thread dans l’environnement Java
Auteur : S. Bouchenak, D. Hagimont, X. Rousset de Pina
*
Les systèmes multi-agents : un aperçu général
Auteur : Jacques Ferber
*
Le langage Java
Auteur : S. Morvan
*
JAVA 2
Auteur :
Rogers Cadenhead
Sites Internet :
*
http://www.limsi.fr/Individu/martin/ens-20002001/java
*
http://www.infini-fr.com/Sciences/Informatique/
*
http://www-sor.inria.fr/~aline/mobile/biblio.html
*
http://java.sun.com
*
http://www.javasoft.com
----------------------------------------------------------------------------------------------------------------------------49
Réalisé par MOHAMED & FILALI
Juin 2001