CS 5220

Lumped parameter simulations

Examples include:

• SPICE-level circuit simulation
  • nodal voltages vs. voltage distributions
• Structural simulation
  • beam end displacements vs. continuum field
• Chemical concentrations in stirred tank reactor
  • mean concentrations vs. spatially varying

Typically involves ordinary differential equations (ODEs), or with constraints (differential-algebraic equations, or DAEs).

Often (not always) sparse.

Sparsity

Consider system of ODEs $x' = f(x)$ (special case: $f(x) = Ax$)

• Dependency graph has edge $(i,j)$ if $f_j$ depends on $x_i$
• Sparsity means each $f_j$ depends on only a few $x_i$
• Often arises from physical or logical locality
• Corresponds to $A$ being a sparse matrix (mostly zeros)

Sparsity and partitioning

Want to partition sparse graphs so that

• Subgraphs are same size (load balance)
• Cut size is minimal (minimize communication)

We’ll talk more about this later.

Types of analysis

Consider $x' = f(x)$ (special case: $f(x) = Ax + b$).

• Static analysis ($f(x_*) = 0$)
  • Boils down to $Ax = b$ (e.g. for Newton-like steps)
  • Can solve directly or iteratively
  • Sparsity matters a lot!
• Dynamic analysis (compute $x(t)$ for many values of $t$)
  • Involves time stepping (explicit or implicit)
  • Implicit methods involve linear/nonlinear solves
  • Need to understand stiffness and stability issues
• Modal analysis (compute eigenvalues of $A$ or $f'(x_*)$)

Explicit time stepping

• Example: forward Euler
• Next step depends only on earlier steps
• Simple algorithms
• May have stability/stiffness issues

Implicit time stepping

• Example: backward Euler
• Next step depends on itself and on earlier steps
• Algorithms involve solves — complication, communication!
• Larger time steps, each step costs more

A common kernel

In all these analyses, spend lots of time in sparse matvec:

• Iterative linear solvers: repeated sparse matvec
• Iterative eigensolvers: repeated sparse matvec
• Explicit time marching: matvecs at each step
• Implicit time marching: iterative solves (involving matvecs)

We need to figure out how to make matvec fast!

An aside on sparse matrix storage

• Sparse matrix $\implies$ mostly zero entries
  • Can also have “data sparseness” — representation with less than $O(n^2)$ storage, even if most entries nonzero
• Could be implicit (e.g. directional differencing)
• Sometimes explicit representation is useful
• Easy to get lots of indirect indexing!
• Compressed sparse storage schemes help

Example: Compressed sparse row storage

This can be even more compact:

• Could organize by blocks (block CSR)
• Could compress column index data (16-bit vs 64-bit)
• Various other optimizations — see OSKI