autres librairies
autres librairies
appendix b autres librairies
b.1 pvm3.4la version 3.4 est la toute dernière version de pvm. elle ajoute
quelques fonctionnalités type mpi, et en particulier:
contextes de communication
handlers
messages persistants
etc.
b.1.1 contextes de communicationc'est un ``tag'' supplémentaire qui permet en particulier
de bien filtrer les messages utilisateurs des messages systèmes
(ou entre groupes, ou entre applications différentes).
pour ces nouveaux ``tag'', il n'y a pas de possibilité de ``wildcard'' (filtrage
à la réception avec tag=-1).
ces ``tags'' assurent un certain nombre de propriétés. toute création d'un nouveau
contexte
définit un unique tag pour toute une machine pvm. de plus
les tâches filles héritent
du contexte du père.
a noter que cette extension de pvm ne rend pas obsolète les anciens
programmes pvm. les principales commandes associées sont:
new_context=pvm_newcontext() crée un nouveau contexte
pour le reste du code,
old_context=pvm_setcontext(new_context) change le contexte
à newcontext et renvoie l'ancien contexte,
info=pvm_freecontext(context) libère le tag context,
context=pvm_getcontext() renvoie le contexte courant.
dans la pratique,
une tâche demande un nouveau contexte et le distribue à toutes
les autres taches par newcontext=pvm_newcontext().
puis les autres tâches se mettent au nouveau contexte pendant les
appels aux fonctionnalités privées de la première tâche par:
oldcontext=pvm_setcontext(newcontext);
/* communications sures */
newcontext=pvm_setcontext(oldcontext);
pvm_freecontext(newcontext);
/* on revient a l'ancien contexte */
b.1.2 handlersles ``handlers''
permettent d'exécuter une fonction c à la réception d'un message
spécifique.
ils agissent comme des interruptions (qui n'interrompent le cours
du programme que uniquement pendant
les appels à la librairie pvm).
la fonction c (il n'y a aucune restriction d'usage) est appelée
quand un message correspond à un pattern (context,msgtag,source) donné.
les principales commandes correspondantes sont:
mhid=pvm_addmhf(src,tag,context,func) déclare le handler
func (n'importe quelle fonction c) à activer à la réception
de tout message compatible avec le pattern src,tag,context.
pvm_delmhf(mhid) détruit le handler mhid.
b.1.3 messages persistantsles messages persistants sont des messages ``uni-directionnels'',
similaire au ``tuple-space'' de linda.
les tâches pvm peuvent enregister et récupérer des messages par leurs
noms: cela
organise de fait une base de données distribuée pour les processus.
il est également possible de ranger plusieurs messages sous un même nom.
les principales commandes sont:
index=pvm_putinfo(name,msgbuf,flag) qui range dans la base
de données un message sous le nom name,
index=pvm_recvinfo(name,index,flag) qui extrait de la base
de données un message de nom name,
index=pvm_delinfo(name,index,flag) qui supprime de la base
de données un message de nom name.
b.2 mpimpi (``message passing interface'')
est le prochain standard de fait (voir http: //www.mcs.anl.gov/mpi/).
mpi fait l'objet fin 1992 d'un groupe de travail
de 40 experts industriels et académiques.
le premier standard mpi-1 est réalisé fin 1993.
le principe est que chaque vendeur de supercalculateurs implémente
sa propre api propriétaire
en respectant le standard. cela fait que
mpi est particulièrement bien optimisé sur un grand nombre d'architectures
de super-calculateurs.
mais le système n'est pas basé comme pvm
sur la notion de machine virtuelle, et les implémentations sont moins bien
étudiées pour les réseaux de stations (éventuellement hétérogènes).
l'abstraction
utilisée par mpi est celle de topologie de passage de messages.
la deuxième version du standard a commencé début
1995, et le premier brouillon a été publié fin 1996.
b.2.1 mpi-1le premier standard décrit
128 fonctions, mais pas d'équivalent de pvm_spawn. les processus sont
donc définis
de façon statique uniquement.
mpi-1 comprend une notion de communicator englobant les notions de
contextes (de pvm3.4) et les
groupes de processus (de pvm3.3).
la grande force du standard est le fait qu'il inclut énormément de
fonctions de communication point à point et
entre groupes de processus.
ces fonctions reposent sur des fonctions de
définition de topologies de communication ainsi que
de définitions de datatypes qui décrivent des
messages pris à des endroits non contigus de la mémoire.
b.2.2 mpi-2le deuxième standard décrit
120 fonctions de plus et en particulier
des fonctions de communication collectives non-bloquantes
et un mpi_spawn (équivalent de pvm_spawn).
mpi-2 intègre également des communications unidirectionnelles
(les messages persistants de pvm3.4) et l'équivalent des handlers de pvm3.4.
mpi-2 devrait avoir des fonctions pour gérer la tolérance aux
pannes.
il existe quelques versions gratuites actuellement implémentant en
partie les standards mpi dont,
lam (version 6.3 et 6.4a) qui implémente mpi-1 plus quelques fonctionnalités
mpi-2 (mpi_spawn etc.), voir
http://www.mpi.nd.edu/lam/
mpich (version ) qui implémente strictement mpi-1, voir
http://www.mcs.
anl.gov/mpi/mpich/
et ftp://info.mcs.anl.gov/pub/mpi sinon, il existe des versions contructeurs (non gratuites...)
sur cray, sgi, ibm etc.
b.2.3 exempleon donne ci-après un petit exemple de code mpi (fourni avec la distribution
standard).
/* transmet un message dans un systeme a 2 processus. */
#include <mpi.h>
#define bufsize 64
int buf[bufsize];
int main(argc, argv)
int argc;
char *argv[];
{
int size, rank;
mpi_status status;
/* initialisation de mpi. */
mpi_init(&argc, &argv);
/* on verifie le nombre de processus presents */
mpi_comm_size(mpi_comm_world, &size);
if (2 != size) {
mpi_finalize(); /* comme pvm_exit */
return(1);
}
/* determine son rang dans le groupe "world" */
mpi_comm_rank(mpi_comm_world, &rank);
/* l'envoyeur aura rang 0, le receveur, rang 1 */
/* si rang 0 envoyer au rang 1 */
if (0 == rank) {
mpi_send(buf, bufsize, mpi_int, 1, 11, mpi_comm_world);
}
/* si rang 1 recevoir du rang 0 */
else {
mpi_recv(buf,bufsize,mpi_int,0,11,mpi_comm_world,&status);
}
mpi_finalize();
return(0);
}
exemple:
#include <mpi.h>
#define worktag 1
#define dietag 2
#define num_work_reqs 200
static void master();
static void slave();
/* ce programme est mimd, mais est ecrit spmd pour */
/* etre plus simple a lancer */
int main(argc, argv)
int argc;
char *argv[];
{
int myrank;
mpi_init(&argc, &argv);
mpi_comm_rank(mpi_comm_world, /* groupe de tout le monde */
&myrank); /* 0 a n-1 */
if (myrank == 0) {
master();
} else {
slave();
}
mpi_finalize();
return(0);
}
/* le maitre envoie des demandes de travaux aux */
/* esclaves puis collecte les resultats */
static void master()
{
int ntasks, rank, work;
double result;
mpi_status status;
mpi_comm_size(mpi_comm_world,&ntasks); /* #processus */
/* initialiser les esclaves */
work = num_work_reqs; /* simulation */
for (rank = 1; rank < ntasks; ++rank) {
mpi_send(&work, /* tampon de messages */
1, /* un seul element */
mpi_int, /* de ce type */
rank, /* au proc de ce rang */
worktag, /* message "travail" */
mpi_comm_world);/* contexte */
work--;
}
/* recoit un resultat de n'importe quel esclave et */
/* renvoie un nouveau travail jusqu'a ce que les */
/* requetes soient epuisees */
while (work > 0) {
mpi_recv(&result, /* tampon de messages */
1, /* un seul element */
mpi_double, /* de ce type */
mpi_any_source, /* de n'importe qui */
mpi_any_tag, /* n'importe quel message */
mpi_comm_world, /* communicator */
&status); /* info */
mpi_send(&work, 1, mpi_int, status.mpi_source,
worktag, mpi_comm_world);
work--; /* simulation */
}
/* recoit les resultats des esclaves */
for (rank = 1; rank < ntasks; ++rank) {
mpi_recv(&result, 1, mpi_double, mpi_any_source,
mpi_any_tag, mpi_comm_world, &status);
}
/* dit aux esclaves de terminer */
for (rank = 1; rank < ntasks; ++rank) {
mpi_send(0, 0, mpi_int, rank, dietag, mpi_comm_world);
}
}
/* chaque esclave accepte les requetes de travaux et */
/* retourne les resultats jusqu'a requete terminaison */
static void slave()
{
double result;
int work;
mpi_status status;
for (;;) {
mpi_recv(&work, 1, mpi_int, 0, mpi_any_tag,
mpi_comm_world, &status);
/* verifie le tag du message */
if (status.mpi_tag == dietag) {
return;
}
sleep(2);
result = 6.0; /* simulation */
mpi_send(&result, 1, mpi_double, 0, 0, mpi_comm_world);
}
}
b.3 comparaison pvm, mpien général mpi a de meilleures performances que pvm (mais
elles restent quand même très comparables même sur un cray t3d ou un ibm sp2).
pvm sacrifie les performances pour être portable sur un réseau hétérogène.
par contre mpi est non portable sur réseau de stations (pas de méthode
standard pour démarrer mpi, ni de notion de machine virtuelle).
mpi a plus de primitives de communications, mais il y a encore un
certain nombre de problèmes non-résolus
pour les pannes (en particulier vis-à-vis des communicators).
en conclusion, pvm3.4 et mpi-2 se ressemblent maintenant beaucoup,
aux performances près. parmi les projets en cours, on trouve d'ailleurs
un projet de ``convergence'' pvm et mpi qui se nomme pvmmpi.
autres librairies
Précédent 512 Précédent 511 Précédent 510 Précédent 509 Précédent 508 Précédent 507 Précédent 506 Précédent 505 Précédent 504 Précédent 503 Précédent 502 Précédent 501 Précédent 500 Précédent 499 Précédent 498 Précédent 497 Précédent 496 Précédent 495 Précédent 494 Précédent 493 Précédent 492 Précédent 491 Précédent 490 Précédent 489 Précédent 488 Précédent 487 Précédent 486 Précédent 485 Précédent 484 Précédent 483 Suivant 514 Suivant 515 Suivant 516 Suivant 517 Suivant 518 Suivant 519 Suivant 520 Suivant 521 Suivant 522 Suivant 523 Suivant 524 Suivant 525 Suivant 526 Suivant 527 Suivant 528 Suivant 529 Suivant 530 Suivant 531 Suivant 532 Suivant 533 Suivant 534 Suivant 535 Suivant 536 Suivant 537 Suivant 538 Suivant 539 Suivant 540 Suivant 541 Suivant 542 Suivant 543