La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Exposé GT 24/10/2002 Dimitri Lecas. ScotchFaxBlendSopalin graphe sequentielparallele global local symbolique numerique noeud ddl permutationsymbolMatrix.

Présentations similaires


Présentation au sujet: "Exposé GT 24/10/2002 Dimitri Lecas. ScotchFaxBlendSopalin graphe sequentielparallele global local symbolique numerique noeud ddl permutationsymbolMatrix."— Transcription de la présentation:

1 Exposé GT 24/10/2002 Dimitri Lecas

2

3 ScotchFaxBlendSopalin graphe sequentielparallele global local symbolique numerique noeud ddl permutationsymbolMatrix solverMatrix distribuée solverMatrix distribuée et factorisée solution distribuée element

4 Fax

5 Factorisation Symbolique

6 Blend

7 ScotchFaxBlendSopalin graphe sequentielparallele global local symbolique numerique noeud ddl permutationsymbolMatrix solverMatrix distribuée solverMatrix distribuée et factorisée solution distribuée element

8 Repartitionnement et distribution des blocs Gère le parallélisme induit par le creux (arbre délimination par blocs). Découpe et distribue les blocs afin de prendre en compte le parallélisme potentiel induit par les calculs en plein. Utilise la taille de bloc optimale pour les routines BLAS de niveau 3.

9 Arbre délimination par blocs

10 Repartitionnement de la matrice Graphe de tâches Matrice symbolique par blocs Modélisation coûts calcul et comm Nombre de processeurs Distribution et ordonnancement Données locales Ordonnancement tâches Schéma de communication Factorisation et résolution // Estimation du temps de calcul Espace Mémoire nécessaire

11 Repartitionnement de la matrice Graphe de tâches Matrice symbolique par blocs Modélisation coûts calcul et comm Nombre de processeurs Distribution et ordonnancement Données locales Ordonnancement tâches Schéma de communication Limitation mémoire Réduction surcoût mémoire Factorisation et résolution // Nouveau schéma de communication

12 Repartitionnement de la matrice Graphe de tâches Matrice symbolique par blocs Modélisation coûts calcul et comm Nombre de processeurs Distribution et ordonnancement Données locales Ordonnancement tâches Schéma de communication Factorisation et résolution // OOC Calcul dun schéma I/O pour lOOC Limitation mémoire Schéma I/O disque

13 Distribution mixte 1D/2D Le solveur gère une distribution 1D ou 2D des blocs 1D sur les petits supernodes -> efficacité BLAS 2D sur les plus gros supernodes -> scalabilité Critère de basculement entre les 2 distributions 1D block distribution 2D block distribution

14 Repartionnement et processeurs candidats

15 Sopalin

16 ScotchFaxBlendSopalin graphe sequentielparallele global local symbolique numerique noeud ddl permutationsymbolMatrix solverMatrix distribuée solverMatrix distribuée et factorisée solution distribuée element

17 Lalgorithme de factorisation parallèle A est Symétrique Définie Positive factorisation sans pivotage Algorithme supernodal de factorisation parallèle creuse L.L t / L.D.L t avec agrégation locale complète et distribution mixte 1D/2D.

18 BStruct(L k* ) BStruct(L *k )

19 Repartitionnement de la matrice Graphe de tâches Matrice symbolique par blocs Modélisation coûts calcul et comm Nombre de processeurs Distribution et ordonnancement Données locales Ordonnancement tâches Schéma de communication Limitation mémoire Réduction surcoût mémoire Factorisation et résolution // Nouveau schéma de communication

20 Algorithme de la factorisation // FACTOR(k): factoriser le bloc diagonal k Factoriser A kk en L kk L t kk ; BDIV(j,k): mis-à-jour L jk Résoudre L kk L jk t = A t jk ; BMOD(i,j,k): calculer la contribution de L ik pour le bloc L ij Calculer C j =L ik L jk t ; Si map(i,j) == p Alors A ij = A ij – C j ; Sinon AUB ij =AUB ij + C j ; k L jk L ik L ij j

21 Algorithme de la factorisation // COMP1D(k): factoriser le bloc-colonne k et calculer toutes les contributions destinées aux blocs-colonnes de BCol(k) Factoriser A kk en L kk L t kk ; Résoudre L kk L t * = A t *k ; Pour j BCol(k) Faire Calculer C [j] =L [j]k L jk t ; Si map([j],j) == p Alors A [j]j = A [j]j – C [j] ; Sinon AUB [j]j =AUB [j]j + C [j] ;

22 Algorithme de la factorisation // Pour n = 1 à NT p Faire Selon (le type de K p [n]) Faire COMP1D: Recevoir et ajouter tous les AUB [k]k dans A [k]k ; COMP1D(k); Phase_Envoi(); FACTOR: Recevoir et ajouter tous les AUB kk dans A kk ; FACTOR(k); envoyer L kk à tous les processeurs dans map([k], k); BDIV: Recevoir L kk et recevoir et ajouter les AUB ij pour A jk ; BDIV(j,k); envoyer F j t à tous les processeurs dans map([j], k); BMOD: Recevoir L jk t BMOD(i,j,k); Phase_Envoi();

