Skip to content

Benchmark Results — Arduino Ventuno Q

An assessment of the arduino-ventuno-q system described on the benchmark systems page: a Qualcomm “Monaco” with 4× Cortex-A78C and 4× Cortex-A55. It is read from the capability cards of the platform benchmark of #721, and from the interleave sweeps taken in the same sessions (#780). This is the only machine of the campaign with both GCC and Clang on AArch64.

Provenance. Everything on this page comes from two sessions on 2026-11-11, except the two 2026-11-13 sections (#811 and OpenBLAS, native-fast with DotProd) and the later figures under Fixed since these sessions: the A/B runs of the fixes and the 2026-11-13 confirmations. The two 2026-11-11 sessions used the same commit and the same build, and the board had a cold boot between them. The published card has since moved to the last 2026-11-13 pair, so its figures differ from the ones quoted outside those sections.

Sessions20261111T185721Z and 20261111T191603Z (raw data). The card now shows 20261113T174232Z, the second of a later pair (the first is 20261113T170450Z)
Commitbfa1c2822688
CompilerGCC 13.3.0, -O3 -DNDEBUG, MTL5_NATIVE_ARCH=ON. The build ISA is NEON without DotProd: GCC 13 resolves -march=native to baseline Armv8.0-a on this board (#806). Highway’s target is NEON_WITHOUT_AES. Clang 18.1.3 ran only the interleave sweep
Coresthe four Cortex-A78C, CPUs 0–3, pinned with taskset. The A55s (CPUs 4–7) are excluded
Clock policygovernor performance on the A78C policies: 902–2112 MHz on CPUs 0–1, 940–2361 MHz on CPUs 2–3
Runsnative and native-fast, each at 1 and 4 threads, class medium. CMake found no BLAS/LAPACK on the board, so platform.sh skipped the blas variant
Failed checks0
Repeatability413 of 444 entries (93.0%) within ±5% between the two sessions; 21 of the 31 outliers are in the 4-thread runs
Thermal36.3 °C before and 34.8 °C after the 4-thread native-fast run. The board doesn’t come near its limit
  • native-fast GEMM reaches 57% of the FMA peak on one A78C and scales 3.6× on four. The generic build reaches 30% and scales 2.0×. There is no vendor BLAS to compare with on this board.
  • One core saturates memory. The bandwidth probe reads 24.9 GB/s on one core and 24.8 on four. Bandwidth-bound kernels therefore gain little from threads: gemv gains 1.25–1.35× in native-fast and spmv 1.3×. The Jetson’s single core reaches less than half its module’s bandwidth.
  • The threaded LU was 4.4× slower on four cores than on one (#805); #811 fixed it. factor/lu f64 512×512 took 24.6 ms on one thread and 109 ms on four, in both builds and in both sessions. The thread pool’s workers slept between parallel regions, and the A78C takes 1.5–1.8 ms to leave its idle state. In the 2026-11-13 sessions four threads take 17.2 ms, 1.4× faster than one. See Sessions of 2026-11-13.
  • GCC’s f32 triangular kernels show #795. In the generic native build, the f32 trsv takes 20.7 ms against 4.95 ms for f64. Clang on the same board doesn’t show it. The defaults of #798 set W = 2 for these kernels under GCC on AArch64, which brought them to 4.7–4.8 ms, 1.45–1.48× slower than Clang’s W = 4. The keep_scalar barrier was the cause; without it on AArch64, GCC’s W = 4 takes 3.12 ms (trmv) and 2.99 ms (forward substitution), now the default (interleave width).

The median %roof of each area, from the “Across the runs” section of session 20261111T191603Z’s card. Areas without a roofline are left out.

areanative 1Tnative 4Tnative-fast 1Tnative-fast 4T
blas183%90%94%90%
blas255%52%55%57%
blas330%9%45%18%
factor12%2%12%2%
eigen15%4%15%4%
elementwise5%5%5%5%
sparse30%54%29%55%
direct1%0%1%0%
smoother47%51%47%52%
mg36%33%37%33%
mixed33%30%38%35%
  • The memory roof is the same at one and four threads, so the memory-bound areas (blas1, blas2, sparse, smoother, mg) compare directly between the columns. The compute roof is four times higher at four threads.
  • blas1 and blas2 are close in the generic build and in native-fast: 83% against 94% and 55% against 55% on one core, and within 5 points on four. On this board, memory limits the vector kernels more than the instructions do.

Roofline plots of the generic and native-fast builds, at 1 and 4 threads

Each panel places one build’s entries at their arithmetic intensity (flops per byte moved) and their measured GFLOP/s. The rows are 1 thread and all 4 threads. The columns are the generic native build, the baseline a straightforward implementation gives, and native-fast, the best MTL5 does. There is no OpenBLAS column, because CMake found no BLAS/LAPACK on the board. The lines are each run’s own roofs: the measured bandwidth up to the ridge, then the FMA peak, solid for f64 and dashed for f32. An entry at 100% of its roof sits on the line. Integer entries are left out, because the model has no integer ceiling, and so are the 28 entries that record no flops or bytes (Krylov solvers, preconditioners, orderings and sparse eigensolvers). That leaves 74 of the 111 entries in each panel.

Across the columns:

  • Level 3 is where the builds separate. GEMM is at 30% and 57% of the FMA peak on one core, and at 15% and 51% on four.
  • The factorizations and eigensolvers don’t move: the factor median is 12% in both builds on one core.
  • The memory-bound entries sit on the slope in both columns. blas1 is at a median 83% in the generic build and 94% in native-fast.

Within the native-fast column:

  • The memory-bound points line up along the slope, and the slope is the same in both panels: one core already draws the 24.9 GB/s. blas1 is at a median 94% of its roof on one core and 90% on four, the smoothers at 47–52%.
  • Level 3 is the only area near the ceiling. GEMM is at 57% of the FMA peak on one core and 47–51% on four.
  • A few memory-bound points sit slightly above the slope. The slope is the best of three bandwidth probes (triad, read and update), not a hard limit, and a kernel with a lighter read/write mix can beat it. axpy and scale reach 101–109%.
  • Points far under the slope at an intensity near 0.06 are the elementwise transcendentals (sin, erf, log, exp, sqrt). The model counts one flop per element, but each costs tens of instructions, so they are compute- bound in fact and sit 13–28× under the slope on one core.
  • The compute-bound points other than level 3 sit far under the ceiling: at most a third of it, and the sparse direct solvers under 4%. These are the factorizations at 512×512, the dense eigensolvers at 256×256 and the sparse direct solvers. Their flop counts are nominal, and most of their time goes to panels, pivoting, iteration and indirect access, not to FMAs at full width.

blas3/gemm, 512×512×512, GFLOP/s and % of the measured FMA peak. The peak is 16.8 GFLOP/s on one A78C in f64 (128-bit NEON, two FMA pipes, at 2.1 GHz) and 67.8 GFLOP/s on four.

nativenative-fastnative-fast speedup
f64, 1 thread4.98 (30%)9.52 (57%)
f64, 4 threads9.93 (15%)34.34 (51%)3.6×
f32, 1 thread10.64 (32%)19.39 (58%)
f32, 4 threads22.29 (16%)63.71 (47%)3.3×
  • Per core, native-fast lands at the Jetson’s fraction of the peak (57% against 60%). The A78C’s clock gives it 1.5× the Jetson’s absolute figure.
  • The register-tile sweep found 8×4 the best tile on this board, and that 12×4 loses at four threads (register-tile sweep).
  • Mixed precision (mixed/gemm, f32 inputs and f64 accumulation) reaches 6.43 GFLOP/s on one core and 24.0 on four in native-fast.

The platform sessions are GCC only. The interleave sweep built the same generic row kernels with both compilers, on one pinned A78C, n = 4096. The values are the median of 6 runs over both sessions, in ms, at each compiler’s fastest width.

kernelGCC 13.3Clang 18.1Clang / GCC
gemv f648.10 (W=4)8.25 (W=4)1.02
trmv f644.45 (W=4)4.52 (W=4)1.02
trisolve f644.39 (W=4)4.48 (W=4)1.02
gemv f325.56 (W=4)6.39 (W=4)1.15
trmv f324.76 (W=2)3.29 (W=4)0.69
trisolve f324.71 (W=2)3.18 (W=4)0.68
  • Under Clang, W = 4 is the fastest width of every kernel, and W = 6 is 18–24% slower. That is the clean AArch64 result behind #798’s W = 4 default.
  • Under GCC, f32 trmv and forward substitution at W = 4 take 31.7 and 26.2 ms: 6.7× and 5.6× slower than at W = 2 (#795). In these sessions only W = 2 avoided it, and even with #798’s GCC exception these two kernels stayed 1.45–1.48× behind Clang. The cause was the keep_scalar barrier. Without it on AArch64, GCC takes 3.12 and 2.99 ms at W = 4, within 6% of Clang’s 3.29 and 3.18 (an A/B after these sessions).
  • The two compilers are within 2% on f64, and GCC is 15% faster on f32 gemv.

Column-major gemv in native-fast (#804). In these sessions it takes 49.2 ms on one core against 9.8 ms in the generic build: 5.0× slower, and the same gap appeared on every machine of the campaign. #809 fixed the kernel’s traversal (see the i7-12700K page). In its A/B run on this machine (one core, n = 4096), f64 went from 47.52 to 7.74 ms and f32 from 22.77 to 4.10 ms, against 10.06 and 4.74 ms in the generic build. The 2026-11-13 sessions confirm it: 7.73 ms in native-fast against 10.03 ms in the generic build, f64, one core.

The threaded LU (#805). In these sessions factor/lu f64 512×512 is 4.4× slower on four threads than on one (native-fast 24.6 → 109.1 ms; the generic build 26.2 → 109.5 ms; the first session 24.7 → 112.4 ms). #811 fixed it; the next section has the figures.

The quad integer gemm (#806). In these sessions gemm_quad i8>i32 is slower than the plain i8 gemm: 11.4 against 16.2 GOP/s on one core, 41.2 against 62.6 on four. Its cause was the build, not the kernel. GCC 13 resolves -march=native to baseline Armv8.0-a here, passing no -march or -mcpu on to the compiler, so native-fast had no DotProd and the quad step ran Highway’s emulation of SDOT. #819 added MTL5_NATIVE_ARCH_FLAGS and the profile now names the cores’ features; the last section has the figures.

Two more sessions, after OpenBLAS and SuiteSparse were installed on the board. Their native-fast build was still baseline Armv8.0-a (#806); the next section has the pair that fixed it.

Sessions20261113T131507Z and 20261113T135246Z, a cold boot before each
Commit967d20ac6b04, after #809 (column-major gemv), #811 (the thread pool) and #817
Runsnative, native-fast and blas (OpenBLAS 0.3.26, with CHOLMOD for the reference entries), each at 1 and 4 threads, class medium. The same cores, compiler and clock policy as above
Failed checks0. The 14 PARDISO entries are skipped: MKL is x86-only
Repeatability780 of 824 entries (94.7%) within ±5% between the two sessions; 26 of the 44 outliers are in the 4-thread runs

Threading after #811. native-fast, f64, the second session of each pair, ms:

entry11-11, 1T11-11, 4T11-13, 1T11-13, 4T4T speedup, 11-13
factor/lu24.6109.124.717.21.43×
factor/lu_iterative_refine (f32>f64)20.9108.016.712.21.37×
factor/qr2501992511471.70×
factor/lq60.6126.460.836.71.66×
factor/hessenberg3484403502001.75×
factor/householder1.551.031.560.453.5×
factor/inv1432241471271.16×
factor/cholesky22.320.122.419.91.12×
  • Every entry that four threads made slower is now faster on four. The 1-thread times are unchanged, except the refinement’s, which fell from 20.9 to 16.7 ms between the pairs. The thread pool’s workers now spin for up to 1 ms before they sleep (MTL5_THREAD_POOL_SPIN_US), so a parallel region that follows within that time no longer pays the A78C’s 1.5–1.8 ms wake-up. The unblocked LU opens one region per column, about 150 that split at n = 512, which is why it lost the most.
  • The LU’s 1.4× is now in line with the Jetson’s (1.4× on six cores in its sessions). It is still modest: the unblocked algorithm has little parallel work per column at this size.
  • factor/cholesky didn’t change. Its regions were long enough before.

The OpenBLAS column. On one core OpenBLAS’s gemm reaches 89% of the FMA peak (17.9 GFLOP/s), and native-fast’s 57% is 64% of it. At four threads they are at 80% and 53%. The factor median is 41% of the roof in OpenBLAS against 12% in native-fast. LAPACK’s LU takes 9.16 ms on one core and 4.10 ms on four, so MTL5’s is 2.7× and 4.2× slower.

The direct solvers against CHOLMOD are on the direct-solver references page.

Sessions of 2026-11-13: native-fast with DotProd (#806)

Section titled “Sessions of 2026-11-13: native-fast with DotProd (#806)”

Two more sessions after #819, with the native-fast build on the cores’ own features. The published card shows the second.

Sessions20261113T170450Z and 20261113T174232Z, a cold boot before each
Commitbf315e4, after #819 (MTL5_NATIVE_ARCH_FLAGS)
native-fast flags-march=armv8.2-a+dotprod+fp16+rcpc -mtune=cortex-a78c, what /proc/cpuinfo lists on every core. The sidecars record build_isa=NEON DOTPROD
Runsas in the previous pair. native and blas don’t use MTL5_NATIVE_ARCH and are unchanged
Failed checks0, with the 14 PARDISO entries skipped
Repeatability780 of 824 entries (94.7%) within ±5% between the two sessions; 30 of the 44 outliers are in the 4-thread runs

What DotProd changes. native-fast, second session of each pair, ms:

entryArmv8.0-a, 1TDotProd, 1TspeedupArmv8.0-a, 4TDotProd, 4Tspeedup
integer/gemm_quad i8>i3223.73.686.4×5.960.966.2×
integer/gemm_quad u8i8>i3250.913.63.8×12.73.323.8×
integer/dot i8>i322.330.6953.4×2.120.6773.1×
integer/dot u8i8>i324.261.532.8×3.811.362.8×
mixed/block_scaled_dot i8+f322.650.7553.5×2.370.9622.5×
smoother/gauss_seidel f644.672.501.9×4.072.271.8×
integer/gemm i8>i3216.616.61.0×4.194.201.0×
blas3/gemm f6428.128.31.0×7.437.431.0×
  • gemm_quad i8 is now 4.5× faster than the plain i8 gemm on one core (72.8 against 16.2 GOP/s) and 4.4× on four, where it was 30% slower. That is the relation the Jetson showed, and for the same reason: its build has DotProd. The u8i8 pairing is emulated even with DotProd (USDOT needs I8MM, which the A78C lacks), but the emulation now builds on SDOT/UDOT and is 3.8× faster.
  • The 8-bit dots gain 2.8–3.4× for the same reason.
  • Native-fast’s Gauss–Seidel smoother took 1.9× the generic build’s time on Armv8.0-a (4.67 against 2.50 ms) and now matches it (2.50 ms).
  • Everything else is unchanged. The median native-fast entry moves by 0.1–0.2%, and no other entry by more than 16% (blas3/kron, whose run-to-run spread here is about that size). Floating-point FMA and NEON are in Armv8.0-a already, so GEMM and the factorizations don’t change.
  • The kernel exposes no cache sizes, so the card’s last-level-cache probe reads 0. A cache-blocked kernel then runs on its defaults, and the cache-blocking A/B was a null run for the same reason (cache-blocking A/B).
  • The two A78C policies have different caps: 2112 MHz on CPUs 0–1 and 2361 MHz on CPUs 2–3. A 1-thread run is on CPU 0. A 4-thread run mixes the two.
  • The 4-thread runs are less repeatable than the 1-thread runs: 21 of the 31 entries outside ±5%.
  • No vendor reference in the 2026-11-11 sessions. Without OpenBLAS on the board then, %roof is the only yardstick for native-fast in them. The 2026-11-13 sessions have an OpenBLAS column.
Terminal window
benchmarks/remote_session.sh <ssh-host> arduino-ventuno-q-platform.sh --reboot --interleave
cmake -DRESULTS=build-platform/remote/arduino-ventuno-q/<session> -DMACHINE=arduino-ventuno-q \
-P benchmarks/publish_platform.cmake
benchmarks/plot_roofline.py benchmarks/data/arduino-ventuno-q/mtl5_bench/20261111T191603Z \
--out docs/img/benchmarks/arduino-ventuno-q/roofline-platform.svg
benchmarks/compare_sessions.py benchmarks/data/arduino-ventuno-q/mtl5_bench/20261111T185721Z \
benchmarks/data/arduino-ventuno-q/mtl5_bench/20261111T191603Z

The harness README gives the full session and publishing steps. The raw results of both sessions are under benchmarks/data/arduino-ventuno-q/mtl5_bench/.