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.

Présentations similaires


Présentation au sujet: "Exposé GT 24/10/2002 Dimitri Lecas."— Transcription de la présentation:

1 Exposé GT 24/10/2002 Dimitri Lecas

2

3 Scotch Fax Blend Sopalin solverMatrix distribuée et factorisée
graphe permutation symbolMatrix Scotch Fax Blend Sopalin solution distribuée element noeud ddl sequentiel parallele global local symbolique numerique

4 Fax

5 Factorisation Symbolique

6 Blend

7 Scotch Fax Blend Sopalin solverMatrix distribuée et factorisée
graphe permutation symbolMatrix Scotch Fax Blend Sopalin solution distribuée element noeud ddl sequentiel parallele global local symbolique numerique

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. Dans la phase de partitionnement et de distribution des blocs, on utilise l’arbre d’elimination par blocs pour montrer les 3 niveaux de parallelisme…

9 Arbre d’élimination par blocs

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

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

12 Repartitionnement de la matrice
Modélisation coûts calcul et comm Nombre de processeurs Matrice symbolique par blocs Repartitionnement de la matrice Graphe de tâches Distribution et ordonnancement Limitation mémoire Schéma de communication Données locales Ordonnancement tâches Calcul d’un schéma I/O pour l’OOC Factorisation et résolution // OOC 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 2D block distribution 1D block distribution

14 Repartionnement et processeurs candidats
5 1 2 3 4 5 6 7 8 4 1 2 2 3 8 6 7 This example will show you how works the partitionning method. So this is a block elimination tree that represents precedence constraints in computation of the factorization algorithm. We begin at the root of the elimination tree with the entire set of processors the root is then splitted using the critized block size for BLAS3, and each resumlting column block has this set of processors as set of candidate processors. Then the set of processors is divided between subtrees proportionnaly to their workload. It is important to notice that since a candidate is just a suggestion for the mapping and scheduling phase, we avoid any problem of rounding to integral numbers of processor by allowing a processor, like the processor 5 in our exemple to be in two sets of candidate processors for two subtrees having the same father. The mapping and scheduling step will determine if it ’s better to use it or not. Then recursively the set of processor is divided proportionnaly to the workload of subtrees until the set is a single element. 2 3 1 6 7

15 Sopalin

16 Scotch Fax Blend Sopalin solverMatrix distribuée et factorisée
graphe permutation symbolMatrix Scotch Fax Blend Sopalin solution distribuée element noeud ddl sequentiel parallele global local symbolique numerique

17 L’algorithme de factorisation parallèle
A est Symétrique Définie Positive  factorisation sans pivotage Algorithme supernodal de factorisation parallèle creuse L.Lt / L.D.Lt avec agrégation locale complète et distribution mixte 1D/2D. Suivant la nature de la matrice, on distingue plusieurs types de factorisation : cholesky (LLt), Chloesky crout (LDLt) pour les matrices symetriques definies positives, avec ou sans pivotage numerique. Notre travail s inscrit dans le cadre de machines paralleles homogenes et sans pivotage numerique. Notre strategie d ‘aggregation locale complete des contributions, ce qui va permettrre de diminuer fortement les communications …. Travail de Pierre Ramet en collaboration avec Pascal Henon et Jean Roman.

18 BStruct(Lk*) BStruct(L*k)
This is some structures we need to explain before talking about the parallel factorization algorithm. First this is the Aggregate Update Column Block that will be denoted by AUCB of k. This structure is the overlapped column block of each contributions on a given processor for column block K. And we call BSTRUCT(Lk*) the set of column blocks that have contribution to column block k In the same manner we call Bstruct(L*k) the set of colum block that wait for conbtributions from column block k

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

20 Algorithme de la factorisation //
FACTOR(k): factoriser le bloc diagonal k Factoriser Akk en LkkLtkk; BDIV(j,k): mis-à-jour Ljk Résoudre LkkLjkt = Atjk; BMOD(i,j,k): calculer la contribution de Lik pour le bloc Lij Calculer Cj=LikLjkt; Si map(i,j) == p Alors Aij = Aij – Cj; Sinon AUBij=AUBij + Cj; k j Ljk Lik Lij

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 Akk en LkkLtkk; Résoudre LkkLt* = At*k ; Pour j  BCol(k) Faire Calculer C[j]=L[j]kLjkt; 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 à NTp Faire Selon (le type de Kp[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 AUBkk dans Akk; FACTOR(k); envoyer Lkk à tous les processeurs dans map([k], k); BDIV: Recevoir Lkk et recevoir et ajouter les AUBij pour Ajk; BDIV(j,k); envoyer Fjt à tous les processeurs dans map([j], k); BMOD: Recevoir Ljkt BMOD(i,j,k);

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; Structure de données

25 Structure de données #define COMP_1D 0 #define DIAG 1 #define E1 2
#define DRUNK 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 Transposition Lkk Ukk U*k Lkk kkU Lk* Lk* k*U

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; Structure de données

31 Algorithme de la factorisation //
FACTOR(k): factoriser le bloc diagonal k Factoriser Akk en LkkUkk; BDIV(j,k): mis-à-jour Ljk et Uik Résoudre LkkUki = Aki; Résoudre Ukk Lik = Aik; BMOD(i,j,k): calculer la contribution de Lik pour le bloc Lij Calculer Cj=LikUkj; Calculer Dj=LjkUki; Si map(i,j) == p Alors Aij = Aij – Cj; Aji = Aji – Dj; Sinon AUBij=AUBij + Cj; AUBji=AUBji + Dj; Ukj k j Ljk Lik Lij

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 Akk en LkkUkk; Résoudre LkkUk* = Ak* ; Résoudre L*kUkk = A*k ; Pour j  BCol(k) Faire Calculer C[j]=L[j]kUkj; Calculer D[j]=LjkUk[j]; Si map([j],j) == p Alors A[j]j = A[j]j – C[j]; Aj[j]=Aj[j]-D[j]; Sinon AUB[j]j=AUB[j]j + C[j]; AUBj[j]=AUBj[j] + D[j];

33 Pour n = 1 à NTp Faire Selon (le type de Kp[n]) Faire COMP1D: Recevoir et ajouter tous les AUB[k]k dans A[k]k; Recevoir et ajouter tous les AUBk[k] dans Ak[k]; COMP1D(k); Phase_Envoi(); FACTOR: Recevoir et ajouter tous les AUBkk dans Akk; FACTOR(k); envoyer Lkk et Ukk à tous les processeurs dans map([k], k); BDIV: Recevoir Lkk et Ukk et recevoir et ajouter les AUBij pour Ajk et Aki; BDIV(j,k); envoyer Fjt à tous les processeurs dans map([j], k); BMOD: Recevoir Uki et Lik BMOD(i,j,k);

34 Pivotage Statique Factorisation A=LU avec contrôle de l’amplitude de la diagonale Si (|aii|) < Alors aii = Resoudre LUx = b Iterer:

35 Perspectives Interface externe Portabilité


Télécharger ppt "Exposé GT 24/10/2002 Dimitri Lecas."

Présentations similaires


Annonces Google