23 Structure de données typedef struct SymbolCblk_ { INT fcolnum; // First column index INT lcolnum; // Last column index (inclusive) INT bloknum; // First block in column (diag.) } SymbolCblk; typedef struct SymbolBlok_ { INT frownum; // First row index INT lrownum; // Last row index (inclusive) INT cblknum; // Facing column block INT levfval; // Level-of-fill value } SymbolBlok; typedef struct SymbolMatrix_ { INT baseval; // Base value for numberings INT cblknbr; // Number of column blocks INT bloknbr; // Number of blocks SymbolCblk * restrict cblktab; // Array of column blocks SymbolBlok * restrict bloktab; // Array of blocks INT nodenbr; // Number of nodes in matrix } SymbolMatrix;

24 Structure de données typedef struct SolverMatrix_ { SymbolMatrix symbmtx; SolverCblk * restrict cblktab; SolverBlok * restrict bloktab; INT coefnbr; INT ftgtnbr; FLOAT * restrict coeftab; FanInTarget * restrict ftgttab; int procnum; int procnbr; BlockTarget * restrict btagtab; INT btagnbr; BlockCoeff * restrict bcoftab; INT bcofnbr; Task * restrict tasktab; INT tasknbr; Ooc * restrict oocstr; UpDownVector updovct; } SolverMatrix; typedef struct SolverCblk_ { INT stride; INT procdiag; INT cblkdiag;} SolverCblk; typedef struct SolverBlok_ { INT coefind;} SolverBlok;

25 Structure de données #define COMP_1D 0 #define DIAG 1 #define E1 2 #define E2 3 #define DRUNK 4 typedef struct Task_ { INT taskid; INT prionum; INT cblknum; INT bloknum; INT ctrbcnt; BlockTarget * btagptr; INT indnum; INT tasknext;} Task;

26 Structure de données typedef enum { FTGT_CTRBNBR = 0, FTGT_CTRBCNT, FTGT_PROCDST, FTGT_TASKDST, FTGT_BLOKDST, FTGT_PRIONUM, FTGT_FCOLNUM, FTGT_LCOLNUM, FTGT_FROWNUM, FTGT_LROWNUM, MAXINFO } FanInInfo; typedef struct FanInTarget_ { INT infotab[MAXINFO]; FLOAT * coeftab;} FanInTarget;

27

28 Factorisation LU

29 Stockage de la partie U L k* U *k L kk U kk L k* L kk k* U kk U Transposition

30 Structure de données typedef struct SolverMatrix_ { SymbolMatrix symbmtx; SolverCblk * restrict cblktab; SolverBlok * restrict bloktab; INT coefnbr; INT ftgtnbr; FLOAT * restrict coeftab; FLOAT * restrict ucoeftab; FanInTarget * restrict ftgttab; int procnum; int procnbr; BlockTarget * restrict btagtab; INT btagnbr; BlockCoeff * restrict bcoftab; INT bcofnbr; Task * restrict tasktab; INT tasknbr; Ooc * restrict oocstr; UpDownVector updovct; } SolverMatrix; typedef struct SolverCblk_ { INT stride; INT procdiag; INT cblkdiag;} SolverCblk; typedef struct SolverBlok_ { INT coefind;} SolverBlok;

31 Algorithme de la factorisation // FACTOR(k): factoriser le bloc diagonal k Factoriser A kk en L kk U kk ; BDIV(j,k): mis-à-jour L jk et U ik Résoudre L kk U ki = A ki ; Résoudre U kk L ik = A ik ; BMOD(i,j,k): calculer la contribution de L ik pour le bloc L ij Calculer C j =L ik U kj ; Calculer D j =L jk U ki ; Si map(i,j) == p Alors A ij = A ij – C j ; A ji = A ji – D j ; Sinon AUB ij =AUB ij + C j ; AUB ji =AUB ji + D j ; k L jk L ik L ij j U kj

32 Algorithme de la factorisation // COMP1D(k): factoriser le bloc-colonne k et calculer toutes les contributions destinées aux blocs-colonnes de BCol(k) Factoriser A kk en L kk U kk ; Résoudre L kk U k* = A k* ; Résoudre L *k U kk = A *k ; Pour j BCol(k) Faire Calculer C [j] =L [j]k U kj ; Calculer D [j] =L jk U k[j] ; Si map([j],j) == p Alors A [j]j = A [j]j – C [j] ; A j[j] =A j[j] -D [j] ; Sinon AUB [j]j =AUB [j]j + C [j] ; AUB j[j] =AUB j[j] + D [j] ;

33 Pour n = 1 à NT p Faire Selon (le type de K p [n]) Faire COMP1D: Recevoir et ajouter tous les AUB [k]k dans A [k]k ; Recevoir et ajouter tous les AUB k[k] dans A k[k] ; COMP1D(k); Phase_Envoi(); FACTOR: Recevoir et ajouter tous les AUB kk dans A kk ; FACTOR(k); envoyer L kk et U kk à tous les processeurs dans map([k], k); BDIV: Recevoir L kk et U kk et recevoir et ajouter les AUB ij pour A jk et A ki ; BDIV(j,k); envoyer F j t à tous les processeurs dans map([j], k); BMOD: Recevoir U ki et L ik BMOD(i,j,k); Phase_Envoi();

34 Pivotage Statique Factorisation A=LU avec contrôle de lamplitude de la diagonale Si (|a ii |) < Alors a ii = Resoudre LUx = b Iterer:

35 Perspectives Interface externe Portabilité


Télécharger ppt "Exposé GT 24/10/2002 Dimitri Lecas. ScotchFaxBlendSopalin graphe sequentielparallele global local symbolique numerique noeud ddl permutationsymbolMatrix."

Présentations similaires


Annonces Google