Benchmark: Assembly Performance

[adtzlr]

This is a simple benchmark to compare assembly times for linear elasticity and hyperelasticity on tetrahedrons.

Benchmark code

from timeit import timeit

import matplotlib.pyplot as plt
import numpy as np

import felupe as fem


def pre_linear_elastic(n, **kwargs):
    mesh = fem.Cube(n=n).triangulate()
    region = fem.RegionTetra(mesh)
    field = fem.FieldContainer([fem.Field(region, dim=3)])
    umat = fem.LinearElastic(E=1, nu=0.3)
    solid = fem.SolidBody(umat, field)
    return mesh, solid


def pre_hyperelastic(n, **kwargs):
    mesh = fem.Cube(n=n).triangulate()
    region = fem.RegionTetra(mesh)
    field = fem.FieldContainer([fem.Field(region, dim=3)])
    umat = fem.NeoHooke(mu=1.0, bulk=2.0)
    solid = fem.SolidBody(umat, field)
    return mesh, solid


print("# Assembly Runtimes")
print("")
print("|   DOF   | Linear-Elastic in s | Hyperelastic in s |")
print("| ------- | ------------------- | ----------------- |")

points_per_axis = np.round((np.logspace(3, 5, 6) / 3)**(1 / 3)).astype(int)

number = 3
parallel = False

runtimes = np.zeros((len(points_per_axis), 2))

for i, n in enumerate(points_per_axis):
    mesh, solid = pre_linear_elastic(n)
    matrix = solid.assemble.matrix(parallel=parallel)
    time_linear_elastic = (
        timeit(lambda: solid.assemble.matrix(parallel=parallel), number=number) / number
    )

    mesh, solid = pre_hyperelastic(n)
    matrix = solid.assemble.matrix(parallel=parallel)
    time_hyperelastic = (
        timeit(lambda: solid.assemble.matrix(parallel=parallel), number=number) / number
    )

    runtimes[i] = time_linear_elastic, time_hyperelastic

    print(
        f"| {mesh.points.size:7d} | {runtimes[i][0]:19.2f} | {runtimes[i][1]:17.2f} |"
    )

dofs_le = points_per_axis ** 3 * 3 / runtimes[:, 0]
dofs_he = points_per_axis ** 3 * 3 / runtimes[:, 1]

print("")
print("| Analysis       |        DOF/s      |")
print("| -------------- | ----------------- |")
print(
    f"| Linear-Elastic |   {np.mean(dofs_le):5.0f} +/-{np.std(dofs_le):5.0f}  |"
)
print(f"| Hyperelastic   |   {np.mean(dofs_he):5.0f} +/-{np.std(dofs_he):5.0f}  |")

plt.figure()
plt.loglog(
    points_per_axis ** 3 * 3,
    runtimes[:, 1],
    "C0",
    label=r"Stiffness Matrix (Hyperelastic)",
)
plt.loglog(
    points_per_axis ** 3 * 3,
    runtimes[:, 0],
    "C1--",
    label=r"Stiffness Matrix (Linear-Elastic)",
)
plt.xlabel(r"Number of degrees of freedom $\longrightarrow$")
plt.ylabel(r"Runtime in s $\longrightarrow$")
plt.legend()
plt.tight_layout()
plt.savefig("benchmark.svg", transparent=False)
plt.savefig("benchmark.png", transparent=False)

Tested on: KDE Neon (Ubuntu 22.04), Python 3.10, Intel® Core™ i7-6650U CPU @ 2.20GHz, 8GB RAM (Surface Pro 4)

Assembly Runtimes

DOF	Linear-Elastic in s	Hyperelastic in s
1029	0.01	0.02
2187	0.02	0.04
6591	0.07	0.13
14739	0.20	0.28
41472	0.51	0.98
98304	1.36	2.47

Analysis	DOF/s
Linear-Elastic	84523 +/- 9541
Hyperelastic	49771 +/- 6781

[adtzlr]

This benchmark is now part of the documentation. The hyperelastic performance has really improved since then!! 🚀