Five-vector comparison — GooseArrays (prototype measurements retained for v0.1)

Measurements from October 31, 2026: 1,406 cases (996 original + 410 additional) and 6,030 passing assertions, using Julia 1.13.3 on an Apple M5 Max with one Julia task and one BLAS thread.

Each cell reports median time in nanoseconds / GC-allocated bytes. Arena initialization and compilation are excluded from these operations and measured separately. — means not measured, never zero. Differences of a few percent may be measurement noise.

The five vector types are measured at lengths 2, 3, 4, 8, 16, 32, 64, 100, and 1,000. MVector cases with 10,000 or 100,000 elements are omitted to limit StaticArrays code expansion and compilation; StaticGooseArray is measured at those lengths.

Vector mapping, reductions, and broadcasting

The mapping function is map(x -> 2x+1, b) and the reduction is mapreduce(abs2,+,b). Fused summation is sum(x -> 2x+1, b) and does not materialize an intermediate result. Out-of-place operations are followed by sum to consume the result, measuring the full pipeline. For arena-backed arrays, this includes entering and leaving the scope.

<!– BEGIN GENERATED BENCHMARK: vectors –>

<!– END GENERATED BENCHMARK: vectors –>

Matrix multiplication

Square Float64 matrices. mul! uses a preallocated destination; multiplying and then summing includes allocation and consumption of the result. MMatrix is only measured up to 16×16.

<!– BEGIN GENERATED BENCHMARK: matrices –>

<!– END GENERATED BENCHMARK: matrices –>

Additional operations, construction allocations, SVector / SMatrix, and specialization are covered below and in the CSV files under benchmark/reference/m5-max-2026-10-31/.

Multiple inputs and scaling operations

Functions: f₂(x,y)=xy and f₃(x,y,z)=x+yz. Mapping followed by summation remains two operations and materializes an intermediate result. Native global numeric + mapreduce implementations do not store mapped elements. For Goose arrays, out-of-place operations and multi-input reductions use the same scope per invocation across all four benchmark groups, including after temporaries are released. axpy! uses α=0.25; axpby! uses α=0.25 and β=0.5. All 410 additional cases use the same kernels at each stage.

<!– BEGIN GENERATED BENCHMARK: multi-input –>

<!– END GENERATED BENCHMARK: multi-input –>

Matrix–vector products

Square n×n matrices and n-element vectors. mul! uses a preallocated output; multiplication followed by summation includes allocation and consumption of the result, as in the matrix–matrix benchmarks.

<!– BEGIN GENERATED BENCHMARK: matvec –>

<!– END GENERATED BENCHMARK: matvec –>

Exact benchmark environment

GooseArrays: 0.6.0 (measured before the prototype was renamed to v0.1.0)
Julia: 1.13.3; kernel: Darwin; architecture: aarch64
CPU: Apple M5 Max
Julia threads: 1; BLAS threads: 1
FixedSizeArrays: 1.5.1
StaticArrays: 1.9.24
BenchmarkTools: 1.8.0
Seconds per case: 0.25; max samples: 3000
Lengths: 2,3,4,8,16,32,64,100,1000,10000,100000; StaticArrays max: 1000
Square matrix sides: 2,3,4,8,16,64,256
BLAS: LBTConfig([ILP64] libopenblas64_.0.3.30.dylib)

Additional benchmark campaign:

GooseArrays=0.6.0 (measured before the prototype was renamed to v0.1.0)
Julia=1.13.3
CPU=Apple M5 Max
BLAS=LBTConfig([ILP64] libopenblas64_.0.3.30.dylib)
threads=1, BLAS=1
seconds=0.25, samples=3000
lengths=2,3,4,8,16,64,1000,10000,100000
StaticGoose max=100000
sides=2,3,4,8,16,64,256

The four packages are Base, FixedSizeArrays, GooseArrays, and StaticArrays. The five vector columns contain mutable vectors. Immutable SVector and SMatrix provide additional reference points, not replacements for in-place operations.

