shdr1.0.0CPU + GPU compute

Hardware report

Raspberry Pi 5 and Broadcom V3D: pipeline benchmark

Measurements recorded on 2026-10-15.

Method

All pipelines use seed 12345, scale 1, twenty timed repetitions and the es31 profile. Times are mean completed workload milliseconds. CPU stages execute serially, and the asynchronous ring uses two CPU workers. GPU timings include dispatch-loop completion. Timing starts after compilation, initial uploads and warmup, and ends before final downloads. Mixed-backend transfers occur within the timed interval. The dynamic library is loaded before timing.

The asynchronous row measures thirty-two completed affine jobs of 257 floats through three reusable slots, including submission and polling. Each neural training row measures one mini-batch gradient/SGD update, and inference measures a separate forward dispatch. The executables check full training convergence separately.

The EVT3 workload decodes 65536 sixteen-bit words into 223772 ordered uvec4 events through five stages including reset. Its timing covers those decoder stages. The optical-flow workload uses 610 seeded samples from a 32×24 temporal plane, history 64 and six linked stages. The RLE workload produces 13556 payload words plus 257 offset words, a 4.74-fold size reduction.

The FFT rows transform eight complex channels of length 1024. The FIR row filters eight real channels of 2048 samples with 65 coefficients. The biquad row uses the same channel and sample counts, retaining state between timed blocks after each backend starts from an identical reset. The frequency mask keeps the 4–10 kHz band at a 48 kHz sample rate.

The LeNet row measures seven native inference stages for 32 images and 61,706 parameters. Its resident inputs and parameters are seeded random values. The separate trained-model evaluation below uses original MNIST test images.

The benchmark compares floating outputs with absolute and relative tolerances and unsigned outputs exactly. It checks Fourier reconstruction and compression round trips using seeded inputs and parameters. Each timing run has a dedicated measurement interval after builds and tests finish.

# Configure the example build directory.
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
# Compile the configured targets and embedded shaders.
cmake --build build -j4
# Run the registered correctness checks and report any failures.
ctest --test-dir build --output-on-failure -j2
# Measure completed ES 3.1 workloads with the recorded benchmark settings.
SHDR_BENCH_ITERATIONS=20 SHDR_BENCH_SCALE=1 build/example_benchmark --gpu es31

The measured runtime-header SHA-256 is 0555b3742fa5646d094747786a9d90bbda334bf0dfbf35c639b359224f571416. The results provenance records the header and frontend fingerprints used for validation.

Results

CPU/GPU is the unrounded CPU mean divided by the unrounded graphics mean. A value above one means the graphics path completed faster for that workload. Table values are rounded to three decimal places.

Pipeline Workload CPU ms GPU ms CPU/GPU
Buffer affine/clamp/sum 16384 floats 0.516 1.956 0.264
Buffer/image blur 128 x 128 1.033 0.471 2.192
Borrowed image blur 128 x 128 0.951 0.469 2.029
Hybrid affine/clamp/sum 16384 floats 0.597 2.188 0.273
Dynamic library stages 16384 floats 0.838 1.968 0.426
RAW10/debayer/luminance 128 x 128 2.466 2.522 0.978
2D convolution 5 x 5 128 x 128 vec2 3.283 2.444 1.343
3D convolution 3 x 3 x 3 24 x 24 x 24 3.156 3.020 1.045
Forward/inverse direct DFT 32 x 32 complex 2.589 0.579 4.472
Gaussian/Sobel/Harris/NMS 128 x 128 4.571 2.345 1.949
Lossless tiled RLE round trip 65536 uints 1.256 1.253 1.002
EVT3 event decoding 65536 packed words 4.873 6.988 0.697
Async ring 32 x 257 floats, 3 slots 0.143 1.976 0.072
EVT3 + optical flow 32 x 24 sampled plane, history 64 0.640 0.656 0.976
ANN training 32 samples, 33 parameters 0.206 0.114 1.804
ANN inference 32 samples, 33 parameters 0.006 0.037 0.173
CNN training 32 samples, 23 parameters 3.254 0.490 6.636
CNN inference 32 samples, 23 parameters 0.138 0.057 2.393
Transformer training 8 sequences, 4 tokens x 4, 134 parameters 2.404 0.729 3.296
Transformer inference 8 sequences, 4 tokens x 4, 134 parameters 0.018 0.055 0.330
FFT forward/inverse 8 x 1024 complex 5.936 4.174 1.422
FIR low-pass 8 x 2048 floats, 65 taps 6.570 5.499 1.195
Biquad low-pass 8 x 2048 floats, persistent state 0.156 0.691 0.226
FFT band-pass 8 x 1024 complex, 4-10 kHz 6.153 5.001 1.230
LeNet classifier 32 x 28 x 28, 61,706 parameters 116.491 136.617 0.853

Complete held-out model evaluation

The native seven-stage classifier used the prepared model and all 10,000 original MNIST test images. Both backends produced 9778 correct predictions, matching the independent preparation result. Each score was compared with the shipped PyTorch reference logits. The normalized error is abs(actual-reference)/(1+abs(reference)), maximized across every score.

Backend Correct Accuracy Maximum normalized logit error Completed evaluation seconds
CPU 9778/10000 97.78% 4.00418e-6 35.0628
V3D, ES 3.1 profile 9778/10000 97.78% 4.57699e-6 41.5901

These times include bounded batch construction, input preparation, program setup, native inference, result reads and reference comparisons. They are separate from the resident benchmark above. All other public-data functional cases passed in the same runs. See the dataset guide for source provenance, preparation and metric scope.