Télécharger coll.notice

Retour à la liste thématique

Afficher cette notice en

Numérotation des lignes :
   1 : $$$$ COLL     NOTICE  GF238795  15/01/26    21:15:01     8355           
   2 :                                              DATE     15/01/26
   3 :                                              
   4 :     Operateur COLLABORATEUR                   Voir aussi : ASSI
   5 :     --------------  
   6 : L'opérateur COLL(aborateur) fournit des fonctionnalités de communication et
   7 : d'échanges d'objets entre différents collaborateurs de Cast3m (copies) pour
   8 : pouvoir réaliser des calculs à mémoire distribuée.
   9 : L'opérateur utilise actuellement la libraire openMPI pour transmettre les
  10 : messages. La fonctionnalité voulue est sélectionnée en précisant un mot clef
  11 : qui peut être :
  12 :         -DEBUT
  13 :         -FIN
  14 :         -RANG
  15 :         -NOMBRE
  16 :         -ENVOYER
  17 :         -RECEVOIR
  18 :                 
  19 : --------------------------------------------------------------------------------
  20 :  1) Initialisation des communications : DEBUT
  21 : --------------------------------------------------------------------------------
  22 :    --------------------------
  23 :         Syntaxe :
  24 :    --------------------------
  25 :       COLL 'DEBUT';
  26 : 
  27 :    --------------------------
  28 :         Arguments et résultats :
  29 :    --------------------------
  30 :       N/A
  31 :           
  32 :    -------------------------
  33 :         Description :
  34 :    --------------------------
  35 :       La directive COLL 'DEBUT' initialise l'environnement de communication MPI.
  36 :       Elle initialise aussi les piles de communication gardant l'historique des
  37 :       communications entre les collaborateurs.
  38 : 
  39 :       Cette directive doit être appelée avant toute utilisation des autres
  40 :       fonctionnalités des collaborateurs. Un appel à une autre fonctionnalité
  41 :       avant un appel à COLL 'DEBUT' provoque une sortie en erreur de l'opérateur
  42 :       COLL.
  43 :       Elle appelle la fonction mpi_Init_Thread et la documentation d'OpenMPI
  44 :       recommande de l'appeler le plus tôt possible. De plus, MPI limite son
  45 :       appel à une fois par exécution de Cast3m.
  46 : 
  47 : --------------------------------------------------------------------------------
  48 :  2) Fermeture des communications : FIN
  49 : --------------------------------------------------------------------------------
  50 :    --------------------------
  51 :         Syntaxe :
  52 :    --------------------------
  53 :       COLL 'FIN';
  54 : 
  55 :    --------------------------
  56 :         Arguments et résultats :
  57 :    --------------------------
  58 :       N/A
  59 :           
  60 :    --------------------------
  61 :         Description :
  62 :    --------------------------    
  63 :       Cette directive ferme l'environnement de communication MPI. Elle libère
  64 :       ensuite les piles de communication. Elle doit être appelée avant de
  65 :       quitter cast3m et une fois toutes les communications terminées.
  66 : 
  67 :       La directive COLL 'FIN' réalise un appel à la fonction mpi_Finalize et
  68 :       ne peut être appelée qu'une fois par exécution. Ceci est une limitation
  69 :       de MPI.
  70 : 
  71 :       Une fois COLL 'FIN' appelée, il n'est plus possible d'obtenir des
  72 :       informations sur l'environnement parallèle ou d'échanger des messages même
  73 :       après un autre appel à COLL 'DEBUT'.
  74 : 
  75 :       Si un collaborateur se termine sans appeler cette routine, l'environnement
  76 :       d'exécution MPI détecte une sortie non prévue. Il arrête tous les autres
  77 :       collaborateurs et renvoie une erreur.
  78 : 
  79 : --------------------------------------------------------------------------------
  80 :  3) Récupération du rang du collaborateur : RANG
  81 : --------------------------------------------------------------------------------
  82 :    --------------------------
  83 :         Syntaxe :
  84 :    --------------------------
  85 :       ENT1= COLL 'RANG';
  86 : 
  87 :    --------------------------
  88 :         Arguments et résultats :
  89 :    --------------------------
  90 :       ENT1 : entier, numéro du collaborateur
  91 :    
  92 :    --------------------------
  93 :         Description :
  94 :    --------------------------
  95 :       L'opérateur COLL 'RANG' permet de récupérer le numéro du collaborateur
  96 :       dans l'environnement parallèle.
  97 :       Ce numéro est compris entre 1 et (COLL 'NOMBRE').
  98 : 
  99 : --------------------------------------------------------------------------------
 100 :  4) Récupération du nombre de collaborateurs : NOMBRE
 101 : --------------------------------------------------------------------------------
 102 :    --------------------------
 103 :         Syntaxe :
 104 :    --------------------------
 105 :       ENT1= COLL 'NOMBRE'; 
 106 : 
 107 :    --------------------------
 108 :         Arguments et résultats :
 109 :    --------------------------
 110 :       ENT1 : entier, nombre de collaborateurs
 111 : 
 112 :    --------------------------
 113 :         Description :
 114 :    --------------------------
 115 :       L'opérateur COLL 'NOMBRE' permet de récupérer le nombre total de
 116 :       collaborateurs dans l'environnement parallèle.
 117 :            
 118 : --------------------------------------------------------------------------------
 119 :  5) Envoi d'un message : ENVOYER
 120 : --------------------------------------------------------------------------------
 121 :    --------------------------
 122 :         Syntaxe :
 123 :    --------------------------
 124 :       COLL 'ENVOYER' ENT1 OBJ1 .. OBJi .. OBJn; 
 125 : 
 126 :    --------------------------
 127 :         Arguments et résultats :
 128 :    --------------------------
 129 :       ENT1 : Entier, numéro du collaborateur destinataire du message.
 130 :       OBJi : Objets à envoyer. Leur type doit faire partie des types supportés. 
 131 :           
 132 :    --------------------------
 133 :         Description :
 134 :    --------------------------
 135 :       L'opérateur COLL 'ENVOYER' permet d'envoyer des objets à un collaborateur.
 136 :       Cet opérateur est bloquant. L'envoi du message ne commence que lorsque le
 137 :       destinataire est prêt à recevoir et l'exécution de l'opérateur ne se
 138 :       termine que lorsque le message est reçu.
 139 : 
 140 :       Les types d'objet actuellement supportés sont :
 141 :          -FLOTTANT    : flottant
 142 :          -ENTIER      : entier
 143 :          -LOGIQUE     : logique
 144 :          -MOT         : mot
 145 :          -CONFIGUR    : configuration
 146 :          -POINT       : noeud
 147 :          -MAILLAGE    : maillage
 148 :          -CHPOINT     : champ par point
 149 :          -MCHAML      : champ par élément
 150 :          -RIGIDITE    : rigidité
 151 :          -MMODEL      : modèle
 152 :   
 153 :    --------------------------
 154 :         Notes :
 155 :    --------------------------
 156 :       L'opérateur COLL 'ENVOYER' utilise des fonctions bloquantes de MPI
 157 :       (mpi_send, mpi_recv, mpi_probe). La communication est synchrone et peut
 158 :       empêcher un script de se terminer si l'appel à COLL 'RECEVOIR'
 159 :       correspondant n'est pas réalisé par le destinataire.
 160 : 
 161 :       En utilisation directe, il n'est pas possible à un collaborateur de
 162 :       s'envoyer lui-même un message. En effet, l'appel à COLL 'ENVOYER' étant
 163 :       bloquant, le collaborateur ne peut pas lancer l'appel au COLL 'RECEVOIR'
 164 :       correspondant. Cela provoque des blocages lors d'un envoi à soi-même.
 165 :       La solution est alors d'utiliser les assistants pour réaliser l'envoi du
 166 :       message. Pour cela, voir la remarque plus bas sur les communications
 167 :       asynchrones.
 168 : 
 169 : --------------------------------------------------------------------------------
 170 :  6) Réception d'un message : RECEVOIR
 171 : --------------------------------------------------------------------------------
 172 :    --------------------------
 173 :         Syntaxe :
 174 :    --------------------------
 175 :       OBJ1 .. OBJi .. OBJn = COLL 'RECEVOIR' ENT1; 
 176 : 
 177 :    --------------------------
 178 :         Arguments et résultats :
 179 :    --------------------------
 180 :       ENT1 : Entier, numéro du collaborateur expéditeur du message
 181 :       OBJi : Objets reçus
 182 :           
 183 :    --------------------------
 184 :         Description :
 185 :    --------------------------
 186 :       L'opérateur COLL 'RECEVOIR' attend et reçoit un message d'un collaborateur
 187 :       donné et puis renvoie à l'utilisateur les objets fournis en argument du
 188 :       COLL 'ENVOYER' correspondant. Cet appel est bloquant et ne se termine
 189 :       qu'une fois le message reçu.
 190 : 
 191 :    --------------------------
 192 :         Notes :
 193 :    --------------------------
 194 :       Les objets sont renvoyés dans l'ordre dans lequel ils ont été donnés à
 195 :       l'envoi.  Ainsi, l'objet i lors d'un appel à COLL 'ENVOYER'  restera
 196 :       l'objet i dans la liste des objets résultats de COLL 'RECEVOIR'.
 197 : 
 198 :       L'opérateur COLL 'RECEVOIR' utilise des fonctions bloquantes de MPI
 199 :       (mpi_send, mpi_recv, mpi_probe). La communication est synchrone et peut
 200 :       empêcher un script de se terminer si l'appel à COLL 'ENVOYER'
 201 :       correspondant n'est pas fait.
 202 : 
 203 : --------------------------------------------------------------------------------
 204 :     Remarques
 205 : --------------------------------------------------------------------------------
 206 :    ----------------------------
 207 :         Détection des objets envoyés
 208 :    ----------------------------
 209 :       Afin de limiter la quantité de données envoyées, les objets déjà envoyés
 210 :       sont détectés. L'expéditeur ne ré-envoie pas les objets déjà traité et le
 211 :       destinataire ré-utilise les objets qui possède déjà en mémoire.
 212 :       Ceci est facilement vérifiable en envoyant deux fois le même objet et en
 213 :       vérifiant que les deux objets reçus ont le même pointeur Ésope.
 214 : 
 215 :    ----------------------------
 216 :         Communications asynchrones
 217 :    ----------------------------
 218 :       Les opérateurs COLL 'ENVOYER' et COLL 'RECEVOIR' réalisent des
 219 :       communications synchrones et utilisent des appels bloquants de MPI. Il est
 220 :       toutefois possibles de réaliser des communications asynchrones avec ces
 221 :       opérateurs.  Pour cela, il faut utiliser les assistants de Cast3m via
 222 :       l'opérateur ASSI.  Cet opérateur permet d'exécuter les lignes de commande
 223 :       Gibiane de manière asynchrone.
 224 :       L'interpréteur Gibiane passe à l'instruction suivante sans attendre la fin
 225 :       de la précédente ce qui permet de lancer la communication sur un assistant
 226 :       et de continuer tout de suite d'exécuter le reste du script. 
 227 :       Un communication peut donc se faire de manière asynchrone en utilisant les
 228 :       commandes
 229 :       ASSI 1 COLL 'ENVOYER' ENT1 OBJi;
 230 :       et
 231 :       OBJi = ASSI 1 COLL 'RECEVOIR' ENT2;
 232 : 
 233 :       Les résultats de COLL 'RECEVOIR' ne peuvent pas être utilisé tant que
 234 :       l'opérateur ne s'est pas terminé, c'est à dire tant qu'ils n'ont pas été
 235 :       correctement reçus.
 236 : 
 237 :       De cette manière, un collaborateur peut réaliser une communication vers
 238 :       lui-même en lançant l'envoi sur un assistant. L'exécution du script pourra
 239 :       continuer jusqu'à ce que COLL 'RECEVOIR' soit appelé.
 240 :    
 241 :    ----------------------------
 242 :    Communication globale
 243 :    ----------------------------
 244 :       Les opérateurs de communication réalisent des communications point à
 245 :       point.  Il est possible de réaliser facilement une communication globale
 246 :       en utilisant l'option TOUS de l'opérateur ASSI.
 247 :       
 248 :       Il faut remplir une liste de destinataire et lancer la commande
 249 :       ASSI TOUS COLL 'ENVOYER' DESTI OBJ TABOBJ;
 250 : 
 251 :       La table DESTI est une table d'entier de sous-type ESCLAVE contenant les
 252 :       numéro des collaborateurs destinataires. (voir exemple 2)
 253 : 
 254 :       Si OBJ est un objet simple, il sera envoyé à tous les destinataires de la
 255 :       liste DESTI. Si TABOBJ est une table de sous-type ESCLAVE, elle est
 256 :       remplacée par l'élément correspondant de la table. Ainsi, l'objet TABOBJ.i
 257 :       sera envoyé au destinataire DESTI.i.
 258 : 
 259 :       De la même manière, il est possible de recevoir un message d'une liste
 260 :       d'expéditeur en utilisant
 261 :       TABRESU = ASSI TOUS COLL 'RECEVOIR' DESTI;
 262 : 
 263 :    ----------------------------
 264 :    Objets configuration
 265 :    ----------------------------
 266 :       Lors de leur première apparition dans un message, les noeuds sont
 267 :       initialisés avec les coordonnées de la configuration actuelle de
 268 :       l'expéditeur.
 269 : 
 270 :       Une fois créé chez le destinataire, un noeud n'est pas modifié même si ses
 271 :       coordonnées ont changé chez l'expéditeur. Pour transmettre des nouvelles
 272 :       coordonnés de noeuds, il faut envoyer un objet CONFIGUR contenant les
 273 :       coordonnées à jour des noeuds et appliquer l'objet chez le destinataire
 274 :       par l'opérateur FORM (voir exemple 1). 
 275 : 
 276 :       Les configurations envoyées sont réduites à uniquement à la liste des
 277 :       noeuds nécessaires. Seule les coordonnées des noeuds présents dans des
 278 :       objets échangés sont envoyées. Les objets CONFIGUR reçus sont complétés
 279 :       avec les coordonnées des autres noeuds en mémoire du destinataire.
 280 : 
 281 :       Si le nombre de dimensions est différent entre les deux collaborateurs,
 282 :       les composantes supplémentaires des coordonnées sont tronquées et les
 283 :       composantes manquantes sont mises à zéro. Par exemple, si un collaborateur
 284 :       en dimension 2 envoie le noeud (12,42) à un collaborateur en dimension 3,
 285 :       le noeud créé aura les coordonnées (12,42,0). Si un collaborateur en
 286 :       dimension 3 envoie le noeud (21,24,6) à un collaborateur en dimension 2,
 287 :       le noeud crée aura les coordonnées (21,24).
 288 : 
 289 : --------------------------------------------------------------------------------
 290 :     Exemples
 291 : --------------------------------------------------------------------------------
 292 :    ----------------------------
 293 :    Envoi d'un maillage et 
 294 :    application d'une 
 295 :    configuration
 296 :    ----------------------------
 297 :                 COLL DEBUT;
 298 :                 NPROCE = COLL RANG;
 299 :                 SI(NPROCE EGA 1);
 300 :          MA1 = SURF ...;
 301 :                         COLL ENVOYER 2 MA1;
 302 :          DEPLA PLUS MA1 (1 1);
 303 :          CFG1 = FORM;
 304 :          COLL ENVOYER 2 CFG1;
 305 :                 SINON;
 306 :                         REMA1 = COLL RECEVOIR 1;
 307 :          RECFG1 = COLL RECEVOIR 1;
 308 :          FORM RECFG1;
 309 :                 FINSI;
 310 :       COLL FIN;
 311 :       FIN;
 312 :                 
 313 :    ----------------------------
 314 :         Envoi global et détection 
 315 :    d'objets déjà envoyés
 316 :    ----------------------------
 317 :                 COLL DEBUT;
 318 :                 NPROCE = COLL RANG;
 319 :                 TOTPROC = COLL NOMBRE;
 320 :                 SI(NPROCE EGA 1);
 321 :          DESTI = TABLE 'ESCLAVE';
 322 :          REPETER IDOM (TOTPROC);
 323 :             DESTI.&IDOM=&IDOM;
 324 :          FIN IDOM;
 325 :          MA1 = SURF ...;
 326 :          MA2 = SURF ...;
 327 :          PART1 = PART TOTPROC MA1;
 328 :          ASSI TOUS COLL ENVOYER DESTI PART1 MA2;
 329 :          COLL ENVOYER 2 PART1.2;
 330 :                 FINSI;
 331 :       REMA1 REMA2 = COLL RECEVOIR 1;
 332 :                 SI(NPROCE EGA 2);
 333 :          REMA3 = COLL RECEVOIR 1;
 334 :          LIST REMA1; 
 335 :          LIST REMA3;
 336 : *  Chez le collaborateur 2, REMA3 est le même objet que REMA1, le lister
 337 : *  permet de vérifier qu'ils ont le même pointeur
 338 :                 FINSI;
 339 :       COLL FIN;
 340 :       FIN;
 341 :         

© Cast3M 2003 - Tous droits réservés.
Mentions légales