Download - Traitement des données massives (INF442, A4)
![Page 1: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/1.jpg)
INF442 : Traitement des donnees massivesA4 : Algebre lineaire distribuee
Frank Nielsen
X20136 mai 2015
Frank Nielsen A6-1
![Page 2: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/2.jpg)
Plan
un peu de MPI
produit matriciel sur la topologie du tore
la genericite avec la bibliotheque C++ STL
Frank Nielsen A6-2
![Page 3: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/3.jpg)
MPI : pas de memoire globale !
→ memoire locale pour chaque processus, echange de messagesDifferent d’un fil de calcul (fork) avec memoire globale partagee(INF431)
i n t main ( i n t argc , cha r ∗∗ a rgv ) i n t rang , n , va r ;
i n t ∗ p t r=&va r ;MP I I n i t (&argc , &argv ) ;MPI Comm size (MPI COMM WORLD, &n ) ;MPI Comm rank (MPI COMM WORLD, &rang ) ;
∗ p t r=rang ; ( ∗ p t r )++;p r i n t f ( ”P%d va r=%d\n” , rang , va r ) ;MP I F i n a l i z e ( ) ;
P0 var =1
P2 var =3
P1 var =2
P3 var =4
Frank Nielsen A6-3
![Page 4: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/4.jpg)
#i n c l u d e <s t d i o . h>#i n c l u d e <mpi . h>
i n t main ( i n t argc , c ha r∗∗ a rgv ) i n t rang , p , autre , taga =0, tagb=1; doub l e a , b ;MPI Status s t a t u s ; MPI Request r e qu e s t ;
MP I I n i t (&argc , &argv ) ; MPI Comm size (MPI COMM WORLD, &p ) ; MPI Comm rank (MPI COMM WORLD, &rang ) ;
i f ( p==2)
// Memoire locale de chaque processusau t r e=1−rang ; // l’autre processusa=0; b=1;p r i n t f ( ”Proc . %d au t r e=%d avant a=%f b=%f \n” , rang , autre , a , b ) ;// double swap en utilisant une operation de communication sans variable locale tmp !// on utilise en fait le buffer de communication pour tmpMPI I send(&a , 1 , MPI DOUBLE, autre , taga , MPI COMM WORLD, &r e qu e s t ) ;MPI I send(&b , 1 , MPI DOUBLE, autre , tagb , MPI COMM WORLD, &r e qu e s t ) ;p r i n t f ( ”Attendons avec MPI WAIT que l e s messages s o i e n t b i e n p a r t i s . . . \ n” ) ;MPI Wait(& reque s t , &s t a t u s ) ;// Recoit dans a le message avec tagb (donc la valeur de b)MPI Recv(&a , 1 , MPI DOUBLE, autre , tagb , MPI COMM WORLD, &s t a t u s ) ;// Recoit dans b le message avec taga (donc la valeur de a)MPI Recv(&b , 1 , MPI DOUBLE, autre , taga , MPI COMM WORLD, &s t a t u s ) ;p r i n t f ( ”Proc . %d apr e s a=%f b=%f \n” , rang , a , b ) ;
e l s ei f ( rang==0) p r i n t f ( ” Executez avec mpirun −np 2 mpiswap442 . exe ” ) ;
MP I F i n a l i z e ( ) ;
Frank Nielsen A6-4
![Page 5: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/5.jpg)
taga=0; tagb=1;
a=0;
b=1;
Isend(a,P1,taga);
Isend(b,P1,tagb);
MPI Wait;
Recv(&a,tagb);
Recv(&b,taga);
P0
taga=0; tagb=1;
a=0;
b=1;
Isend(a,P0,taga);
Isend(b,P0,tagb);
MPI Wait;
Recv(&a,tagb);
Recv(&b,taga);
P1
0, taga
1, tagb1, tagb
0, taga
memoire locale P0 memoire locale P1
[france ~]$ mpirun -np 2 mpiswap442 .exe
Proc . 1 autre =0 avant a=0.000000 b=1.000000
Attendons avec MPI_WAIT que les messages soient bien partis ...
Proc . 0 autre =1 avant a=0.000000 b=1.000000
Attendons avec MPI_WAIT que les messages soient bien partis ...
Proc . 1 apres a=1.000000 b=0.000000
Proc . 0 apres a=1.000000 b=0.000000
Frank Nielsen A6-5
![Page 6: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/6.jpg)
Algebre lineaire en parallele : la regression
Frank Nielsen 1.Les matrices en HPC-1.Regression A6-6
![Page 7: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/7.jpg)
La regression lineaire
on veut predire y = f (x) avec f (x) = β0 +∑d
i=1 βixi .
les observations (xi , yi) sont dans Rd × R. Pour des classes
C0 et C1 (valeurs de y), on peut encoder y = 0 ssi. xi ∈ C0 ety = 1 ssi. xi ∈ C1
on classifie avec la regression en evaluant yi = f (xi ) puis enseuillant : xi ∈ C0 ssi. yi <
12 et xi ∈ C1 ssi. yi ≥ 1
2
on peut augmenter l’espace des donnees en rajoutant unecoordonnee x0 = 1. Ainsi x ← (x , 1) etf (x) =
∑di=0 βixi = x⊤i β (d + 1 parametres a evaluer)
l’erreur que l’on veut minimiser est les moindres carres
( Residual Sum of Squares , RSS) :
β = minβ
n∑
i=1
(yi − x⊤i β)2
Frank Nielsen 1.Les matrices en HPC-1.Regression A6-7
![Page 8: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/8.jpg)
La regression lineaire et la classification
Frontiere de decision = hyperplan (espace affine de dimension
d − 1 dans Rd )
Frank Nielsen 1.Les matrices en HPC-1.Regression A6-8
![Page 9: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/9.jpg)
La regression lineaire ordinaireSoit X la matrice des donnees de dimension n× (d + 1), y levecteur colonne de dimension n et β le vecteur parametre dedimension d + 1. On a la somme des differences au carre :
RSS(β) =
n∑
i=1
(yi − x⊤i β)2 = (y − Xβ)⊤(y − Xβ)
En prenant le gradient ∇βRSS(β), on trouve l’equation dite
normale ( normal equation ) :
X⊤(y − Xβ) = 0
Pour X⊤X non-singuliere, on trouve β minimisant les moindrescarres par la matrice pseudo-inverse (Penrose-Moore) :
β = (X⊤X )−1X⊤y = X †y
Frank Nielsen 1.Les matrices en HPC-1.Regression A6-9
![Page 10: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/10.jpg)
La regression lineaire en Scilab
rand(’seed ’,getdate(’s’))
x = -30:30; a=0.8; b=5; y=a
*x+b;
// on perturbe avec un bruit
uniforme
bruit=rand(1,61,’uniform ’)
-0.5;
y = y+10*bruit;
// regression lineaire en scilab
[aa, bb] = reglin(x, y);
plot(x, y,’r+’ );
plot(x, a*x+b,’bo-’)
Frank Nielsen 1.Les matrices en HPC-1.Regression A6-10
![Page 11: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/11.jpg)
La regression lineaire : ordinaire ou totale
x
yy = a× x
(x1, y1)
(x2, y2)
(x3, y3)
ordinary regression vs. total regression
Frank Nielsen 1.Les matrices en HPC-1.Regression A6-11
![Page 12: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/12.jpg)
Comparaison de la classification par regression ou par
k-PPV
Classifieur sur un vecteur aleatoire = variable aleatoire ⇒ varianceet biais
Frank Nielsen 1.Les matrices en HPC-1.Regression A6-12
![Page 13: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/13.jpg)
Comparaison de la classification par regression vs. k-PPV
regression = bon pour interpoler et extrapoler mais modelerigide avec l’hypothese globale d’une fonction lineaire f (x)(faible complexite = d + 1 parametres).⇒ grand biais et petite variance
k-PPV : modele f (x) localement constant, flexible, maisgrande complexite = d × n “parametres”.⇒ petit biais mais grande variance
Frank Nielsen 1.Les matrices en HPC-1.Regression A6-13
![Page 14: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/14.jpg)
Algebre lineaire : les briques de base
des vecteurs colonnes :
v =
v1...vl
des matrices (square, skinny, ou fat) :
M =
m1,1 ... m1,c...
. . ....
ml ,1 ... ml ,c
plusieurs types de matrices avec leur stockage memoire :matrices denses O(lc), matrices diagonales, matricessymetriques, matrices triangulaires, matrices creuses O(l + c).Algebre multi-lineaire et tenseurs.
Frank Nielsen 1.Les matrices en HPC-1.Regression A6-14
![Page 15: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/15.jpg)
Les operations/primitives en algebre lineaire
Soit l = c = d les dimensions des matrices et vecteurs.
le produit scalaire v1 · v2 = v⊤1 × v2 : O(d)
le produit matrice-vecteur M × v : O(d2)
le produit matrice-matrice M1 ×M2 : O(d3)
la factorisation (decomposition) LU M = L× U (pourresoudre les systemes lineaires), QR , etc.
Toutes ces primitives sont implementees dans la bibliotheque BLAS,Basic Linear Algebra Subroutines en plusieurs niveauxhttp://www.netlib.org/blas/
Frank Nielsen 1.Les matrices en HPC-1.Regression A6-15
![Page 16: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/16.jpg)
La multiplication matricielle : un defi = probleme ouvert !
meme en sequentiel, on ne connait pas d’algorithmeoptimal !
borne inferieure : Ω(d2), nombre d’entrees de la matricecarree resultat.
meilleur algorithme connu a ce jour : O(d2.3728639) , analysefine de l’algorithme de Coppersmith et Winograd.
Le Gall, Francois (2014), “Powers of tensors and fast matrixmultiplication,” Proceedings of the 39th InternationalSymposium on Symbolic and Algebraic Computation (ISSAC2014), arXiv:1401.7714
Frank Nielsen 1.Les matrices en HPC-1.Regression A6-16
![Page 17: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/17.jpg)
Differents motifs pour le parallelisme de donnees
acces et transmissions des donnees M et v sur un cluster demachines : depend de la topologie du reseau d’interconnexion
dispositions bloc-colonnes et bloc-colonne cycliques→ largeur b du bloc elementaire (chaque bloc tient dans lamemoire locale)
Idem si on prend les lignes (= colonnes de la matrice transposee)Frank Nielsen 1.Les matrices en HPC-2.Motifs A6-17
![Page 18: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/18.jpg)
Differents motifs pour le parallelisme des donnees
Motif 2D bloc ligne-colonne , et 2D bloc ligne-colonne cyclique
Damier, echiquier
Frank Nielsen 1.Les matrices en HPC-2.Motifs A6-18
![Page 19: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/19.jpg)
Le produit matrice vecteursur la topologie del’anneau oriente
Frank Nielsen 1.Les matrices en HPC-3.Produit matrice-vecteur sur l’anneau A6-19
![Page 20: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/20.jpg)
Produit matrice-vecteur sur l’anneau : Bloc colonne 1D
En BLAS, une operation de base :
y ← y + Ax
A(i) = Ai× np:(i+1)× n
p−1,·: sous-matrice bloc ligne de dimension
n × np
y(i)← y(i) + A(i)× x(i) = y(i) +∑
j
A[i ][j]× x [j]
initialement, A(i), x(i) et y(i) sont stockes sur le processus Pi
faire tourner les sous-vecteurs x(i) sur la topologie del’anneau oriente
Frank Nielsen 1.Les matrices en HPC-3.Produit matrice-vecteur sur l’anneau A6-20
![Page 21: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/21.jpg)
Regardons la situation pour y(1)
X1
X2
X3
X4
X1
X2
X3
X4 Y1 = A1,4 ×X4 + A1,1 ×X1
Y1 = A1,1 ×X1P1
P2
P3
P4 A4,4A4,3
A1,1
A2,2
A3,3
A1,2 A1,3 A1,4
A2,1
A3,1
A4,1 A4,2
A3,2 A3,4
A2,4A2,3
A4,4A4,3
A1,1
A2,2
A3,3
A1,2 A1,3 A1,4
A2,1
A3,1
A4,1 A4,2
A3,2 A3,4
A2,4A2,3
En fond gris, les blocs qui servent aux produits locauxy(·)← A(·, ·)x(·) + y(·)
Frank Nielsen 1.Les matrices en HPC-3.Produit matrice-vecteur sur l’anneau A6-21
![Page 22: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/22.jpg)
X1
X2
X3
X4
X2
X1
X4
X3
Y1 = A1,3 ×X3 + A1,4 ×X4 + A1,1 ×X1
Y1 = A1,2 ×X2 + A1,3 ×X3 + A1,4 ×X4 + A1,1 ×X1
A4,4A4,3
A1,1
A2,2
A3,3
A1,2 A1,3 A1,4
A2,1
A3,1
A4,1 A4,2
A3,2 A3,4
A2,4A2,3
A4,4A4,3
A1,1
A2,2
A3,3
A1,2 A1,3 A1,4
A2,1
A3,1
A4,1 A4,2
A3,2 A3,4
A2,4A2,3
Frank Nielsen 1.Les matrices en HPC-3.Produit matrice-vecteur sur l’anneau A6-22
![Page 23: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/23.jpg)
p r odu i tMa t r i c eV ec t eu r (A , x , y ) q = Comm rank ( ) ; // rang du processusp = Comm size ( ) ; // nombre de processusr = n/p ; // taille des blocsf o r ( s t e p =0; s tep<p ; s t e p++)
// on envoie le bloc de x sur le prochain nœud de l’anneausend ( x , r ) ; // communication non-bloquante
// calcul local : produit matrice-vecteur blocf o r ( i =0; i<r ; i++)
f o r ( j =0; j<r ; j++) y [ i ] = y [ i ] + a [ i , ( q−s t e p mod p ) r + j
] ∗ x [ j ] ;
// on recoit le bloc de x du processus precedent de l’anneaur e c e i v e ( temp , r ) ;x = temp ;
Frank Nielsen 1.Les matrices en HPC-3.Produit matrice-vecteur sur l’anneau A6-23
![Page 24: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/24.jpg)
Produit matriciel parallele
Les algorithmes paralleles vont dependre :
des motifs des donnees
de la topologie du reseau d’interconnexion des machines
des types d’operations de communications utilises
Cout d’une communication entre deux nœuds voisins :
Temps Message = Latence + #longeur× temps par unite de longeur
Temps Message = α+ τ l
on mesure α et τ en equivalent FLOPS
efficacite : temps sequentiel/(P × temps parallele)
speed-up optimal ⇔ efficacite = 1
Frank Nielsen 1.Les matrices en HPC-4.Complexite des communications A6-24
![Page 25: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/25.jpg)
Le produit matriciel sur un cluster de machines
C = A× B
les elements des matrices n × n sont initialement distribuessur les P processus P1, ...,PP−1
on echange par messages des matrices blocs (rappel MPI : pasde memoire partagee globale)
plusieurs motifs de decompositions : blocs de lignes blocs de colonnes blocs de damiers
les decompositions sont en rapport avec les algorithmes et lereseau d’interconnexion (graphe complet, anneau, tore)
Frank Nielsen 3.Produit matriciel A6-25
![Page 26: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/26.jpg)
Le tore 2D
on considere√P ∈ N le cote de la grille torique a√
P ×√P = P processeurs (NB : anneau = tore 1D)
chaque processeur Pi peut communiquer avec ses 4 voisins :Nord, Sud, Est, Ouest
Frank Nielsen 3.Produit matriciel A6-26
![Page 27: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/27.jpg)
Produit matriciel C = A× B sur le tore
initialement, les matrices sont stockes par bloc avec le motifde damier (par bloc 2D) sur le tore.
le processus Pi ,j pour i , j ∈ 1, ...,√P est responsable du
calcul de
C (i , j) =
√P
∑
k=1
A(i , k)× B(k , j)
Plusieurs facons de transmettre les matrices blocs A(·, ·),B(·, ·) et C (·, ·).
→ nous allons voir trois principaux algorithmes
Frank Nielsen 3.Produit matriciel A6-27
![Page 28: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/28.jpg)
Produit matriciel :l’algorithme de Cannon
Frank Nielsen 3.Produit matriciel-1.L’algorithme de Cannon A6-28
![Page 29: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/29.jpg)
Algorithme de Cannon : vue generale
necessite des operations de pre-skewing des matrices avant
les calculs locaux et des operations de post-skewing apres cescalculs locaux
les communications des sous-matrices A et B sont desrotations horizontales (←) et des rotations verticales (↑).
Frank Nielsen 3.Produit matriciel-1.L’algorithme de Cannon A6-29
![Page 30: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/30.jpg)
A0,0
B0,0
A0,0 A0,1 A0,2
A1,2A1,1A1,0
A2,0 A2,1 A2,2
B0,0 B0,1 B0,2
B1,2B1,1B1,0
B2,0 B2,1 B2,2
A0,1
B0,1
A0,2
B0,2
A1,0
B1,0
A2,0
B2,0
A1,1
B1,1
A2,1
B2,1
A2,2
B2,2
A1,2
B1,2
A0,0 A0,1 A0,2
A1,2A1,1 A1,0
A2,0 A2,1A2,2
B0,0
B0,1
B0,2
B1,2
B1,1
B1,0
B2,0
B2,1
B2,2
A0,1
B1,0
A0,0A0,1 A0,2
A1,2 A1,1A1,0
A2,0 A2,1 A2,2 B0,0
B0,1
B0,2
B1,2
B1,1
B1,0
B2,0
B2,1
B2,2
A0,2
B2,1
A0,0
B0,2
A1,2
B2,0
A2,0
B0,0
A1,0
B0,1
A2,1
B1,1
A2,2
B2,2
A1,1
B1,2
Initialisation
Pre-processing :
Preskewing
etape 1 :
Calculs locaux
Rotations
etape 2:
Calculs locaux
Rotations
A0,0
B0,0
A0,1
B1,1
A0,2
B2,2
A1,1
B1,0
A2,2
B2,0
A1,2
B2,1
A2,0
B0,1
A2,1
B1,2
A1,0
B0,2
Frank Nielsen 3.Produit matriciel-1.L’algorithme de Cannon A6-30
![Page 31: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/31.jpg)
A0,2
B2,0
A0,0 A0,1A0,2
A1,2A1,1A1,0
A2,0A2,1 A2,2
B0,0
B0,1
B0,2
B1,2
B1,1
B1,0
B2,0
B2,1
B2,2
A0,0
B0,1
A0,1
B1,2
A1,0
B0,0
A2,0
B0,0
A1,1
B1,1
A2,1
B1,1
A2,0
B0,2
A1,2
B2,2
etape 3 :
Calculs locaux
Rotations
A0,0 A0,1 A0,2
A1,2A1,1 A1,0
A2,0 A2,1A2,2
B0,0
B0,1
B0,2
B1,2
B1,1
B1,0
B2,0
B2,1
B2,2A0,0
B0,0
A0,1
B1,1
A0,2
B2,2
A1,1
B1,0
A2,2
B2,0
A1,2
B2,1
A2,0
B0,1
A2,1
B1,2
A1,0
B0,2
A0,0
B0,0
A0,0 A0,1 A0,2
A1,2A1,1A1,0
A2,0 A2,1 A2,2
B0,0 B0,1 B0,2
B1,2B1,1B1,0
B2,0 B2,1 B2,2
A0,1
B0,1
A0,2
B0,2
A1,0
B1,0
A2,0
B2,0
A1,1
B1,1
A2,1
B2,1
A2,2
B2,2
A1,2
B1,2
Postprocessing:
Post-skewing
Configuration
initiale !
Frank Nielsen 3.Produit matriciel-1.L’algorithme de Cannon A6-31
![Page 32: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/32.jpg)
// Pre-traitement des matrices A et B
// Preskew ← : elements diagonaux de A alignes
verticalement sur la premiere colonne
PreskewHorizontal(A);
// Preskew ↑ : elements diagonaux de B alignes
horizontalement sur la premiere ligne
PreskewVertical(B);
// Initialise les blocs de C a 0
C = 0;
pour k = 1 a√P faire
C ← C+ProduitsLocaux(A,B);
// decalage vers la gauche ←RotationHorizontale(A);
// decalage vers le haut ↑RotationVerticale(B);
fin
// Post-traitement des matrices A et B : operations
inverses du pre-traitement
// Preskew →PostskewHorizontal(A);
// Preskew ↓PostskewVertical(B);
Frank Nielsen 3.Produit matriciel-1.L’algorithme de Cannon A6-32
![Page 33: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/33.jpg)
Produit matriciel :algorithme de Fox
Frank Nielsen 3.Produit matriciel-2.Algorithme de Fox A6-33
![Page 34: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/34.jpg)
Algorithme de Fox
initialement, les donnees ne bougent pas (= pas depre-traitement)
diffusions horitonzales des diagonales de A (decalees vers ladroite)
rotations verticales de B , de bas en haut
... appele aussi algorithme broadcast-multiply-roll
Frank Nielsen 3.Produit matriciel-2.Algorithme de Fox A6-34
![Page 35: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/35.jpg)
A0,0 A0,0 A0,0
A1,1A1,1 A1,1
A2,2 A2,2A2,2
etape 1 :Diffusion A
(premiere diagonale)Calculs locaux
etape 1’:Rotation verticalede B
A0,1
B1,0
A0,1 A0,1A0,1
A1,2A1,2A1,2
A2,0A2,0 A2,0
A0,1
B1,1
A0,1
B1,2
A1,2
B2,0
A2,0
B0,0
A1,2
B2,1
A2,0
B0,1
A2,0
B0,2
A1,2
B2,2
etape 2 :Diffusion A(deuxieme diagonale)Calcul locaux
A0,0
B0,0
A0,0
B0,1
A0,0
B0,2
A1,1
B1,0
A2,2
B2,0
A1,1
B1,1
A2,2
B2,1
A2,2
B2,2
A1,1
B1,2
B0,0 B0,1 B0,2
B1,2B1,1B1,0
B2,0 B2,1 B2,2
B1,2B1,1B1,0
B2,0 B2,1 B2,2
B0,0 B0,1 B0,2
A0,0 A0,0 A0,0
A1,1A1,1 A1,1
A2,2 A2,2A2,2
B1,2B1,1B1,0
B2,0 B2,1 B2,2
B0,0 B0,1 B0,2
Frank Nielsen 3.Produit matriciel-2.Algorithme de Fox A6-35
![Page 36: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/36.jpg)
A0,2
B2,0
A0,2 A0,2 A0,2
A1,0A1,0A1,0
A2,1 A2,1 A2,1
A0,2
B2,1
A0,2
B2,2
A1,0
B0,0
A2,1
B1,0
A1,0
B0,1
A2,1
B1,1
A2,1
B1,2
A1,0
B0,2
etape 2’:Rotation verticalede B
etape 3:Diffusion A
(troisieme diagonale)Calculs locaux
A0,1 A0,1A0,1
A1,2A1,2A1,2
A2,0A2,0 A2,0
B2,0 B2,1 B2,2
B0,0 B0,1 B0,2
B1,2B1,1B1,0
B2,0 B2,1 B2,2
B0,0 B0,1 B0,2
B1,2B1,1B1,0
A0,0
B0,0
A0,1
B0,1
A0,2
B0,2
A1,0
B1,0
A2,0
B2,0
A1,1
B1,1
A2,1
B2,1
A2,2
B2,2
A1,2
B1,2
etape 3’:Rotation verticalede B
→ etat final
B0,0 B0,1 B0,2
B1,2B1,1B1,0
B2,0 B2,1 B2,2
Frank Nielsen 3.Produit matriciel-2.Algorithme de Fox A6-36
![Page 37: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/37.jpg)
// Initialise les blocs de C a 0
C = 0;
pour i = 1 a√P faire
// Broadcast
Diffusion de la i -ieme diagonale de A sur les lignes de processusdu tore;
// Multiply
C ← C+ProduitsLocaux(A,B);
// Roll
// Rotation verticale : decalage vers le haut ↑RotationVerticale(B);
fin
Frank Nielsen 3.Produit matriciel-2.Algorithme de Fox A6-37
![Page 38: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/38.jpg)
Produit matriciel :algorithme de Snyder
Frank Nielsen 3.Produit matriciel-3.Algorithme de Snyder A6-38
![Page 39: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/39.jpg)
Produit matriciel : algorithme de Snyder
initialement, on transpose B : B ← B⊤
sommes globales (reduce) sur les lignes de processeurs
accumulation des resultats sur les diagonales principales deC (decalees a chaque etape vers la droite)
rotations verticales de bas en haut
A0,0 A0,1 A0,2
A1,0 A1,1 A1,2
A2,0 A2,1 A2,2 premiere diagonale
deuxieme diagonale
troisieme diagonale
Frank Nielsen 3.Produit matriciel-3.Algorithme de Snyder A6-39
![Page 40: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/40.jpg)
A0,0 A0,1 A0,2
A1,2A1,1A1,0
A2,0 A2,1 A2,2
B0,0 B0,1 B0,2
B1,2B1,1B1,0
B2,0 B2,1 B2,2
Initialisation
Pre-processing :
Transpose B → B⊤
etape 1:
Calculs locaux et
accumulation sur
la premiere diagonale
de C
B0,0
B1,1
B2,2
B1,0 B2,0
B0,2
B0,1 B2,1
B1,2
C0,0
C1,1
C2,2
∑
∑
∑
B⊤
A0,0 A0,1 A0,2
A1,2A1,1 A1,0
A2,0 A2,1A2,2
A0,0 A0,1 A0,2
A1,2A1,1 A1,0
A2,0 A2,1A2,2
B0,0
B1,1
B2,2
B1,0 B2,0
B0,2
B0,1 B2,1
B1,2
Frank Nielsen 3.Produit matriciel-3.Algorithme de Snyder A6-40
![Page 41: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/41.jpg)
etape 1’:
Rotation verticale
de B
A0,0 A0,1 A0,2
A1,2A1,1 A1,0
A2,0 A2,1A2,2 B0,0 B1,0 B2,0
B1,1B0,1 B2,1
B2,2B0,2 B1,2
etape 2:
Calculs locaux et
accumulation sur
la deuxieme diagonale
de C
etape 2’:
Rotation verticale de B
A0,0 A0,1 A0,2
A1,2A1,1 A1,0
A2,0 A2,1A2,2 B0,0 B1,0 B2,0
B1,1B0,1 B2,1
B2,2B0,2 B1,2
C0,1
C1,2
C2,0
A0,0 A0,1 A0,2
A1,2A1,1 A1,0
A2,0 A2,1A2,2
B0,0 B1,0 B2,0
B1,1B0,1 B2,1
B2,2B0,2 B1,2 C0,2
C1,0
C2,1
etape 3:
Calculs locaux et
accumulation sur
la troisieme diagonale
de C
∑
∑
∑
∑
∑
∑
Frank Nielsen 3.Produit matriciel-3.Algorithme de Snyder A6-41
![Page 42: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/42.jpg)
// Preskewing
Transpose B ;
// Phase de calcul
for k = 1 to√P do
// Produit scalaire ligne par ligne sur A et B
Calcule localement par bloc : C = A× B ;
// On calcule les matrices blocs definitives de Cpour la k-ieme diagonale
// Somme globale equivaut au produit scalaire
d’une ligne de A avec une ligne de B
Somme globale∑
de C sur les processeurs lignes pour lak-ieme diagonale de C ;
Decalage vertical de B ;
end
// On transpose B afin de retrouver la matrice
initiale
Transpose B ;
Frank Nielsen 3.Produit matriciel-3.Algorithme de Snyder A6-42
![Page 43: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/43.jpg)
En resume
Le produit matriciel sur le tore :
algorithme de Cannon (pre-processing)
algorithme de Fox (broadcast-multiply-roll)
algorithme de Snyder (sommes globales)
Comparatif des trois algorithmes :
Algorithme Cannon Fox Snyder
pretraitement preskewing de A et B rien transposition B ← B⊤
produits matriciels en place en place∑
sur les lignes PEs
mouvements A gauche → droite diffusion horizontale rien
mouvements B bas → haut bas→ haut bas → haut
Frank Nielsen 3.Produit matriciel-3.Algorithme de Snyder A6-43
![Page 44: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/44.jpg)
La bibliotheque
C++ STL :genericite
Frank Nielsen 4.STL A6-44
![Page 45: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/45.jpg)
Les classes generiques en C++
But de la genericite = produire du code independant des
types (instancies lors de l’usage):
// returns 0 if equal, 1 if value1 is bigger, -1 otherwisei n t compare ( con s t i n t &va lue1 , con s t i n t &va l u e2 ) i f ( va l u e1 < va l u e2 ) r e t u r n −1;i f ( va l u e2 < va l u e1 ) r e t u r n 1 ;r e t u r n 0 ;// returns 0 if equal, 1 if value1 is bigger, -1 otherwisei n t compare ( con s t s t r i n g &va lue1 , con s t s t r i n g &
va l u e2 ) i f ( va l u e1 < va l u e2 ) r e t u r n −1;i f ( va l u e2 < va l u e1 ) r e t u r n 1 ;r e t u r n 0 ;
⇒ factorisation du code puis a la compilation, code polymorphiquepour les divers types requis : generation des codes specifiques pourles types demandes.
Frank Nielsen 4.STL A6-45
![Page 46: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/46.jpg)
#i n c l u d e <i o s t ream>#i n c l u d e <s t r i n g >
// returns 0 if equal, 1 if value1 is bigger, -1 otherwiset emp l a t e <c l a s s T>i n t compare ( con s t T &va lue1 , con s t T &va l u e2 ) i f ( va l u e1 < va l u e2 ) r e t u r n −1;i f ( va l u e2 < va l u e1 ) r e t u r n 1 ;r e t u r n 0 ;
// On est gentil ici pour le compilateur :// on indique explicitement les types demandes
i n t main ( i n t argc , cha r ∗∗ argv ) s td : : s t r i n g h ( ” h e l l o ” ) , w( ” wor ld ” ) ;s t d : : cout << compare<s td : : s t r i n g >(h , w) << s td : :
end l ;s t d : : cout << compare<i n t >(10 , 20) << s td : : end l ;s t d : : cout << compare<double >(50 .5 , 5 0 . 6 ) << s td : :
end l ;r e t u r n 0 ;
Frank Nielsen 4.STL A6-46
![Page 47: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/47.jpg)
Inference des types demandes par le compilateur#i n c l u d e <i o s t ream>#i n c l u d e <s t r i n g >
// returns 0 if equal, 1 if value1 is bigger, -1 otherwiset emp l a t e <c l a s s T>i n t compare ( con s t T &va lue1 , con s t T &va l u e2 ) i f ( va l u e1 < va l u e2 ) r e t u r n −1;i f ( va l u e2 < va l u e1 ) r e t u r n 1 ;r e t u r n 0 ;
// Le compilateur doit trouver le type demande ici :// inference de types
i n t main ( i n t argc , cha r ∗∗ argv ) s td : : s t r i n g h ( ” h e l l o ” ) , w( ” wor ld ” ) ;s t d : : cout << compare (h , w) << s td : : end l ;s t d : : cout << compare (10 , 20) << s td : : end l ;s t d : : cout << compare ( 5 0 . 5 , 5 0 . 6 ) << s td : : end l ;r e t u r n 0 ;
Frank Nielsen 4.STL A6-47
![Page 48: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/48.jpg)
Mecanisme de compilation
le compilateur ne genere pas de code directement lorsqu’ilrencontre une classe/fonction template parce qu’il ne connaıtpas encore quelles seront les types demandes.
quand le compilateur rencontre une fonction template
utilisee, il sait quel type est demande : Il instancie alors letemplate et compile le code correspondant
⇒ les classes/fonctions templates doivent donc se trouver dans lefichier d’en-tete, header .hLe mecanisme de template ressemble donc a une macroexpansion...
Frank Nielsen 4.STL A6-48
![Page 49: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/49.jpg)
fichier compare.h :
#i f n d e f COMPARE H#de f i n e COMPARE H
temp l a t e <c l a s s T> i n t comp ( con s t T& a , con s t T& b )
i f ( a < b ) r e t u r n −1;i f ( b < a ) r e t u r n 1 ;r e t u r n 0 ;
#en d i f // COMPARE H
fichier main.cpp :
#i n c l u d e <i o s t ream>#i n c l u d e ”compare . h”u s i n g namespace s td ;
i n t main ( i n t argc , cha r ∗∗ argv ) cout << comp<i n t >(10 , 20) ; cout << end l ;r e t u r n 0 ;
Frank Nielsen 4.STL A6-49
![Page 50: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/50.jpg)
Lire un fichier dans un vector de la STLVous avez deja utilise la classe vector de la STL ! (tableauxdynamiques)
i f s t r e am f i n ;f i n . open ( ” f i c h i e r . t x t ” ) ;v ec to r<s t r i n g > t e x t e ; s t r i n g mote ;
wh i l e ( f i n >> mot ) t e x t e . push back (mot ) ;
f i n . c l o s e ( ) ;
La boucle while lit jusqu’a temps de rencontrer EOF (EndOf File)
Les donnees sont des chaınes de caracteres separees par desdelimiteurs (espace, tab, retour a la ligne, point virgule pourles fichiers CSV, Comma-Separated Values)
Frank Nielsen 4.STL A6-50
![Page 51: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/51.jpg)
STL : une collection de structures de donnees
Le concept fondamental est le containeur avec son iterator , letout en template !
Structure de donnees nom STL #include
tableau dynamique vector <vector>
liste chaınee list <list>
pile stack <stack>
file queue <queue>
arbre binaire set <set>
table de hachage map <set>
tas ordonne file de priorite <queue>
Les #include sont a faire sans le .h
Frank Nielsen 4.STL A6-51
![Page 52: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/52.jpg)
La STL : structures de donnees generiques
se t<s t r i n g > mots ;l i s t <Eleve> PromoX2013 ;s tack< vec to r<i n t> > nombres ;
A chaque container STL, on a un iterateur (iterator) associe detype container<T>::iterator
se t<s t r i n g > : : i t e r a t o r p=mots . f i n d ( ” cou r s ” ) ;l i s t <Eleve > : : i t e r a t o r p r em i e r=PromoX2013 . beg i n
( ) ;s tack< vec to r<i n t> > : : i t e r a t o r f i n=nombres . end
( ) ;
On dereference un iterateur comme pour un pointeur : *it
Frank Nielsen 4.STL A6-52
![Page 53: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/53.jpg)
Les containeurs stockent par valeur, pas par reference
quand on insere un objet, le containeur va en faire une copie
quand le containeur doit rearranger les objets, il procede enfaisant des copies de ceux-ci. Par exemple, si on tri, ou si oninsere sur un containeur map, etc.
si on veut eviter cela, il faudra donc faire des containeurs depointeurs !
C++11 a le mot clef auto pour inferer directemement les types etun “foreach” (pour les curieux !) :
f o r ( ve c to r<Pr i n t e r > : : i t e r a t o r i t = vec . b eg i n ( ) ; i t< vec . end ( ) ; i t++) cout << ∗ i t << end l ;
f o r ( auto i t = vec . b eg i n ( ) ; i t < vec . end ( ) ; i t ++) cout << ∗ i t << end l ;
s td : : s t r i n g s t r ( ”Bonjour INF442” ) ; f o r ( auto c :s t r ) s td : : cout << c << end l ;
Frank Nielsen 4.STL A6-53
![Page 54: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/54.jpg)
Fonctions membres communes a la STL
Toutes les classes containeurs ont les fonctions membres :
i n t s i z e ( )i t e r a t o r beg i n ( )i t e r a t o r end ( )boo l empty ( )
Pour lister tous les elements d’un containeur, on fait :
l i s t <s t r i n g > : : i t e r a t o r i t=maLi s t e . b eg i n ( ) ;wh i l e ( i t !=maLi s t e . end ( ) ) cout << ∗ i t<<end l ; i t e r ++;
Notons que end() est un element sentinel . On ne peut pasdereferencer end().
Frank Nielsen 4.STL A6-54
![Page 55: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/55.jpg)
Differents acces aux elements d’un containeur
pour vector, on peut acceder aux elements en utilisant unindex [i ] :
v e c to r<i n t> vec442<double >;vec442 [0 ]=280 ;
... mais les crochets ne peuvent pas etre utilises pourlist<int> par exemple
on peut rajouter un element a la fin d’une liste ou d’unvecteur avec push back :
monVecteur . push back (2013) ;maL i s t e . push back (2013) ;
... mais il n’ y a pas de push_back pour les ensembles (codespar des arbres binaires) :
s e t<i n t> monEnsemble ;monEnsemble . push back (2013) ; // Erreur !!!
Frank Nielsen 4.STL A6-55
![Page 56: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/56.jpg)
La liste (doublement chaınee)
On peut ajouter a la tete ou a la queue d’une liste en temps
constant :
maL i s t e . push back (2013) ;maL i s t e . p u s h f r o n t (2015) ;
On peut inserer ou supprimer un element avec un iterateur :
l i s t <s t r i n g > : : i t e r a t o r p=maLi s te . b eg i n ( ) ;p=maLi s te . e r a s e ( p ) ;p=maLi s te . i n s e r t ( p , ”HPC” ) ;
On peut avancer ou reculer dans une liste avec les operateursunaires ++ et -- :
p++; p−−; // faire attention aux debordements possibles
Seul bemol : on ne peut pas directement acceder i -ieme element(cela demande de parcourir la liste, pas de crochets).
Frank Nielsen 4.STL A6-56
![Page 57: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/57.jpg)
La liste doublement chaınee en STL
Voir INF311/INF411
NULL
NULL
C++ HPC MPI
list<string>::iterator it=liste.find("HPC")
q=it-- q=it++
Frank Nielsen 4.STL A6-57
![Page 58: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/58.jpg)
Les piles et les files
Piles ( stacks ) et files ( queues ) sont des sous-classes de laclasse deque
Une pile est une liste chaınee avec la propriete Dernier ArrivePremier Sorti, DAPS (LIFO : Last In First Out).
Une file est une liste chaınee avec la propriete Premier ArrivePremier Sorti, PAPS (FIFO : First In First Out).
On accede au dernier eleement au sommet de la pile ou aupremier element d’une file avec les primitives push et pop
Pour les piles, on a aussi top, et pour les files front et back
Frank Nielsen 4.STL A6-58
![Page 59: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/59.jpg)
Les piles : illustration
s tack<s t r i n g > S ;S . push ( ”A” ) ;S . push ( ”B” ) ;S . push ( ”C” ) ;S . pop ( ) ;Q. pop ( ) ;S . push ( ”D” ) ;Q. push ( ”D” ) ;cout << S . top ( ) ;
Frank Nielsen 4.STL A6-59
![Page 60: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/60.jpg)
Les files : illustration
queue<s t r i n g > Q;Q. push ( ”A” ) ;Q. push ( ”B” ) ;Q. push ( ”C” ) ;Q. pop ( ) ;Q. push ( ”D” ) ;cout << Q. f r o n t ( ) << Q. back ( ) ;
Frank Nielsen 4.STL A6-60
![Page 61: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/61.jpg)
Les files de priorite
On doit definir un operator < .
La plus grande valeur est sur le haut (max-heap, top).
p r i o r i t y q u e u e <i n t> Q;Q. push (23) ; Q. push (12) ; Q. push (71) ; Q. push (2) ;cout << Q. top ( ) ;Q. pop ( ) ;cout << Q. top ( ) ;
pour la plus petite valeur (min-heap), il faut donc changer le senssemantique de l’operateur < ...
http://en.cppreference.com/w/cpp/language/operator_comparison
Frank Nielsen 4.STL A6-61
![Page 62: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/62.jpg)
On peut trier facilement avec une file de priorite...
#i n c l u d e <queue>#i n c l u d e <i o s t ream>u s i n g namespace s td ;
s t r u c t comparator boo l o p e r a t o r ( ) ( i n t i , i n t j ) r e t u r n i < j ;
;
i n t main ( i n t argc , cha r con s t ∗ argv [ ] )
p r i o r i t y q u e u e <i n t , s t d : : v e c to r<i n t >,comparator> minHeap ;
minHeap . push (10) ; minHeap . push (5 ) ;minHeap . push (12) ; minHeap . push (3 ) ;minHeap . push (3 ) ; minHeap . push (4 ) ;
wh i l e ( ! minHeap . empty ( ) ) cout << minHeap . top ( ) << ” ” ;minHeap . pop ( ) ;
r e t u r n 0 ; // 12 10 5 4 3 3
Frank Nielsen 4.STL A6-62
![Page 63: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/63.jpg)
Les ensembles : set (arbres binaires equilibres)
On doit definir operator <. Toutes les valeurs sont uniques
(sinon, utiliser un multiset).insert(value), erase(value), erase(iterator),iterator find(value)
se t<s t r i n g > s ;s . i n s e r t ( ” Eco l e ” ) ;s . i n s e r t ( ” Po l y t e chn i q u e ” ) ;s . e r a s e ( ” Eco l e ” ) ;cout << ∗( s . f i n d ( ” Po l y t e chn i q u e ” ) ) ;
Frank Nielsen 4.STL A6-63
![Page 64: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/64.jpg)
Le hachage (map)
Difference entre hachage ferme (tableau) et hachage ouvert(tableau de pointeurs sur des listes).
Templates pour la clef et le type de donnees map<K,T>.
On doit definiroperator < pour le type K.
map<i n t , s t r i n g > monHachage ;monHachage [23121981 ] = ” A n n i v e r s a i r e Toto” ;monHachage [05031953 ] = ” A n n i v e r s a i r e T i t i ” ;. . .map<s t r i n g , i n t> monHachageRev ;monHachageRev [ ”Toto” ] = 23121981;monHachageRev [ ” T i t i ” ] = 05031953;
Frank Nielsen 4.STL A6-64
![Page 65: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/65.jpg)
Le hachage (map)
Les fonctions membres pour la classe STL map :erase(iterator), erase(K clef), map_name(K key)
map<s t r i n g , i n t> M;M[ ”A” ] = 23 ;M[ ”B” ] = 12 ;M[ ”C” ] = 71 ;M[ ”D” ] = 5 ;M. e r a s e ( ”D” ) ;cout << M[ ”B” ] ;
Frank Nielsen 4.STL A6-65
![Page 66: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/66.jpg)
La classe STL paire a la rescousse
map<s t r i n g , i n t> maMap;pa i r<s t r i n g , i n t> p a i r e ( ”Tutu” , 606) ;maMap. i n s e r t ( p a i r e ) ;. . .// on cree un nouvel enregistrement en faisant aussi :maMap[ ”Tata” ] = 707;
⇒ operateur crochet [K]
Frank Nielsen 4.STL A6-66
![Page 67: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/67.jpg)
Les temps d’acces aux structures de donnees
Pour un containeur a n elements :
vecteur list set map
Inserer/supprimer O(n) O(1) O(log n) O(1)
Rechercher O(n) O(n) O(log n) O(1)
Voir INF311/INF411.
Frank Nielsen 4.STL A6-67
![Page 68: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/68.jpg)
Les iterateurs
Chaque containeur est equippe d’un iterateur :
c on t a i n e r<T> : : i t e r a t o r i t ;i t=C . beg i n ( ) ;
++ et -- pour avancer ou reculer
* pour dereferencer
== et =! pour les tests de comparaisons
Seulement dans la classe vector, on peut bouger de p elements(arithmetique) en faisant
v ec to r<T> : : i t e r a t o r i t ;i t=i t+p ;i t=i t−p ;
Frank Nielsen 4.STL A6-68
![Page 69: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/69.jpg)
Les iterateurs : premier et dernier elements
Le dernier element est une sentinelle :
cout << ∗( L . beg i n ( ) ) ; // oui, si pas vide !cout << ∗( L . end ( ) ) ; // toujours non !
l i s t <s t r i n g > : : i t e r a t o r p = L . end ( ) ;p−−;cout << ∗p ; // ok, si pas vide !
Frank Nielsen 4.STL A6-69
![Page 70: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/70.jpg)
La classe STL algorithm
Procedures (pas des methodes de classe) : find, remove, count,shuffle, replace, sort, for each, min element,binary search, transform, copy, swap :
i t e r = f i n d (L . beg i n ( ) , L . end ( ) , ” Cours INF442”) ;
i n t x = count (L . beg i n ( ) , L . end ( ) , ” i n s c r i t enINF442” ) ;
r e p l a c e (L . beg i n ( ) , L . end ( ) , ”DEP442” , ” INF442”) ;
if : prend une fonction booleene utilisateur :
r e p l a c e i f (L . begin , L . end ( ) , appa r t i en t442S , ”Tutora t ” ) ;
Frank Nielsen 4.STL A6-70
![Page 71: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/71.jpg)
La bibliothequeBoost
Frank Nielsen 5.Boost uBLAS A6-71
![Page 72: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/72.jpg)
Boost
un ensemble de bibliotheques qui se comportent bien avec laSTL :http://www.boost.org/
liste des bibliotheques de Boost :http://www.boost.org/doc/libs/
Graph BGL generic graph componentsMPI MPI interface in Boost styleRational rational number classThread Portable multi-threadinguBlas linear algebra for vector/matrixXpressive regular expression
Installe dans le repertoire /usr/local/boost-1.56.0
Frank Nielsen 5.Boost uBLAS A6-72
![Page 73: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/73.jpg)
Boost : la bibliotheque uBLAS
#i n c l u d e <boos t / numer ic / ub l a s /mat r i x . hpp>#i n c l u d e <boos t / numer ic / ub l a s / i o . hpp>u s i n g namespace s td ;u s i n g namespace boos t : : numer ic : : u b l a s ;
i n t main ( ) matr ix<double> m (3 , 3) ;f o r ( un s i gned i = 0 ; i < m. s i z e 1 ( ) ; ++ i )
f o r ( un s i gned j = 0 ; j < m. s i z e 2 ( ) ;++ j )m ( i , j ) = i + j ∗ j ;
cout << m << end l ;
Frank Nielsen 5.Boost uBLAS A6-73
![Page 74: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/74.jpg)
Boost : la bibliotheque uBLAS
alias mpiboost =’/usr/local/openmpi -1.8.3/ bin
/mpic++ -I/usr/local/boost -1.56.0/ include
/ -L/usr/local/boost -1.56.0/ lib/ -
lboost_mpi -lboost_serialization ’
mpiboost matrice442.cpp -o matrice442.exe
mpirun -np 1 matrice442.exe
[3 ,3]((0 ,1 ,4) ,(1,2,5) ,(2,3,6))
http://www.boost.org/doc/libs/1_58_0/libs/numeric/ublas/doc/
Frank Nielsen 5.Boost uBLAS A6-74
![Page 75: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/75.jpg)
# i n c l u d e <boos t / numer ic / ub l a s /mat r i x . hpp># i n c l u d e <boos t / numer ic / ub l a s / i o . hpp># i n c l u d e <boos t / numer ic / ub l a s /mat r i x . hpp>u s i n g namespace boos t : : numer ic : : u b l a s ;u s i n g namespace s td ;i n t main ( ) mat r i x <doub l e > myMat (3 ,3 , 2 . 5 ) ;myMat (0 , 0 )= myMat (2 , 2 ) =1.0 ;myMat (0 , 2 )= −3.6; myMat (2 , 0 ) =5.9 ;cout << ”My Mat : ” << myMat << end l ;cout << ”Num Rows : ” << myMat . s i z e 1 ( ) << end l ;cout << ”Num Co l s : ” << myMat . s i z e 2 ( ) << end l ;cout << ”My Mat Transp : ” << t r a n s (myMat ) << end l
;cout << ”My Mat Rea l Par t : ” << r e a l (myMat ) <<
end l ;myMat . r e s i z e (4 , 4 ) ;cout << ”My Res i z ed Mat : ” << myMat << end l ;r e t u r n 0 ;
Frank Nielsen 5.Boost uBLAS A6-75
![Page 76: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/76.jpg)
mat r i x <doub l e > myMat (3 ,3 , 2 . 5 ) ;myMat (0 ,0 )= myMat (2 ,2 ) =1.0;myMat (0 ,2 )= −3.6; myMat (2 ,0 ) =5.9;
mpirun -np 1 matricefun442.exe
My Mat :[3 ,3]((1 ,2.5 , -3.6) ,(2.5 ,2.5 ,2.5)
,(5.9,2.5,1))
Num Rows :3
Num Cols :3
My Mat Transp :[3,3]((1,2.5,5.9)
,(2.5 ,2.5 ,2.5) ,(-3.6,2.5,1))
My Mat Real Part :[3 ,3]((1 ,2.5 , -3.6)
,(2.5 ,2.5 ,2.5) ,(5.9,2.5,1))
My Resized Mat :[4,4]((1,2.5, -3.6,3.57355e
-115) ,(2.5,2.5,2.5,2.02567e-322)
,(5.9,2.5,1,0) ,(0,0,0,0))
Frank Nielsen 5.Boost uBLAS A6-76
![Page 77: Traitement des données massives (INF442, A4)](https://reader037.vdocuments.pub/reader037/viewer/2022100300/55bff4abbb61ebbe188b4701/html5/thumbnails/77.jpg)
Resume A4
X la classification par regression lineaire (et comparaison avec leclassifieur k-PPV)
X le produit matrice-vecteur sur l’anneau oriente
X produits matriciels sur le tore : algorithmes de Cannon(pre-processing), de Fox (broadcast-multiply-roll) et de Snyder(sommes globales)
X la genericite avec la bibliotheque C++ STL
X la bibliotheque Boost uBLAS
Pour la prochaine fois : lire le chapitre 5 du polycopie
Frank Nielsen 5.Boost uBLAS A6-77