Supports%20d

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

• Introduction
• Supports dexécution, environnements,
  middlewares, intergiciels,
• Communications dans les grappes (RN)
• Technologies, interfaces, hétérogène,
• Multithreading (JFM)
• Rappels, exploitation des SMP,
• Grilles de calcul (JFM)
• Toolkit Globus, gestion de ressources,

3
Programmation parallèle et répartie

• Conception
• Modélisation
• Algorithmique
• Langage
• Compilation
• Exécution
• Gestion dactivités
• Communications
• Mise au point
• Régulation de charge
• Gestion de données
• Sécurité

Programme parallèle
Proc. 0
Proc. 1
Proc. 2
Proc. 3
4
Supports et environnements dexécution (1)

• Pour les utilisateurs et leurs applications
• Abstractions de haut niveau
• Portabilité
• Efficacité !

Applications
Interface de programmation (API)
Support dexécution
Systèmes dexploitation (OS)
Grappes, grilles, machines parallèles, réseaux,
5
Supports et environnements dexécution (2)

• Etendre 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,

Applications
Interface de programmation (API)
Support dexécution
Systèmes dexploitation (OS)
Grappes, grilles, machines parallèles, réseaux
6
Discussions

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

7
Compromis à trouver
Fonctionalités
X
Efficacité
Portabilité
8
PM2 support pour les grappes
Applications
HPF, C
Régulation
C//, Java
Interface de programmation (RPC, migration,
allocation iso-adresse)
Marcel PM2
Madeleine
Unix (10 versions)
Architecture (grappes, machines parallèles)

• Légende
• Marcel noyau de processus légers
• Madeleine module de communication

9
Globus support pour les grilles
10
Communications dans les grappes hautes
performances

• Raymond Namyst
• LaBRI
• Université de Bordeaux I

11
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

12
Technologiesmatérielles
Cartes passives, actives,réseaux à capacité
dadressage
13
(FastGiga)-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 lEthernet classique

Hub
Switch
14
Ethernet

• Cartes passives (sauf Giga-Ethernet)
• Interfaces TCP, SBP, GAMMA, VIA,

Memory
TX-ring
DMA
TX reg RX reg
Network
PCI Bus
PCI Bridge
Packet Interface
NIC
15
Myrinet

• Société Myricom (C. Seitz)
• Interconnexion
• Switch
• Câblage
• Nappes courtes
• Cartes équipées dun processeur
• Latence
• 12 µs
• Débit
• 1 Gb/s
• Note
• Durée de vie limitée des messages (50 ms)

16
Myrinet

• Routage
• Réseau commuté, routage wormhole
• Carte programmable
• Protocoles de transmission  intelligents 
• Stratégie adaptée à la taille des messages
• Déclenchement dinterruptions

DMA
SRAM
Network
Packet Interface
PCI Bus
PCI Bridge
RISC
LANai
NIC
17
SCI

• Scalable Coherent Interface
• Norme IEEE (1993)
• Société Dolphin
• Fonctionnement par accès mémoire distants
• Projections despaces dadressage

Réseau SCI
Mémoire
Mémoire
Bus PCI
Bus PCI
Machine A
Machine B
18
Carte à capacité d addressage
BUS PCI
BUS PCI
Pci req addrdata
Pci req addrdata

Interface paquet

Interface paquet
Paquet SCI
Paquet SCI
Partie émission
Partie réception
19
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 nest pas (forcément)
  interrompu

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

• Latence 2.5 ms (écriture de processus à
  processus)
• Débit 45 Mo/s
• Verrou lt 10 ms (fetchadd)

23
Interfaces de bas niveau
BIP, SISCI, VIA
24
Communications performantes

• Comment exploiter les réseaux rapides ?
• Faible latence
• Quelques microsecondes
• Bande passante élevée
• De lordre 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

25
Interfaces

• Initialisation
• Réservée au système
• Uniquement en début de session
• Transferts
• Directs depuis lespace utilisateur
• Pas dappels systèmes
• Pas de transitions
• Transmissions zéro-copie

26
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

27
Basic Interface for Parallelism BIP

