Eigen vs. BLAS/LAPACK libraries, Raspberry Pi 5 in 32-bit mode (October 2026)

The cells of the 64-bit page measured again on the same board with 32-bit binaries: the Raspberry Pi 5’s Cortex-A76 executes AArch32 at the user level, and the 64-bit kernel runs 32-bit programs as they are. Eigen is built for the Armv8-A baseline in AArch32 state with NEON and hard-float calling conventions, against OpenBLAS. Arm Performance Libraries are not on this page: they provide no AArch32 build.

NEON in AArch32 state has no double-precision lanes, so Eigen’s double-precision kernels on this page run on the scalar floating-point unit, while its single-precision kernels use 4-lane NEON packets. The double-precision and single-precision results therefore differ in kind from each other, and from the 64-bit page’s.

Conditions

GEMM at n = 1024 ran at 3.5 GFLOP/s in double and 19.9 in float in Eigen, against 8.9 and 9.3 for OpenBLAS.

How to read the numbers. Every rate is nominal GFLOP/s: the textbook operation count of the operation, stated in each section below, divided by the median wall time of one call. Both arms of a comparison are built into the same binary and run on the same freshly randomized operands, and the reference library’s result is validated against Eigen’s before it is timed. A ratio divides Eigen’s rate by OpenBLAS’s rate from the same binary and the same run. Eigen was measured once per cell, in that binary, so the charts carry no pass-to-pass band; the ten repetitions within a cell span at most 3 % of their median in 77 % of the cells. For the eigenvalue and singular value decompositions the count is the one of the classical algorithm, so a divide-and-conquer or blocked implementation is credited with work it does not do; the ratios between arms are unaffected.

Each run covered one operation, under an exclusive benchmark lock that keeps other timing jobs off the board. It started only after an idle gate (no compilers, one-minute load below 0.5, less than 0.2 of a core busy, SoC temperature below 70 °C) and was discarded and repeated if the whole machine reached 1.8 busy cores in any 4 s sample, or if the firmware’s throttle flags (vcgencmd get_throttled) changed during the run: 1 of 18 attempts was discarded (DOT: the first attempt produced no result file). The flags read 0x0 before and after every accepted run. The SoC temperature peaked at 70.5 °C during the session.

The dotted vertical lines on the charts mark the sizes at which the operands of the call, inputs and outputs together, fill a core’s L1 data cache (64 KiB), its L2 cache (512 KiB) and the shared L3 cache (2 MiB).

AXPY

y += alpha * x against ?axpy, alpha = 0.75; (2n) flops. Lengths run from 2 to (2^{24}) (128 MiB per double vector), through every cache level into DRAM.

Short vectors. Up to about n = 32 the AXPY and DOT rates measure the cost of a call rather than the kernel. Eigen’s expression compiles inline into the calling loop, while a call into a library pays a cost of its own before it reads an element. That cost is fixed per call, so the ratios at the small end are ratios of fixed costs. The DOT cells in double at n = 2 show it directly: 3.41 ns per call for Eigen against 11.3 ns for OpenBLAS. Eigen still computes the whole operation on every call; nothing is hoisted out of the timed loop.

DOT

x.dot(y) against ?dot; (2n) flops, the same lengths. Real scalars only: the Fortran convention for returning a complex function value is not fixed by the platform ABI and differs between library builds, so ?dotc cannot be declared portably.

Up to about n = 32 the rates measure the cost of a call; see AXPY.

GEMV

y.noalias() += A * x against ?gemv, column-major, no transposition; (2mn) flops.

Square matrices, then the short-fat (n = 10000, m grows) and tall-skinny (m = 10000, n grows) sweeps.

GEMM

C.noalias() += A * B against ?gemm, column-major, no transposition; (2mnk) flops.

Square matrices first; then the two tall-skinny sweeps, where m stays at 4096 or 10000 while n = k grows; then the assorted non-square shapes that fit neither.

TRSM

A.triangularView<Lower>().solveInPlace(X) against ?trsm with the m-by-m lower triangle on the left and n right-hand sides, no transposition, non-unit diagonal; (m(m+1)n) flops. The solve is destructive, so the timed region includes one copy of B for both arms.

Square shapes (m = n), then the sweeps with a fixed triangle of order 1024 or 4096 and a growing number of right-hand sides, then the remaining shapes with 4096 right-hand sides against a small triangle.

