Modules

Published configurations

Search benchmarks

This catalogue presents Rodin's performance benchmarks, from individual mathematical operations to assembled finite element problems. Each benchmark describes the operation measured, the inputs and the measurement conditions. Published timing histories help track changes across commits for a selected configuration and benchmark case.

Benchmarks are organized by their owning module, following the library's directory hierarchy. The module groups below provide entry points to classes and workloads; MPI and PETSc benchmarks remain within their respective modules. Physical contexts, such as Stokes, collect benchmarks whose meaning depends on a mathematical model. Descriptions become more detailed as the navigation reaches individual benchmarks, explaining what is measured and why. Use the search to find a class, operation or workload directly. Modules without registered benchmarks are identified on their pages.

Benchmark machine

Published CI benchmarks run on standard GitHub-hosted ubuntu-24.04 virtual machines for public repositories.

SystemCPUMemorySSD
Ubuntu 24.04, x644 vCPUs16 GB14 GB

The benchmark builds use GCC 14 and Release mode. Each job runs one benchmark executable at a time. OpenMP, OpenBLAS and MKL use one thread; MPI ranks share the same runner. The selected configuration identifies the build and rank count.

The CPU model and host load can vary between virtual machines, so small timing differences should be checked across repeated runs. GitHub runner specifications describe the available hardware. The source workflow is BenchmarkGroup.yml.

Core

Geometry, finite element spaces, variational expressions, assembly and linear algebra form the path from a weak formulation to an algebraic system.

Assembly

Global assembly of discrete operators.

\[ A_{ij}=a(\phi_j,\psi_i), \qquad b_i=\ell(\psi_i). \]

Assembly::Sequential evaluates local integrals and accumulates global matrices and vectors; Assembly::Default selects the configured assembly strategy. BilinearFormAssemblyInput supplies spaces and integrators, and ConstraintMap expands degree-of-freedom constraints when assembling constrained or coupled problems.

Browse benchmarks
13 benchmarks

Form language

Typed expressions for constructing variational forms.

auto stiffness = Integral(Grad(u), Grad(v));
auto load = Integral(f, v);
Problem problem(u, v);
problem = stiffness - load + DirichletBC(u, Zero());

An expression's C++ type records its operands and algebraic role. Function expressions represent known fields; shape-function expressions carry a trial or test slot; bilinear integrators pair those slots. Traits propagate scalar type, range and finite element space through composition.

No benchmarks yet

Geometry

Meshes, geometric transformations, and mapped evaluation.

\[ \mathbf{x}=F_K(\widehat{\mathbf{x}}). \]

Mesh<Context::MPI> and getConnectivity().compute(d1, d2) describe mesh entities and their incidence relations. Polytope, Geometry::Point, and PolytopeTransformation connect reference elements to physical geometry for integration, field evaluation, mesh extraction, and deformation.

Browse benchmarks
8 benchmarks

IO

Reading and writing meshes, fields, and associated data.

IO::XDMF xdmf("output");
xdmf.grid().setMesh(mesh).add("u", u.getSolution());
xdmf.write();

MeshLoader and MeshPrinter import and export meshes; GridFunctionLoader and GridFunctionPrinter transfer discrete fields. Format-specific backends support MFEM, MEDIT, and HDF5 data, while IO::XDMF writes meshes, multiple fields, and time series for visualization.

Browse benchmarks
1 benchmark

Math

Spatial arithmetic, matrix operations, and sparse linear algebra.

SpatialVector<Real> a{1, 2, 3};
SpatialVector<Real> b{4, 5, 6};
const Real product = dot(a, b);       // 32
const auto normal = a.cross(b);      // {-3, 6, -3}
const Real length = a.norm();        // sqrt(14)

SpatialVector<T> and SpatialMatrix<T> support small spatial calculations without heap allocation. Vector<T>, Matrix<T>, and their fixed-size counterparts provide Eigen-compatible algebra; LinearSystem<Operator, Vector> groups system data and constraint elimination. These types support geometric mappings, constitutive calculations, assembly, and linear solves.

Browse benchmarks
11 benchmarks

Quadrature formulae

Reference integration formulas selected by geometry and exactness.

\[ \int_{\widehat K}f(\widehat x)\,d\widehat x \approx\sum_qw_qf(\widehat x_q). \]

A reference rule consists of sites $\widehat x_q$ and weights $w_q$ .

Browse benchmarks
2 benchmarks

Solver

Solution of linear and nonlinear discrete systems.

\[ \text{Find } \mathbf{x} \text{ such that } A\mathbf{x}=\mathbf{b}. \]