• L. Prylli B. Tourancheau
• Principe
• Envoi de message classique (asynchrone)
• Pas de contrôle de flux
• Pas de detection derreur
• Performances
• Latence 4.8us, débit 126 Mo/s

28
BIP

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

29
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

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

31
SCI optimisations matérielles

• Caches dans la carte
• Read Prefetching
• Write Combining

32
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 datomicité des transactions PCI
• Assez inhabituel (?)

33
VIA

• Virtual Interface Architecture
• Tentative de standardisation
• Beaucoup dindustriels impliqués
• Caractéristiques
• Principe dinterfaces virtuelles
• Zones de transmission protégées
• Lectures/Ecritures distantes

34
VIA Basic Principles

• Use the Kernel for Set-Upand 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 SANs at Gigabit Speeds
• No Reliability of Underlying Media Assumed

35
VI Architecture
VI Consumer
Host
VI User Agent (libvia)
VI Kernel Agent (Slow)
User-Level (Fast)
Descriptor Read, Write
Open, Connect, Map Memory
Doorbells
Undetermined
RequestsCompleted
NIC
VI-Capable 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
Send Q
Recv Q
Send Doorbell
Receive Doorbell
Descriptor
Descriptor
Descriptor
Descriptor
Status
Status
VI-Capable NIC
38
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...

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

• 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

41
Ce quil 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é ???

42
Interfaces de haut niveau
MPI la solution idéale ?
43
Bibliothèques

• Paradigme passage de message
• Les nœuds se synchronisent et communiquent par
  messages
• Deux instructions de base
• Send émission dun message
• Receive réception dun message
• Points forts
• Simple à mettre en oeuvre
• Permet démuler les autres paradigmes

44
PVM

• Parallel Virtual Machine
• Laboratoire National dOak Ridge (Tennessee)
• 1989
• Caracté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

• Message Passing Interface
• MPI-Forum v1.0 1994 v2.0 1997
• Caracté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 ?

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

47
Transmissions zéro-copie
Processus A
Processus B
Réseau
48
Et la réactivité alors ?

• Problèmes
• Assurer la progression des communications
  asynchrones
• Réagir rapidement aux sollicitations extérieures

réseau
49
Envois asynchrones

• Parvient-on vraiment à assurer du recouvrement ?

MPI_Isend
MPI_recv
MPI_test
Processus A
Processus B
50
Interfaces deniveau intermédiaire
Madeleine principe et interface
51
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 doptimisation
• Transferts immédiats possibles
• Statut
• Disponible sur BIP, SISCI, TCP et MPI.
• Portage en cours sur VIA

52
Interface

• Construction des messages
• Gestion des canaux ( communicators)
• Choix explicite du dispositif physique

mad_begin_packing
mad_pack
mad_end_packing
mad_begin_unpacking
mad_unpack
mad_end_unpacking
53
Packing et Unpacking

• Commandes
• mad_pack (cnx, buffer, len, pack_mode,
  unpack_mode)
• mad_unpack (cnx, buffer, len, pack_mode,
  unpack_mode)
• Modes

Send_SAFER
Send_CHEAPER
Send_LATER
Receive_EXPRESS
Receive_CHEAPER
54
Emission modes dempaquetage
Send_SAFER
Send_LATER
Send_CHEAPER
Pack
Modification
?
End_packing
Version transmise
55
Réception mode de déballage (1)

• RECV_EXPRESS

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

• RECV_CHEAPER

