La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Supports dexécution parallèles et répartis Raymond Namyst LaBRI Université de Bordeaux I Jean-François Méhaut GRIMAAG Université des Antilles-Guyane.

Présentations similaires


Présentation au sujet: "Supports dexécution parallèles et répartis Raymond Namyst LaBRI Université de Bordeaux I Jean-François Méhaut GRIMAAG Université des Antilles-Guyane."— Transcription de la présentation:

1 Supports dexécution parallèles et répartis Raymond Namyst LaBRI Université de Bordeaux I Jean-François Méhaut GRIMAAG Université des Antilles-Guyane

2 Plan uIntroduction Supports dexécution, environnements, middlewares, intergiciels, … uCommunications dans les grappes (RN) Technologies, interfaces, hétérogène,… uMultithreading (JFM) Rappels, exploitation des SMP, … uGrilles de calcul (JFM) Toolkit Globus, gestion de ressources,…

3 Programmation parallèle et répartie uConception Modélisation Algorithmique Langage Compilation uExécution Gestion dactivités Communications Mise au point Régulation de charge Gestion de données Sécurité … Application Programme parallèle Proc. 0Proc. 1Proc. 2Proc. 3

4 Supports et environnements dexécution (1) u Pour les utilisateurs et leurs applications Abstractions de haut niveau Portabilité Efficacité ! Support dexécution Grappes, grilles, machines parallèles, réseaux,… Systèmes dexploitation (OS) Interface de programmation (API) Applications

5 Supports et environnements dexécution (2) uEtendre et spécialiser les OS Centralisés et complétés pour le distribué Nouveaux modèles (tâches, communication, fichiers,…) Exemple: Stockage de fichiers, réplication, cache, … Support dexécution Grappes, grilles, machines parallèles, réseaux Systèmes dexploitation (OS) Interface de programmation (API) Applications

6 Discussions u Souplesse par rapport à des développement au niveau système u Définition dinterface standard Exemples: POSIX Threads, MPI, CORBA, OpenMP… Difficulté de faire évoluer les standards u Implémentation basée sur des standards Exemple: Globus-MDS basé sur LDAP

7 Compromis à trouver Fonctionalités Portabilité Efficacité X

8 PM2 : support pour les grappes uLégende Marcel : noyau de processus légers Madeleine : module de communication Marcel PM2 Madeleine Architecture (grappes, machines parallèles) Unix (~10 versions) Interface de programmation (RPC, migration, allocation iso-adresse) Régulation HPF, C* C++//, Java Applications

9 Globus : support pour les grilles Applications Boite à outils Application DUROCglobusrunMPINimrod/GCondor-GHPC++ GlobusViewTestbed Status Base de la Grille LSF CondorMPI NQEPBS TCP NTLinux UDP Solaris DiffServ Services de la Grille GRAM GSI HBM Nexus I/OGASS GSI-FTP MDS

10 Communications dans les grappes hautes performances Raymond Namyst LaBRI Université de Bordeaux I

11 Plan u Technologies matérielles Ethernet, Myrinet, SCI u Interfaces de bas niveau BIP, SISCI, VIA u Interfaces de haut niveau MPI et les communications irrégulières u Interfaces de niveau intermédiaire FM, Madeleine u Vers les grappes hétérogènes…

12 Technologies matérielles Cartes passives, actives, réseaux à capacité dadressage

13 (Fast|Giga)-Ethernet uInterconnexion Hub ou switch uCâblage Cuivre ou fibre optique uLatence ~20 µs uDébit 100 Mb/s et 1Gb/s uNote Compatibilité avec lEthernet classique Hub Switch

14 Ethernet u Cartes passives (sauf Giga-Ethernet) Interfaces : TCP, SBP, GAMMA, VIA, … Network TX reg RX reg Packet Interface PCI Bridge PCI Bridge PCI Bus DMA Memory TX-ring NIC

15 Myrinet uSociété Myricom (C. Seitz) uInterconnexion Switch uCâblage Nappes courtes uCartes équipées dun processeur uLatence 1~2 µs uDébit 1 Gb/s uNote Durée de vie limitée des messages (50 ms) LANai

16 Myrinet u Routage Réseau commuté, routage wormhole u Carte programmable Protocoles de transmission « intelligents » Ù Stratégie adaptée à la taille des messages Ù Déclenchement dinterruptions Network RISC Packet Interface DMA PCI Bridge PCI Bridge PCI Bus LANai SRAM NIC

17 SCI uScalable Coherent Interface Norme IEEE (1993) Société Dolphin uFonctionnement par accès mémoire distants Projections despaces dadressage Machine AMachine B Réseau SCI Mémoire Bus PCI

18 Carte à capacité d addressage BUS PCI TLB Interface paquet Paquet SCI Pci req: addr+ data BUS PCI TLB Interface paquet Paquet SCI Pci req: addr+ data Partie émissionPartie réception

19 Adressage à distance u Projections effectués par le pilote (SISCI) Zones de mémoire physiques souvent spécifiques u Accès mémoire effectués par le processeur Le processeur distant nest pas (forcément) interrompu

20 SCI : mécanisme dadressage Adresse Virtuelle 32 bits MMU Adresse Physique (E/S) Bus dE/S 32 bits 10 bits 18 bits Table de Translation des Adresses 16 bits 30 bits 18 bits Destinataire Réseau

21 30 bits 18 bits Réseau Adresse Physique (E/S) Bus dE/S 32 bits Mémoire SCI : mécanisme dadressage

22 SCI : performances Latence : 2.5 s (écriture de processus à processus) Débit :45 Mo/s Verrou :< 10 s (fetch&add)

23 Interfaces de bas niveau BIP, SISCI, VIA

24 Communications performantes u Comment exploiter les réseaux rapides ? Faible latence Ù Quelques microsecondes Bande passante élevée Ù De lordre du Gb/s u Tendance actuelle Interaction directe avec la carte réseau Ù Communication en « mode utilisateur » Transmissions zéro-copie Ù La carte récupère/dépose les données au bon endroit

25 Interfaces uInitialisation Réservée au système Uniquement en début de session uTransferts Directs depuis lespace utilisateur Pas dappels systèmes Pas de transitions Transmissions zéro- copie Interface Programme Réseau Système Espace utilisateur Transferts Initialisation

26 Streamline Buffer Protocol uUNH (R. Russell & P. Hatcher) uPrincipe Partage de tampons entre noyau/processus Tampons préformatés (trames ethernet) uDeux jeux de files de tampons : RQ & SQ uPerformances (Linux, P133) Latence : 24 us, débit : ~ 12 Mo/s

27 Basic Interface for Parallelism: BIP uL. Prylli & B. Tourancheau uPrincipe Envoi de message classique (asynchrone) Pas de contrôle de flux Pas de detection derreur uPerformances Latence : 4.8us, débit : 126 Mo/s

28 BIP uFonctionnalités réduites au minimum Ù Messages courts : recopiés à larrivée Ù Messages longs : mode zéro-copie (RDV) u Contrôle de flux minimal Matériel (msgs évaporés au dela de 50ms)

