Expressive Environments and Code Generation for High Performance Computing

Size: px

Start display at page:

Download "Expressive Environments and Code Generation for High Performance Computing"

Elaine Estella Johnson
5 years ago
Views:

1 Expressive Environments and Code Generation for High Performance Computing Garth N. Wells University of Cambridge SIAM Parallel Processing, 20 February 2014

2 Collaborators Martin Alnæs, Johan Hake, Richard Katz, Anders Logg, Marie Rognes, Sander Rhebergen, Andy Wathen, Kristian Ølgaard

3 Scientific software SUBROUTINE DROTG(DA,DB,C,S) DOUBLE PRECISION C,DA,DB,S DOUBLE PRECISION R,ROE,SCALE,Z INTRINSIC DABS,DSIGN,DSQRT ROE = DB IF (DABS(DA).GT.DABS(DB)) ROE = DA SCALE = DABS(DA) + DABS(DB) IF (SCALE.EQ.0.0d0) THEN C = 1.0d0 S = 0.0d0 R = 0.0d0 Z = 0.0d0 ELSE R = SCALE*DSQRT((DA/SCALE)**2+ (DB/SCALE)**2) R = DSIGN(1.0d0,ROE)*R C = DA/R S = DB/R Z = 1.0d0 IF (DABS(DA).GT.DABS(DB)) Z = S IF (DABS(DB).GE.DABS(DA).AND. C.NE.0.0d0) Z = 1.0d0/C END IF DA = R DB = Z RETURN END

4 Be more expressive. Why? Simpler development Accelerated development Faster code with acceptable effort Detach mathematical intent from underlying algorithms, implementations and hardware User accessibility

5 Outline Domain-specific language for variational forms Code generator for variational forms Solver environment Illustrative application: block-preconditioned systems All presented tools are part of the FEniCS Project ( ) - all available under a free license Development site:

6 Unified Form Language (UFL) A domain-specific embedded language for variational forms Embedded in Python Highly expressive Mathematical error checking Implements various form manipulations Does not do any non-trivial computation Provides abstract representation (DAG) of a variational problem Requires a backend to generate concrete code Alnæs, Logg, Ølgaard, Rognes, Wells (2014) ACM TOMS,

7 Stokes equations Find where u, p V Q such that: a({u, p}, {v, q}) = L({v, q}) v, q V Q a L D D := u : v p v + ( u)q dx := f v dx

8 Stokes equations in the Unified Form Language V = VectorElement("Lagrange", triangle, 2) Q = FiniteElement("Lagrange", triangle, 1) TH = V * Q (u, p) = TrialFunctions(TH) (v, q) = TestFunctions(TH) f = Coefficient(V) a = (inner(grad(u), grad(v)) - p*div(v) + div(u)*q)*dx L = dot(f, v)*dx

9 Hyperelasticity Displacement field where u given by: u = argmin v V Π(v) Π := ψ(e(v)) B u dx T v ds ψ(e) E := ( F := Ω Ω is the strain energy density F T F I)/2 is the Green-Lagrange strain is the deformation gradient X v + I

10 Hyperelasticity in UFL V = VectorElement("Lagrange", "tetrahedron", 1) # Current displacement u = Coefficient(V).. # Kinematics (deformation gradient, right Cauchy-Green tensor) F, C = Identity(V.cell().d) + grad(u), F.T*F # Invariants of deformation tensors J, Ic = det(f), tr(c) # Stored strain energy density (compressible neo-hookean model) psi = (mu/2)*(ic - 3) - mu*ln(j) + (lmbda /2)*(ln(J))**2 # Total potential energy Pi = psi*dx - dot(b, u)*dx - dot(t, u)*ds # First variation of Pi v = TestFunction(V) F = derivative(pi, u, v) # Compute Jacobian of F (Hessian of Pi) du = TrialFunction(V) a = derivative(f, u, du)

11 Form to directed acyclic graph (1)

12 Form to directed acyclic graph (2)