Unpack
Tampon
Après Unpack
Données disponibles ???
End_packing
Données disponibles
57
Exemple
Sending side
Receiving side
int n
int n
char s NULL
char s "Hello, World !"
p_mad_connection_t cnx
p_mad_connection_t cnx
cnx mad_begin_unpacking(channel)
cnx mad_begin_packing(channel, dest)
n strlen(s) 1
mad_unpack(cnx, n, sizeof(int),
mad_pack(cnx, n, sizeof(int),
send_CHEAPER,receive_EXPRESS)
send_CHEAPER, receive_EXPRESS)
s malloc(n)
mad_unpack(cnx, s, n,
mad_pack(cnx, s, n,
send_CHEAPER,receive_CHEAPER)
send_CHEAPER, receive_CHEAPER)
mad_end_unpacking(cnx)
mad_end_packing(cnx)
58
Exemple
Sending side
Receiving side
int n
int n
char s NULL
char s "Hello, World !"
p_mad_connection_t cnx
p_mad_connection_t cnx
cnx mad_begin_unpacking(channel)
cnx mad_begin_packing(channel, dest)
n strlen(s) 1
mad_unpack(cnx, n, sizeof(int),
mad_pack(cnx, n, sizeof(int),
send_CHEAPER,receive_EXPRESS)
send_CHEAPER, receive_EXPRESS)
s malloc(n)
mad_unpack(cnx, s, n,
mad_pack(cnx, s, n,
send_CHEAPER,receive_CHEAPER)
send_CHEAPER, receive_CHEAPER)
mad_end_unpacking(cnx)
mad_end_packing(cnx)
59
Exemple
Sending side
Receiving side
int n
int n
char s NULL
char s "Hello, World !"
p_mad_connection_t cnx
p_mad_connection_t cnx
cnx mad_begin_unpacking(channel)
cnx mad_begin_packing(channel, dest)
n strlen(s) 1
mad_unpack(cnx, n, sizeof(int),
mad_pack(cnx, n, sizeof(int),
send_CHEAPER,receive_EXPRESS)
send_CHEAPER, receive_EXPRESS)
s malloc(n)
mad_unpack(cnx, s, n,
mad_pack(cnx, s, n,
send_CHEAPER,receive_CHEAPER)
send_CHEAPER, receive_CHEAPER)
mad_end_unpacking(cnx)
mad_end_packing(cnx)
60
Exemple
Sending side
Receiving side
int n
int n
char s NULL
char s "Hello, World !"
p_mad_connection_t cnx
p_mad_connection_t cnx
cnx mad_begin_unpacking(channel)
cnx mad_begin_packing(channel, dest)
n strlen(s) 1
mad_unpack(cnx, n, sizeof(int),
mad_pack(cnx, n, sizeof(int),
send_CHEAPER,receive_EXPRESS)
send_CHEAPER, receive_EXPRESS)
s malloc(n)
mad_unpack(cnx, s, n,
mad_pack(cnx, s, n,
send_CHEAPER,receive_CHEAPER)
send_CHEAPER, receive_CHEAPER)
mad_end_unpacking(cnx)
mad_end_packing(cnx)
61
Exemple
Sending side
Receiving side
int n
int n
char s NULL
char s "Hello, World !"
p_mad_connection_t cnx
p_mad_connection_t cnx
cnx mad_begin_unpacking(channel)
cnx mad_begin_packing(channel, dest)
n strlen(s) 1
mad_unpack(cnx, n, sizeof(int),
mad_pack(cnx, n, sizeof(int),
send_CHEAPER,receive_EXPRESS)
send_CHEAPER, receive_EXPRESS)
s malloc(n)
mad_unpack(cnx, s, n,
mad_pack(cnx, s, n,
send_CHEAPER,receive_CHEAPER)
send_CHEAPER, receive_CHEAPER)
mad_end_unpacking(cnx)
mad_end_packing(cnx)
62
Exemple
Sending side
Receiving side
int n
int n
char s NULL
char s "Hello, World !"
p_mad_connection_t cnx
p_mad_connection_t cnx
cnx mad_begin_unpacking(channel)
cnx mad_begin_packing(channel, dest)
n strlen(s) 1
mad_unpack(cnx, n, sizeof(int),
mad_pack(cnx, n, sizeof(int),
send_CHEAPER,receive_EXPRESS)
send_CHEAPER, receive_EXPRESS)
s malloc(n)
mad_unpack(cnx, s, n,
mad_pack(cnx, s, n,
send_CHEAPER,receive_CHEAPER)
send_CHEAPER, receive_CHEAPER)
mad_end_unpacking(cnx)
mad_end_packing(cnx)
63
Exemple
Sending side
Receiving side
int n
int n
char s NULL
char s "Hello, World !"
p_mad_connection_t cnx
p_mad_connection_t cnx
cnx mad_begin_unpacking(channel)
cnx mad_begin_packing(channel, dest)
n strlen(s) 1
mad_unpack(cnx, n, sizeof(int),
mad_pack(cnx, n, sizeof(int),
send_CHEAPER,receive_EXPRESS)
send_CHEAPER, receive_EXPRESS)
s malloc(n)
mad_unpack(cnx, s, n,
mad_pack(cnx, s, n,
send_CHEAPER,receive_CHEAPER)
send_CHEAPER, receive_CHEAPER)
mad_end_unpacking(cnx)
mad_end_packing(cnx)
64
Interfaces deniveau intermédiaire
Madeleine implantation
65
Proposition
Interface
Unpack
Pack
Gestion des tampons
Receive
Send
Gestion de protocole
66
Madeleine structure
Application
Application
Generic BufferManagementModules
Switch
Switch
BMM1
BMMn
BMM1
BMMm
Specific Transmission Modules
Selection
Selection
TM1
TMn
TM1
TMn
Network
67
Adaptativité

