get_time(host, problème, data_desc, localisation)

FAST : Fast Agent System Timer
Un outil de modélisation des
performances dans un environnement
de metacomputing
Équipe ReMaP
LIP, ENS Lyon, France
Plan
•
•
•
•
•
•
Introduction
Comment utiliser FAST ?
L’API de FAST
Extension parallèle (Freddy – FS et EC)
Quelques résultats expérimentaux
Conclusions et travaux futurs
Grid computing
Objectif : Fédérer les ressources de calcul
Le web est pour les informations, la grille sera pour les calculs
Avantages : Potentiel sans fin.
En bref, c’est l’avenir.
Problèmes : Encore nombreux…
•
•
•
•
Découverte des ressources
Ordonnancement
Prédiction de performances
Sécurité
Passage à l’échelle
Présentation de FAST
interactif
échelle macro
Objectif : prédire les performances de sous-programmes
sur machine donnée à un instant donné.
Besoin des routines
Disponibilité du système
• Temps de calcul
• Charge processeur
• Espace mémoire
• Mémoire et disque libre
Étalonnage
• Communications
préalable • Surveillance
Bande passante
du système
et latence
des sous programmes
(NWS)
Connaître les besoins des routines
Différentes méthodes selon la routine :
• Routines simples (BLAS)
• Étalonnage à l’installation
• Routines complexes (ScaLAPACK)
• Étude du source et décomposition en appels à
FAST élémentaires
• Routines compliquées (Matrices creuses)
• Pas de prédiction, choix de la machine la plus
puissante
Les problèmes de l’étalonnage
• Obtention des chronométrages
• Charge extérieure
 Temps processeur (utime + stime)
• Obtention de l’espace mémoire
• Variation au cours de la vie du processus
 Exécution en mode pas à pas (comme gdb)
Le processus est long, mais
• Uniquement à l’installation
• Réutilisation des résultats pour un parc de machines
• Étalonnage pour des machines types puis facteur correctif
Connaître les disponibilités du
système : NWS
Network Weather Service (Prof. Wolski)
•
Mesure la disponibilité de ressources
•
•
•
•
charge CPU, bande passante, etc.
Prédit les futures variations par traitement statistique
Extensible et ouvert
Largement répandu (Globus, NetSolve, Ninf, etc.)
Mémoire
Serveur de nom
Prédicateur
Données
Stockage
Stockage
Requête
Senseur
Test
Senseur
Test
Requête
Réponse
Client
Plan
•
•
•
•
•
•
Introduction
Comment utiliser FAST ?
L’API de FAST
Extension parallèle (Freddy – FS et EC)
Quelques résultats expérimentaux
Conclusions et travaux futurs
Utiliser FAST
Phase 1 : Lors de l’installation
Étape 1 : Installer
Étape 2 : Étalonner les routines possibles
Phase 2 : Pour l’utilisation
Étape 3 : Mettre en place la plate-forme
Étape 4 : Utiliser FAST
Installer FAST
Dépendances :
-
Berkeley DB 2 : base de donnée classique.
Gnu Scientific Library : pour faire des maths facilement
LDAP : base de données hiérarchique et distribuée
NWS : système de surveillance du système
Mais c’est très simple :)
- ces éléments sont simples à installer
- autoconf pour trouver ces bibliothèques automagiquement
- on pourrait retirer des dépendances…
Étalonner les routines possibles
Entrée :
Programme contenant
les opérations à tester
Base de données des
résultats bruts (10-100Mo)
Dépendances :
Scénario des tests
fast_bench
Programme :
Résultat :
+
BDB
+
+
Interpolation polynomiale
fonction des paramètres
GSL
Programme contenant l’opération
int main(int argc,char **argv){
[…]
TransA=(argv[1])[0]; TransB=(argv[2])[0];
M=atol(argv[3]); N=atol(argv[4]); K=atol(argv[5]);
alpha=atof(argv[6]); beta=atof(argv[7]);
LDA=(TransA == 'n' || TransA == 'N' ? M : K);
ka =(TransA == 'n' || TransA == 'N' ? K : M);
[…]
A=(double *)malloc(sizeof(double)*LDA*ka); memset(A,2,sizeof(double)*LDA*ka);
[…]
dgemm_(&TransA,&TransB,&M,&N,&K, &alpha,A,&LDA, B,&LDB, &beta,C,&M);
return 0;
}
Scénario des tests à réaliser
CATEGORY=BLAS/dtrsm
BINARY=./fast_bench_blas
ARGS=%!s=dtrsm;%s=l|r;%s=u|l;%s=n|t;%s=u|n;%d=128:1152:128;%c=5
#side=l|r uplo=u|l TransA=n|t diag=u|n M N
CATEGORY=BLAS/dgemm
BINARY=./fast_bench_blas
ARGS=%!s=dgemm;%s=n;%s=n;%d=128:1152:128;%d=128:1152:128;
%d=128:1152:128;%a;%a
Un jour, ce fichier sera en XML :)
Interpolation des résultats
(fonctionS des paramètres)
Pour le temps de dgemm dans le cas {n,n,2,2} sur icluster : degré 3, 20 termes.
Time(M,N,K)=2-2
-2-4 M -6-6 N -9-8 K
+4-7 M2 -2-8 N2 -2-11 K2
-2-10 M3 +7-5 N3 -8-7 K3
+9-8 MN +1-10 MK +2-7 NK
+4-11 M2N -2-11 MN2 +1-7 M2K +3-11 MNK
-3-8 N2K -3-11 MK2 -1-8NK2
Chi2= 3.765074-1
Remarques :
Degré entre 3 et 6 (limite pratique)
Mécanisme automatique
Utiliser FAST
(suite)
Phase 1 : Lors de l’installation
Étape 1 : Installer
Étape 2 : Étalonner les routines possibles
Phase 2 : Pour l’utilisation
Étape 3 : Mettre en place la plate-forme
Étape 4 : Utiliser FAST
Ex. : plate-forme de test pour NetSolve
NameServer
slapd
Client
Agent
Senseur
Forecaster
Mémoire
Senseur
Client
Maître
Serveur
Serveur
Serveur
Senseur
Senseur
Senseur
Esclave 1
2
3
…
Serveur
Senseur
n
Mettre en place la plate-forme
NWS : NWS ne fournit aucun outil pour la configuration, et
lancement, et nous avons un script Perl.
LDAP :
- Configuration et lancement : template sur ma page
- Peupler : ldapadd
DiET : ???
L’API FAST
FAST masque la complexité à l’ordonnanceur
 seulement 3 fonctions de haut niveau