13 Code generator (FEniCS Form Compiler) Code generator takes abstract representation and generates code in target language Kirby, Logg (2005) ACM TOMS; Ølgaard, Wells (2010) ACM TOMS; Logg, Ølgaard, Rognes, Wells (2012), FEniCS Book.

14 Domain-specific code optimisations Ølgaard & Wells (2010) ACM TOMS,

15 Problem solving environment DOLFIN is the FEniCS Project problem solving environment Synthesises domain-specific language, code generation, linear algebra, domain representation (mesh),... C++ and Python interfaces (implemented primarily in C++) Design reflects mathematical abstractions Logg and Wells (2010) ACM TOMS,

16 DOLFIN example from dolfin import * # Create mesh and define function space mesh = UnitSquareMesh(32, 32) V = FunctionSpace(mesh, "Lagrange", 1) # Define Dirichlet boundary (x = 0 or x = 1) def boundary(x): return x[0] < DOLFIN_EPS or x[0] > DOLFIN_EPS # Define boundary condition bc = DirichletBC(V, 0.0, boundary) # Define variational problem u, v = TrialFunction(V), TestFunction(V) f = Expression("10*exp(-(pow(x[0] - 0.5, 2) + pow(x[1] - 0.5, 2)) / 0.02)") a, L = inner(grad(u), grad(v))*dx, f*v*dx # Compute solution u = Function(V) solve(a == L, u, bc)

17 Mixed language development Language has large impact on productivity Low-level, performance necessary language will inevtitably not be suitable at the user/solver level Language has large impact on (potential) user base

18 Melt migration model Simplified model: ϵ(u) + p α u u k p where ϵ = ( u + u T )/2, α 0 and k 0 = 0 = 0

19 Block precondition a la Stokes: [ A 0 ] 0 Q + C 1 [ A ][ u] = [ A 0 ] [ f] B C p 0 Q + C g B T Code representing operator and preconditioner forms a = inner(sym(grad(u)), sym(grad(v)))*dx + alpha*div(u)*div(v)*dx \ - p*div(v)*dx - q*div(u)*dx - k*dot(grad(q), grad(p))*dx a_pc = inner(sym(grad(u)), sym(grad(v)))*dx + alpha*div(u)*div(v)*dx \ + p*q + k*dot(grad(q), grad(p))*dx 1 Identifying subspaces/matrix blocks TH = MixedFunctionSpace([V, Q]) V0 = TH.sub(0) # Extract first subspace V1 = TH.sub(1) # Extract second subspace

20 Solving the Stokes-like problem Iteration count using PETSc FieldSplit and MINRES N α = 1 α = 1 α = 100 α = 100 α = 1000 α = 100 LU AMG LU AMG LU AMG The devil is the grad - div term! Rhebergen, et al.

21 Modified problem formulation Introduce compaction pressure 1 ϵ(u) + p + + ( f p c u) 3 u + k p f u ξp c = 0 = 0 = 0 Code representing operator and preconditioner forms a = inner(sym(grad(u)), sym(grad(v)))*dx - (1.0/3.0)*div(u)*div(v)*dx \ - pf*div(v)*dx - pc*div(v)*dx - q*div(u)*dx \ - kappa*dot(grad(pf), grad(q))*dx - xi*pc*w*dx - w*div(u)*dx a_pc = inner(sym(grad(u)), sym(grad(v)))*dx \ + pf*q*dx + kappa*dot(grad(q), grad(pf))*dx \ + (xi + 1.0)*pc*w*dx

22 Solving the three-field problem Iteration count using AMG on the blocks + MINRES N α = 0 α = 1 α = New block preconditioners can created and tested in minutes

23 Summary Domain-specific approaches can accelerate development Detach mathematical intent from underlying algorithm/hardware Preserve mathematical abstractions Dynamic and configurable

FEniCS Course. Lecture 1: Introduction to FEniCS. Contributors Anders Logg André Massing

FEniCS Course. Lecture 1: Introduction to FEniCS. Contributors Anders Logg André Massing FEniCS Course Lecture 1: Introduction to FEniCS Contributors Anders Logg André Massing 1 / 15 What is FEniCS? 2 / 15 FEniCS is an automated programming environment for differential equations C++/Python