108 lines
2.8 KiB
Plaintext
108 lines
2.8 KiB
Plaintext
|
Jeudi 12 février 2009
|
||
|
|
A61
|
||
|
|
Pierre.Gancarski@lsirt.u-strasbg.fr
|
||
|
|
Pôle API
|
||
|
|
C334
|
||
|
|
|
||
|
|
Dernier cours = examen
|
||
|
|
|
||
|
|
====== Cours sur RPC ======
|
||
|
|
|
||
|
|
Ne jamais dit ON !!!
|
||
|
|
|
||
|
|
Il ne faut pas dire le programme boucle, mais dire : ce processus tourne ici, boucle, fait ceci, cela, etc.
|
||
|
|
|
||
|
|
On doit être définissable en terme de processus.
|
||
|
|
|
||
|
|
Calcul = suite d'instruction
|
||
|
|
|
||
|
|
Procédure est comme calcul aussi. C'est mieux que de dire "service".
|
||
|
|
|
||
|
|
Pour s'occuper de mettre en relation deux machines (ou plusieurs), il faut :
|
||
|
|
* réseau
|
||
|
|
* identifiant
|
||
|
|
* un langage commun
|
||
|
|
* un mécanisme pour renvoyer la réponse
|
||
|
|
|
||
|
|
Cet ensemble de techniques existent depuis un bout de temps, années 80, et se nomme RPC :
|
||
|
|
|
||
|
|
RPC = Remote Procedure Call
|
||
|
|
|
||
|
|
===== Problème =====
|
||
|
|
|
||
|
|
Comment "permettre" à une personne sur une machine de demander l'exécution d'une procédure sur une autre machine ?
|
||
|
|
|
||
|
|
==== Rappel ====
|
||
|
|
|
||
|
|
Dans un programme :
|
||
|
|
|
||
|
|
<code java>
|
||
|
|
int a, b;
|
||
|
|
a = 0; b = 12;
|
||
|
|
a=f(b);
|
||
|
|
</code>
|
||
|
|
|
||
|
|
<code java>
|
||
|
|
int f(int x) {
|
||
|
|
return x++;
|
||
|
|
}
|
||
|
|
</code>
|
||
|
|
|
||
|
|
* Le MC (?mémoire centrale?) va allouer de l'espace mémoire à A, puis à B.
|
||
|
|
* Puis la pile va mémoriser l'adresse de retour de la fonction.
|
||
|
|
* La pile va empiler les paramètres de la fonction (il empile la valeur : 12)
|
||
|
|
* Il va crée X puis va mettre dedans la valeur du paramètre (12)
|
||
|
|
* Puis il prend la fonction et fait 12 + 1 = 13 => il remplace X par 13
|
||
|
|
* Puis il va remplacer A par 13 dans la mémoire centrale
|
||
|
|
|
||
|
|
à un appel de fonction correspond un saut. Pour réaliser ce saut il faut empiler les paramètres, c'est à dire créer autant de case que de paramètres. Recopier la valeur des paramètres dans les variables de la fonction et ensuite exécuter la fonction.
|
||
|
|
|
||
|
|
La fin de la fonction stocke le résultat, vide la pile, prend l'adresse de retour pour terminer la fonction, et faire ce qu'il faut avec le résultat.
|
||
|
|
|
||
|
|
MC = Le tas !!!
|
||
|
|
|
||
|
|
----
|
||
|
|
|
||
|
|
Si on en venait à mettre la fonction sur une machine M2, le code Java étant sur M1, il nous faudrait :
|
||
|
|
* Contacter M2
|
||
|
|
* Demander le numéro de processus dans lequel trouver F
|
||
|
|
* Prendre F
|
||
|
|
* Donner les paramètres que la fonction F a besoin
|
||
|
|
|
||
|
|
Ceci reviendrait à remplacer a = f(b) par :
|
||
|
|
<code java>
|
||
|
|
a = callprc(M2, f, 12);
|
||
|
|
</code>
|
||
|
|
|
||
|
|
Sur la machine M2, on doit avoir une fonction qui attend qu'on lui donne des choses :
|
||
|
|
<code java>
|
||
|
|
main {
|
||
|
|
registerrpc(f);
|
||
|
|
svc_run();
|
||
|
|
}
|
||
|
|
</code>
|
||
|
|
|
||
|
|
Où *svc_run* correspond à :
|
||
|
|
<code java>
|
||
|
|
(nom, prénom, machine_retour) = attendre();
|
||
|
|
if (nom == f) {
|
||
|
|
a= f(paramètre);
|
||
|
|
}
|
||
|
|
</code>
|
||
|
|
|
||
|
|
Nom = f
|
||
|
|
prénom = 12
|
||
|
|
|
||
|
|
Maintenant que svc_run permet d'appeler la fonction, il doit renvoyer le résultat.
|
||
|
|
|
||
|
|
==== Registerrpc ====
|
||
|
|
|
||
|
|
A besoin de :
|
||
|
|
* N° de programme
|
||
|
|
* N° de version
|
||
|
|
* N° de fonction
|
||
|
|
|
||
|
|
Ceci pourrait se comparer à des numéros de téléphone au sein d'une machine, bien que la machine n'ait qu'une et une seule adresse mais plusieurs codes pour les fonctions.
|
||
|
|
|
||
|
|
|