Abstractions for Specifying Sparse Matrix Data Transformations - - PowerPoint PPT Presentation

▶
abstractions for specifying sparse matrix data
SMART_READER_LITE
LIVE PREVIEW

Abstractions for Specifying Sparse Matrix Data Transformations - - PowerPoint PPT Presentation

Dec 21, 2023 127 likes •328 views

Abstractions for Specifying Sparse Matrix Data Transformations Payal Nandy Eddie C. Davis Mahdi S Mohammadi, Wei He Mary Hall Catherine Olschanowsky Michelle Strout University of Utah Boise State University University of Arizona 1

slide-1
SLIDE 1

Abstractions for Specifying Sparse Matrix Data Transformations

1

Payal Nandy Mary Hall Eddie C. Davis Catherine Olschanowsky Mahdi S Mohammadi, Wei He Michelle Strout University of Utah Boise State University University of Arizona

slide-2
SLIDE 2

Motivation

  • The polyhedral model is suitable for affine

– loop bounds, array access expressions and transformations

  • Polyhedral model unsuitable for sparse matrix &

unstructured mesh computations (non-affine)

– Array accesses of the form A[B[i]] – Loop bounds of the form index[i] ≤ j < index[i+1]

  • Key Observation

– Compiler generated code for run time inspector & executor – Run time inspection

  • can reveal mapping of iterations to array indices
  • Potentially change iteration or data space

2

slide-3
SLIDE 3

Related Work

Inspector/Executor

Polyhedral Support for Indirection Data Transformations Frameworks for Sparse Computations Mirchandaney, Saltz et al., 1988 Rauchwerger, 1998 Basumallik and Eigenmann, 2006 Ravishankar et al., 2012 SIPR: Shpeisman, 1999 Bernoulli: Mateev, 2001 Bik, 1996 Ding and Kennedy, 1999 Mellor-Crummey et al., 2001 Gilad et al., 2010 van derSpek, 2011 Pugh and Wonnacott, 1994

Prior work did not integrate all of these, and mostly did not expand data with zero-valued elements.

slide-4
SLIDE 4

CHiLL-I/E - Vision

4

slide-5
SLIDE 5

Foundation – Sparse Polyhedral Framework

  • Loop transformation framework built on the polyhedral

model

  • Uses uninterpreted functions to represent index arrays
  • Enables the composition of inspector-executor

transformations

  • Exposes opportunities for compiler to

– Simplify indirect array accesses and – Optimize inspector-executor code

5

slide-6
SLIDE 6

Foundation – CHiLL Compiler Framework

  • Runtime data & iteration reordering transformations for

non-affine loop bounds and array access

– Make-dense – Compact, compact-and-pad

  • Composable with polyhedral transformations

– Tile, skew, permute

  • Integration with user-specified Inspectors
  • Automatically generated Inspector/Executors

– Inspectors optimized for making less passes over data – Optimized executors performed comparable to runtime libraries

[CGO ‘14], [PLDI ‘15] [SC ‘16] [IPDPS ‘16] [LCPC ‘16]

6

slide-7
SLIDE 7

Prior Research Performance Indicators

7

Performance of Compiler generated Inspectors and Executors competitive with CUSP

0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2 Speedup over CUSP Matrices

DIA Inspector Speedup

10 20 30 40 50 60 70 Performance/GFLOPS Matrices

DIA Executor Performance

CUDA-CHiLL CUSP

[PLDI’15]

slide-8
SLIDE 8

Contribution

  • Derive abstractions for Sparse Matrix Data

Transformations

– Focus on transformations that modify data representation

  • Extend Sparse Polyhedral Framework to Support data

transformations

– Modify data representation to reflect structure of input matrix – Expand iteration space to match new data representation

  • Generalize representation of Inspector/executor

transformations

– Goal: automatically compose them

8

slide-9
SLIDE 9

Abstractions

9

Transformation Relations

  • Include

uninterpreted functions

  • Inc ludes non-

affine transformations

  • Composable

with existing transformations

Inspector Dependence Graph

  • Derived from

Transformation relations

  • Data flow

representation of Inspector functionality

Automatic Generation of

  • ptimized

Inspector/ Executor

  • Compiler walks

IDG to generate Inspector

  • Inspector

instantiates explicit functions for Executor

slide-10
SLIDE 10

Sparse Matrix-Vector Multiply (SpMV)

10

for (i=0; i < n; i++) for (j=index[i]; j<index[i+1]; j++) y[i]+=A[j]*x[col[j]]; Begin with Compressed Sparse Row (CSR) format

Non-affine subscript

A: [ 1 5 7 2 3 6 4 ] index: [ 0 2 4 6 7 ] col: [ 0 1 0 1 2 3 3 ] Compressed Sparse Row (CSR)

Non-affine loop bounds

slide-11
SLIDE 11

Sparse Matrix Formats

11

1 5 7 2 3 6 4

BCSR

1 5 7 2 3 6 4

ELL