CG handles symmetric positive-definite systems, GMRES handles general iterative solves, and SparseLU provides direct sparse factorization. NewtonSolver drives nonlinear solves. These solvers operate on prepared systems or variational problems and provide convergence controls for PDE and optimization calculations.

Browse benchmarks
5 benchmarks

Variational

Finite element spaces, fields, and variational problems.

\[ \text{Find} \quad u \in U \quad \text{ s.t. } \quad \forall v \in V \quad a(u, v) = b(v) \ , \]

H1 and P1 define finite element spaces, while GridFunction evaluates and interpolates discrete fields. TrialFunction, TestFunction, and Problem express weak forms, boundary conditions, and the algebraic problems used to solve PDEs.

Browse benchmarks
27 benchmarks

Infrastructure

Execution contexts, diagnostics, spatial search, type utilities, serialization and numerical test helpers support the numerical modules.

Alert

Contextual exceptions and diagnostic reporting.

Alert::Info() << "Assembling the system..." << Alert::Raise;

Alert::Exception and Alert::MemberFunctionException report errors with contextual diagnostics. Alert::Info and Alert::Warning provide nonfatal messages through the same stream interface. These classes communicate invalid inputs, unavailable operations, and solver or mesh-processing status.

No benchmarks yet

Context

Execution contexts for local and distributed computation.

using LocalMesh = Geometry::Mesh<Context::Local>;
auto mesh = LocalMesh::UniformGrid(Geometry::Polytope::Type::Triangle, {8, 8});

Local selects local execution, and Context::MPI carries the environment and communicator for distributed execution. Mesh, connectivity, and finite element specializations use these context types to select their data distribution and backend behavior while preserving the same mathematical interfaces.

No benchmarks yet

Location

Spatial indexing and geometric search.

Location::AABB locator(mesh);
const auto point = locator.locate(physicalCoordinates);

AABB builds a bounding-volume hierarchy to locate physical coordinates in a mesh and recover the containing cell and reference coordinates. The resulting Geometry::Point can be used for field sampling and evaluation at arbitrary locations. The locator must be rebuilt when the mesh geometry or topology changes.

Browse benchmarks
2 benchmarks

Serialization

Serialization and reconstruction of library objects.

archive << values;

Boost.Serialization adapters store arrays, Eigen-compatible dense matrices, flat containers, and optional values. The export registrations cover selected ParametricTransformation instantiations used in MPI shard transfer. Including the relevant adapter headers enables binary archives of supported numerical data and container structures.

No benchmarks yet

Test

Helpers for constructing numerical tests.

\[ A(u)w \approx -\frac{b(u+\epsilon w)-b(u-\epsilon w)}{2\epsilon}. \]

FDProbe compares assembled tangents with finite differences and returns error diagnostics in FDProbeReport. ExpectedResultTable organizes known input-output cases, and random generators supply test samples. These helpers support numerical regression tests for constitutive laws, geometry, and variational operators.

No benchmarks yet

Utility

Type utilities and generic programming helpers.

std::variant<int, Real> value = 2;
const Real result = std::visit(Utility::Overloaded{
  [](int x) { return Real(x); },
  [](Real x) { return x; }
}, value);

ParameterPack and Zip support compile-time type and parameter manipulation. Overloaded combines callable visitors, and OptionalReference represents optional non-owning access. These helpers support generic expressions, type dispatch, and reusable library extensions.

No benchmarks yet

Models

Transport, distance construction, regularization, solid mechanics and cardiac models are expressed using the core numerical interfaces.

Adaptation

Mesh adaptation and deformation operations.

\[ \mathbf{x}^{\prime}=\mathbf{x}+\mathbf{d}(\mathbf{x}). \]

SWIFT::Adapt and SWIFT::Problem fit mesh interfaces to level sets while controlling element distortion. DeformationMap and CellDeformation describe mapped geometry for evaluating deformed cells and fields. These components support moving-interface calculations and body-fitted mesh updates.

No benchmarks yet

Advection

Transport and advection of fields.

\[ \frac{\partial \phi}{\partial t} + \mathbf{v} \cdot \nabla \phi = 0 \]

Lagrangian advances scalar fields on unstructured meshes by tracing characteristics and projecting the transported field into a finite element space. It is used to transport level sets and other evolving fields; boundary policies control the treatment of characteristics that reach the mesh boundary.

No benchmarks yet

Distance

Distance propagation and Poisson-based level-set approximations.

\[ d(x,\Gamma)=\inf_{y\in\Gamma}\lVert x-y\rVert. \]

The unsigned distance to a geometric set $\Gamma$ is

No benchmarks yet

Eikonal

Eikonal equations and distance propagation.

\[ F(x)\lVert\nabla u\rVert = 1 \]