29 Interface Dolphin pour SCI uDeux niveaux : Interface orientée fichiers projetés Interface orientée VIA (cf + loin) uFichiers projetés Utilisation de mmap uSynchronisation Segments spéciaux fetch & add

30 SISCI: principe u Communications Accés mémoire distants Ù Implicites (après projection) Ù Explicites (remote DMA) Support matériel pour une MVP (?) u Performances Ecriture 2 us, lecture 4 us Bande passante 85 Mo/s (difficilement !)

31 SCI : optimisations matérielles uCaches dans la carte : Read Prefetching Write Combining

32 Conséquences u Une Grappe SCI est une NC-NUMA Non-Coherent Non-uniform Memory Arch. Cohérence séquentielle non vérifiée u Plus gênant : ordre des écritures modifié Pb datomicité des transactions PCI Assez inhabituel (?)

33 VIA uVirtual Interface Architecture uTentative de standardisation Beaucoup dindustriels impliqués uCaractéristiques Principe dinterfaces virtuelles Zones de transmission protégées Lectures/Ecritures distantes

34 VIA: Basic Principles uUse the Kernel for Set-Up… …and Get It Out of the Way for Send/Receive! uThe Virtual Interface (VI) Protected Application-Application Channel Memory Directly Accessible by User Process uTarget Environment LANs and SANs at Gigabit Speeds No Reliability of Underlying Media Assumed

35 VI Architecture VI Consumer VI User Agent (libvia) Open, Connect, Map Memory Descriptor Read, Write VI-Capable NIC Sockets, MPI, Legacy, etc. Requests Completed VI C SSS COMPCOMP RRR Doorbells Undetermined VI Kernel Agent (Slow) User-Level (Fast) Host NIC

36 VI Kernel Agent A Privileged Part of Operating System (driver) Usually supplied by the VI NIC vendor Possibly supplied by research groups (UCB,…) Setup and Resource Management Functions Creation/Destruction of Vis VI Connection setup/tear-down Management of System Memory used by the VI NIC

37 A Virtual Interface VI Consumer VI-Capable NIC Descriptor Send Q Send Doorbell Descriptor Recv Q Receive Doorbell Status

38 Descriptors uDescriptors Contain: Address and Length of Data Buffer Status Fields Memory Protection Information Multiple Segments to Allow Scatter/Gather etc., etc., etc. uA minimum of 45 bytes long Many messages may only be a few bytes...

39 Queues and Doorbells Queues of Descriptors Transmit and Receive Completions and Errors May Reside on Host or NIC (Unspecified) Doorbells Addresses of Descriptors, Small and Fast Allows NIC to Use Descriptors… Future VIA-NICs May Have Hardware Support

40 Memory Registration uData buffers and descriptors must reside within a region of registered memory Call VipRegisterMemory uPins the specified pages into physical memory uCommunicates the addresses to the NIC To allow DMA I/O from the NIC

41 Ce quil faut retenir u Interfaces de très bas niveau ! Fonctionnalités proches du matériel Ù Grande efficacité Ù Paradigmes très différents Ù Approche non généralisable Pas de consensus Ù Tentative de standard : VIA -Virtual Interface Architecture (Intel, Microsoft, Compaq) -But : dénominateur commun -Bas niveau, peu adapté à certaines technologies Portabilité ???

42 Interfaces de haut niveau MPI : la solution idéale ?

43 Bibliothèques uParadigme passage de message Les nœuds se synchronisent et communiquent par messages uDeux instructions de base Sendémission dun message Receiveréception dun message uPoints forts Simple à mettre en oeuvre Permet démuler les autres paradigmes

44 PVM uParallel Virtual Machine Laboratoire National dOak Ridge (Tennessee) 1989 uCaractéristiques Notion de machine virtuelle ÙEnsemble de machines physiques ÙConstruction préalable au lancement de la session Disponibilité très large Réseaux ÙUDP + protocole de réémission Support de lhétérogénéité ÙXDR

45 MPI uMessage Passing Interface MPI-Forumv v uCaractéristiques Un standard, pas une bibliothèque Diverses implémentations ÙMPI-CH ÙLAM-MPI Ù… Supplante PVM Version 2.0 encore peu implémentée

46 MPI répond-t-il aux besoins ? u Implantations efficaces existantes Ù MPICH/BIP, MPICH/SISCI, etc. u Quid des schémas de communication de la vraie vie ? Ù Messages dont le contenu est inconnu a priori par le récepteur -Transmissions zéro-copie ? Ù Messages asynchrones -Recouvrement des communications ? Ù Accès mémoire distants (PUT/GET) -Temps de réponse ?

47 Transmissions zéro-copie Processus A Processus BRéseau Préparation mémoire Acquittement Message Entête Données DMA

48 Et la réactivité alors ? u Problèmes Assurer la progression des communications asynchrones Réagir rapidement aux sollicitations extérieures proc réseau

49 Envois asynchrones u Parvient-on vraiment à assurer du recouvrement ? Processus AProcessus B Acquittement MPI_Isend MPI_recv MPI_test

50 Interfaces de niveau intermédiaire Madeleine : principe et interface

51 Madeleine u Interface de communication Efficace et portable u Double objectif Support de multiples paradigmes/modes Support de multiples réseaux simultanément u Proposition Programmation par « contrat » Ù Contrôle du niveau doptimisation Ù Transferts immédiats possibles u Statut Disponible sur BIP, SISCI, TCP et MPI. Portage en cours sur VIA

52 u Construction des messages u Gestion des canaux (~ communicators) Choix explicite du dispositif physique Interface mad_begin_packing mad_pack mad_end_packing mad_begin_unpacking mad_unpack mad_end_unpacking

53 Packing et Unpacking u Commandes : mad_pack (cnx, buffer, len, pack_mode, unpack_mode) mad_unpack (cnx, buffer, len, pack_mode, unpack_mode) u Modes : Send_SAFER Send_CHEAPER Send_LATER Receive_EXPRESS Receive_CHEAPER

54 Emission : modes dempaquetage Version transmise Pack Modification End_packing Send_SAFERSend_LATERSend_CHEAPER

55 Réception : mode de déballage (1) Unpack Après Unpack End_packing Tampon Données disponibles u RECV_EXPRESS

56 Réception : mode de déballage (2) u RECV_CHEAPER Unpack Après Unpack End_packing Tampon Données disponibles ??? Données disponibles

