Traitement des données massives (INF442, A4)

INF442 : Traitement des donnees massivesA4 : Algebre lineaire distribuee

Frank Nielsen

X20136 mai 2015

Frank Nielsen A6-1

Plan

un peu de MPI

produit matriciel sur la topologie du tore

la genericite avec la bibliotheque C++ STL

Frank Nielsen A6-2

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

#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

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

Algebre lineaire en parallele : la regression

Frank Nielsen 1.Les matrices en HPC-1.Regression A6-6

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


La regression lineaire et la classification

Frontiere de decision = hyperplan (espace affine de dimension

d − 1 dans Rd )


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


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


La regression lineaire : ordinaire ou totale

x

yy = a× x

(x1, y1)

(x2, y2)

(x3, y3)

ordinary regression vs. total regression


Comparaison de la classification par regression ou par

k-PPV

Classifieur sur un vecteur aleatoire = variable aleatoire ⇒ varianceet biais


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


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.


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/


http://www.netlib.org/blas/

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


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

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

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

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


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


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


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 ;


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

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

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


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


Produit matriciel :l’algorithme de Cannon

Frank Nielsen 3.Produit matriciel-1.L’algorithme de Cannon A6-28

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


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


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 !


// 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);


Produit matriciel :algorithme de Fox

Frank Nielsen 3.Produit matriciel-2.Algorithme de Fox A6-33

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


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


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


→ etat final

B0,0 B0,1 B0,2

B1,2B1,1B1,0

B2,0 B2,1 B2,2


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


Produit matriciel :algorithme de Snyder

Frank Nielsen 3.Produit matriciel-3.Algorithme de Snyder A6-38

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


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


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

∑

∑

∑

∑

∑

∑


// 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 ;


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


La bibliotheque

C++ STL :genericite

Frank Nielsen 4.STL A6-44

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.


#i n c l u d e #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(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 ;


Inference des types demandes par le compilateur#i n c l u d e #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 ;


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


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 #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(10 , 20) ; cout << end l ;r e t u r n 0 ;


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)


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


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 > 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 t e r a t o r f i n=nombres . end

( ) ;

On dereference un iterateur comme pour un pointeur : *it


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 ;


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


Differents acces aux elements d’un containeur

pour vector, on peut acceder aux elements en utilisant unindex [i ] :

v e c to r 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 monEnsemble ;monEnsemble . push back (2013) ; // Erreur !!!


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


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


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


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


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


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


http://en.cppreference.com/w/cpp/language/operator_comparison

On peut trier facilement avec une file de priorite...

#i n c l u d e <queue>#i n c l u d e 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 ,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


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 ” ) ) ;


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


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” ] ;


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]


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.


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 ;


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 !


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 ” ) ;


La bibliothequeBoost

Frank Nielsen 5.Boost uBLAS A6-71

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


http://www.boost.org/

http://www.boost.org/doc/libs/

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 ;


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/


http://www.boost.org/doc/libs/1_58_0/libs/numeric/ublas/doc/

# 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 ;


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


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

Science

Traitement des données massives (INF442, A4)