• Sélection du mode de transmission adéquat

Interface
Pack
Gestion des tampons
?
Gestion de protocole
68
Implementation

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

69
BIP/Myrinet
70
BIP/Myrinet
71
SISCI/SCI
72
SISCI/SCI
73
Quelques résultats

• Latence
• 7 µs sur BIP/Myrinet
• 4 µs sur SISCI/SCI
• Bande passante
• 125 Mo/s sur BIP/Myrinet
• 80 Mo/s sur SISCI/SCI
• Migration (PM2)
• 24 µs sur SISCI/SCI
• 52 µs sur BIP/Myrinet

74
MPICH/Madeleine II

• MPICH general-purpose portable MPI
  implementation
• well-defined protocol interface
• Abstract Device
• Madeleine cluster-specific high-performance
  communication
• generic structure
• available on Gigabit networks
• highly optimized implementation
• The best of both worlds!
• Madeleine as a MPICH device

75
MPICH/Madeleine II
MPI API
Generic part (collective operations,
context/group management, ...)
ADI
Generic ADI code, datatype management, request
queues management
ProtocolInterface
CH_MAD device inter-node communication polling
loops eager protocol rendez-vous-protocol
SMP_PLUG device intra-node communication
CH_SELF device self communication
Madeleine II multi-protocol management
TCP
SISCI
BIP
Fast-Ethernet
SCI
Myrinet
76
Latency
77
Bandwidth
78
Vers les grappes degrappes
79
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 !

Réseau rapide
PC/Myrinet
80
PACX-MPI

• 2 nœuds sacrifiés pour les communications
• Transparence pour lapplication
• Protocole TCP/IP entre les grappes

MPI
MPI
TCP
81
Globus

• Principe Appel de Procédure à Distance
• Librairie de communication Nexus
• Multiprotocole
• Multithreading non nécessairement préemptif
• La passerelle est sacrifiée
• Tout est à faire par lutilisateur
• Pas de gestion explicite des grappes de grappes
• Pas adapté au problème

82
Madeleine II

• Bibliothèque de communication
• Multiprotocole
• Canaux de communication indépendants
• Un canal correspond à un adaptateur réseau

Canal SCI
Canal TCP
Canal TCP
83
Structure interne

• Couche générique de gestion de tampons
• Couche de portabilité avec les protocoles

Application
Réseau
84
Structure interne
Application
Application
Couche de gestion de tampons
Aiguillage
Aiguillage
MGT1
MGTn
MGT1
MGTn
Sélection
Sélection
Couche de portabilité
MT1
MTn
MT1
MTn
Réseau
Réseau
85
Structure (suite)

• Organisation 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

• Utilisation de réseaux qui ne sont pas présents
  sur tous les nœuds
• Envoi de messages entre des machines non
  directement reliées

Myrinet
SCI
87
Intégration dans Madeleine

• MTs pas portable
• MGTs problèmes de conversion
• Au-dessus perte defficacité

