Benchmark for math functions

[adtzlr]

A first idea. At least for Python, this looks already quite good to me 🍹. cdya_ik and cdya_il could be improved, but then the ouput would be not contiguous. This affects the performance on subsequent operations. So better leave it as it is.

Results

Note

FElupe math-functions are not as fast as the tensor ops in @Ferrite-FEM Tensors.jl, but the results are okay.

┌───────────┬─────────────┬───────────┐
│ function  │ without out │ with out  │
╞═══════════╪═════════════╪═══════════╡
│ det       │    9.1 ns   │    8.3 ns │
├───────────┼─────────────┼───────────┤
│ inv       │   48.2 ns   │   32.0 ns │
├───────────┼─────────────┼───────────┤
│ dya       │  139.1 ns   │   67.6 ns │
├───────────┼─────────────┼───────────┤
│ cdya      │  465.4 ns   │  379.9 ns │
├───────────┼─────────────┼───────────┤
│ cdya_ik   │  168.1 ns   │   92.3 ns │
├───────────┼─────────────┼───────────┤
│ cdya_il   │  167.1 ns   │   92.8 ns │
├───────────┼─────────────┼───────────┤
│ transpose │    0.0 ns   │     n/a   │
├───────────┼─────────────┼───────────┤
│ dot       │   32.3 ns   │   18.3 ns │
├───────────┼─────────────┼───────────┤
│ ddot      │    3.4 ns   │    3.4 ns │
├───────────┼─────────────┼───────────┤
│ trace     │    1.0 ns   │     n/a   │
└───────────┴─────────────┴───────────┘

Source Code

import timeit

import numpy as np

import felupe as fem

np.random.seed(5463456)

npoints = 1
ncells = 100000

n = npoints * ncells
x = (np.random.rand(3, 3, npoints, ncells).T / 10 + np.eye(3).T).T

# out locations
u = np.zeros((npoints, ncells))
v = np.zeros((3, 3, npoints, ncells))
w = np.zeros((3, 3, 3, 3, npoints, ncells))

number = 7
repeat = 7
perf = lambda fun: (
    np.array(timeit.repeat(fun, repeat=repeat, number=number)).min() / number / n * 1e9
).round(1)

# in ns
runtimes = dict(
    det=perf(lambda: fem.math.det(x)),
    inv=perf(lambda: fem.math.inv(x)),
    dya=perf(lambda: fem.math.dya(x, x)),
    cdya=perf(lambda: fem.math.cdya(x, x)),
    cdya_ik=perf(lambda: fem.math.cdya_ik(x, x)),
    cdya_il=perf(lambda: fem.math.cdya_il(x, x)),
    transpose=perf(lambda: fem.math.transpose(x)),
    dot=perf(lambda: fem.math.dot(x, x)),
    ddot=perf(lambda: fem.math.ddot(x, x)),
    trace=perf(lambda: fem.math.trace(x)),
)

runtimes2 = dict(
    det=perf(lambda: fem.math.det(x, out=u)),
    inv=perf(lambda: fem.math.inv(x, out=v)),
    dya=perf(lambda: fem.math.dya(x, x, out=w)),
    cdya=perf(lambda: fem.math.cdya(x, x, out=w)),
    cdya_ik=perf(lambda: fem.math.cdya_ik(x, x, out=w)),
    cdya_il=perf(lambda: fem.math.cdya_il(x, x, out=w)),
    dot=perf(lambda: fem.math.dot(x, x, out=v)),
    ddot=perf(lambda: fem.math.ddot(x, x, out=u)),
)

import termtables as tt

lines = []
for key in runtimes.keys():
    line = [key, f"{runtimes[key]:6.1f} ns"]
    if key in runtimes2.keys():
        line.append(f"{runtimes2[key]:6.1f} ns")
    else:
        line.append("    n/a")
    lines.append(line)

tt.print(lines, header=["function", "without out", "with out"])

[adtzlr]

cdya is used in LinearElastic (but only on 1d-data) and in linear_elastic as well as in linear_elastic_plastic_isotropic_hardening (for the latter two functions we have a performance problem...)