comm_time(source, destination, data_desc)
comp_time(host, problème, data_desc)
get_time(host, problème, data_desc, localisation)
Plan
•
•
•
•
•
•
Introduction
Comment utiliser FAST ?
L’API de FAST
Extension parallèle (Freddy – FS et EC)
Quelques résultats expérimentaux
Conclusions et travaux futurs
Un peu de modélisation
Modéliser une application parallèle


Description de l’application
Modélisation de la plate-forme
Différents modèles théoriques



Communications nulles, délai, LogP, …
Supposent une connaissance à priori de la
plate-forme d’exécution
Contraire à la « philosophie » de FAST
Modèles utilisés
Modèle +L pour les communications
point-à-point
Pour les communications globales


Dépendant de la plate-forme et de la
topologie
Fonctions basées sur  et  (valeurs
déterminées par FAST)
Appels à FAST pour les calculs
Simplifications effectuées
Utilisation efficace de ScaLAPACK
 Processeurs et réseau homogènes
Processeurs homogènes
 Étalonnage sur un seul processeur
Réseau homogène
 Surveillance de quelques liens
représentatifs
Produit de matrices ScaLAPACK
N
Distribution cyclique par
blocs bidimensionnelle
Chaque processeur est
responsable de ses blocs
A chaque étape


Diffusion des pivots
Multiplication d’un bloc de
lignes par un bloc de
colonnes
K
B
K
A
M
R
C
0
1
2
0
1
3
4
5
3
4
0
1
2
0
1
3
4
5
3
4
0
1
2
0
1
Modélisation avec FAST (1)
Temps de calcul sur une grille (p x q)
  x temps_dgemm
K
R
temps_dgemm obtenu par l’appel FAST
fast_comp_time_best (hôte, dgemm_desc, temps_dgemm)
Tailles des matrices pour l’appel

M
P

N
x R et R x q
Modélisation avec FAST (2)
Temps de communication



q
p
q p K
(MxK) p (KxN) q (βp βq) R
Cas d’un arbre de diffusion


Remplacement des fonctions par leurs
valeurs  termes en log
 et  acquis par appels à FAST