Application
MGT1
MGT2
MGTn
MT1
MT2
Réseau
88
Solution retenue

• MT générique entre les MTs et les MGTs
• Pas de MGT au niveau de la passerelle

Application
MGT1
MGT2
MGTn
MT générique
MT1
MT2
Réseau
89
Canaux virtuels

• Contiennent plusieurs canaux réels
• Permettent de séparer les messages à
  retransmettre des messages normaux (canaux réels
  différents)

Canal virtuel
Canaux SCI
Canaux Myrinet
1
2
3
4
Canal spécial
Canal normal
90
Réactivité et parallélisme

• Retransmission des messages par des threads
  dédiés
• Une paire de threads par réseau physique
• Mécanisme de pipeline
• Réception des messages normaux sur la passerelle
• Pas dinformations à priori sur la provenance
• Threads de scrutation

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

• Ping-pong entre 2 machines séparées par une
  passerelle

3
2
1
Myrinet
SCI
93
Évaluation
94
Intégration des threadset des communications
Réactivité des nœuds aux E/S
95
Progression des communications

• Problème
• Comment assurer la progression des communications
  ?

réseau
96
Scrutation et interruptions

• 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
• Les interruptions sont nécessaires
• Réactivité
• Problème
• Outils de synchronisation interrupt safe ?

97
Support de lordonnanceur

• Ordonnanceur serveur de scrutation
• Choix de la méthode daccè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 

98
Scrutation par lordonnanceur
? Création dune catégoriede polling (ex MPI),
assignation dune fréquence et enregistrement de
callbacks.
Polling jobsqueue
? Régulièrement, lordonnanceur appelle la
fonction de scrutation définie par
lutilisateur...
Ordonnanceur
des threads
99
Multithreading
Introduction et rappels
100
Rappel les processus lourds

• Caractéristiques
• Entité active directement supportée par lOS
• Flot dexécution
• Espace dadressage privé
• Ressources systèmes
• Exécution séquentielle
• Coût de gestion élevé
• Allocation des ressources
• Appels systèmes

101
Processus lourds

• Ressources noyau données utilisateur

Espace utilisateur
Processus
Processus
Processus
Ordonnanceur
Noyau
102
Threads Motivations

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

103
Simplicité de programmation

• Objectif
• Mener plusieurs activités indépendantesau sein
  dun processus
• Exemples
• Simulations
• Serveurs de fichiers
• Systèmes dexploitation (!)
• Seule solution (?)
• Automate à états finis implanté  à la main 
• (sauvegardes détats)

104
Structure dun OS monolytique

• Exemple
• Séquence infinie dopérations courtes
• Ordre et fréquence des scrutations ?

for () if(networkMsgIn()) getNetworkMsg() i
f(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 key stroke getKey()
for () wait for network msg getNetworkMsg()

for () wait for disk block handleDiskBlock(
)
106
Processus serveur classique

• Sérialisation des requêtes
• Pas de recouvrement des E/S
• Exploitation SMP délicate
• Prise en compte de priorités ?

client
serveur
OS
OS
107
Sur lefficacité des E/S

• 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)
• Débit sans/avec recouvrement des E/S
• Sans recouvrement
• 25 requêtes/seconde
• Avec recouvrement
• 33.33 requêtes/seconde (33)

108
Les processus légers

• Principe
• Détacher flot dexécution et ressources
• Introduits dans divers langages systèmes
• Programmation concurrente
• Recouvrement des E/S
• Exploitation des architectures SMP

thread
ressources
109
Caractéristiques de base

• Thread pile contexte
• Partage de ressources
• Code, tas, espace dadressage
• Fichiers ouverts
• Etc.
• Opérations de base performantes
• Création, destruction
• Synchronisation, commutation de contextes
• Création dun processus léger
• Adresse de fonction à exécuter paramètres

110
Performance des threads

• Opérations critiques
• Création/destruction (gestion mémoire)
• Changement de contexte (temps-partagé)
• Synchronisation (mode utilisateur)
• Programme dévaluation
• Création dune activité (processus, thread)
  synchronisation (terminaison de lactivité)

