On the design of parallel linear solvers for large scale problems

Size: px

Start display at page:

Download "On the design of parallel linear solvers for large scale problems"

Antony Wilkins
5 years ago
Views:

1 On the design of parallel linear solvers for large scale problems Journée problème de Poisson, IHP, Paris M. Faverge, P. Ramet M. Faverge Assistant Professor Bordeaux INP LaBRI Inria Bordeaux - Sud-Ouest January 26, 2015

2 Context Inria HiePACS team Objectives: Contribute to the design of effective tools for frontier simulations arising from challenging research and industrial multi-scale applications towards exascale computing M. Faverge - Journée problème de Poisson January 26,

3 1 Introduction

4 Introduction Guideline Introduction Dense linear algebra Sparse direct solver over runtimes: PaStiX On homogeneous shared memory nodes On heterogeneous shared memory nodes Hybrid direct/sparse solver: MaPHyS Conclusion M. Faverge - Journée problème de Poisson January 26,

5 Introduction What are the modern architectures? Today software developers face systems with: 1 TFlop/s of compute power per node 32 cores or more per nodes, sometimes 100+ hardware threads Highly heterogeneous architectures (cores + specialized cores + accelerators/co-processors) Deep memory hierarchies And also distributed Consequences of our programming paradigms are systemic noise, load imbalance, overheads (< 70% peak on DLA) M. Faverge - Journée problème de Poisson January 26,

6 Introduction How to harness these devices productively? Certainly not the way we did it so far We need to shift our focus on: Power (forget GHz think MW) Cost (forget FLOPS think data movement) Concurrency (not linear anymore) Memory Scaling (compute grows twice faster than memory bandwidth) Heterogeneity (it s not going away) Reliability (it is supposed to fail one day). M. Faverge - Journée problème de Poisson January 26,

7 Introduction A short history of computing paradigms M. Faverge - Journée problème de Poisson January 26,

8 Introduction A short history of computing paradigms M. Faverge - Journée problème de Poisson January 26,

9 Introduction A short history of computing paradigms M. Faverge - Journée problème de Poisson January 26,

10 Introduction A short history of computing paradigms M. Faverge - Journée problème de Poisson January 26,

11 Introduction A short history of computing paradigms M. Faverge - Journée problème de Poisson January 26,

Introduction Task-based programming Focus on concepts, data

for an impermeable portability layer Let the runtime deal

flexibility if possible StarSS, Swift, Parallax, Quark,

12 Introduction Task-based programming Focus on concepts, data dependencies and flows Don t develop for an architecture but for an impermeable portability layer Let the runtime deal with the hardware characteristics But provide some flexibility if possible StarSS, Swift, Parallax, Quark, XKaapi, StarPU, PaRSEC,... M. Faverge - Journée problème de Poisson January 26,

13 Introduction Task-based programming Workflows, bag-of-task, grid are similar concepts but at another level of granularity (we re talking tens of microseconds) Time constraint: Reduces the opportunity for complex dynamic scheduling strategies, but increases the probability to do the wrong thing Separation of concerns: each layer with it s own issues Humans focus on depicted the flow of data between tasks Compiler focus on tasks, problems that fit in one memory level And a runtime orchestrate the flows to maximize the throughput of the architecture M. Faverge - Journée problème de Poisson January 26,

14 2 Dense linear algebra

15 Dense linear algebra From sequential code to DAG Sequential code for QR factorization M. Faverge - Journée problème de Poisson January 26,

16 Dense linear algebra From sequential code to DAG Sequential C code Annotated through some specific syntax Insert Task INOUT, OUTPUT, INPUT REGION L, REGION U, REGION D,... LOCALITY M. Faverge - Journée problème de Poisson January 26,

17 Dense linear algebra From sequential code to DAG Automatic dataflow analysis M. Faverge - Journée problème de Poisson January 26,

18 Dense linear algebra From sequential code to DAG Automatic dataflow analysis M. Faverge - Journée problème de Poisson January 26,

