communications dans les grappes hautes performances raymond namyst labri université de bordeaux i
TRANSCRIPT
Communications dans les grappes hautes performances
Raymond NamystLaBRIUniversité de Bordeaux I
Plan
Technologies matérielles Ethernet, Myrinet, SCI
Interfaces de bas niveau BIP, SISCI, VIA
Interfaces de haut niveau MPI et les communications irrégulières
Interfaces de niveau intermédiaire FM, Madeleine
Vers les grappes hétérogènes…
Technologiesmatérielles
Cartes passives, actives,réseaux à capacité d’adressage
(Fast|Giga)-Ethernet
Interconnexion Hub ou switch
Câblage Cuivre ou fibre optique
Latence ~20 µs
Débit 100 Mb/s et 1Gb/s
Note Compatibilité avec l’Ethernet classique
Hub
Switch
Ethernet
Cartes passives (sauf Giga-Ethernet) Interfaces : TCP, SBP, GAMMA, VIA, …
Network
TX reg
RX reg
Packet InterfacePacket InterfacePCI
Bridge
PCI
Bridge
PCI Bus
DMADMA
Memory
TX-ring
NIC
Myrinet
Société Myricom (C. Seitz) Interconnexion
Switch Câblage
Nappes courtes Cartes équipées d’un processeur Latence
1~2 µs Débit
1 Gb/s Note
Durée de vie limitée des messages (50 ms)
LANai
Myrinet
Routage Réseau commuté, routage wormhole
Carte programmable Protocoles de transmission
« intelligents » Stratégie adaptée à la taille des messages Déclenchement d’interruptions
NetworkRISC
Packet
Interface
DMADMA
PCI
Bridge
PCI
Bridge
PCI Bus
LANai
SRAMSRAM
NIC
SCI
Scalable Coherent Interface Norme IEEE (1993) Société Dolphin
Fonctionnement par accès mémoire distants Projections d’espaces d’adressage
Machine A Machine B
Réseau SCI
Mémoire
MémoireBus PCI Bus PCI
Carte à capacité d ’addressage
BUS PCI
TLB
Interface
paquetPaquet
SCI
Pci req:
addr+data
BUS PCI
TLB
Interface
paquet
Paquet SCI
Pci req:
addr+data
Partie émission Partie réception
Adressage à distance
Projections effectués par le pilote (SISCI) Zones de mémoire physiques souvent spécifiques
Accès mémoire effectués par le processeur Le processeur distant n’est pas (forcément) interrompu
Interconnexion SCI
Processus A
Espace d'adressage
virtuel
Bus PCI
PCI-SCI
Processus B
Espace d'adressage
virtuel
Bus PCI
PCI-SCI
Mémoire physique
SCI : mécanisme d’adressage
Adresse Virtuelle 32 bits
MMU
Adresse Physique (E/S)
Bus d’E/S
32 bits
10 bits 18 bits
Table de Translationdes Adresses
16 bits 30 bits 18 bitsDestinataire
Réseau
30 bits 18 bits
Réseau
Adresse Physique (E/S)
Bus d’E/S
32 bits
Mémoire
SCI : mécanisme d’adressage
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
Comment exploiter les réseaux rapides ? Faible latence
Quelques microsecondes Bande passante élevée
De l’ordre du Gb/s
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
Initialisation Réservée au système Uniquement en début
de session
Transferts Directs depuis
l’espace utilisateur Pas d’appels
systèmes Pas de transitions Transmissions zéro-
copie
Interface
Programme
Réseau
Système
Espace utilisateur
TransfertsInitialisation
Streamline Buffer Protocol
UNH (R. Russell & P. Hatcher) Principe
Partage de tampons entre noyau/processus Tampons préformatés (trames ethernet)
Deux jeux de files de tampons : RQ & SQ
Performances (Linux, P133) Latence : 24 us, débit : ~ 12 Mo/s
Basic Interface for Parallelism: BIP
L. Prylli & B. Tourancheau Principe
Envoi de message “classique” (asynchrone)
Pas de contrôle de flux Pas de detection d’erreur
Performances Latence : 4.8us, débit : 126 Mo/s
BIP
Fonctionnalités réduites au minimum Messages courts : recopiés à l’arrivée Messages longs : mode zéro-copie (RDV)
Contrôle de flux minimal Matériel (msgs “évaporés” au dela de
50ms)
Interface Dolphin pour SCI
Deux niveaux : Interface orientée “fichiers projetés” Interface orientée “VIA” (cf + loin)
Fichiers projetés Utilisation de “mmap”
Synchronisation Segments spéciaux “fetch & add”
SISCI: principe
Communications Accés mémoire distants
Implicites (après projection) Explicites (remote DMA)
Support matériel pour une MVP (?) Performances
Ecriture 2 us, lecture 4 us Bande passante 85 Mo/s (difficilement
!)
SCI : optimisations matérielles
Caches dans la carte : Read Prefetching Write Combining
Interconnexion SCI
Processus A
Espace d'adressage
virtuel
Bus PCI
PCI-SCI
Processus B
Espace d'adressage
virtuel
Bus PCI
PCI-SCI
Mémoire physique
Conséquences
Une Grappe SCI est une NC-NUMA Non-Coherent Non-uniform Memory
Arch. Cohérence séquentielle non vérifiée
Plus gênant : ordre des écritures modifié Pb d’atomicité des transactions PCI Assez inhabituel (?)
VIA
Virtual Interface Architecture
Tentative de standardisation Beaucoup d’industriels impliqués
Caractéristiques Principe d’interfaces virtuelles Zones de transmission protégées Lectures/Ecritures distantes
VIA: Basic Principles
Use the Kernel for Set-Up……and Get It Out of the Way for Send/Receive!
The “Virtual Interface” (VI) Protected Application-Application Channel Memory Directly Accessible by User Process
Target Environment LANs and “SAN”s at Gigabit Speeds No Reliability of Underlying Media Assumed
VI Architecture
VI Consumer
VI User Agent (“libvia”)O
pen,
Con
nect
, M
ap M
emor
y
Descriptor Read, Write
VI-Capable NIC
Sockets, MPI,Legacy, etc.
RequestsCompleted
VI VI C
S S S COMP
R R R
VI
Do
orb
ells
Und
eter
min
ed
VI Kernel Agent (Slow) User-Level (Fast)
Host
NIC
A Virtual Interface
VI Consumer
VI-Capable NIC
Descriptor
Descriptor
Send Q
Sen
d D
oo
rbel
l
Descriptor
Descriptor
Recv Q
Rec
eive
Do
orb
ell
Status Status
Descriptors
Descriptors Contain: Address and Length of Data Buffer Status Fields Memory Protection Information Multiple Segments to Allow
Scatter/Gather etc., etc., etc.
A minimum of 45 bytes long Many messages may only be a few
bytes...
Queues and Doorbells
Queues of DescriptorsTransmit and ReceiveCompletions and Errors May Reside on Host or NIC (Unspecified)
Doorbells“Addresses” of Descriptors, Small and FastAllows NIC to Use Descriptors…Future “VIA-NICs” May Have Hardware Support
Memory Registration
Data buffers and descriptors must reside within a region of “registered memory”
Call VipRegisterMemory Pins the specified pages into physical
memory Communicates the addresses to the NIC
To allow DMA I/O from the NIC
Ce qu’il faut retenir
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
Paradigme passage de message Les nœuds se synchronisent et communiquent
par messages
Deux instructions de base Send émission d’un message Receive réception d’un message
Points forts Simple à mettre en oeuvre Permet d’émuler les autres paradigmes
PVM
Parallel Virtual Machine Laboratoire National d’Oak Ridge (Tennessee) 1989
Caractéristiques Notion de machine virtuelle
Ensemble de machines physiquesConstruction préalable au lancement de la session
Disponibilité très large Réseaux
UDP + protocole de réémission
Support de l’hétérogénéité XDR
MPI
Message Passing Interface MPI-Forum v1.0 1994 v2.0 1997
Caractéristiques Un standard, pas une bibliothèque Diverses implémentations
MPI-CHLAM-MPI…
Supplante PVM Version 2.0 encore peu implémentée
MPI répond-t-il aux besoins ?
Implantations efficaces existantes MPICH/BIP, MPICH/SISCI, etc.
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êteDonnées
Transmissions zéro-copie
Processus A Processus BRéseau
EntêteDonnées
Transmissions zéro-copie
Processus A Processus BRéseau
EntêteDonnées
Transmissions zéro-copie
Processus A Processus BRéseau
Préparation mémoire
EntêteDonnées
Transmissions zéro-copie
Processus A Processus BRéseau
Acquittement
EntêteDonnées
Transmissions zéro-copie
Processus A Processus BRéseau
EntêteDonnées
DMA
Transmissions zéro-copie
Processus A Processus BRéseau
Préparation mémoire
Acquittement
Message
EntêteDonnées
DMA
Transmissions zéro-copie
Processus A Processus BRéseau
Préparation mémoire
Acquittement
Message
EntêteDonnées
DMA
Et la réactivité alors ?
Problèmes Assurer la progression des communications
asynchrones Réagir rapidement aux sollicitations extérieures
procproc proc proc
réseau
Envois asynchrones
Parvient-on vraiment à assurer du recouvrement ?
Processus A Processus B
Acquittement
MPI_Isend
MPI_recv
MPI_test
Interfaces deniveau intermédiaire
Madeleine : principe et interface
Madeleine
Interface de communication Efficace et portable
Double objectif Support de multiples paradigmes/modes Support de multiples réseaux simultanément
Proposition Programmation par « contrat »
Contrôle du niveau d’optimisation Transferts immédiats possibles
Statut Disponible sur BIP, GM, SISCI, VIA, TCP et MPI.
Construction des messages
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
Commandes Mad_pack(cnx, buffer, len, pack_mode, unpack_mode) Mad_unpack(cnx, buffer, len, pack_mode, unpack_mode)
Modes d’émission Send_CHEAPER Send_SAFER Send_LATER
Modes de réception Receive_CHEAPER Receive_EXPRESS
Contraintes d’utilisation 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
Contrôle du transfert des données Latitude d’optimisation
Engagement du programmeur Intégrité des données
Services particuliers Émission différée Réutilisation de tampons
Spécification au niveau sémantique Indépendance : service requis / technique sélectionnée
Émission
Pack
Modification
End_packing
Send_SAFER Send_LATER Send_CHEAPER
Structuration des messages
Receive_CHEAPER/Receive_EXPRESS
Receive_EXPRESS Réception immédiate impérative Interprétation/extraction du message
Receive_CHEAPER Réception libre du bloc Contenu du message Express
Réception
Unpack
Après Unpack
End_unpacking
Receive_EXPRESS Receive_CHEAPER
Donnée disponible Disponibilité ???
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 side Receiving 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 side Receiving 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 side Receiving 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 side Receiving 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 side Receiving 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 side Receiving 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 side Receiving side
Interfaces deniveau intermédiaire
Madeleine : implantation
Organisation verticale
Utilisation 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
Gestionde
protocoleRéseauRéseau
Organisation horizontale
Approche modulaire Module de gestion de tampons (MGT) Module de gestion de protocole (MGP) Module de transmission (MT)
Interface
Gestion des
tampons
Gestionde
protocole
MGT MGT
MT MT MT
RéseauRéseau
MGP MGP
Modules de transmission
Thread
Réseau
Pack
Madeleine
Interface MGT
MGT
MT
MT
Processus
Adaptativité
Sélection du mode de transmission adéquat
Interface
Gestion des
tampons
Gestionde
protocole
Pack
??
Implementation
Madeleine II a été portée sur : SISCI/SCI BIP/Myrinet MPI VIA TCP SBP
Évaluation
Environnement de test Grappe de PC bi-Pentium II 450 MHz, 128 Mo Réseau Fast-Ethernet Réseau SISCI/SCI Réseau BIP/Myrinet
Méthode de test Unidirectionnel
Mesure : 1000 émissions + 1 réception Résultat : moyenne sur 5 mesures
Bidirectionnel Mesures : 1000 x (émission + réception) Résultat : moyenne sur 5 mesures
SISCI/SCI – temps de transfertTest unidirectionnel
1
10
100
1000
10000
100000
4 16 64 256
1024
4096
1638
4
6553
6
2621
44
1048
576
Mad/ SISCI
SISCI
Taille de paquet (octets)
Tem
ps d
e
tran
sfe
rt(µ
s)
SISCI/SCI – débitTest unidirectionnel
0,1
1
10
100
4 16 64 256
1024
4096
1638
4
6553
6
2621
44
1048
576
Mad/ SISCI
SISCI
Taille de paquet (octets)
Déb
it
(Mo/
s)
SISCI/SCI – temps de transfertTest bidirectionnel
1
10
100
1000
10000
100000
4 16 64 256
1024
4096
1638
4
6553
6
2621
44
1048
576
Mad/ SISCI
SISCI
Taille de paquet (octets)
Tem
ps d
e
tran
sfe
rt(µ
s)
SISCI/SCI – débitTest bidirectionnel
0,1
1
10
100
4 16 64 256
1024
4096
1638
4
6553
6
2621
44
1048
576
Mad/ SISCI
SISCI
Taille de paquet (octets)
Déb
it
(Mo/
s)
SISCI/SCI – temps de transfertPacks/messages
1
10
100
1000
10000
100000
4 16 64 256
1024
4096
1638
4
6553
6
2621
44
1048
576
Mad/ SISCI
2 msgs
2 packs
4 msgs
4 packs
8 msgs
8 packs
16 msgs
16 packs
32 msgs
32 packs
64 msgs
64 packs
128 msgs
128 packs
256 msgs
256 packs
Taille de paquet (octets)
Tem
ps d
e
tran
sfe
rt(µ
s)
SISCI/SCI – débitPacks/messages
Taille de paquet (octets)
Déb
it
(Mo/
s)
0,1
1
10
100
4 16 64256
10244096
1638465536
262144
1048576
Mad/ SISCI
2 msgs
2 packs
4 msgs
4 packs
8 msgs
8 packs
16 msgs
16 packs
32 msgs
32 packs
64 msgs
64 packs
128 msgs
128 packs
256 msgs
256 packs
Interfaces deniveau intermédiaire
Gestion du multiplexage
Proposition
Concept de canal Similaire à un communicator MPI Un canal, c’est :
Un protocole Une carte d’interface Un ensemble de nœuds Un ensemble de connexions point-à-
point
Les Canaux
Canal Réseau Ensemble de noeuds Ensemble de connexions point-à-point
Noeud 1
Noeud 2
Noeud 3
Noeud 4
TCP
TCP
SCI
Gestion des ressources
Problème Chaque canal consomme des
ressources réseauTags BIP, descripteurs SCI, descripteurs TCP
Le nombre de ressources peut dépendre du nombre de nœuds !Segments de mémoire partagée SCI
Solution Introduire des fonctionnalités de
multiplexage
C’est quoi le Multiplexage ?
Virtualisation des ressources Idéalement : disposer de « xchannels »
Utilisables comme des « channels »Disponibles en quantité arbitraire
Arghhh! Et les performances ? Trouver le bon niveau d’abstraction Conserver les canaux réels
Multiplexage à quel niveau ?
Sur-couche au-dessus de Madeleine Ex: abtraction de type « messages actifs
»Multiplexage partiel -> pas d’entrelacement
des packsMultiplexage complet -> contrôle de flux à
chaque pack ou recopies à l’arrivée
Contrôle de flux interne à Madeleine A chaque pack Même problème que ci-dessus…
Vers les grappes degrappes
Objectifs
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/MyrinetPC/SCI
Réseau rapide
PACX-MPI
Mécanismes transparents pour l’application
TCP/IP est utilisé sur les liaisons inter-grappes
Deux noeuds “passerelles” sont dédiés sur chaque grappe
MPI MPITCP
TCP
MPI MPIInternet
MPICH-G2
Implémentation Multi-grappes de MPICH Communications intra-grappe
MPI Communications inter-grappes
TCP Communications directes (pas de routage)
Myrinet
SCI
Support multi-grappe
Exploitation 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ébitRéseau
hautes performance
s
Réseau hautes
performances
Principe
Canaux réels Liés à un réseau Ne couvrent pas nécessairement tous les nœuds
Canaux virtuels Couvrent tous les nœuds Contiennent plusieurs canaux réels
MyrinetSCI
Virtuel
Fonctionnement
Retransmission multi-réseau automatique Approche générique Fonctionnement multi-threadé Routes statiques
Notion de MTU
Nœud passerelle
Mémoire
Bus PCI
Myrinet
LANai
SCI
Préservation du débit
Pipeline 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
Module de transmission générique Limitation du code traversé sur les passerelles
Interface
Gestion des
tampons
Gestionde
protocole
MGT MGT
MT MT MT
RéseauRéseau
MT générique
Module de retransmission
Thread
Réseau 2
Madeleine
MGT MT
MT
Processus
MTInterface
Threads
Réseau 1
Tests de performances
Ping-pong entre 2 machines séparées par une passerelle
SCI Myrinet
321
Retransmission: BIP&SCI
0
20
40
60
80
100
120
1 4 16 64 256
1024
4096
1638
4
6553
6
2621
44
1048
576
Taille de paquets (octets)
Ban
de
pas
san
te (
MO
/s)
BIP-SCI
BIP
SCI
Retransmission: BIP&SCI
0
20
40
60
80
100
120
1 4 16 64 256
1024
4096
1638
4
6553
6
2621
44
1048
576
Taille de paquets (octets)
Ban
de
pas
san
te (
MO
/s)
BIP-SCI
BIP
SCI
Multi-grappes
Myrinet
SCI
Évaluation
SCI
BIP
BIP/SCI Avec une passerelle
Bande passante
80 Mo/s
116 Mo/s
41 Mo/s
Latence
5,3 μs
7,8 μs
32,5 μs
Intégration des threadset des communications
Réactivité des nœuds aux E/S
Progression des communications
Problème Comment assurer la progression des
communications ?
procproc proc proc
réseau
Scrutation et interruptions
La scrutation est nécessaire API réseau ne fournissant pas d’appels
bloquants OS ne fournissant pas “d’activations”
Problème Fréquence difficile à assurer Coûteux en présence de multiple “pollers ”
Les interruptions sont nécessaires Réactivité
Problème Outils de synchronisation “interrupt safe” ?
Support de l’ordonnanceur
Ordonnanceur = serveur de scrutation Choix de la méthode d’accès
(scrutation/intr.) Support pour la scrutation
Fréquence contrôlée Factorisation des scrutations multiples
Support pour les interruptions Utilisation possible des activations Verrous spécifiques « interrupt-safe »
Scrutation par l’ordonnanceur
Ordonnanceurdes threads
Création d’une catégoriede polling (ex: MPI), assignation d’une fréquence et enregistrement de callbacks.
Polling jobsqueue
MPI
MPI_IsendMarcel_poll
Chaque thread candidat à une opération de polling adresse une requête à l’ordonnanceur et se bloque.
MPI_IrecvMarcel_poll
callbackcallback
Régulièrement, l’ordonnanceur appelle la fonction de scrutation définie par l’utilisateur...
Polling( )