57 Exemple mad_end_unpacking(cnx); send_CHEAPER,receive_CHEAPER); mad_unpack(cnx, s, n, s = malloc(n); send_CHEAPER,receive_EXPRESS); mad_unpack(cnx, &n, sizeof(int), cnx = mad_begin_unpacking(channel); p_mad_connection_t cnx; char *s = NULL; int n; mad_pack(cnx, s, n, send_CHEAPER, receive_CHEAPER); mad_end_packing(cnx); send_CHEAPER, receive_EXPRESS); mad_pack(cnx, &n, sizeof(int), n = strlen(s) + 1; cnx = mad_begin_packing(channel, dest); p_mad_connection_t cnx; char *s = "Hello, World !"; int n; Sending sideReceiving side

58 Exemple mad_end_unpacking(cnx); send_CHEAPER,receive_CHEAPER); mad_unpack(cnx, s, n, s = malloc(n); send_CHEAPER,receive_EXPRESS); mad_unpack(cnx, &n, sizeof(int), cnx = mad_begin_unpacking(channel); p_mad_connection_t cnx; char *s = NULL; int n; mad_pack(cnx, s, n, send_CHEAPER, receive_CHEAPER); mad_end_packing(cnx); send_CHEAPER, receive_EXPRESS); mad_pack(cnx, &n, sizeof(int), n = strlen(s) + 1; cnx = mad_begin_packing(channel, dest); p_mad_connection_t cnx; char *s = "Hello, World !"; int n; Sending sideReceiving side

59 Exemple mad_end_unpacking(cnx); send_CHEAPER,receive_CHEAPER); mad_unpack(cnx, s, n, s = malloc(n); send_CHEAPER,receive_EXPRESS); mad_unpack(cnx, &n, sizeof(int), cnx = mad_begin_unpacking(channel); p_mad_connection_t cnx; char *s = NULL; int n; mad_pack(cnx, s, n, send_CHEAPER, receive_CHEAPER); mad_end_packing(cnx); send_CHEAPER, receive_EXPRESS); mad_pack(cnx, &n, sizeof(int), n = strlen(s) + 1; cnx = mad_begin_packing(channel, dest); p_mad_connection_t cnx; char *s = "Hello, World !"; int n; Sending sideReceiving side

60 Exemple mad_end_unpacking(cnx); send_CHEAPER,receive_CHEAPER); mad_unpack(cnx, s, n, s = malloc(n); send_CHEAPER,receive_EXPRESS); mad_unpack(cnx, &n, sizeof(int), cnx = mad_begin_unpacking(channel); p_mad_connection_t cnx; char *s = NULL; int n; mad_pack(cnx, s, n, send_CHEAPER, receive_CHEAPER); mad_end_packing(cnx); send_CHEAPER, receive_EXPRESS); mad_pack(cnx, &n, sizeof(int), n = strlen(s) + 1; cnx = mad_begin_packing(channel, dest); p_mad_connection_t cnx; char *s = "Hello, World !"; int n; Sending sideReceiving side

61 Exemple mad_end_unpacking(cnx); send_CHEAPER,receive_CHEAPER); mad_unpack(cnx, s, n, s = malloc(n); send_CHEAPER,receive_EXPRESS); mad_unpack(cnx, &n, sizeof(int), cnx = mad_begin_unpacking(channel); p_mad_connection_t cnx; char *s = NULL; int n; mad_pack(cnx, s, n, send_CHEAPER, receive_CHEAPER); mad_end_packing(cnx); send_CHEAPER, receive_EXPRESS); mad_pack(cnx, &n, sizeof(int), n = strlen(s) + 1; cnx = mad_begin_packing(channel, dest); p_mad_connection_t cnx; char *s = "Hello, World !"; int n; Sending sideReceiving side

62 Exemple mad_end_unpacking(cnx); send_CHEAPER,receive_CHEAPER); mad_unpack(cnx, s, n, s = malloc(n); send_CHEAPER,receive_EXPRESS); mad_unpack(cnx, &n, sizeof(int), cnx = mad_begin_unpacking(channel); p_mad_connection_t cnx; char *s = NULL; int n; mad_pack(cnx, s, n, send_CHEAPER, receive_CHEAPER); mad_end_packing(cnx); send_CHEAPER, receive_EXPRESS); mad_pack(cnx, &n, sizeof(int), n = strlen(s) + 1; cnx = mad_begin_packing(channel, dest); p_mad_connection_t cnx; char *s = "Hello, World !"; int n; Sending sideReceiving side

63 Exemple mad_end_unpacking(cnx); send_CHEAPER,receive_CHEAPER); mad_unpack(cnx, s, n, s = malloc(n); send_CHEAPER,receive_EXPRESS); mad_unpack(cnx, &n, sizeof(int), cnx = mad_begin_unpacking(channel); p_mad_connection_t cnx; char *s = NULL; int n; mad_pack(cnx, s, n, send_CHEAPER, receive_CHEAPER); mad_end_packing(cnx); send_CHEAPER, receive_EXPRESS); mad_pack(cnx, &n, sizeof(int), n = strlen(s) + 1; cnx = mad_begin_packing(channel, dest); p_mad_connection_t cnx; char *s = "Hello, World !"; int n; Sending sideReceiving side

64 Interfaces de niveau intermédiaire Madeleine : implantation

65 Proposition Interface Gestion des tampons Gestion de protocole UnpackPack ReceiveSend

66 Madeleine – structure BMM 1 BMM n TM 1 TM n Network Application Generic Buffer Management Modules Switch Selection BMM 1 BMM m TM 1 TM n Application Switch Selection Specific Transmission Modules

67 Adaptativité u Sélection du mode de transmission adéquat Interface Gestion des tampons Gestion de protocole Pack ? ?

68 Implementation u Madeleine II a été portée sur : SISCI/SCI BIP/Myrinet MPI VIA TCP SBP

69 BIP/Myrinet

70

71 SISCI/SCI

72

73 Quelques résultats u Latence 7 µs sur BIP/Myrinet 4 µs sur SISCI/SCI u Bande passante 125 Mo/s sur BIP/Myrinet 80 Mo/s sur SISCI/SCI u Migration (PM2) 24 µs sur SISCI/SCI 52 µs sur BIP/Myrinet

74 MPICH/Madeleine II uMPICH: general-purpose portable MPI implementation well-defined protocol interface Abstract Device uMadeleine: cluster-specific high-performance communication generic structure available on Gigabit networks highly optimized implementation uThe best of both worlds! Madeleine as a MPICH device

75 MPICH/Madeleine II MPI API ADI Protocol Interface Generic part (collective operations, context/group management,...) Generic ADI code, datatype management, request queues management SMP_PLUG device intra-node communication CH_SELF device self communication CH_MAD device inter-node communication polling loops eager protocol rendez-vous-protocol Madeleine II multi-protocol management Fast-EthernetSCIMyrinet TCPSISCIBIP

76 Latency

77 Bandwidth

78 Vers les grappes de grappes

79 Objectifs u Support des grappes de grappes Communications hétérogènes Transparence Efficacité du routage sur les machines « passerelles » Ù Minimisation des copies Ù Maintien du débit par techniques de pipeline Ù Utilisation des threads ! PC/Myrinet PC/SCI Réseau rapide

80 PACX-MPI u2 nœuds sacrifiés pour les communications uTransparence pour lapplication uProtocole TCP/IP entre les grappes MPI TCP

81 Globus uPrincipe : Appel de Procédure à Distance uLibrairie de communication : Nexus Multiprotocole Multithreading non nécessairement préemptif La passerelle est sacrifiée uTout est à faire par lutilisateur Pas de gestion explicite des grappes de grappes uPas adapté au problème

82 Madeleine II uBibliothèque de communication Multiprotocole Canaux de communication indépendants Un canal correspond à un adaptateur réseau Canal TCP Canal SCI

83 Structure interne uCouche générique de gestion de tampons uCouche de portabilité avec les protocoles Réseau Application MGT 1 MGT n MGT 2 MT 1 MT n MT 2

84 Structure interne MGT 1 MGT n MT 1 MT n Réseau Application Couche de gestion de tampons Couche de portabilité Aiguillage Sélection MGT 1 MGT n MT 1 MT n Réseau Application Aiguillage Sélection

85 Structure (suite) uOrganisation des données Madeleine : données globales Driver : spécifique à un protocole Adapter : virtualisation dune carte réseau Channel : isolation des communications Connection : connexion point à point Link : virtualisation dune méthode de transfert

86 Ce qui manque u Utilisation de réseaux qui ne sont pas présents sur tous les nœuds u Envoi de messages entre des machines non directement reliées SCI Myrinet

87 Intégration dans Madeleine u MTs : pas portable u MGTs : problèmes de conversion u Au-dessus : perte defficacité Application MGT 1 MGT 2 MGT n MT 1 MT 2 Réseau

88 Solution retenue u MT générique entre les MTs et les MGTs u Pas de MGT au niveau de la passerelle MT générique MGT 1 MGT 2 MGT n MT 1 MT 2 Réseau Application

89 Canaux virtuels uContiennent plusieurs canaux réels uPermettent de séparer les messages à retransmettre des messages normaux (canaux réels différents) 1234 Canaux SCI Canaux Myrinet Canal spécial Canal normal Canal virtuel

90 Réactivité et parallélisme uRetransmission des messages par des threads dédiés Une paire de threads par réseau physique Mécanisme de pipeline uRéception des messages normaux sur la passerelle Pas dinformations à priori sur la provenance Threads de scrutation

91 Principe de la passerelle Application Threads de retransmission Thread de scrutation SCI Myrinet

92 Tests de performances Ping-pong entre 2 machines séparées par une passerelle SCI Myrinet 321

93 Évaluation

94 Intégration des threads et des communications Réactivité des nœuds aux E/S

95 Progression des communications u Problème Comment assurer la progression des communications ? proc réseau

96 Scrutation et interruptions u La scrutation est nécessaire Ù API réseau ne fournissant pas dappels bloquants Ù OS ne fournissant pas dactivations Problème Ù Fréquence difficile à assurer Ù Coûteux en présence de multiple pollers u Les interruptions sont nécessaires Ù Réactivité Problème Ù Outils de synchronisation interrupt safe ?

97 Support de lordonnanceur u Ordonnanceur = serveur de scrutation Choix de la méthode daccès (scrutation/intr.) u Support pour la scrutation Fréquence contrôlée Factorisation des scrutations multiples u Support pour les interruptions Utilisation possible des activations Verrous spécifiques « interrupt-safe »

98 Scrutation par lordonnanceur Ordonnanceur des threads Création dune catégorie de polling (ex: MPI), assignation dune fréquence et enregistrement de callbacks. Polling jobs queue MPI MPI_Isend Marcel_poll Chaque thread candidat à une opération de polling adresse une requête à lordonnanceur et se bloque. MPI_Irecv Marcel_poll callback Régulièrement, lordonnanceur appelle la fonction de scrutation définie par lutilisateur... Polling( )

99 Multithreading Introduction et rappels

100 Rappel : les processus lourds u Caractéristiques Entité active directement supportée par lOS Ù Flot dexécution Ù Espace dadressage privé Ù Ressources systèmes Exécution séquentielle u Coût de gestion élevé Allocation des ressources Appels systèmes

101 Processus lourds u Ressources noyau + données utilisateur processeur Noyau Processus Ordonnanceur Espace utilisateur Processus

102 Threads : Motivations u Difficulté de programmation Fil dexécution unique une seule chose à la fois ! Partage de données laborieux Réactivité aux sollicitations externes u Performances Opérations de base coûteuses Recouvrement des opérations dE/S difficiles

103 Simplicité de programmation u Objectif Mener plusieurs activités indépendantes au sein dun processus u Exemples Simulations Serveurs de fichiers Systèmes dexploitation (!) u Seule solution (?) Automate à états finis implanté « à la main » (sauvegardes détats)

104 Structure dun OS monolytique u Exemple Séquence infinie dopérations courtes Ordre et fréquence des scrutations ? for (;;) { if(networkMsgIn()) getNetworkMsg(); if(kbdReady()) getKey(); if(diskBlockReady()) handleDiskBlock(); … }

105 Systèmes multiprogrammés Exécution indépendante des activités Concurrence entre les différents traitements for (;;) { wait for network msg; getNetworkMsg(); } for (;;) { wait for key stroke; getKey(); } for (;;) { wait for disk block; handleDiskBlock(); }

106 Processus serveur classique u Sérialisation des requêtes Pas de recouvrement des E/S Exploitation SMP délicate Prise en compte de priorités ? OS clientserveur

107 Sur lefficacité des E/S u Caractéristiques du serveur de fichiers Tps de traitement dune requête = 15ms Tps supplémentaire pour laccès disque = 75ms (pour 1/3 des requêtes) u Débit sans/avec recouvrement des E/S Sans recouvrement Ù 25 requêtes/seconde Avec recouvrement Ù requêtes/seconde (+33%)

108 Les processus légers u Principe Détacher flot dexécution et ressources u Introduits dans divers langages & systèmes Programmation concurrente Recouvrement des E/S Exploitation des architectures SMP thread ressources

109 Caractéristiques de base u Thread = pile + contexte u Partage de ressources Ù Code, tas, … : espace dadressage Ù Fichiers ouverts Ù Etc. u Opérations de base performantes Ù Création, destruction Ù Synchronisation, commutation de contextes u Création dun processus léger Adresse de fonction à exécuter + paramètres

110 Performance des threads u Opérations critiques Création/destruction (gestion mémoire) Changement de contexte (temps-partagé) Synchronisation (mode utilisateur) u Programme dévaluation Création dune activité (processus, thread) + synchronisation (terminaison de lactivité) OS/ProcesseurProcessusThread noyauThread utilisateurPM2 Linux 2.2/PII Solaris 2.7/PII

111 Repères historiques u Lancêtre : les coroutines Entrelacement explicite des exécutions Langages : Simula (67), Modula2 (82) Primitives clés : create + resume u Les threads dans les systèmes Ù Cthread (Mach) -> DecThread -> PThread (~90) Ù Chorus, Solaris (87), winNT, IRIX, Linux, etc. u Les threads dans les langages Ù Ada (83), Java, etc. Ù C++ //, Eiffel //, etc.

112 Multithreading Premier contact

113 Linterface POSIX-Threads u Interface de programmation standard pour Unix Portabilité des applications Solaris, IRIX, HP-UX, Linux, Etc. u Fonctionnalités Création/destruction de threads Synchronisation Ordonnancement, priorités Signaux Etc.

114 Exemple: création Création dun nouveau thread Éventuels attributs dans la structure attr Exécution de start_func avec le paramètre arg *pid est lidentificateur du thread créé int pthread_create(pthread_t *pid, pthread_attr_t *attr, void * (*start_func)(void *), void *arg);

115 Attente de fin dexécution Attente de la terminaison du thread pid Récupération de son code de retour status On peut contourner ce mécanisme en « détachant » les threads : int pthread_join(pthread_t pid, void **status); int pthread_detach(pthread_t pid);

116 « Hello World! » #include void *func(void *arg) { printf(Thread %x says %s\n, pthread_self(), arg); return NULL; } int main(void) { pthread_t pid; pthread_create(&pid, NULL, func, Hello World!); printf(This is the main thread\n); pthread_join(pid, NULL); return 0; }

117 Attributs u Ensemble fixé de caractéristiques Utilisé à linitialisation Threads, verrous, variables de condition, etc. u Threads Ù Priorité Ù Pile : taille, emplacement Ù Détaché : oui/non Ù Type dordonnancement u Verrous Ù Inversion de priorités, récursivité

118 Attributs : exemple #include void *handle_request(void *arg) { … } int main(void) {… pthread_attr_t attr; for(;;) { fd = accept(sock, …); pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED ); pthread_create( NULL, &attr, handle_request, fd); }

119 Exemple bis : pile À manipuler avec précaution ! Ù Quelle taille de pile choisir ? Ù Comment prévenir/détecter les débordements ? pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setstacksize(&attr, 128*1024 ); pthread_create( NULL, &attr, func, NULL );

120 Le standard OpenMP u Interface pour écrire des applications multithreads portables (sur SMP) Directives de compilation (C, C++, Fortran) + routines Objectif = simplicité + portabilité Constructeurs + fabricants de logiciels + etc. u Modèle de programmation « Fork-Join » Parallélisation des boucles (#pragma omp)

121 Multithreading Partage mémoire efficace

122 Les threads et la mémoire u Chaque thread possède sa propre pile Variables locales « privées » ( visibilité) u Les threads partagent lespace dadressage Variables globales Tas (malloc) Variables locales (piles) également ! u Intérêt Communications par pointeurs ! Parallélisation de programmes séquentiels aisée ?

123 Outils pour la synchronisation u Exclusion mutuelle : les verrous u uSynchronisations plus complexes : Ù Variables de condition (cf moniteurs de Hoare) Ù pthread_cond_wait Ù pthread_cond_signal, pthread_cond_bcast int glob = 0; void *inc(void *arg) { for(i=0; i<100; i++) { pthread_mutex_lock(&mutex); glob++; pthread_mutex_unlock(&mutex); }

124 Code réentrant u «code demeurant correct lorsquil est exécuté simultanément par plusieurs threads » u Exemples typiques Fonction nutilisant que des variables locales Code protégé par un verrou u Quid du code que lon écrit pas soi-même ? Malloc, free, …, la bibliothéque standard Fonctions « MT-safe » Ù Option –D_REENTRANT Ù Certains prototypes changent…

125 Importance de la synchro. u Cohérence séquentielle de la mémoire ? Compilateurs/Optimiseurs Ù Instructions réordonnées Processeurs modernes Ù Ecritures réordonnées On ne peut pas supposer lordre des écritures u Primitives de synchronisation Agissent comme des « barrières mémoire »

126 Variables spécifiques u Pb : comment gérer les variables globales « privées » int my_x; void g(void) { …my_x… } void f(void) { my_x = do_compute(); … g(); }

127 Variables spécifiques u Principe Variable accessible à partir dune clé Allocation globale (souvent à linitialisation) Ù pthread_setspecific(clé, valeur) Ù pthread_getspecific(clé) -> valeur u Exemple : la variable errno Fichier errno.h #ifdef _REENTRANT #define errno (*__errno_location()) #else extern int errno; #endif

128 Exploitation efficace des machines SMP Quelle catégorie de threads ?

129 Multithreading utilisateur u Deux ordonnanceurs indépendants : processor OS Kernel Process Scheduler User Space Scheduler

130 Multithreading noyau u Un seul ordonnanceur : processor OS Kernel Process Scheduler User Space

131 Multithreading mixte u Deux ordonnanceurs coopérants processor OS Kernel Process Scheduler User Space Scheduler Note: Quid des appels systèmes bloquants ?

132 E/S et ordonnancement u Threads noyaux : OK u Threads utilisateurs Appel bloquant -> blocage du processus entier u Threads mixtes Idem au bout dun certain nombre ! u Solutions ? Appels toujours non-bloquants (polling) Appels effectués par des threads dédiés Support système spécifique

133 Exploitation efficace des machines SMP Scheduler Activations

134 Recouvrement des E/S u Au lieu de Espace noyau Espace utilisateur Matériel syscall u …on voudrait : Espace noyau Espace utilisateur Matériel I/O request interrupt Temps CPU perdu CPU utilisé

135 Scheduler Activations u Introduit par [Anderson et al. 91] u Idée: la coopération entre les deux ordonnanceurs est bidirectionnelle Ù Lordonnanceur utilisateur utilise des appels systèmes Ù Lordonnanceur noyau utilise des upcalls! u Upcalls Informe lapplication des événements noyaux u Activations Autant dactivations en exécution que de processeurs Contrôlées par le noyau u Principe mis en œuvre dans Solaris

136 Difficultés de mise en œuvre u Retour dun appel bloquant Un « unblock upcall » nécessite deux appels systèmes supplémentaires… La généricité coûte cher !! u Perte du processeur Signalée par un upcall particulier Ù Objectif = éviter les attentes actives ! Conséquences Ù Lordonnanceur de niveau utilisateur doit se prémunir contre ces interruptions intempestives Ù Le coût est prohibitif !

137 Un modèle revisité u Contexte = calcul haute performance Une application // à la fois sur la grappe Optimisations pour ce cas de figure Ù Les activations perdent rarement le processeur u Propositions Suppression des évènements « preempt » Utilisation dune pile par processeur u Implantation Linux 2.2.x Bibliothèque de threads Marcel

138 A propos de réactivité… u Problèmes liés aux évènements « unblock » Coût important, réactivité non-garantie u Proposition Pour les notifications non-urgentes Ù Positionnement dune variable partagée Ù Test à chaque changement de contexte Pour les notifications critiques Ù Lors du retour en mode utilisateur : -Déviation vers le thread « client » de lévénement Ù Déviation éventuellement différée…

139 Modifications du noyau Linux u Parties du noyau modifiées schedule(), do_fork() and do_exit() Ù Implantation des transitions task_struct structure Ù Nouveaux champs (état des activations, etc.) u Code ajouté Appels systèmes + API pour les upcalls Gestion des upcalls (~signaux) Code pour les changements détat des activations

140 Performances

141 Meilleure réactivité au réseau u Illustration : MPI et les communications asynchrones Processus AProcessus B Acquittement MPI_Isend MPI_recv MPI_test

142 Multithreading Distribué Principe et Enjeux

143 Principe u Introduire les threads dans les applications distribuées et parallèles proc réseau

144 Enjeux u Bénéfices escomptés Meilleur support du parallélisme à grain fin Recouvrement naturel des communications Uniformisation de la configuration Ù Machines monoprocesseur/machines SMP

145 Intérêts u Apports des threads Virtualisation de larchitecture Ù Threads = processeurs virtuels Ù Passage à léchelle (scalability) Ù Bonne cible pour des compilateurs Meilleure réactivité au réseau Ù Traitement asynchrone des messages Équilibrage de charge par migration de threads Ù Équilibrage dynamique Ù Régulateur indépendant de lapplication (plug-ins) !

146 Multithreading Distribué Quel modèle de programmation ?

147 Approche par juxtaposition u Principe : pas de modèle ! Simplement utiliser conjointement Ù Une bibliothèque de communication (ex: MPI) Ù Une bibliothèque de multithreading u Problèmes Conceptuels Ù Pas de visibilité globale des threads Ù Sémantique des communications ? Techniques Ù Compatibilité entre les bibliothèques Ù Travail dintégration spécifique -> non réutilisable

148 Approche intégrée u Threads communicants A0, Chant u Pthreads + extensions Rthreads u Pthreads DSM-threads u Appels de procédure à distance « threadés » A0, Nexus, PM2

149 Threads communicants u Principe Envoi de message entre threads Ù Modèle « MPI-like » Ù Modèle « Acteurs » Nommage Ù Nommage global des threads Ù Ports de communication u Exemples Chant (M. Haines, ICASE) Athapascan-0b (J. Briat, INRIA Grenoble)

150 Modèle Pthreads étendu u Principe Threads + primitives étendues Ù Create/Join à distance Ù Synchronisations distribuées Particularités Ù Nommage global des threads Ù Restriction du modèle Pthreads u Exemples Chant (M.Haines, ICASE), Rthreads (M. Zahn, Allemagne)

151 Modèle Pthreads distribué u Principe Adaptation complète (?) de Pthreads Ù Threads + mémoire virtuellement partagée Transparence Ù Cohérence assurée lors des défauts de pages Ù Restriction sur les E/S Extensions Ù Cohérences mémoires relâchées u Exemple DSM-Threads (F. Mueller, Berlin)

152 Modèle dérivé des RPC u Principe Appel de procédure à distance (A. Birell) Ù Extension du concept aux threads Ù Création de threads pour exécuter les procédures Désignation globale des services Ù Numéro fonction Ù Souches (stubs) pour la transmission des paramètres u Exemples Nexus (I. Foster, Argonne), PM2

153 Multithreading Distribué Lenvironnement PM2

154 Premières réflexions sur PM2 uParallel Multithreaded Machine (R. Namyst) Virtualisation de larchitecture Régulateurs génériques de charge (Y. Denneulin) Plateformes usuelles (COW, NOW), machines parallèles Distribution du logiciel, assistance, documentation:-( uInterPRC Stratagème (C. Roucairol) Applications irrégulières Ù Optimisation combinatoire Ù Algèbre linéaire creuse (J. Roman) Ordonnancement, régulation Ù Fortement irrégulière : placement + migration

155 Projet PM2 (95-xx) uObjectif ambitieux : virtualisation Indépendance de la machine cible (#processeurs) Degré de parallélisme important (#processus) Parler de traitement / processus Ù mécanismes de décomposition parallèle uPropositions Mécanisme de décomposition Ù Appel de procédure à distance léger (LRPC) Support des activités Ù Processus légers (threads) Régulateur dynamique de charge Ù Placement + Migration

156 Appel de procédure à distance uDifférentes déclinaisons Synchrone Attente différée Asynchrone PM 2 LRPC uNos concurrents... Nexus : RSR Athapascan : appels de service

157 Hello World! #include unsigned SAMPLE; void sample_func(void) { char msg[128]; pm2_unpack_byte(SEND_CHEAPER, RECV_CHEAPER, msg, 128); pm2_rawrpc_waitdata(); printf(%s\n, msg); } void main(int argc, char **argv) { int module[MAX_MODULES], nb_modules; pm2_rawrpc_register(&SAMPLE, sample_func); pm2_init(&argc, argv, 2, module, &nb_modules); if(pm2_self() == les_modules[0]) { pm2_rawrpc_begin(module[1], SAMPLE, NULL); pm2_pack_byte(SEND_CHEAPER, RECV_CHEAPER, Hello World!, 128); pm2_rawrpc_end(); pm2_kill_modules(module, nb_modules); } pm2_exit(); }

158 Threaded Hello world! Création dun thread Obligatoirement par pm2_thread_create Ù positionnement dun certain nombre dattributs Ù héritage du droit de faire unpack... void thread_func(void *arg) { char msg[128]; pm2_unpack_byte(SEND_CHEAPER, RECV_CHEAPER, msg, 128); pm2_rawrpc_waitdata(); printf(%s\n, msg); } void sample_func(void) { pm2_thread_create(thread_func, NULL); }...

159 Mobilité des activités uMigration de processus légers PM 2 uPourquoi ? Régulation de charge Localité des données uComment ? Transfert du contexte Programmes SPMD

160 Multithreading Distribué Communications dans un environnement multithreads

161 Appel de procédure à distance RPC Intensivement utilisé Ù Accès mémoire distants, migration, etc. Consensus (?) Ù Athapascan, Nexus, Panda, PM2

162 Transmission zéro-copie Processus A Processus BRéseau Préparation mémoire Acquittement Message Entête Vecteur DMA

163 Portabilité u Bibliothèques de haut niveau MPI Ù Pas adapté aux interactions de type « RPC » u Bibliothèques de bas niveau BIP (Myrinet), SISCI (SCI), GAMMA (Ethernet) Ù Paradigmes très différents ! Portabilité ?? u Niveau intermédiaire Exemple: Fast-Messages (Illinois) Ù Adapté aux RPC Ù Trop souple (surcoûts inutiles)

164 RPC efficaces avec Madeleine LRPC, Migration Madeleine Gestion générique de tampons Gestion des transmissions BIP, SISCI, VIA, TCP, MPI

165 u Construction des messages uGestion des canaux (~ communicators) Choix explicite du dispositif physique Interface de Madeleine mad_begin_packing mad_pack mad_end_packing mad_begin_unpacking mad_unpack mad_end_unpacking

166 Packing et Unpacking u Commandes: mad_pack (cnx, buffer, len, pack_mode, unpack_mode) mad_unpack (cnx, buffer, len, pack_mode, unpack_mode) u Modes: Send_SAFER Send_CHEAPER Send_LATER Receive_EXPRESS Receive_CHEAPER

167 Conclusion u Multithreading Exploitation efficace des architectures SMP Contrôle fin de lordonnancement Ù Conditionné par les fonctionnalités du système u Multithreading distribué Communications de type RPC Ù Support spécifique nécessaire Intégration des threads et des communications Ù Délicate !! Ù Mieux maîtrisée si fonctionnement coopératif

168 Contexte technologique uArchitecture homogène, faiblement hétérogène Grappes (Cluster, COW), machines // Ù PC, stations de travail Ù Ethernet, Myrinet, SCI,... Protocoles de communication ÙBIP, SISCI, SciOS, VIA, TCP, UDP,... Myrinet/BIP PC Commutateur

169 Contexte technologique uInfrastructure hétérogène Grilles Ù Supercalculateurs (Superordinateur virtuel) Ù Grappes (grappes hiérarchiques, HNOW) Ù PC Interconnexion à plus large échelle Ressources hétérogènes Ù Processeurs (puissance, cache, mémoire) Ù Réseaux (latence, bande passante, protocoles) Multi-protocoles, déploiement, algorithmique,... PowerPC/Switch/MPI Bordeaux PC/Myrinet/BIP Lyon PC/SCI/sciOS Grenoble Internet

170 Superordinateur virtuel (Globus)

171 Grappes hiérarchiques uDistributed ASCI Supercomputer (DAS) Plate-forme commune pour la recherche Informatique parallèle (à grande échelle) et applications distribuées Novembre 1998, 4 universités, 200 nœuds Nœud ÙPentium Pro 200 MHz Ù128 MB de mémoire, 2.5 GB de disque ÙMyrinet 1.28 Gbit/s (full duplex) ÙSystème dexploitation : BSD Réseau ATM

172 Grappes hiérarchiques

173 Ressources uRessource entité capable de lancer un ou plusieurs processus pour le compte dun utilisateur. Désigne également des composants matériels (mémoire, réseau, senseurs, etc.) Composants logiciels (fichiers, softs, …) uPartage Contrôlé des Ressources Informations, disponibilité Allocation, co-allocation Sécurité Administration, politiques daccès…

174 Application Programming Interface uSpécification dun ensemble de fonctions pour faciliter le développement dapplications Définition, pas dimplementation Exemples: il y a plusieurs implémentations MPI uSpécifique pour certains langages Noms des routines, nombre, type des paramètres Comportement de la fonction uExemples GSS API (sécurité), MPI (échange de messages)

175 Software Development Kit uUne instantiation particulière dune API uSDK est constitué de bibliothèques et doutils Fournir une implémentation de la spécification dune API uPlusieurs SDKs pour une même API uExemples de SDKs MPICH, Motif Widgets

176 Pourquoi les Grilles ? uEvolution des réseaux à très haut débit uNouvelles applications basées sur le couplage rapide de personnes, dordinateurs, de bases de données, dinstruments,... Instruments en ligne Ingénierie collaborative Calcul parallèle distribué Utilisation de ressources distantes Simulations à très grande échelle Applications classiques du parallélisme faiblement couplé uLaboratoires virtuels

177 Instruments en ligne Reconstruction tomographique récupération en temps réel Dissémination à grande échelle Bureaux & clients de RV à contrôle partagés Source de photons Stockage pour archive

178 Ingénierie Collaborative uManipulation despaces virtuels partagés avec Composants de simulation Flots multiples : Contrôle, Texte, Vidéo, Audio, Base de données, Simulation, Tracking, Rendering uProblèmes associés : uni/multi-diffusion fiable (ou non fiable) Sécurité (comptes, accès, transferts de données) Réservation et Qualité de Service

179 Calcul parallèle distribué uProblèmes associés Découverte de ressources (matérielles et logicielles) Ordonnancement (on-line & off-line) Visualisation de données Plusieurs bibliothèques de communications Passage de messages Passage à léchelle Tolérance aux pannes Réservation de ressources Sécurité Rennes Rocquencourt Nancy Grenoble Sophia

180 Challenges techniques uApplications complexes qui combinent des aspects du parallélisme, du multimédia et du système distribué uRessources dont les caractéristiques varient en fonction du temps et de lespace uBesoin de performances « end-to-end » bonnes et garanties, malgré lhétérogénéité et le manque de contrôle global uProblèmes de sécurité, de politique et de paiement entre les domaines

181 Les défis logiciels uAdministration Sécurité, équité, disponibilité, équilibrage des charges uHétérogénéité Réseaux, processeurs, hiérarchie mémoire Équilibrage des charges Distribution des données Informations sur la charge en temps réel Évaluation des performances Modélisation des architectures Couplage de codes

182 Globus

183 Le projet Globus uRecherches sur les technologies liées aux grilles Gestion des données et des ressources, sécurité, Qualité de Service, communication, adaptation,... uDéveloppement de la boite à outils Globus Services de base pour les outils et applications de la grille uConstruction de grilles uExpérimentations des applications

184 Lapproche Globus uUne boite à outils et plein de services pour résoudre des problèmes techniques cruciaux « sac à malices » modulaire Middleware applicable dans différents domaines dapplication uFaire interopérer plusieurs « mondes » existants au lieu de les fusionner uDifférenciation des services locaux et globaux

185 Approche Technique uPermettre le développement incrémental doutils et dapplications pour la grille Support de nombreux langages, modèles de programmations, outils, applications Évoluer en fonction des besoins de lutilisateur uSe déployer à léchelle internationale Développements et tests à grande échelle uFournir un environnement riche en informations

186 Les grilles Globus uGrilles et Plates-formes de tests EMERGE : Pré-réservation & QoS GUSTO : Globus Ubiquitous Supercomputing Testbed Organization Particle Physics Data Grid uGrilles de production NSF PACIs National Technology Grid NASA Information Power Grid DOE ASCI European Grid

187 Plate-forme GUSTO durant SC98 uGlobus Ubiquitous Supercomputing Testbed Organization (GUSTO) 02/00: 125 sites dans 23 pays Lun des plus grands environnements de calcul jamais construits

188 The 13.6 TF TeraGrid: Computing at 40 Gb/s HPSS 5 UniTree External Networks Site Resources NCSA/PACI 8 TF 240 TB SDSC 4.1 TF 225 TB CaltechArgonne TeraGrid/DTF: NCSA, SDSC, Caltech, Argonne

189 Le Sablier Globus uUn ensemble de services comme infrastructure de base uUtilisables pour construire des solutions spécifiques de haut niveau uButs: Limiter limplication des utilisateurs Permettre un contrôle local Divers services globaux Cœur des Services Globus OS Local A p p l i c a t i o n s

190 Architecture en couche Applications Boite à outils Application DUROCglobusrunMPINimrod/GCondor-GHPC++ GlobusViewTestbed Status Base de la Grille LSF CondorMPI NQEPBS TCP NTLinux UDP Solaris DiffServ Services de la Grille GRAM GSI HBM Nexus I/OGASS GSI-FTP MDS

191 Différents services Globus uServices dinformation (MDS) uGestion des ressources (GRAM & DUROC) uGestion distante des fichiers (GASS) uCommunication (Nexus, MPI) uSécurité (GSI) uSurveillance des processus (HBM)

192 Le besoin dinformations uSystème dinformation point crucial pour les opérations sur la grille et la construction dapplications Comment une application détermine quelles ressources sont disponibles ? Quel est « létat » de la grille uBesoin dun système dinformation général pour répondre à ces questions

193 Quelques informations utiles uCaractéristiques dun serveur de calcul Adresse IP, logiciels disponibles, administrateur système, connections aux réseaux, version dOS, charge uCaractéristiques dun réseau Bande passante et latence, protocoles, topologie logique uCaractéristiques de linfrastructure Globus Hôtes, gestionnaires de ressources

194 Utilisation de linformation pour le courtage des ressources 10 GFlops,20 Mb/sec pendant 20 mins Metacomputing Directory Service GRAM Courtier ressources Service Info : localisation + selection Globus Resource Allocation Managers GRAM Fork LSF EASYLL Condor etc. Quelles machines? Quelle vitesse? Dispo quand? 50 processeurs + disques de 22h20 à 22h40 20 Mb/sec

195 Service dinformation uFournir un accès à des informations statiques et dynamiques sur les composants uBase pour la configuration et ladaptation de systèmes dynamiques et hétérogènes uBesoins et caractéristiques Accès uniforme et flexible à linformation Accès efficace et extensible aux données dynamiques Accès à des sources dinformations multiples Maintenance décentralisée

196 Approche MDS uBasée sur LDAP Lightweight Directory Access Protocol v3 (LDAPv3) Modèle de données standard Protocole de requête standard uSchéma spécifique à Globus Représentation centrée sur lhôte uOutils spécifiques Globus GRIS, GIIS Découverte, publication de données GRIS NIS NWS LDAP API LDAP Middleware … Application GIIS… SNMP

197 Le MDS uMetacomputing Directory Service uAnnuaire de ressource de Globus uContient toutes les informations sur tous les nœuds globus uConsultable sur Internet uDistribué depuis la version Permet de créer son propre « sous-Globus »

198 Metacomputing directory service nn=SP-switch MDS Representation Carl Steve Switch Ethernet Ian Gregor Steve Warren sunny hot IBM SP dark cold LAN WAN USC/ISI ANL/MCS c=US o=globus o=USCo=ANL ou=MCSou=ISI nn=WAN cn=Ian cn=Gregor cn=Warren cn=Steve nn=SP-ether nn=MCS-lan hn=sp1.mcs.anl.gov hn=spN.mcs.anl.gov cn=Carl cn=Steve … … … … Structure physique

199

200 Gestion de ressources uUn langage de spécification de ressources flexible qui fournit la puissance nécessaire pour exprimer les contraintes requises uDes services pour la co-allocation de ressources, lorganisation dexécutables, laccès à des données distantes et la gestion des flux dentrées/sorties uIntégration de ces services dans des outils de haut niveau MPICH-G: un MPI pour la grille globus-job-*: commandes flexible dexécution à distance

201 Gestion de ressources uResource Specification Language (RSL) est utilisé pour communiquer les besoins uLAPI du Globus Resource Allocation Manager (GRAM) permet de lancer les programmes sur des ressources distantes, sans tenir compte de lhétérogénéité locale uUne architecture en couche permet de définir des courtiers de ressources et des co-allocateurs spécifiques aux applications comme étant des services GRAM

202 Modèle dordonnancement uGRAM supporte le modèle suivant suspendu actifterminé échec uSuspendu : ressources non encore allouées uActif : ressources allouées, exécution en cours uÉchec : terminaison prématurée (erreur ou arrêt) uTerminé : terminaison avec succès

203 Composants GRAM Globus Security Infrastructure Job Manager Appels GRAM pour requête dallocation de ressources et création de processus. Appels MDS pour localiser les ressources Requête sur létat de la ressource Création Bibliothèque RSL Parse Requête Allocation & création des processus Processus Monitoring & contrôle Limite du site ClientMDS: Grid Index Info Server Gatekeeper MDS: Grid Resource Info Server Local Resource Manager Appels MDS pour avoir des infos sur les ressources Mise à jour GRAM

204 LSFEASY-LLNQE Application RSL Simple ground RSL Service dInformation Gestionnaires de ressources locaux spécialisation RSL Courtier Ground RSL Co-allocateur Requêtes & Info Architecture de la gestion de ressources

205 Langage de spécification de ressource uNotation commune pour léchange dinformation entre composants uRSL fournit deux types dinformations : Besoins en ressources : type de machine, nombre de nœuds, mémoire, etc. Configuration dun job : Répertoire, exécutable, arguments, environnement uAPI fournie pour manipuler RSL

206 Syntaxe RSL uForme élémentaire : clauses parenthésées (attribut op valeur [ valeur … ] ) uOpérateurs supportés: =, >, != uQuelques attributs supportés : exécutable, arguments, environnement, stdin, stdout, stderr, resourceManagerContact, resourceManagerName uLes attributs inconnus sont ignorés Peut-être gérés par dautres outils

207 Contraintes : & uPar exemple : & (count>=5) (count<=10) (max_time=240) (memory>=64) (executable=myprog) uCréer entre 5-10 instances de myprog, chacune sur une machine with ayant au moins 64 MB de mémoire et disponible pour moi pendant 4 heures

208 Multi-requêtes : + uUne multi-requête permet de spécifier plusieurs besoins de ressources, par exemple : + (& (count=5)(memory>=64) (executable=p1)) (&(network=atm) (executable=p2)) Exécuter 5 instances de p1 sur une machine ayant au moins 64Mb de mémoire Exécuter p2 sur une machine ayant une connexion ATM uMulti-requêtes sont le cœur de la co-allocation

209 GRAM uGlobus Resource Allocation Manager uPermet à un programme dêtre lancé sur des ressources distantes malgré lhétérogénéité locale uUtilise le langage de spécification de ressources (RSL)

210 DUROC uDynamically Updated Request Online Co- allocator uCo-allocation : allocation simultanée dun ensemble de ressources uBasée sur des prédictions concernant les nœuds libres et la taille des files dattentes

211 GASS uGlobal Access to Secondary Storage open/close globus_gass_open/close : lectures/écritures directement à distance URLs pour nommer les exécutables, les flux dentrée et de sortie. Utilitaire de gestion de caches distants èChargement transparent de données distantes, cache de données,...

212 Supprimer la référence cache Mettre à jour les changements Modifié non Oui globus_gass_open()/close() Charger le fichier dans le cache Ouvrir le fichier caché, ajouter une reference cache URL dans le cache? non oui globus_gass_open() globus_gass_close()

213 Nexus uDans un système tel que Globus, la meilleure méthode de communication peut changer Nexus Support pour des communications multi-méthodes Principes de base : lien de communication et RSR (Remote Service Request) start point end point

214 GSI uGrid Security Infrastructure uBasé sur le système de clé publique certificats au standard X.509 (comme sur Internet) uChaque utilisateur a : un identificateur dutilisateur de la grille, une clé privée, un certificat en bonne et due forme. uUn fichier « globusmap » sur chaque site fait la correspondance entre grid-id et local-id

215 HBM et GloPerf uHeartBeat Monitor : outil de surveillance des composants Globus. Détection de léchec dun nœud de calcul Monitoring de processus système depuis Globus Utilisé par dautres applications (ex : NetSolve) comme module de tolérance aux pannes uGloPerf : Globus Network Performance Measurement Tool Mesure de la bande passante et de la latence entre chaque site du MDS Pas très évolué et un peu lourd

216

217 Compléments dinformation uGlobus Project uGrid Forum uLivre (Morgan Kaufman) uGlobus 2.2 Maintenu jusque fin 2003 uGlobus 3 Web Services Janvier 2003 (GlobusWorld)


Télécharger ppt "Supports dexécution parallèles et répartis Raymond Namyst LaBRI Université de Bordeaux I Jean-François Méhaut GRIMAAG Université des Antilles-Guyane."

Présentations similaires


Annonces Google