19 Dense linear algebra Parameterized Task Graph VS Sequential Task Flow Advantages of PTG Local view of the DAG No need to unroll the full graph Full knowledge of Input/Output for each task Strong separation of concerns (Data/task distribution, algorithm) Advantages of STF Knowledge of the full graph for scheduling strategies Handle dynamic representation of the algorithm Submission process can be postponed to hang on data values (convergence criteria) More simple to implement than PTG M. Faverge - Journée problème de Poisson January 26,

20 Dense linear algebra QR factorization with Chameleon (StarPU) Heterogeneous shared memory node GPUs + 4 CPUs - Single 3 GPUs + 3 CPUs - Single 2 GPUs + 2 CPUs - Single 1 GPUs + 1 CPUs - Single 4 GPUs + 4 CPUs - Double 3 GPUs + 3 CPUs - Double 2 GPUs + 2 CPUs - Double 1 GPUs + 1 CPUs - Double Gflop/s Matrix order M. Faverge - Journée problème de Poisson January 26,

21 Dense linear algebra QR factorization with Chameleon (StarPU) Heterogeneous shared memory node GPUs + 16 CPUs - Single 4 GPUs + 4 CPUs - Single 3 GPUs + 3 CPUs - Single 2 GPUs + 2 CPUs - Single 1 GPUs + 1 CPUs - Single 4 GPUs + 16 CPUs - Double 4 GPUs + 4 CPUs - Double 3 GPUs + 3 CPUs - Double 2 GPUs + 2 CPUs - Double 1 GPUs + 1 CPUs - Double Gflop/s Matrix order GFlop/s but 12 cores = 150 GFlop/s M. Faverge - Journée problème de Poisson January 26,

22 Dense linear algebra QR factorization with DPLASMA (PaRSEC) Distributed homogeneous memory nodes (60 8 cores) Theoretical Peak: GFlop/s Theoretical Peak: GFlop/s Scalapack [BBD+10] [SLHD10] HQR Performance (GFlop/s) Performance (GFlop/s) Scalapack [BBD+10] [SLHD10] HQR N (M=67,200) M (N=4,480) M. Faverge - Journée problème de Poisson January 26,

