An Integrative Model for Parallelism

Transcription

1 An Integrative Model for Parallelism Victor Eijkhout ICERM workshop 2012/01/09

2 Introduction Formal part Examples Extension to other memory models Conclusion tw-12-exascale 2012/01/09 2

3 Introduction tw-12-exascale 2012/01/09 3

4 Practical starting point Data movement is very important: need to model this I m starting with distributed memory. We understand parallelism through MPI (running at 300,000 cores); the problem is one of programmability. Goal To find a high level way of parallel programming, that can be compiled down to what I would have written in MPI high productivity because working in global terms portable performance since the MPI code is derived Pie in the sky Apart from distributed memory, we would like to cover task parallelism, multicore, accelerators tw-12-exascale 2012/01/09 4

5 My claim It is possible to have a global model of parallelism where MPI-type parallelism can be derived through formal reasoning about global objects. The model is versatile in dealing with applications and memory models beyond linear algebra on clusters. Prospects for a high productivity high performance way of parallel programming. No silver bullet: algorithm designer still needs to design data and work distributions. tw-12-exascale 2012/01/09 5

6 Claim in CS terms Given distributions on input, output, instructions: a communication pattern becomes a formally derived first-class object; communication is an instantiation of this object Consequences: communication is properly aggregated data can be sent (asynchronously) when available inspector-executor model where the pattern is derived once, then applied many times. tw-12-exascale 2012/01/09 6

7 Working title: I/MP: Integrative Model for Parallelism tw-12-exascale 2012/01/09 7

8 Formal part tw-12-exascale 2012/01/09 8

9 Theoretical model Computation is bipartite graph from input to output, edges are instructions Edge: A = In, Out, E (α, β) E : α In, β Out is elementary computation between data elements. This models a kernel, (not a whole code), possibly even less: compare supersteps in BSP tw-12-exascale 2012/01/09 9

10 Parallel computation: where A = A 1,..., A P, A p = In p, Out p, E p, In = p In p, Out = p Out p, E = p E p ; Possibly non-disjoint partitions (redundant work) Example. If all In p, Out p identical: shared memory Note explicit distribution of work, independently of data tw-12-exascale 2012/01/09 10

11 Where does communication come from? Define total input/output of a processor: In(E p ) = {α: (α, β) E p }, Out(E p ) = {β : (α, β) E p }. Not the same as In p, Out p! In p In(E p) Out p Out(E p) local part of input total needed input local part of output total computed output Communication: In(E p ) In p is communicated in before computation Communication: Out(E p ) Out p is communicated out after computation Example. Owner computes: Out(E p ) = Out p Example. Embarrassingly parallel: In(E p ) = In p, Out(E p ) = Out p, and everything disjoint By defining the distributions, communication becomes formally derivable tw-12-exascale 2012/01/09 11

12 Object view of communication Analyze all computation edges in terms of p, q source/target processors The sum over all p, q of these is an object describing the total communication in a kernel Compare to a PETSc VecScatter object: describe what goes where, not how. Compare to active messages: communication and computation in one. Communication objects are derivable from the algorithm, they are not defined during the execution of the communication; inspector/executor paradigm tw-12-exascale 2012/01/09 12

13 Examples tw-12-exascale 2012/01/09 13

14 What am I going to show you? The algorithm is mathematics Data distributions are easy to design The communication is derived through formal reasoning Some distributions lead to efficient communication, some don t: we still need a smart programmer. Today I m only showing your math, but I think it s implementable tw-12-exascale 2012/01/09 14

15 Example: Matrix-vector product In p local part of input In(E p) total needed input Out p local part of output Out(E p) total computed output i : y i = j a ij x j. Split computation in temporaries and reduction: i : y i = j a ijx j = j t ij, t ij = a ij x j. Work distribution: t ij is computed where a ij lives We will derive communication for row/col-distributed matrix tw-12-exascale 2012/01/09 15

16 MVP by rows Data: In p = x(i p ) In p In(E p) Out p Out(E p) local part of input total needed input local part of output total computed output work: { E p = {τ ij : i I p }, τ ij := t ij a ij x j derived fact: In(E p ) = x( ) allgather tw-12-exascale 2012/01/09 16

17 MVP by rows Data: In p = t(i p, ) work: { E p = {η i : i I p } η i := y i j t ij derived fact: In p In(E p) Out p Out(E p) In(E p ) = t(i p, ) local operation local part of input total needed input local part of output total computed output tw-12-exascale 2012/01/09 17

18 MVP by columns t ij calculation: In p In(E p) Out p Out(E p) local part of input total needed input local part of output total computed output local In(E p ) = x(i p ), In p = x(i p ) Out(E p ) = t(, I p ) tw-12-exascale 2012/01/09 18

19 MVP by columns reduction: In p In(E p) Out p Out(E p) local part of input total needed input local part of output total computed output In(E p ) = t(i p, ) but now derived: In p = t(, I p ) global transpose or reduce-scatter tw-12-exascale 2012/01/09 19

20 Sparse MVP A little more notation, but no essential difference tw-12-exascale 2012/01/09 20

21 LU solution Derivation of messages is identical, now no longer data parallel communication. VecPipeline instead of VecScatter, dataflow Note: IMP kernels do not imply synchronization: dataflow, supply driven execution Example: one IMP kernel per level in an FFT butterfly operations execute based on availability of data (a bit like DAG scheduling but not entirely) tw-12-exascale 2012/01/09 21

22 Complicated example: n-body problems Tree computation framework according to Katzenelson 1989: The field due to cell i on level l is given by g(l, i) = g(l + 1, j) j C(i) where C(i) denotes the set of children of cell i The field felt by cell i on level l is given by f (l, i) = f (l 1, p(i)) + g(l, j) j I l (i) p(i): the parent cell of i; I l (i): interaction region of i tw-12-exascale 2012/01/09 22

23 Implementation E (g) = E τ E γ, { i j C(i) : i : E τ = {τ l ij}, E γ = {γ l i } τij l = tl ij = g l+1 j γi l = gi l = j C(i) tij l E (f ) = E ρ E σ E φ, E ρ = {ρ l i }, E σ = {σij}, l E φ = {φ l i } i : ρ l i = ri l = f l 1 p(i) i j Il (i) : σij l = sl ij = g j l i : φ l i = fi l = ri l + j I l (i) sl ij tw-12-exascale 2012/01/09 23

24 Extension to other memory models tw-12-exascale 2012/01/09 24

25 Attached accelerators tw-12-exascale 2012/01/09 25

26 Decompose GPU-GPU operations E as e = A 1 e A where A is memory copy from CPU to GPU, so e = A e A 1 is between CPUs: quotient graph. We have derived the MPI communication of an algorithm with distributed GPUs through formal means tw-12-exascale 2012/01/09 26

27 Shared memory multicore Processors still operate on local stores (L1/L2 cache) So it s really distributed memory except with the shared memory as network again factor out physical data movement from logical data movement (this still needs work) tw-12-exascale 2012/01/09 27

28 Conclusion tw-12-exascale 2012/01/09 28

29 Conclusion Integrative Model for Parallelism also: Interface without Message Passing Based on explicit distribution of everything that needs distributing Communication objects derived through formal reasoning Trivially covers distributed memory, can be interpreted for other models Theoretical questions remain: correctness, deadlock, relation to DAG models, interpretation as functional model, relation to BSP, suitability for graph algorithms Practical question: how do you implement this? (Inspiration from PETSc, ParPre, Charm++, elemental) tw-12-exascale 2012/01/09 29