fast_bandwidth (source, dest, TAU)
fast_latency (source, dest, BETA)
Plan
•
•
•
•
•
Introduction
Comment utiliser FAST ?
L’API de FAST
Extension parallèle (Freddy – FS et EC)
Quelques résultats expérimentaux
•
•
•
Séquentiel (FAST)
Parallèle (Freddy)
Conclusions et travaux futurs
Plateforme de tests
• On s’intéresse à la qualité des prédictions et non leur
impact sur la qualité de l’ordonnancement
Plateforme assez simple, bien qu’hétérogène
• Deux machines :
• Kwad : serveur de calcul expérimental

Quadriprocesseur Pentium III (550 MHz), Linux 2.4, 512 Mo de RAM
• Pixies : machine de bureau
Pentium II (350 MHz), Linux 2.2, 128 Mo de RAM
• Liens Fast Ethernet entre les nœuds
Modélisation temporelle de dgemm
Comparaison des temps modélisés et mesurés
120
Modèle Pixies
Mesure Pixies
Modèle Kwad
Mesure Kwad
80
60
40
20
Moyenne : 1%
0
12
8
25
6
38
4
51
2
64
0
76
8
89
6
10
24
11
52
Temps (s)
100
Taille des matrices
Modélisation temporelle du plus
1
0,9
0,8
0,7
0,6
0,5
0,4
0,3
0,2
0,1
0
Prédiction Pixies
Mesuré Pixies
Prédiction kwad
Mesuré kwad
Moyenne : 10%
12
8
25
6
38
4
51
2
64
0
76
8
89
6
10
24
11
52
Temps (s)
Comparaison des temps modélisés et mesurés
Taille des matrices
Modélisation spatiale
• Les résultats sont quasi parfaits :
Moins de 1% d’erreur maximale
Erreur moyenne de l’ordre de 0,1%
• La taille d’un programme effectuant une opération
matricielle est :
Taille du code + Taille des matrices
(constante)
(polynomiale)
Prédiction de performances
Produit de matrices complexes parallèle :
Cr=Ar x Br – Ai x Bi et Ci=Ai x Br + Ar x Bi
Lancement
Arrêt du du
chronomètre
chronomètre
Prédiction
LDAP
Valeur
?
Client
NWS
Ai,Ar,Br
Ci
Ai,Ar,Bi
Cr
Ci =x Ci1
Ci2 x Br
Cr1=Ar
Br ;+Ci1=Ai
Cr =
Cr1; Ci2=Ar
– Cr2 x Bi
Cr2=Ai
x Bi
Serveur 1
Valeur
?
Ci2
Cr1
Serveur 2
Prédiction de performances :
Le produit de matrices complexes
Comparaison des temps prédits et mesurés
160
140
23%
Temps (s)
120
100
Mesuré
Prédiction
80
60
Moyenne: 15%
40
20
0
128
256
384
512
640
768
Taille des matrices
896 1024
Prédiction de performances :
Freddy
•
•
•
•
Processeurs et réseau homogènes
Taille fixe et forme de grille variable
Grille fixe et taille variable
Matrices identiques et grilles disjointes
• Alignement
• Grilles virtuelles
• Redistributions
Comparatif
Erreur max. : 14,7 %
Erreur moy. : 3,8 %
35,00
30,00
25,00
20,00
15,00
10,00
5,00
0,00
35,00
1
6
1
11
6
16
30,00
11
16
21
21
26
25,00
26
31
31
20,00
15,00
10,00
Mesuré
Estimé
5,00
0,00
1
6
1
11
6
16
11
16
21
21
26
26
31
31
Taux d’erreur
12
Grille 8x4
Taux d'erreur (en %)
10
8
6
4
2
0
1024
2048
3072
4096
5120
6144
Taille des matrices
7168
8192
9216
10240
Redistributions et calculs
A
B
60
Temps (s)
50
40
30
20
10
0
Redistribution
Produit
Plan
•
•
•
•
•
•
Introduction
Comment utiliser FAST ?
L’API de FAST
Extension parallèle (Freddy – FS et EC)
Quelques résultats expérimentaux
Conclusions et travaux futurs
Conclusions
• Metacomputing prometteur, et sujet de recherche actif
• Problème : ordonnancement et estimation de performances
• FAST est capable d’estimer les performances de séquences
d’opérations en modélisant les opérations simples
• Il n’est pas si compliqué à utiliser…
Travaux futurs
• Tester pour d’autres opérations
• Gérer les opérations parallèles
• Diminuer le temps d’étalonnage
• Enlever des dépendances, ajouter PCP et autres
• Porter sur d’autres plateformes comme SP3 et Sun Entreprise
• Coopération accrue avec les équipes de NWS et de NetSolve
• Étendre aux réseaux Myrinet, SCI, VIA, etc.
• Intégration à DIET