Exposé GT 24/10/2002

Exposé GT 24/10/2002 Dimitri Lecas

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

Fax

Factorisation Symbolique

Blend

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.

Arbre d’élimination par blocs

Modélisation coûts calcul et comm Nombre de processeurs Matrice symboliquepar 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 //

Modélisation coûts calcul et comm Nombre de processeurs Matrice symboliquepar 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 //

Modélisation coûts calcul et comm Nombre de processeurs Matrice symboliquepar 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

2D block distribution 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

56 7 8 1 2 3 45 6 7 8 1 2 3 4 5 5 12 6 7 23 4 4 8 2 6 7 7 1 2 3 Repartionnement et processeurs candidats 1 2 3 4 5 6 7 8

Sopalin

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.Ltavec agrégation locale complète et distribution mixte 1D/2D.

BStruct(Lk*) BStruct(L*k)

Modélisation coûts calcul et comm Nombre de processeurs Matrice symboliquepar 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 //

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 LijCalculer Cj=LikLjkt; Si map(i,j) == p Alors Aij = Aij – Cj; Sinon AUBij=AUBij + Cj; k j Ljk Lik Lij

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

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

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;

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

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;

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;

Factorisation LU

Stockage de la partie U Transposition Lkk Ukk U*k Lkk kkU Lk* Lk* k*U

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

Algorithme de la factorisation // FACTOR(k):factoriser le bloc diagonal k Factoriser Akk en LkkUkk; BDIV(j,k):mis-à-jour Ljket Uik Résoudre LkkUki = Aki; Résoudre Ukk Lik = Aik; BMOD(i,j,k):calculer la contribution de Lik pour le bloc LijCalculer 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

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

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

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

Perspectives • Interface externe • Portabilité

Exposé GT 24/10/2002