• Développé à Oak Ridge National Laboratory depuis 1989.
• Sous PVM, un ensemble hétérogène d'ordinateurs apparait comme une seule machine à mémoire distribuée.
• Permet le lancement et l'arrêt de tâches et la communication entre les tâches. La tâche est l'unité d'exécution et est souvent analogue à un processus Unix, mais pas nécessairement.
• Assure la conversion des données si nécessaire.
• Indépendant du réseau d'interconnexion.
• Composé de deux éléments. Le premier est un démon appelé pvmd qui réside sur tous les ordinateurs composant la machine virtuelle et qui sert à gérer la machine virtuelle. Le second est une bibliothèque de fonctions pour la création et la terminaison de tâches et l'envoi et la réception de messages entre les tâches.

Communication

En PVM, les communications utilisent un tampon (buffer) pour le stockage des messages. L'envoi de messages est asynchrone : le processus émetteur n'est pas bloqué si le processus receveur n'est pas prêt à recevoir. La réception peut être bloquante ou non. Une réception bloquante stoppe le processus receveur tant que les données ne sont pas dans le buffer de réception. Une réception non bloquante ne stoppe pas le processus receveur mais retourne une valeur indiquant si les données sont arrivées ou non.

Les communications peuvent être point-à-point (1-1) ou bien multiple (1-n). Les messages sont étiquetés. Le receveur peut spécifier l'émetteur ou bien l'ignorer, de même il peut spécifier l'étiquette ou bien l'ignorer.

Le buffer utilisé pour les messages est ordonné. Si une tâche 1 envoie successivement un message A puis un message B à une tâche 2, alors A arrivera avant B.

L'interface PVM

Fichier d'entêtes : #include "pvm3.h" à placer au début de tout programme utilisant la bibliothèque PVM.

Le code doit être lié à celui de la bibliothèque grâce à l'option -lpvm3. Pour simplifier la compilation, un fichier Makefile est fourni.

Ci-dessous, quelques fonctions qu'il est utile de connaître :

Contrôle des processus

int tid = pvm_mytid()

int info = pvm_exit()

Tout programme PVM doit débuter par un appel à pvm_mytid() et doit comporter un appel à pvm_exit() avant de se terminer.

int numt = pvm_spawn(char *task, char** argv, int flag,
                     char* where, int ntask, int *tids)

démarre ntask instances de l'exécutable spécifié par task sur la machine virtuelle. argv est un pointeur vers un tableau d'arguments, la fin du tableau doit être marquée par la valeur NULL. Si les tâches n'ont pas d'arguments, argv doit recevoir la valeur NULL. flag permet de spécifier des options de lancement, on doit passer 0 pour avoir les options par défaut. Si l'on a passé 0 pour flag alors passer NULL pour where. La fonction retourne le nombre de tâches effectivement lancées ou un code d'erreur si aucune tâche n'a pu être lancée. Si des tâches ont été lancées alors la fonction retourne dans tids un tableau contenant les identificateurs de ces tâches.

Information

int tid = pvm_parent()

Passage de messages

• Encodage

  Les données d'un message peuvent être encodées. Il y a deux politiques d'encodage :

  • PvmDataDefault - encodage XDR, doit être utilisé si les machines composant la PVM n'ont pas la même architecture.
  • PvmDataRaw - pas d'encodage, plus rapide si toutes les machines ont la même architecture.

• Buffer

  int bufid = pvm_initsend(int encoding)

  crée un buffer d'émission en vue de l'envoi d'un message. La politique d'encodage des données à émettre est spécifiée par encoding. Le buffer est identifié par bufid. Cette fonction doit être appelée avant de commencer le rangement des données dans le buffer.

• Rangement

  int info = pvm_pkbyte(unsigned char *xp, int nitem, int stride)

  int info = pvm_pkint(int xp*, int nitem, int stride)

  int info = pvm_pklong(long xp*, int nitem, int stride)

  int info = pvm_pkfloat(float xp*, int nitem, int stride)

  int info = pvm_pkdouble(double xp*, int nitem, int stride)

  int info = pvm_pkstr(char *xp)

  il y a une fonction pour chaque type de données. xp est un pointeur vers le premier élément à mettre dans le buffer, nitem est le nombre total d'éléments que l'on doit mettre, stride est un pas de progression qui permet de ne prendre que les éléments d'indice k x stride.

• Envoi

  int info = pvm_send(int tid, int msgtag)

  envoie le contenu du buffer courant au processus tid. Le message est étiqueté avec msgtag.

  int info = pvm_mcast(int *tids, int ntask, int msgtag)

  diffuse le contenu du buffer courant aux processus spécifiés dans le tableau tids. Seuls les ntask premiers éléments du tableau tids sont utilisés. Le message est étiqueté avec msgtag.

• Réception

  int bufid = pvm_recv(int tid, int msgtag)

  attend qu'un message d'étiquette msgtag émis par tid arrive. Si la valeur -1 est utilisé pour tid (resp. msgtag), cela signifie tout émetteur (resp. toute étiquette)

  int bufid = pvm_nrecv(int tid, int msgtag)

  version non bloquante de la fonction précédente. Si le message n'est pas arrivé, elle retourne la valeur 0.

• Extraction

  int info = pvm_upkbyte(unsigned char *xp, int nitem, int stride)

  int info = pvm_upkint(int xp*, int nitem, int stride)

  int info = pvm_upklong(long xp*, int nitem, int stride)

  int info = pvm_upkfloat(float xp*, int nitem, int stride)

  int info = pvm_upkdouble(double xp*, int nitem, int stride)

  int info = pvm_upkstr(char *xp)

  extraient les données présentes dans le buffer de réception. L'extraction doit être effectuée dans le même ordre que le rangement. L'appel à une fonction d'extraction doit correspondre à un appel à une fonction de rangement, en type, en nombre d'éléments (nitem) et en pas (stride).

[Systèmes informatiques distribués]