Construction, indexing, and additional operations

Units: nanoseconds / GC bytes. Escaping constructors store their result in Ref{Any}; arena cases call reset! to reuse storage. Construction plus computation fills the array with 2 and then reduces it. This workload can be optimized substantially when the array length is known.

<!– BEGIN GENERATED BENCHMARK: additional –>

<!– END GENERATED BENCHMARK: additional –>

Construction inside a non-escaping scope is measured separately in the CSV for both Goose variants. The CSV also reports arena bytes consumed. Zero GC bytes does not mean zero memory usage: for these Float64 arrays, elements occupy 8×n bytes, plus initial metadata and any escaping descriptors.

Immutable StaticArrays reference results

<!– BEGIN GENERATED BENCHMARK: svector –>

<!– END GENERATED BENCHMARK: svector –>

SMatrix multiplication followed by summation is also available in the CSV for small matrices.

Compilation and specialization

Measurements use a fresh process, excluding input construction and package loading. The first call uses invokelatest to include compilation of the measured kernel. Timings depend on call order and compiler behavior, so these do not constitute a full startup benchmark. Counts refer to MethodInstance objects, not an exhaustive inventory of CodeInstance objects.

<!– BEGIN GENERATED BENCHMARK: specialization –>

<!– END GENERATED BENCHMARK: specialization –>

GooseArray retains a single concrete type across all tested lengths. StaticGooseArray and StaticArrays intentionally specialize by shape. Generation tokens and arena identities are not type parameters; tests cover recreating arrays with identical shapes.

Validation and limitations

6,030 assertions passed via Pkg.test with --check-bounds=yes in the original benchmark campaign. The tests cover shapes, zero-copy conversions, aliasing, nested scopes, memory reuse, callbacks that invalidate arenas, matrix operations, allocations, and specialization. Both Goose array variants retain lifetime checks even under @inbounds; as in Julia, bounds checks may still be disabled by @inbounds.

Results cover warmed-up kernels with concrete types. The arena and scope states are allocated once, while descriptors can still incur GC allocations if they escape. Static dimensions do not imply inline tuples or native stack placement. The LLVM optimization is enabled on Julia 1.13.x (tested on 1.13.3), with a portable fallback on other versions. Static shapes do not guarantee a speedup for every operation.

The benchmark case count includes all families and sizes; it is not a count of wins by any one type. Minimum and p95 values are in the CSV files; the tables show medians. RSS and physical memory pages were not measured. No direct speed comparison with the Goose language was performed.

Reproduce these measurements

Public release 0.1.0 uses code from the last prototype iteration, which was still internally numbered 0.6.0 when these measurements were collected. The CSV files are historical reference measurements, not universal performance guarantees. Raw values and environment details are available in benchmark/reference/m5-max-2026-10-31/.

From the repository root:

julia --startup-file=no benchmark/bench.jl
julia --startup-file=no benchmark/bench.jl --full

The first command runs a short selection; the second runs both full suites. Outputs are written to the untracked benchmark/results/ directory. Use --out path/to/directory for a different destination.

Refresh the displayed tables

All benchmark tables in this page and the README are generated by a Julia-only script from the CSV files in benchmark/reference/m5-max-2026-10-31/:

julia --startup-file=no benchmark/update_tables.jl

For a new campaign, first save the benchmarks.csv, staged.csv, and, if available, specialization.csv files in a version-controlled reference folder. Then refresh both Markdown files in one command:

julia --startup-file=no benchmark/update_tables.jl --source benchmark/reference/my-new-run

If specialization.csv is missing, its existing table is left unchanged. Update the written hardware, Julia version, date, case counts, and methodology separately: the generator only replaces the tables, not their contextual text. For CI-style consistency checks, use --check instead of regenerating files.

Out-of-place map timings include consuming the result and, for Goose arrays, leaving the scope. Zero reported GC allocation does not mean the arena uses zero bytes. Escaping descriptors and arena initialization can allocate on the GC heap. Results depend on the machine, Julia version, and execution context.