Afficher cette notice en
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