Afficher cette notice en
$$$$ COLL NOTICE GF238795 15/01/26 21:15:01 8355 DATE 15/01/26 Operateur COLLABORATEUR Voir aussi : ASSI -------------- L'opérateur COLL(aborateur) fournit des fonctionnalités de communication et d'échanges d'objets entre différents collaborateurs de Cast3m (copies) pour pouvoir réaliser des calculs à mémoire distribuée. L'opérateur utilise actuellement la libraire openMPI pour transmettre les messages. La fonctionnalité voulue est sélectionnée en précisant un mot clef qui peut être : -DEBUT -FIN -RANG -NOMBRE -ENVOYER -RECEVOIR -------------------------------------------------------------------------------- 1) Initialisation des communications : DEBUT -------------------------------------------------------------------------------- -------------------------- Syntaxe : -------------------------- COLL 'DEBUT'; -------------------------- Arguments et résultats : -------------------------- N/A ------------------------- Description : -------------------------- La directive COLL 'DEBUT' initialise l'environnement de communication MPI. Elle initialise aussi les piles de communication gardant l'historique des communications entre les collaborateurs. Cette directive doit être appelée avant toute utilisation des autres fonctionnalités des collaborateurs. Un appel à une autre fonctionnalité avant un appel à COLL 'DEBUT' provoque une sortie en erreur de l'opérateur COLL. Elle appelle la fonction mpi_Init_Thread et la documentation d'OpenMPI recommande de l'appeler le plus tôt possible. De plus, MPI limite son appel à une fois par exécution de Cast3m. -------------------------------------------------------------------------------- 2) Fermeture des communications : FIN -------------------------------------------------------------------------------- -------------------------- Syntaxe : -------------------------- COLL 'FIN'; -------------------------- Arguments et résultats : -------------------------- N/A -------------------------- Description : -------------------------- Cette directive ferme l'environnement de communication MPI. Elle libère ensuite les piles de communication. Elle doit être appelée avant de quitter cast3m et une fois toutes les communications terminées. La directive COLL 'FIN' réalise un appel à la fonction mpi_Finalize et ne peut être appelée qu'une fois par exécution. Ceci est une limitation de MPI. Une fois COLL 'FIN' appelée, il n'est plus possible d'obtenir des informations sur l'environnement parallèle ou d'échanger des messages même après un autre appel à COLL 'DEBUT'. Si un collaborateur se termine sans appeler cette routine, l'environnement d'exécution MPI détecte une sortie non prévue. Il arrête tous les autres collaborateurs et renvoie une erreur. -------------------------------------------------------------------------------- 3) Récupération du rang du collaborateur : RANG -------------------------------------------------------------------------------- -------------------------- Syntaxe : -------------------------- ENT1= COLL 'RANG'; -------------------------- Arguments et résultats : -------------------------- ENT1 : entier, numéro du collaborateur -------------------------- Description : -------------------------- L'opérateur COLL 'RANG' permet de récupérer le numéro du collaborateur dans l'environnement parallèle. Ce numéro est compris entre 1 et (COLL 'NOMBRE'). -------------------------------------------------------------------------------- 4) Récupération du nombre de collaborateurs : NOMBRE -------------------------------------------------------------------------------- -------------------------- Syntaxe : -------------------------- ENT1= COLL 'NOMBRE'; -------------------------- Arguments et résultats : -------------------------- ENT1 : entier, nombre de collaborateurs -------------------------- Description : -------------------------- L'opérateur COLL 'NOMBRE' permet de récupérer le nombre total de collaborateurs dans l'environnement parallèle. -------------------------------------------------------------------------------- 5) Envoi d'un message : ENVOYER -------------------------------------------------------------------------------- -------------------------- Syntaxe : -------------------------- COLL 'ENVOYER' ENT1 OBJ1 .. OBJi .. OBJn; -------------------------- Arguments et résultats : -------------------------- ENT1 : Entier, numéro du collaborateur destinataire du message. OBJi : Objets à envoyer. Leur type doit faire partie des types supportés. -------------------------- Description : -------------------------- L'opérateur COLL 'ENVOYER' permet d'envoyer des objets à un collaborateur. Cet opérateur est bloquant. L'envoi du message ne commence que lorsque le destinataire est prêt à recevoir et l'exécution de l'opérateur ne se termine que lorsque le message est reçu. Les types d'objet actuellement supportés sont : -FLOTTANT : flottant -ENTIER : entier -LOGIQUE : logique -MOT : mot -CONFIGUR : configuration -POINT : noeud -MAILLAGE : maillage -CHPOINT : champ par point -MCHAML : champ par élément -RIGIDITE : rigidité -MMODEL : modèle -------------------------- Notes : -------------------------- L'opérateur COLL 'ENVOYER' utilise des fonctions bloquantes de MPI (mpi_send, mpi_recv, mpi_probe). La communication est synchrone et peut empêcher un script de se terminer si l'appel à COLL 'RECEVOIR' correspondant n'est pas réalisé par le destinataire. En utilisation directe, il n'est pas possible à un collaborateur de s'envoyer lui-même un message. En effet, l'appel à COLL 'ENVOYER' étant bloquant, le collaborateur ne peut pas lancer l'appel au COLL 'RECEVOIR' correspondant. Cela provoque des blocages lors d'un envoi à soi-même. La solution est alors d'utiliser les assistants pour réaliser l'envoi du message. Pour cela, voir la remarque plus bas sur les communications asynchrones. -------------------------------------------------------------------------------- 6) Réception d'un message : RECEVOIR -------------------------------------------------------------------------------- -------------------------- Syntaxe : -------------------------- OBJ1 .. OBJi .. OBJn = COLL 'RECEVOIR' ENT1; -------------------------- Arguments et résultats : -------------------------- ENT1 : Entier, numéro du collaborateur expéditeur du message OBJi : Objets reçus -------------------------- Description : -------------------------- L'opérateur COLL 'RECEVOIR' attend et reçoit un message d'un collaborateur donné et puis renvoie à l'utilisateur les objets fournis en argument du COLL 'ENVOYER' correspondant. Cet appel est bloquant et ne se termine qu'une fois le message reçu. -------------------------- Notes : -------------------------- Les objets sont renvoyés dans l'ordre dans lequel ils ont été donnés à l'envoi. Ainsi, l'objet i lors d'un appel à COLL 'ENVOYER' restera l'objet i dans la liste des objets résultats de COLL 'RECEVOIR'. L'opérateur COLL 'RECEVOIR' utilise des fonctions bloquantes de MPI (mpi_send, mpi_recv, mpi_probe). La communication est synchrone et peut empêcher un script de se terminer si l'appel à COLL 'ENVOYER' correspondant n'est pas fait. -------------------------------------------------------------------------------- Remarques -------------------------------------------------------------------------------- ---------------------------- Détection des objets envoyés ---------------------------- Afin de limiter la quantité de données envoyées, les objets déjà envoyés sont détectés. L'expéditeur ne ré-envoie pas les objets déjà traité et le destinataire ré-utilise les objets qui possède déjà en mémoire. Ceci est facilement vérifiable en envoyant deux fois le même objet et en vérifiant que les deux objets reçus ont le même pointeur Ésope. ---------------------------- Communications asynchrones ---------------------------- Les opérateurs COLL 'ENVOYER' et COLL 'RECEVOIR' réalisent des communications synchrones et utilisent des appels bloquants de MPI. Il est toutefois possibles de réaliser des communications asynchrones avec ces opérateurs. Pour cela, il faut utiliser les assistants de Cast3m via l'opérateur ASSI. Cet opérateur permet d'exécuter les lignes de commande Gibiane de manière asynchrone. L'interpréteur Gibiane passe à l'instruction suivante sans attendre la fin de la précédente ce qui permet de lancer la communication sur un assistant et de continuer tout de suite d'exécuter le reste du script. Un communication peut donc se faire de manière asynchrone en utilisant les commandes ASSI 1 COLL 'ENVOYER' ENT1 OBJi; et OBJi = ASSI 1 COLL 'RECEVOIR' ENT2; Les résultats de COLL 'RECEVOIR' ne peuvent pas être utilisé tant que l'opérateur ne s'est pas terminé, c'est à dire tant qu'ils n'ont pas été correctement reçus. De cette manière, un collaborateur peut réaliser une communication vers lui-même en lançant l'envoi sur un assistant. L'exécution du script pourra continuer jusqu'à ce que COLL 'RECEVOIR' soit appelé. ---------------------------- Communication globale ---------------------------- Les opérateurs de communication réalisent des communications point à point. Il est possible de réaliser facilement une communication globale en utilisant l'option TOUS de l'opérateur ASSI. Il faut remplir une liste de destinataire et lancer la commande ASSI TOUS COLL 'ENVOYER' DESTI OBJ TABOBJ; La table DESTI est une table d'entier de sous-type ESCLAVE contenant les numéro des collaborateurs destinataires. (voir exemple 2) Si OBJ est un objet simple, il sera envoyé à tous les destinataires de la liste DESTI. Si TABOBJ est une table de sous-type ESCLAVE, elle est remplacée par l'élément correspondant de la table. Ainsi, l'objet TABOBJ.i sera envoyé au destinataire DESTI.i. De la même manière, il est possible de recevoir un message d'une liste d'expéditeur en utilisant TABRESU = ASSI TOUS COLL 'RECEVOIR' DESTI; ---------------------------- Objets configuration ---------------------------- Lors de leur première apparition dans un message, les noeuds sont initialisés avec les coordonnées de la configuration actuelle de l'expéditeur. Une fois créé chez le destinataire, un noeud n'est pas modifié même si ses coordonnées ont changé chez l'expéditeur. Pour transmettre des nouvelles coordonnés de noeuds, il faut envoyer un objet CONFIGUR contenant les coordonnées à jour des noeuds et appliquer l'objet chez le destinataire par l'opérateur FORM (voir exemple 1). Les configurations envoyées sont réduites à uniquement à la liste des noeuds nécessaires. Seule les coordonnées des noeuds présents dans des objets échangés sont envoyées. Les objets CONFIGUR reçus sont complétés avec les coordonnées des autres noeuds en mémoire du destinataire. Si le nombre de dimensions est différent entre les deux collaborateurs, les composantes supplémentaires des coordonnées sont tronquées et les composantes manquantes sont mises à zéro. Par exemple, si un collaborateur en dimension 2 envoie le noeud (12,42) à un collaborateur en dimension 3, le noeud créé aura les coordonnées (12,42,0). Si un collaborateur en dimension 3 envoie le noeud (21,24,6) à un collaborateur en dimension 2, le noeud crée aura les coordonnées (21,24). -------------------------------------------------------------------------------- Exemples -------------------------------------------------------------------------------- ---------------------------- Envoi d'un maillage et application d'une configuration ---------------------------- COLL DEBUT; NPROCE = COLL RANG; SI(NPROCE EGA 1); MA1 = SURF ...; COLL ENVOYER 2 MA1; DEPLA PLUS MA1 (1 1); CFG1 = FORM; COLL ENVOYER 2 CFG1; SINON; REMA1 = COLL RECEVOIR 1; RECFG1 = COLL RECEVOIR 1; FORM RECFG1; FINSI; COLL FIN; FIN; ---------------------------- Envoi global et détection d'objets déjà envoyés ---------------------------- COLL DEBUT; NPROCE = COLL RANG; TOTPROC = COLL NOMBRE; SI(NPROCE EGA 1); DESTI = TABLE 'ESCLAVE'; REPETER IDOM (TOTPROC); DESTI.&IDOM=&IDOM; FIN IDOM; MA1 = SURF ...; MA2 = SURF ...; PART1 = PART TOTPROC MA1; ASSI TOUS COLL ENVOYER DESTI PART1 MA2; COLL ENVOYER 2 PART1.2; FINSI; REMA1 REMA2 = COLL RECEVOIR 1; SI(NPROCE EGA 2); REMA3 = COLL RECEVOIR 1; LIST REMA1; LIST REMA3; * Chez le collaborateur 2, REMA3 est le même objet que REMA1, le lister * permet de vérifier qu'ils ont le même pointeur FINSI; COLL FIN; FIN;
© Cast3M 2003 - Tous droits réservés.
Mentions légales