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

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…

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

(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

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

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

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

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

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

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

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

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

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

Interfaces de bas niveau BIP, SISCI, VIA

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

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

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

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

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)

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

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 !)

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

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 (?)

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

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

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

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

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...

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

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

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é ???

Interfaces de haut niveau LA solution ?

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

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

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

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 ?

Transmissions zéro-copie Processus A Processus BRéseau Message Entête Données

Transmissions zéro-copie Processus A Processus BRéseau Entête Données

Transmissions zéro-copie Processus A Processus BRéseau Entête Données

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

Transmissions zéro-copie Processus A Processus BRéseau Acquittement Entête Données

Transmissions zéro-copie Processus A Processus BRéseau Entête Données DMA

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

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

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

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

Interfaces de niveau intermédiaire Madeleine : principe et interface

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, GM, SISCI, VIA, TCP et MPI.

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

Construction des messages uCommandes Mad_pack(cnx, buffer, len, pack_mode, unpack_mode) Mad_unpack(cnx, buffer, len, pack_mode, unpack_mode) uModes démission Send_CHEAPER Send_SAFER Send_LATER uModes de réception Receive_CHEAPER Receive_EXPRESS uContraintes dutilisation Séquences pack/unpack strictement symétriques Triplets ( len, pack_mode, unpack_mode ) identiques en émission et en réception Cohérence des données

Contrat programmeur/interface Send_SAFER/Send_LATER/Send_CHEAPER uContrôle du transfert des données Latitude doptimisation ÙEngagement du programmeur ÙIntégrité des données Services particuliers ÙÉmission différée ÙRéutilisation de tampons uSpécification au niveau sémantique Indépendance : service requis / technique sélectionnée

É mission Pack Modification End_packing Send_SAFERSend_LATERSend_CHEAPER

Structuration des messages Receive_CHEAPER/Receive_EXPRESS uReceive_EXPRESS Réception immédiate impérative Interprétation/extraction du message uReceive_CHEAPER Réception libre du bloc Contenu du message Express

Réception Unpack Après Unpack End_unpacking Receive_EXPRESSReceive_CHEAPER Donnée disponibleDisponibilité ??? Donnée disponible

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

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

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

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

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

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

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

Interfaces de niveau intermédiaire Madeleine : implantation

Organisation verticale uUtilisation du modèle traditionnel à deux couches Gestion des tampons ÙFactorisation du code de traitements de données Abstraction du matériel Interface Gestion des tampons Gestion de protocole Réseau

Organisation horizontale uApproche modulaire Module de gestion de tampons (MGT) Module de gestion de protocole (MGP) Module de transmission (MT) Interface Gestion des tampons Gestion de protocole MGT MT Réseau MGP

Modules de transmission Thread Réseau Pack Madeleine Interface MGT MT Processus

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

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

Évaluation Environnement de test uGrappe de PC bi-Pentium II 450 MHz, 128 Mo uRéseau Fast-Ethernet uRéseau SISCI/SCI uRéseau BIP/Myrinet Méthode de test uUnidirectionnel Mesure : 1000 émissions + 1 réception Résultat : moyenne sur 5 mesures uBidirectionnel Mesures : 1000 x (émission + réception) Résultat : moyenne sur 5 mesures

SISCI/SCI – temps de transfert Test unidirectionnel Taille de paquet (octets) Temps de transfert (µs)

SISCI/SCI – débit Test unidirectionnel Taille de paquet (octets) Débit (Mo/s)

SISCI/SCI – temps de transfert Test bidirectionnel Taille de paquet (octets) Temps de transfert (µs)

SISCI/SCI – débit Test bidirectionnel Taille de paquet (octets) Débit (Mo/s)

SISCI/SCI – temps de transfert Packs/messages Taille de paquet (octets) Temps de transfert (µs)

SISCI/SCI – débit Packs/messages Taille de paquet (octets) Débit (Mo/s)

Interfaces de niveau intermédiaire Gestion du multiplexage

Proposition Concept de canal uSimilaire à un communicator MPI uUn canal, cest : Un protocole Une carte dinterface Un ensemble de nœuds Un ensemble de connexions point-à-point

Les Canaux uCanal Réseau Ensemble de noeuds Ensemble de connexions point-à-point Noeud 1 Noeud 2 Noeud 3 Noeud 4 TCP SCI

Gestion des ressources uProblème Chaque canal consomme des ressources réseau ÙTags BIP, descripteurs SCI, descripteurs TCP Le nombre de ressources peut dépendre du nombre de nœuds ! ÙSegments de mémoire partagée SCI uSolution Introduire des fonctionnalités de multiplexage

Cest quoi le Multiplexage ? uVirtualisation des ressources Idéalement : disposer de « xchannels » ÙUtilisables comme des « channels » ÙDisponibles en quantité arbitraire uArghhh! Et les performances ? Trouver le bon niveau dabstraction Conserver les canaux réels

Multiplexage à quel niveau ? uSur-couche au-dessus de Madeleine Ex: abtraction de type « messages actifs » ÙMultiplexage partiel -> pas dentrelacement des packs ÙMultiplexage complet -> contrôle de flux à chaque pack ou recopies à larrivée uContrôle de flux interne à Madeleine A chaque pack Même problème que ci-dessus…

Vers les grappes de grappes

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

PACX-MPI uMécanismes transparents pour lapplication uTCP/IP est utilisé sur les liaisons inter-grappes uDeux noeuds passerelles sont dédiés sur chaque grappe MPI TCP

MPI Internet MPICH-G2 uImplémentation Multi-grappes de MPICH uCommunications intra-grappe MPI uCommunications inter-grappes TCP uCommunications directes (pas de routage) Myrinet SCI

Support multi-grappe uExploitation des grappes de grappes Réseaux intra-grappes rapides Liens inter-grappes rapides Hétérogénéité au niveau réseau Réseau à haut débit Réseau hautes performances

Principe uCanaux réels Liés à un réseau Ne couvrent pas nécessairement tous les nœuds uCanaux virtuels Couvrent tous les nœuds Contiennent plusieurs canaux réels Myrinet SCI Virtuel

Fonctionnement uRetransmission multi-réseau automatique uApproche générique uFonctionnement multi-threadé uRoutes statiques Notion de MTU Nœud passerelle MémoireBus PCI Myrinet LANai SCI

Préservation du débit uPipeline Réceptions et réémissions simultanées Une seule copie Même tampon pour réception et retransmission Tampon 1 Tampon 2 Réception Emission LANai

Intégration uModule de transmission générique uLimitation du code traversé sur les passerelles Interface Gestion des tampons Gestion de protocole MGT MT Réseau MT générique

Module de retransmission Thread Réseau 2 Madeleine MGTMT Processus MT Interface Threads Réseau 1

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

Multi-grappes Myrinet SCI

Évaluation

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

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

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 ?

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 »

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( )