Appendix B    Autres librairies

B.1  PVM3.4

• Contextes de communication
• Handlers
• Messages persistants
• etc.

B.1.1  Contextes de Communication

• 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.

oldcontext=pvm_setcontext(newcontext);
/* communications sures */
newcontext=pvm_setcontext(oldcontext);
pvm_freecontext(newcontext);
/* on revient a l'ancien contexte */

B.1.2  Handlers

• 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 persistants

• 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  MPI

B.2.1  MPI-1

B.2.2  MPI-2

• 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

B.2.3  Exemple

/* 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);
}

#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, MPI