1 5 7 2 3 6 4

DIA

A: [ 1 5 7 2 3 6 4 ] row: [ 0 0 1 1 2 2 3 ] col: [ 0 1 0 1 2 3 3 ]

COO

Data & Iteration Space Transformation Iteration Space Transformation Moldyn (molecular dynamics) – Data + Iteration Reordering

slide-12
SLIDE 12

CSR to COO

12

Transformation Relations

Tcoalesce = {[i,j]  [k] | k = c(i,j) 0 ≤ k < NNZ Iexec = Tcoalesce (I)

Generate Inspector

NNZ = count (I) c = order (I) c_inv = invert(c)

IDG Inspector Executor

Count Order NNZ c invert c_inv I

struct access_relation c; for (i=0; i<=n-1; i++) for (j=index[i]; j<=index[i+1]-1; j++) c.create_mapping(i,j);

for (k = 0; k < NNZ; k++) y[c_inv[k][0]] += A[c_inv[k][1]]* x[col[c_inv[k][1]]];

slide-13
SLIDE 13

Enabling Data Transformations

13

for (i=0; i < n; i++) for (j=index[i]; j<index[i+1]; j++) y[i]+=A[j]*x[col[j]];

make-dense

for (i=0; i < n; i++) for(k=0; k <n; k++) for (j=index[i]; j<index[i+1]; j++) if(k== col[j]) y[i]+=A[j]*x[k]

Guard Condition Guard Condition

slide-14
SLIDE 14

k i

1 2 3 1 2 3

k’ i

1 2 3 1 2 3

  • 1
  • 2
  • 3

d i

1 2 3

  • 1

1

j i

1 2 3 1 2 3 4 5 6

j j

CSR to DIA: Transformations

Dense Matrix 1 5 0 0 7 2 0 0 0 0 3 6 0 0 0 4 CSR Format 1 5 7 2 3 6 4 0 2 4 6 7 0 1 0 1 2 3 3 A index col DIA Format 0 1 5 7 2 0 0 3 6 0 4 0 A’

  • 1 0 1
  • ffsets

make-dense Compact &pad

CSR Iteration Space DIA Iteration Space

slide-15
SLIDE 15

Compact-and-pad

15

  • 3
  • 2
  • 1

1 2 3 X X

  • X

X 0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3 X X X X X X X X X • X X •

  • •

X • X X X X X X X X X

k’ i

  • 1

2 3 1 2 3 1 2 3

  • 1

1

d i

Eliminate entirely Eliminate entirely Pad with 0

slide-16
SLIDE 16

CSR to DIA

16

Transformation Relations

Tmake-dense = {[i,j] [i,k,j] | 0 ≤ k < N ^ k = col(j) Tskew = {[i,k,j] [i, k’,j] | k’ = k-i} Tcompact-and-pad = {[k’.i,j] [i;d] | 0 ≤ d < ND ^ k’ = col(j) - i ^ c(d) = k’ Iexec = Tcompact-and-pad(Tskew(Tmake-dense(I))) Generate Inspector D_set = {[k‘] | ∃ j, k' = col(j)-i ^ index(i) ≤ j < index(i+1)}} ND = count(D_set) C = order(D_set) A_prime = calloc(N*ND*sizeof(datatype)) map: RA  A_prime = {[j]  [i,d] | 0 ≤ d <ND ∃ k', k' = col(j)-i ^ c(d)=k' }

IDG

D_Set count ND calloc A_prime

  • rder

c A map A_prime

slide-17
SLIDE 17

CSR to DIA

17

Inspector Code for DIA

ND = 0; D_set = emptyset; for(i = 0; i<N; i++) for(j = index[i]; j < index[i+1]; j++) { k_prime = col(j)-i; if (!marked[k_prime]) D_set = D_set U <k_prime,ND++>; } A_prime = calloc(N*ND*sizeof(datatype)); c = calloc(ND*sizeof(indextype)); for(i = 0; i<N; i++) for(j = index[i]; j < index[i+1]; j++) { k_prime = col(j)-i; d = lookup(k_prime,D_set); c[d] = k_prime; A_prime[i][d] = A[j]; }

D_Set count ND calloc A_prime

  • rder

c A map A_prime

Executor Code for (i=0; i < N; i++) for(d=0; d<ND; d++) y[i] += A[i][d]*x[i+c[d]];

slide-18
SLIDE 18

Future Work - Optimizing the IDG

  • Minimize inspector passes over input data
  • Extend IDG to support fusion of Inspectors
  • Additional optimizations

– Dynamic data structures (e.g. linked lists) to eliminate sweeps to calculate size of data representation – Integrate existing inspector library functions

18

slide-19
SLIDE 19

Conclusion

  • Abstractions for data transformations in sparse

matrix & unstructured mesh computations

  • Approach

– Transformation Relations – Inspector Dependence Graph – Compiler generated optimized Inspector/Executor code

  • Vision: Create a framework to compose complex

transformation sequences for inspectors and executors

19