FMM implements fast marching on simplicial meshes, propagating arrival times from prescribed seed vertices. It provides the underlying distance propagation used by level-set reinitialization and distance-field construction, with a priority queue controlling the order of vertex updates.

No benchmarks yet

Heart

Cardiac models and their coupled state evolution.

const auto report = model.step(dt);

CCMLC2014T advances a reduced ventricular model through a cardiac cycle. HolzapfelReducedLaw and CCMLC2014PassiveLaw supply its reduced passive energy and stress response. The module supports cardiac-cycle studies and constitutive parameter calibration before larger three-dimensional simulations.

No benchmarks yet

Hilbert

Hilbert-space formulations and regularization.

\[ \alpha^2 \int_\Omega \nabla u : \nabla v \, dx + \int_\Omega u \cdot v \, dx = \ell(v) \]

getTrialFunction() / getTestFunction() solves a regularized extension problem that converts a linear functional into a smooth field over the mesh. It is commonly used to extend boundary shape derivatives into volume descent directions, with a configurable length scale controlling smoothing and boundary conditions constraining the extension.

No benchmarks yet

Solid

Finite-strain kinematics, constitutive responses and virtual-work forms.

\[ P(F)=\frac{\partial W}{\partial F},\qquad DP(F)[H]=\frac{\partial^2 W}{\partial F^2}:H. \]

A total-Lagrangian hyperelastic model uses a reference domain $\Omega_0$ , displacement $u$ and deformation gradient $F=I+\nabla_0u$ . The stored energy determines the first Piola–Kirchhoff stress and tangent action.

Browse benchmarks
2 benchmarks

Parallelism and integrations

These modules connect Rodin to distributed execution, external solver backends, mesh adaptation and graph partitioning libraries.

MMG

Mesh adaptation through the MMG integration.

MMG::Mesh cut = MMG::LevelSetDiscretizer()
  .setLevelSet(0.0)
  .split(interior, { interior, exterior })
  .setBoundaryReference(interface)
  .discretize(phi);

MMG::Mesh connects Rodin geometry to MMG. MMG::Adapt performs metric-driven adaptation, MMG::Optimizer improves mesh quality, and LevelSetDiscretizer fits or extracts an isosurface. These workflows support remeshing and interface reconstruction in shape optimization and evolving-geometry simulations.

No benchmarks yet

MPI

Distributed meshes, finite element spaces, and search operations.

using DistributedMesh = Geometry::Mesh<Context::MPI>;

Context::MPI supplies the distributed execution context, while Mesh<Context::MPI> manages distributed mesh entities and connectivity. Sharder partitions mesh data for transfer between ranks. Distributed finite element spaces, point location, and assembly build on these components for multi-process PDE calculations.

Browse benchmarks
2 benchmarks

PETSc

PETSc storage, assembly and linear/nonlinear solver adapters.

PetscErrorCode ierr = PetscInitialize(&argc, &argv, PETSC_NULLPTR, PETSC_NULLPTR);
assert(ierr == PETSC_SUCCESS);
{
  // Construct and use PETSc-backed spaces, fields, forms and solvers here.
}
ierr = PetscFinalize();
assert(ierr == PETSC_SUCCESS);

PETSc-backed trial/test functions connect Rodin variational forms to PETSc matrices, vectors, Krylov solvers and nonlinear solvers. The mesh execution context determines whether those objects are local or distributed. Backends and supported configurations describes the relationship between context, assembly strategy and algebraic storage.

Browse benchmarks
3 benchmarks

Scotch

Graph partitioning through the Scotch integration.

Scotch::Partitioner partitioner(mesh);
partitioner.partition(numRanks);

Partitioner builds a graph-based partition of mesh cells using Scotch. The resulting cell assignments feed mesh sharding and distribution, helping divide finite element workloads across MPI ranks while limiting connections between partitions.

No benchmarks yet

Physical contexts

Stokes

The stationary Stokes model describes slow viscous flow of an incompressible Newtonian fluid, with inertia neglected. In a domain \(\Omega\), the velocity \(\boldsymbol{u}\) and pressure \(p\) satisfy momentum balance and incompressibility:

\[ -\nu\Delta\boldsymbol{u}+\nabla p=\boldsymbol{f}, \qquad \nabla\cdot\boldsymbol{u}=0. \]

Here \(\nu>0\) is the constant viscosity coefficient and \(\boldsymbol{f}\) is the applied force. Pressure enforces the incompressibility constraint. With homogeneous velocity prescribed on \(\partial\Omega\), pressure is determined up to an additive constant; the normalization \(\int_\Omega p\,\mathrm dx=0\) fixes that constant. The mixed velocity–pressure discretization must preserve this coupling to give a stable approximation.

Browse benchmarks
1 benchmark