TRMM

X.noalias() = A.triangularView<Lower>() * B against ?trmm with the m-by-m lower triangle on the left and n columns in B, no transposition, non-unit diagonal; (m(m+1)n) flops, TRSM’s count. ?trmm overwrites B, so the reference arm copies B into the destination and multiplies in place; the Eigen arm writes the product to the destination, which noalias() zero-fills before accumulating. Each arm makes the one pass over the destination its interface requires, and neither allocates inside the timed region.

The same shapes as TRSM: square, then the sweeps with a fixed triangle of order 1024 or 4096 and a growing number of columns, then the remaining shapes with 4096 columns against a small triangle.

SYMM

C.noalias() += A.selfadjointView<Lower>() * B against ?symm (?hemm for a complex scalar) with the m-by-m symmetric matrix stored in its lower triangle, on the left, and n columns in B; (2m^2n) flops, the count of the general product of the same shape. C accumulates across iterations and is never reset, as in GEMM.

The same shapes as TRSM.

SYRK

C.selfadjointView<Lower>().rankUpdate(A) against ?syrk, lower triangle, no transposition, with C n-by-n and A n-by-k; (n(n+1)k) flops.

Square shapes (n = k), then the sweeps: a 4096-by-4096 matrix updated by a growing number of columns, and the Gram matrix of a short, wide factor with 4096 columns.

POTRF

LLT<Ref<MatrixXd>> in place against ?potrf, lower triangle, symmetric positive definite operand; (n^3/3) flops. The timed region includes one copy of the operand for both arms, since the factorization is destructive.

PSTRF

LDLT<Ref<MatrixXd>> in place against ?pstrf, lower triangle, symmetric positive definite operand; (n(n-1)(n-2)/3 + 2n(n-1)) flops for both, (n^3/3) to leading order. The two compute different factors of the same pivoted matrix, (P^T A P = L L^T) for LAPACK and (L D L^T) for Eigen, and pivot on the same entry, the largest diagonal element of the remaining Schur complement. Both arms copy the operand into a destination allocated once and factorize the copy, as GETRF does. LDLT::compute also evaluates the operand’s L1 norm for rcond(), which ?pstrf does not. Each result is checked by applying the stored factors to a random vector and comparing with (Ax).

SYTRF

BunchKaufman<Ref<MatrixXd>> in place against ?sytrf (?hetrf for a complex scalar), lower triangle, symmetric indefinite operand; (n(n-1)(n-2)/3 + 2n(n-1)) flops for both, (n^3/3) to leading order. Both arms copy the operand into a destination allocated once and factorize the copy, as GETRF does; pivot and workspace arrays are set up once per shape. Each result is checked by applying the stored factors, with the pivot blocks of D, to a random vector and comparing with (Ax).

GETRF

PartialPivLU<Ref<MatrixXd>> in place against ?getrf, square operand; (2n^3/3) flops. Both arms copy the operand into a destination allocated once and factorize the copy; neither allocates inside the timed region.

GEQRF

HouseholderQR<Ref<MatrixXd>> in place against ?geqrf, m ≥ n; (2mn^2 - 2n^3/3) flops, the same copy-then-factorize protocol as GETRF.

Square shapes, then the tall-skinny sweeps with m fixed at 4096, 10000 and 100000.

GELS

Full-rank least squares (\min \lVert AX - B \rVert) through Householder QR with A m-by-n, m ≥ n, and B m-by-nrhs: HouseholderQR<Ref<MatrixXd>> followed by qr.solve(B) against ?gels (trans = 'N'); (2mn^2 - 2n^3/3) flops for the factorization plus (\text{nrhs},(4mn - n^2)) for applying (Q^T) and solving with R. ?gels overwrites A and B, so the reference arm copies both into destinations allocated once. The Eigen arm factorizes a copy of A through the in-place HouseholderQR and writes qr.solve(B) to a preallocated X; solve() copies B into a temporary it allocates, which is the cost of the expression a user writes, so it is timed. The solution is checked through the normal equations on a well-conditioned operand.

Square shapes with one right-hand side, then the tall-skinny sweeps with m fixed at 4096, 10000 and 100000, then right-hand-side sweeps: 16 to 256 columns of B at m = n = 1024 and 16 to 1024 at 4096 by 256.