23 Dense linear algebra Libraries for solving large dense linear systems Chameleon ( Inria HiePACS/Runtime StarPU Runtime STF programing model Smart/Complex scheduling DPLASMA ( ICL, University of Tennessee PaRSEC Runtime PTG model Simple scheduling based on data locality M. Faverge - Journée problème de Poisson January 26,

24 Dense linear algebra Libraries for solving large dense linear systems Chameleon ( Inria HiePACS/Runtime StarPU Runtime STF programing model Smart/Complex scheduling DPLASMA ( ICL, University of Tennessee PaRSEC Runtime PTG model Simple scheduling based on data locality What about irregular problems as sparse solvers? M. Faverge - Journée problème de Poisson January 26,

25 3 Sparse direct solver over runtimes: PaStiX

26 3.1 Sparse direct solver over runtimes: PaStiX On homogeneous shared memory nodes

27 Sparse direct solver over runtimes: PaStiX On homogeneous shared memory nodes Tasks structure POTRF TRSM SYRK GEMM (a) Dense tile task decomposition (b) Decomposition of the task applied while processing one panel M. Faverge - Journée problème de Poisson January 26,

28 Sparse direct solver over runtimes: PaStiX On homogeneous shared memory nodes A=>A gemm(3) gemm(4) gemm(6) panel(0) A=>A A=>A gemm(2) panel(1) A=>A panel(4) gemm(8) C=>A panel(2) A=>A A=>A gemm(12) A=>A gemm(1) gemm(10) panel(3) A=>A gemm(15) A=>A panel(5) gemm(14) A=>A C=>A panel(6) A=>A gemm(17) gemm(25) gemm(31) gemm(36) A=>A A=>A gemm(22) gemm(37) A=>A A=>A gemm(27) A=>A gemm(38) A=>A A=>A gemm(21) panel(7) A=>A gemm(19) gemm(20) C=>A panel(8) A=>A gemm(28) panel(9) A=>A gemm(40) C=>A panel(11) C=>A A=>A gemm(35) panel(10) A=>A C=>A A=>A A=>A A=>A gemm(34) A=>A A=>A A=>A gemm(24) gemm(29) gemm(30) gemm(33) A=>A gemm(23) DAG representation POTRF T=>T T=>T T=>T TRSM T=>T C=>A TRSM C=>A TRSM C=>A SYRK C=>A TRSM C=>A C=>B C=>B C=>A C=>A C=>B C=>B T=>T C=>A C=>A C=>B C=>B C=>A GEMM GEMM GEMM POTRF GEMM GEMM GEMM SYRK SYRK T=>T T=>T T=>T SYRK T=>T TRSM T=>T TRSM TRSM T=>T C=>A C=>B C=>A C=>B C=>A C=>A C=>A C=>B C=>A SYRK GEMM SYRK GEMM GEMM SYRK T=>T POTRF T=>T T=>T T=>T T=>T TRSM TRSM C=>A C=>B C=>A C=>A SYRK GEMM SYRK T=>T POTRF T=>T T=>T TRSM C=>A SYRK T=>T POTRF (c) Dense DAG (d) Sparse DAG representation of a sparse LDL T factorization M. Faverge - Journée problème de Poisson January 26,

29 Sparse direct solver over runtimes: PaStiX On homogeneous shared memory nodes Supernodal sequential algorithm forall the Supernode S 1 do panel (S 1 ); /* update of the panel */ forall the extra diagonal block B i of S 1 do S 2 supernode in front of (B i ); gemm (S 1,S 2 ); /* sparse GEMM B k,k i Bi T substracted from S 2 */ end end M. Faverge - Journée problème de Poisson January 26,

30 Sparse direct solver over runtimes: PaStiX On homogeneous shared memory nodes StarPU Tasks submission forall the Supernode S 1 do submit panel (S 1 ); /* update of the panel */ forall the extra diagonal block B i of S 1 do S 2 supernode in front of (B i ); submit gemm (S 1,S 2 ); /* sparse GEMM B k,k i B T i subtracted from S 2 */ end end wait for all tasks (); M. Faverge - Journée problème de Poisson January 26,

31 Sparse direct solver over runtimes: PaStiX On homogeneous shared memory nodes PaRSEC s parameterized task graph panel(0) A=>A A=>A A=>A gemm(3) A=>A gemm(1) gemm(4) gemm(2) C=>A panel(1) A=>A Task Graph 1 p a n e l ( j ) 2 3 / E x e c u t i o n Space / 4 j = 0.. cblknbr / Task L o c a l i t y ( Owner Compute ) / 7 : A( j ) 8 9 / Data d e p e n d e n c i e s / 10 RW A < ( l e a f )? A( j ) : C gemm( l a s t b r o w ) 11 > A gemm( f i r s t b l o c k +1.. l a s t b l o c k ) 12 > A( j ) Panel Factorization in JDF Format gemm(6) panel(2) A=>A gemm(8) panel(3) A=>A M. panel(4) Faverge - Journée gemm(10) problème de panel(5) Poisson panel(7) January 26,

32 Sparse direct solver over runtimes: PaStiX On homogeneous shared memory nodes Matrices and Machines Matrix Prec Method Size nnz A nnz L TFlop FilterV2 Z LU 0.6e+6 12e+6 536e Flan D LL T 1.6e+6 59e e Audi D LL T 0.9e+6 39e e MHD D LU 0.5e+6 24e e Geo1438 D LL T 1.4e+6 32e e+6 23 Pmldf Z LDL T 1.0e+6 8e e+6 28 Hook D LU 1.5e+6 31e e+6 35 Serena D LDL T 1.4e+6 32e e+6 47 Table: Matrix description (Z: double complex, D: double). Machine Processors Frequency GPUs RAM Mirage Westmere Intel Xeon X5650 (2 6) 2.67 GHz Tesla M2070 ( 3) 36 GB M. Faverge - Journée problème de Poisson January 26,

33 Sparse direct solver over runtimes: PaStiX On homogeneous shared memory nodes CPU scaling study: GFlop/s during numerical factorization native StarPU PaRSEC 1 core 1 core 1 core 3 cores 3 cores 3 cores 6 cores 6 cores 6 cores 9 cores 9 cores 9 cores 12 cores 12 cores 12 cores Performance (GFlop/s) FilterV2(Z, LU) Flan(D, LL T ) audi(d, LL T ) MHD(D, LU) Geo1438(D, LL T ) pmldf(z, LDL T ) HOOK(D, LU) Serena(D, LDL T ) M. Faverge - Journée problème de Poisson January 26,

34 Sparse direct solver over runtimes: PaStiX On homogeneous shared memory nodes CPU scaling study: GFlop/s during numerical factorization native StarPU PaRSEC 1 core 1 core 1 core 3 cores 3 cores 3 cores 6 cores 6 cores 6 cores 9 cores 9 cores 9 cores 12 cores 12 cores 12 cores Performance (GFlop/s) FilterV2(Z, LU) Flan(D, LL T ) audi(d, LL T ) MHD(D, LU) Geo1438(D, LL T ) pmldf(z, LDL T ) HOOK(D, LU) Serena(D, LDL T ) M. Faverge - Journée problème de Poisson January 26,

35 Sparse direct solver over runtimes: PaStiX On homogeneous shared memory nodes CPU scaling study: GFlop/s during numerical factorization native StarPU PaRSEC 1 core 1 core 1 core 3 cores 3 cores 3 cores 6 cores 6 cores 6 cores 9 cores 9 cores 9 cores 12 cores 12 cores 12 cores Performance (GFlop/s) FilterV2(Z, LU) Flan(D, LL T ) audi(d, LL T ) MHD(D, LU) Geo1438(D, LL T ) pmldf(z, LDL T ) HOOK(D, LU) Serena(D, LDL T ) M. Faverge - Journée problème de Poisson January 26,

36 Sparse direct solver over runtimes: PaStiX On homogeneous shared memory nodes CPU scaling study: GFlop/s during numerical factorization native StarPU PaRSEC 1 core 1 core 1 core 3 cores 3 cores 3 cores 6 cores 6 cores 6 cores 9 cores 9 cores 9 cores 12 cores 12 cores 12 cores Performance (GFlop/s) FilterV2(Z, LU) Flan(D, LL T ) audi(d, LL T ) MHD(D, LU) Geo1438(D, LL T ) pmldf(z, LDL T ) HOOK(D, LU) Serena(D, LDL T ) M. Faverge - Journée problème de Poisson January 26,

37 Sparse direct solver over runtimes: PaStiX On homogeneous shared memory nodes CPU scaling study: GFlop/s during numerical factorization native StarPU PaRSEC 1 core 1 core 1 core 3 cores 3 cores 3 cores 6 cores 6 cores 6 cores 9 cores 9 cores 9 cores 12 cores 12 cores 12 cores Performance (GFlop/s) FilterV2(Z, LU) Flan(D, LL T ) audi(d, LL T ) MHD(D, LU) Geo1438(D, LL T ) pmldf(z, LDL T ) HOOK(D, LU) Serena(D, LDL T ) M. Faverge - Journée problème de Poisson January 26,

38 3.2 Sparse direct solver over runtimes: PaStiX On heterogeneous shared memory nodes

39 Sparse direct solver over runtimes: PaStiX On heterogeneous shared memory nodes Why using GPUs on sparse problems? P 1 P 2 Compacted in memory P 1 P 2 updates are compute intensive small updates non continuous data rectangular shape M. Faverge - Journée problème de Poisson January 26,

40 Sparse direct solver over runtimes: PaStiX On heterogeneous shared memory nodes GPU kernel performance GFlop/s cublas peak cublas - 1 stream ASTRA - 1 stream Sparse - 1 stream Matrix size M (N=K=128) Figure: Performance comparison on the DGEMM kernel for three implementations: cublas library, ASTRA framework, and the sparse adaptation of the ASTRA framework. M. Faverge - Journée problème de Poisson January 26,

41 Sparse direct solver over runtimes: PaStiX On heterogeneous shared memory nodes GPU kernel performance - 2 Streams GFlop/s cublas peak cublas - 1 stream cublas - 2 streams ASTRA - 1 stream ASTRA - 2 streams Sparse - 1 stream Sparse - 2 streams Matrix size M (N=K=128) Figure: Performance comparison on the DGEMM kernel for three implementations: cublas library, ASTRA framework, and the sparse adaptation of the ASTRA framework. M. Faverge - Journée problème de Poisson January 26,

42 Sparse direct solver over runtimes: PaStiX On heterogeneous shared memory nodes GPU kernel performance - 3 Streams GFlop/s cublas peak cublas - 1 stream cublas - 2 streams cublas - 3 streams ASTRA - 1 stream ASTRA - 2 streams ASTRA - 3 streams Sparse - 1 stream Sparse - 2 streams Sparse - 3 streams Matrix size M (N=K=128) Figure: Performance comparison on the DGEMM kernel for three implementations: cublas library, ASTRA framework, and the sparse adaptation of the ASTRA framework. M. Faverge - Journée problème de Poisson January 26,

43 Sparse direct solver over runtimes: PaStiX On heterogeneous shared memory nodes GPU scaling study : GFlop/s for numerical factorization 250 Native: CPU only StarPU: CPU only 1 GPU 2 GPU 3 GPU PaRSEC 1 stream: CPU only 1 GPU 2 GPU 3 GPU PaRSEC 3 streams: 1 GPU 2 GPU 3 GPU 200 Performance (GFlop/s) FilterV2(Z, LU) Flan(D, LL T ) audi(d, LL T ) MHD(D, LU) Geo1438(D, LL T ) pmldf(z, LDL T ) HOOK(D, LU) Serena(D, LDL T ) M. Faverge - Journée problème de Poisson January 26,

44 Sparse direct solver over runtimes: PaStiX On heterogeneous shared memory nodes GPU scaling study : GFlop/s for numerical factorization 250 Native: CPU only StarPU: CPU only 1 GPU 2 GPU 3 GPU PaRSEC 1 stream: CPU only 1 GPU 2 GPU 3 GPU PaRSEC 3 streams: 1 GPU 2 GPU 3 GPU 200 Performance (GFlop/s) FilterV2(Z, LU) Flan(D, LL T ) audi(d, LL T ) MHD(D, LU) Geo1438(D, LL T ) pmldf(z, LDL T ) HOOK(D, LU) Serena(D, LDL T ) M. Faverge - Journée problème de Poisson January 26,

45 Sparse direct solver over runtimes: PaStiX On heterogeneous shared memory nodes GPU scaling study : GFlop/s for numerical factorization 250 Native: CPU only StarPU: CPU only 1 GPU 2 GPU 3 GPU PaRSEC 1 stream: CPU only 1 GPU 2 GPU 3 GPU PaRSEC 3 streams: 1 GPU 2 GPU 3 GPU 200 Performance (GFlop/s) FilterV2(Z, LU) Flan(D, LL T ) audi(d, LL T ) MHD(D, LU) Geo1438(D, LL T ) pmldf(z, LDL T ) HOOK(D, LU) Serena(D, LDL T ) M. Faverge - Journée problème de Poisson January 26,

46 Sparse direct solver over runtimes: PaStiX On heterogeneous shared memory nodes GPU scaling study : GFlop/s for numerical factorization 250 Native: CPU only StarPU: CPU only 1 GPU 2 GPU 3 GPU PaRSEC 1 stream: CPU only 1 GPU 2 GPU 3 GPU PaRSEC 3 streams: 1 GPU 2 GPU 3 GPU 200 Performance (GFlop/s) FilterV2(Z, LU) Flan(D, LL T ) audi(d, LL T ) MHD(D, LU) Geo1438(D, LL T ) pmldf(z, LDL T ) HOOK(D, LU) Serena(D, LDL T ) M. Faverge - Journée problème de Poisson January 26,

47 Sparse direct solver over runtimes: PaStiX On heterogeneous shared memory nodes GPU scaling study : GFlop/s for numerical factorization 250 Native: CPU only StarPU: CPU only 1 GPU 2 GPU 3 GPU PaRSEC 1 stream: CPU only 1 GPU 2 GPU 3 GPU PaRSEC 3 streams: 1 GPU 2 GPU 3 GPU 200 Performance (GFlop/s) FilterV2(Z, LU) Flan(D, LL T ) audi(d, LL T ) MHD(D, LU) Geo1438(D, LL T ) pmldf(z, LDL T ) HOOK(D, LU) Serena(D, LDL T ) M. Faverge - Journée problème de Poisson January 26,

48 4 Hybrid direct/sparse solver: MaPHyS

49 Hybrid direct/sparse solver: MaPHyS Sparse linear solvers Goal: solving Ax = b, where A is sparse Usual trades off Direct Robust/accurate for general problems BLAS-3 based implementations Memory/CPU prohibitive for large 3D problems Limited weak scalability Iterative Problem dependent efficiency / accuracy Sparse computational kernels Less memory requirements and possibly faster Possible high weak scalability M. Faverge - Journée problème de Poisson January 26,

50 Hybrid direct/sparse solver: MaPHyS Sparse linear solvers Goal: solving Ax = b, where A is sparse Usual trades off Direct Robust/accurate for general problems BLAS-3 based implementations Memory/CPU prohibitive for large 3D problems Limited weak scalability Iterative Problem dependent efficiency / accuracy Sparse computational kernels Less memory requirements and possibly faster Possible high weak scalability M. Faverge - Journée problème de Poisson January 26,

51 Hybrid direct/sparse solver: MaPHyS Sparse linear solvers Goal: solving Ax = b, where A is sparse Usual trades off Direct Robust/accurate for general problems BLAS-3 based implementations Memory/CPU prohibitive for large 3D problems Limited weak scalability Iterative Problem dependent efficiency / accuracy Sparse computational kernels Less memory requirements and possibly faster Possible high weak scalability M. Faverge - Journée problème de Poisson January 26,

52 Hybrid direct/sparse solver: MaPHyS Sparse linear solvers Goal: solving Ax = b, where A is sparse Usual trades off Direct Robust/accurate for general problems BLAS-3 based implementations Memory/CPU prohibitive for large 3D problems Limited weak scalability Iterative Problem dependent efficiency / accuracy Sparse computational kernels Less memory requirements and possibly faster Possible high weak scalability M. Faverge - Journée problème de Poisson January 26,

53 Hybrid direct/sparse solver: MaPHyS Sparse linear solvers Goal: solving Ax = b, where A is sparse Usual trades off Direct Robust/accurate for general problems BLAS-3 based implementations Memory/CPU prohibitive for large 3D problems Limited weak scalability Iterative Problem dependent efficiency / accuracy Sparse computational kernels Less memory requirements and possibly faster Possible high weak scalability M. Faverge - Journée problème de Poisson January 26,

54 Hybrid direct/sparse solver: MaPHyS Sparse linear solvers Goal: solving Ax = b, where A is sparse Usual trades off Direct Robust/accurate for general problems BLAS-3 based implementations Memory/CPU prohibitive for large 3D problems Limited weak scalability Iterative Problem dependent efficiency / accuracy Sparse computational kernels Less memory requirements and possibly faster Possible high weak scalability M. Faverge - Journée problème de Poisson January 26,

Hybrid direct/sparse solver: MaPHyS Hybrid Linear Solvers Develop robust scalable parallel hybrid direct/iterative linear solvers Exploit the efficiency and robustness of the sparse direct solvers

55 Hybrid direct/sparse solver: MaPHyS Hybrid Linear Solvers Develop robust scalable parallel hybrid direct/iterative linear solvers Exploit the efficiency and robustness of the sparse direct solvers Develop robust parallel preconditioners for iterative solvers Take advantage of the natural scalable parallel implementation of iterative solvers Domain Decomposition (DD) Natural approach for PDE s Extend to general sparse matrices Partition the problem into subdomains, subgraphs Use a direct solver on the subdomains Robust preconditioned iterative solver M. Faverge - Journée problème de Poisson January 26,

56 Hybrid direct/sparse solver: MaPHyS Preconditioning methods MaPHyS Global algebraic view Global hybrid decomposition: ( ) AII A A = IΓ A ΓI A ΓΓ Ω 1 Ω 2 Ω 3 Ω 4 88 cut edges Γ 0 Global Schur complement: 50 Ω Ω 2 S = A ΓΓ A ΓI A 1 II A IΓ 250 Ω Ω nz = 1920 Γ M. Faverge - Journée problème de Poisson January 26,

57 Hybrid direct/sparse solver: MaPHyS Preconditioning methods MaPHyS Local algebraic view Local hybrid decomposition: ( ) A (i) AIi I = i A Ii Γ i A Γi I i Local Schur Complement: A (i) ΓΓ Ω 1 Ω 2 Ω 3 Ω 4 88 cut edges Γ S (i) = A (i) ΓΓ A Γ i I i A 1 I i I i A Ii Γ i Algebraic Additive Schwarz Preconditioner 0 50 Ω Ω 2 Ω 3 M = N R T Γ i ( S (i) ) 1 R Γi i=1 Ω nz = 1920 Γ M. Faverge - Journée problème de Poisson January 26,

58 Hybrid direct/sparse solver: MaPHyS Preconditioning methods Parallel implementation Each subdomain A (i) is handled by one CPU core ( ) A (i) AIi I i A Ii Γ i A Ii Γ i A (i) ΓΓ Concurrent partial factorizations are performed on each CPU core to form the so called local Schur complement S (i) = A (i) ΓΓ A Γ i I i A 1 I i I i A Ii Γ i The reduced system Sx Γ = f is solved using a distributed Krylov solver - One matrix vector product per iteration each CPU core computes S (i) (x (i) Γ )k = (y (i) ) k - One local preconditioner apply (M (i) )(z (i) ) k = (r (i) ) k - Local neighbor-neighbor communication per iteration - Global reduction (dot products) Compute simultaneously the solution for the interior unknowns A Ii I i x Ii = b Ii A Ii Γ i x Γi M. Faverge - Journée problème de Poisson January 26,

59 Hybrid direct/sparse solver: MaPHyS Software Modular implementation Sequential partitioners Scotch [Pellegrini et al.] Metis [G. Karypis and V. Kumar] Sparse direct solvers - one-level parallelism Mumps [P. Amestoy et al.] (with Schur option) PaStiX [P. Ramet et al.] (with Schur option) Iterative Solvers Cg/Gmres/FGmres [V.Fraysse and L.Giraud] M. Faverge - Journée problème de Poisson January 26,

60 Hybrid direct/sparse solver: MaPHyS Software Modular implementation and bottlenecks Sequential partitioners Scotch [Pellegrini et al.] Metis [G. Karypis and V. Kumar] Sparse direct solvers - one-level parallelism Mumps [P. Amestoy et al.] (with Schur option) PaStiX [P. Ramet et al.] (with Schur option) Iterative Solvers Cg/Gmres/FGmres [V.Fraysse and L.Giraud] M. Faverge - Journée problème de Poisson January 26,

61 Hybrid direct/sparse solver: MaPHyS Software Modular implementation and bottlenecks Sequential partitioners Scotch [Pellegrini et al.] Metis [G. Karypis and V. Kumar] Sparse direct solvers - one-level parallelism Mumps [P. Amestoy et al.] (with Schur option) PaStiX [P. Ramet et al.] (with Schur option) Iterative Solvers Cg/Gmres/FGmres [V.Fraysse and L.Giraud] M. Faverge - Journée problème de Poisson January 26,

62 Hybrid direct/sparse solver: MaPHyS Software Modular implementation and bottlenecks Sequential partitioners Scotch [Pellegrini et al.] Metis [G. Karypis and V. Kumar] Sparse direct solvers - one-level parallelism Mumps [P. Amestoy et al.] (with Schur option) PaStiX [P. Ramet et al.] (with Schur option) Iterative Solvers Cg/Gmres/FGmres [V.Fraysse and L.Giraud] M. Faverge - Journée problème de Poisson January 26,

63 Hybrid direct/sparse solver: MaPHyS Software MPI-thread on with Nachos4M - Time 3 t/p 6 t/p 12 t/p 24 t/p time (s) #cores M. Faverge - Journée problème de Poisson January 26,

64 Hybrid direct/sparse solver: MaPHyS Software MPI-thread on with Nachos4M - Memory Memroy_peak(MB) t/p 6 t/p 12 t/p 24 t/p #cores M. Faverge - Journée problème de Poisson January 26,

65 5 Conclusion

66 Conclusion Sparse direct solver: PaStiX Main Features LLt, LDLt, LU : supernodal implementation (BLAS3) Static pivoting + Refinement: CG/GMRES/BiCGstab Column-block or Block mapping Simple/Double precision + Real/Complex arithmetic Support external ordering libraries ((PT-)Scotch or METIS...) MPI/Threads (Cluster/Multicore/SMP/NUMA) Multiple GPUs using DAG runtimes X. Lacoste PhD defense on Februar 18th, 2015 Multiple RHS (direct factorization) Incomplete factorization with ILU(k) preconditionner Schur complement computation C++/Fortran/Python/PETSc/Trilinos/FreeFem/... M. Faverge - Journée problème de Poisson January 26,

67 Conclusion Sparse direct solver: PaStiX What next? Exploiting DAG runtimes: distributed memory architectures other accelerators: Intel Xeon Phi Ordering methods for the supernodes: Reduce the number of extra diagonal blocks H-matrix arithmetic (A. Buttari s talk): In collaboration with Univ. of Stanford M. Faverge - Journée problème de Poisson January 26,

68 Conclusion Sparse hybrid solver: MaPHyS Current status and future Sequential version: Original MaPhyS version Multi-threaded implementation Integrated during S. Nakov PhD Hybrid MPI / Multi-threaded implementation Is it worth it? Task-flow programming model L. Poirel PhD started in October 2014 Non blocking algorithms (W. Vanroose s talk) Exploiting H matrix for the Shur complement M. Faverge - Journée problème de Poisson January 26,

Conclusion Softwares Graph/Mesh partitioner and ordering : Sparse linear system solvers : http://scotch.gforge.inria.

69 Conclusion Softwares Graph/Mesh partitioner and ordering : Sparse linear system solvers : MaPHyS M. Faverge - Journée problème de Poisson January 26,

70 Conclusion Softwares Chameleon: DPlasma: M. Faverge - Journée problème de Poisson January 26,

71 Thanks!

On the design of parallel linear solvers for large scale problems

On the design of parallel linear solvers for large scale problems ICIAM - August 2015 - Mini-Symposium on Recent advances in matrix computations for extreme-scale computers M. Faverge, X. Lacoste, G. Pichon,