OS/Processeur Processus Thread noyau Thread utilisateur PM2
Linux 2.2/PII 450 0.540 0.130 - 0.006
Solaris 2.7/PII 350 8.622 0.214 0.160 0.009
111
Repères historiques

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

112
Multithreading
Premier contact
113
Linterface POSIX-Threads

• Interface de programmation standard pour Unix
• Portabilité des applications
• Solaris, IRIX, HP-UX, Linux, Etc.
• 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_att
r_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 ltstdio.hgt
• include ltpthread.hgt
• 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

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

118
Attributs exemple

• include ltstdio.hgt
• include ltpthread.hgt
• 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,
1281024) pthread_create(NULL, attr, func,
NULL)
120
Le standard OpenMP

• Interface pour écrire des applications
  multithreads portables (sur SMP)
• Directives de compilation (C, C, Fortran)
  routines
• Objectif simplicité portabilité
• Constructeurs fabricants de logiciels etc.
• 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

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

123
Outils pour la synchronisation

• Exclusion mutuelle les verrous
• Synchronisations 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(i0
ilt100 i) pthread_mutex_lock(mutex) glob
pthread_mutex_unlock(mutex)
124
Code réentrant

• code demeurant correct lorsquil est exécuté
  simultanément par plusieurs threads
• Exemples typiques
• Fonction nutilisant que des variables locales
• Code protégé par un verrou
• 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.

• 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
• Primitives de synchronisation
• Agissent comme des  barrières mémoire 

126
Variables spécifiques

• 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

• Principe
• Variable accessible à partir dune clé
• Allocation globale (souvent à linitialisation)
• pthread_setspecific(clé, valeur)
• pthread_getspecific(clé) -gt valeur
• Exemple la variable errno
• Fichier errno.h

ifdef _REENTRANT define errno
(__errno_location()) else extern int
errno endif
128
Exploitation efficacedes machines SMP
Quelle catégorie de threads ?
129
Multithreading utilisateur

• Deux ordonnanceurs indépendants

User Space
OS Kernel
130
Multithreading noyau

• Un seul ordonnanceur

User Space
OS Kernel
131
Multithreading mixte

• Deux ordonnanceurs coopérants

User Space
OS Kernel
Note Quid des appels systèmes bloquants ?
132
E/S et ordonnancement

• Threads noyaux OK
• Threads utilisateurs
• Appel bloquant -gt blocage du processus entier
• Threads mixtes
• Idem au bout dun certain nombre !
• Solutions ?
• Appels toujours non-bloquants (polling)
• Appels effectués par des threads dédiés
• Support système spécifique

133
Exploitation efficacedes machines SMP
Scheduler Activations
134
Recouvrement des E/S

• Au lieu de

Espace utilisateur
Espace noyau
Matériel
135
Scheduler Activations

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

136
Difficultés de mise en œuvre

• Retour dun appel bloquant
• Un  unblock upcall  nécessite deux appels
  systèmes supplémentaires
• La généricité coûte cher !!
• 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é

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

138
A propos de réactivité

• Problèmes liés aux évènements  unblock 
• Coût important, réactivité non-garantie
• 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

• Parties du noyau modifiées
• schedule(), do_fork() and do_exit()
• Implantation des transitions
• task_struct structure
• Nouveaux champs (état des activations, etc.)
• 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

• Illustration MPI et les communications
  asynchrones

MPI_Isend
MPI_recv
MPI_test
Processus A
Processus B
142
MultithreadingDistribué
Principe et Enjeux
143
Principe

• Introduire les threads dans les applications
  distribuées et parallèles

réseau
144
Enjeux

• 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

• 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
MultithreadingDistribué
Quel modèle de programmation ?
147
Approche par juxtaposition

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

148
Approche intégrée

• Threads communicants
• A0, Chant
• Pthreads extensions
• Rthreads
• Pthreads
• DSM-threads
• Appels de procédure à distance  threadés 
• A0, Nexus, PM2

149
Threads communicants

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

150
Modèle Pthreads étendu

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

151
Modèle Pthreads distribué