SYEV

SelfAdjointEigenSolver with eigenvectors against ?syev (jobz = 'V', lower triangle), the like-for-like pair: tridiagonalization followed by implicit QR iteration on both sides; (9n^3) flops, the count of that algorithm (Golub & Van Loan, section 8.3.3). Neither works in place: the solver copies the operand internally and the reference arm pays the same one copy. Sizes to 2048, where a call of SelfAdjointEigenSolver takes 32.0 s in double.

GESDD

BDCSVD<MatrixXd, ComputeThinU | ComputeThinV> against ?gesdd with jobz = 'S', divide and conquer on both sides, m ≥ n, the thin U and V computed; (14mn^2 + 8n^3) flops, the Golub-Reinsch count (Golub & Van Loan, table 8.6.1). Square sizes to 2048, then tall-skinny sweeps with m fixed at 4096 and 10000.

GEEV

EigenSolver with eigenvectors against ?geev (jobvr = 'V'), a dense random nonsymmetric operand: Hessenberg reduction, QR iteration to the Schur form and back-substitution for the eigenvectors on both sides; (25n^3) flops, the count of the Hessenberg QR algorithm with Schur vectors (Golub & Van Loan, section 7.5.6). Sizes to 1024, where a call of EigenSolver takes 17.3 s in double.

Summary

Geometric mean of the Eigen ÷ library rate ratio over the square shapes in each size band. Above 1, Eigen is faster. Only the vector operations reach the last band.

Observations

• Double precision: Eigen runs at 0.3 to 0.4 times OpenBLAS on the large products. From n = 24, GEMM is 0.39 to 0.41, TRSM 0.31 to 0.39, TRMM 0.33 to 0.37, SYMM 0.38 to 0.40 and SYRK 0.37 to 0.40; POTRF and GETRF fall from 0.6 at n = 24 to 128 to 0.40 above n = 192. The same Eigen source built for AArch64, where double-precision NEON lanes exist, is level with OpenBLAS (the 64-bit page).
• Single precision: Eigen’s NEON code leads. In float, GEMM is 2.0 to 2.2 times OpenBLAS from n = 24, SYMM 2.0 to 2.1, SYRK 1.6 to 2.1, TRSM 1.5 to 2.0, GETRF 1.7 to 2.0, GEQRF 1.6 to 2.1 and GELS 1.8 to 2.3.
• GEMV is the exception to the double-precision pattern: Eigen is 1.3 to 1.65 times OpenBLAS in double above n = 192, and 2.2 to 3.2 times in float.
• The new factorizations in double: PSTRF is level with OpenBLAS at n = 24 to 128 (1.07) and 0.56 to 0.59 above, SYTRF 0.98 falling to 0.48, GELS 0.89 falling to 0.46.
• SYEV, GESDD and GEEV: SYEV is 0.8 to 1.3 times OpenBLAS in double and 1.1 to 1.9 in float; GESDD 0.52 to 0.74 in double; GEEV 0.33 in double and 0.89 in float at n = 192 to 1024.

Caveats

• The Raspberry Pi 5 has 4 KiB pages and a small shared last-level cache (2 MiB), so rates at sizes beyond a few megabytes are largely set by the memory system; compare arms measured in the same session.
• The binaries are 32-bit hard-float executables run by a 64-bit kernel; 32-bit userspace is not the configuration of the 64-bit page, so absolute rates and ratios on the two pages are not comparable cell by cell.
• OpenBLAS was built without a Fortran compiler, so its LAPACK routines are the C translation of the reference LAPACK rather than the Fortran one the other pages’ OpenBLAS builds use; BLAS kernels are unaffected. OpenBLAS’s ARMV7 target is its generic 32-bit Arm target, not one tuned for the Cortex-A76.
• The board runs the performance governor at 2.4 GHz with an active cooler; its SoC peaked at 70.5 °C and the firmware reported no throttling or under-voltage during any accepted run.
• PSTRF compares two algorithms that pivot on the same entry but produce different factors, (L L^T) and (L D L^T), and charges both the same flop count.

Full tables

GFLOP/s per shape and library, with the Eigen ÷ OpenBLAS ratio. Eigen was measured once per cell, in the same binary and run as the library.