• 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
• Exemple
• DSM-Threads (F. Mueller, Berlin)

152
Modèle dérivé des RPC

• 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
• Exemples
• Nexus (I. Foster, Argonne), PM2

153
MultithreadingDistribué
Lenvironnement PM2
154
Premières réflexions sur PM2

• Parallel 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-(
• InterPRC 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)

• Objectif 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
• Propositions
• 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
PM2
PM2

• Différentes déclinaisons
• Synchrone
• Attente différée
• Asynchrone

• Nos concurrents...
• Nexus RSR
• Athapascan appels de service

157
Hello World!
include ltpm2.hgt unsigned SAMPLE void
sample_func(void) char msg128 pm2_unpack_byt
e(SEND_CHEAPER, RECV_CHEAPER, msg,
128) pm2_rawrpc_waitdata() printf(s\n,
msg) void main(int argc, char argv) int
moduleMAX_MODULES, nb_modules pm2_rawrpc_regis
ter(SAMPLE, sample_func) pm2_init(argc, argv,
2, module, nb_modules) if(pm2_self()
les_modules0) pm2_rawrpc_begin(module1,
SAMPLE, NULL) pm2_pack_byte(SEND_CHEAPER,
RECV_CHEAPER, Hello World!, 128) pm2_rawrpc_e
nd() 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
msg128 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

• Migration de processus légers

PM2
PM2

• Pourquoi ?
• Régulation de charge
• Localité des données

• Comment ?
• Transfert du contexte
• Programmes SPMD

160
MultithreadingDistribué
Communications dans un environnement multithreads
161
Appel de procédure à distance

• Intensivement utilisé
• Accès mémoire distants, migration, etc.
• Consensus (?)
• Athapascan, Nexus, Panda, PM2

162
Transmission zéro-copie
Processus A
Processus B
Réseau
163
Portabilité

• Bibliothèques de haut niveau
• MPI
• Pas adapté aux interactions de type  RPC 
• Bibliothèques de bas niveau
• BIP (Myrinet), SISCI (SCI), GAMMA (Ethernet)
• Paradigmes très différents ! Portabilité ??
• 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
Interface de Madeleine

• Construction des messages
• Gestion des canaux ( communicators)
• Choix explicite du dispositif physique

mad_begin_packing
mad_pack
mad_end_packing
mad_begin_unpacking
mad_unpack
mad_end_unpacking
166
Packing et Unpacking

• Commandes
• mad_pack (cnx, buffer, len, pack_mode,
  unpack_mode)
• mad_unpack (cnx, buffer, len, pack_mode,
  unpack_mode)
• Modes

Send_SAFER
Send_CHEAPER
Send_LATER
Receive_EXPRESS
Receive_CHEAPER
167
Conclusion

• Multithreading
• Exploitation efficace des architectures SMP
• Contrôle fin de lordonnancement
• Conditionné par les fonctionnalités du système
• 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

• Architecture 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, ...

169
Contexte technologique

• Infrastructure 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, ...

Lyon
Internet
Grenoble
Bordeaux
PowerPC/Switch/MPI
170
Superordinateur virtuel (Globus)
171
Grappes hiérarchiques

• Distributed 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

• Ressource
• 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, )
• Partage Contrôlé des Ressources
• Informations, disponibilité
• Allocation, co-allocation
• Sécurité
• Administration, politiques daccès

174
Application Programming Interface

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

175
Software Development Kit

• Une instantiation particulière dune API
• SDK est constitué de bibliothèques et doutils
• Fournir une implémentation de la spécification
  dune API
• Plusieurs SDKs pour une même API
• Exemples de SDKs
• MPICH, Motif Widgets

176
Pourquoi les Grilles ?

• Evolution des réseaux à très haut débit
• Nouvelles 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é
• Laboratoires virtuels

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

• Manipulation despaces virtuels partagés avec
• Composants de simulation
• Flots multiples Contrôle, Texte, Vidéo, Audio,
  Base de données, Simulation, Tracking, Rendering
• Problèmes associés
• uni/multi-diffusion fiable (ou non fiable)