FixedSizeArrays.jl Showcase

[giordano]

I'm starting this discussion to collect examples of how FixedSizeArray can be better (smaller generated code and/or faster) than standard Array. I'll start with the example in the README.md

Simple function which can constant-propagate the size of the array

julia> using FixedSizeArrays

julia> @noinline f(A::AbstractArray) = length(A)
f (generic function with 1 method)

julia> g() = f(FixedSizeVector{Float64}(undef, 3))
g (generic function with 1 method)

julia> h() = f(Vector{Float64}(undef, 3))
h (generic function with 1 method)

julia> code_llvm(g, ())

; Function Signature: g()
;  @ REPL[9]:1 within `g`
define i64 @julia_g_14341() #0 {
top:
;  @ REPL[9] within `g`
  ret i64 3
}

julia> code_llvm(h, ())

; Function Signature: h()
;  @ REPL[10]:1 within `h`
define i64 @julia_h_14351() #0 {
top:
  %gcframe1 = alloca [3 x ptr], align 16
  call void @llvm.memset.p0.i64(ptr align 16 %gcframe1, i8 0, i64 24, i1 true)
  %pgcstack = call ptr inttoptr (i64 6483926436 to ptr)(i64 262) #10
  store i64 4, ptr %gcframe1, align 8
  %task.gcstack = load ptr, ptr %pgcstack, align 8
  %frame.prev = getelementptr inbounds ptr, ptr %gcframe1, i64 1
  store ptr %task.gcstack, ptr %frame.prev, align 8
  store ptr %gcframe1, ptr %pgcstack, align 8
; ┌ @ boot.jl:598 within `Array`
; │┌ @ boot.jl:538 within `GenericMemory`
    %"Memory{Float64}[]" = call ptr @jl_alloc_genericmemory(ptr nonnull @"+Core.GenericMemory#14353.jit", i64 3)
; │└
; │ @ boot.jl:599 within `Array`
; │┌ @ boot.jl:544 within `memoryref`
    %.data_ptr = getelementptr inbounds { i64, ptr }, ptr %"Memory{Float64}[]", i64 0, i32 1
    %0 = load ptr, ptr %.data_ptr, align 8
    %gc_slot_addr_0 = getelementptr inbounds ptr, ptr %gcframe1, i64 2
    store ptr %"Memory{Float64}[]", ptr %gc_slot_addr_0, align 8
; │└
   %ptls_field = getelementptr inbounds ptr, ptr %pgcstack, i64 2
   %ptls_load = load ptr, ptr %ptls_field, align 8
   %"new::Array" = call noalias nonnull align 8 dereferenceable(32) ptr @ijl_gc_small_alloc(ptr %ptls_load, i32 616, i32 32, i64 5266096992) #8
   %"new::Array.tag_addr" = getelementptr inbounds i64, ptr %"new::Array", i64 -1
   store atomic i64 5266096992, ptr %"new::Array.tag_addr" unordered, align 8
   %1 = getelementptr inbounds ptr, ptr %"new::Array", i64 1
   store ptr %0, ptr %"new::Array", align 8
   store ptr %"Memory{Float64}[]", ptr %1, align 8
   %"new::Array.size_ptr" = getelementptr inbounds i8, ptr %"new::Array", i64 16
   store i64 3, ptr %"new::Array.size_ptr", align 8
   store ptr %"new::Array", ptr %gc_slot_addr_0, align 8
; └
  %2 = call i64 @j_f_14357(ptr nonnull %"new::Array")
  %frame.prev10 = load ptr, ptr %frame.prev, align 8
  store ptr %frame.prev10, ptr %pgcstack, align 8
  ret i64 %2
}

julia> versioninfo()
Julia Version 1.12.0-DEV.1082
Commit 58c7186d19* (2024-08-22 02:53 UTC)
Platform Info:
  OS: macOS (arm64-apple-darwin23.4.0)
  CPU: 8 × Apple M1
  WORD_SIZE: 64
  LLVM: libLLVM-18.1.7 (ORCJIT, apple-m1)
Threads: 1 default, 0 interactive, 1 GC (on 4 virtual cores)

[giordano]

Adding vectors of BFloat16

julia> using BenchmarkTools, BFloat16s, FixedSizeArrays

julia> @benchmark A .= A .+ A setup=(A=ones(BFloat16, 1_000)) evals=1
BenchmarkTools.Trial: 10000 samples with 1 evaluation.
 Range (min … max):  861.000 ns …  3.886 μs  ┊ GC (min … max): 0.00% … 0.00%
 Time  (median):     891.000 ns              ┊ GC (median):    0.00%
 Time  (mean ± σ):   893.142 ns ± 49.696 ns  ┊ GC (mean ± σ):  0.00% ± 0.00%

                                     █▁
  ▂▂▁▁▁▁▁▁▁▁▁▄▃▁▁▁▁▁▁▁▁▁▁▅▃▁▁▁▁▁▁▁▁▁▁██▁▁▁▁▁▁▁▁▁▁▇▄▁▁▁▁▁▁▁▁▁▃▃ ▂
  861 ns          Histogram: frequency by time          912 ns <

 Memory estimate: 0 bytes, allocs estimate: 0.

julia> @benchmark A .= A .+ A setup=(A=FixedSizeVector(ones(BFloat16, 1_000))) evals=1
BenchmarkTools.Trial: 10000 samples with 1 evaluation.
 Range (min … max):  570.000 ns …  3.936 μs  ┊ GC (min … max): 0.00% … 0.00%
 Time  (median):     591.000 ns              ┊ GC (median):    0.00%
 Time  (mean ± σ):   596.819 ns ± 60.906 ns  ┊ GC (mean ± σ):  0.00% ± 0.00%

                      █
  ▂▁▁▁▁▁▁▁▁▃█▁▁▁▁▁▁▁▁▄█▁▁▁▁▁▁▁▁▃█▁▁▁▁▁▁▁▁▂▆▁▁▁▁▁▁▁▁▂▃▁▁▁▁▁▁▁▁▂ ▂
  570 ns          Histogram: frequency by time          631 ns <

 Memory estimate: 0 bytes, allocs estimate: 0.

julia> versioninfo()
Julia Version 1.12.0-DEV.1082
Commit 58c7186d198 (2024-08-22 02:53 UTC)
Build Info:
  Official https://julialang.org/ release
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 384 × AMD EPYC 9654 96-Core Processor
  WORD_SIZE: 64
  LLVM: libLLVM-18.1.7 (ORCJIT, znver4)
Threads: 1 default, 0 interactive, 1 GC (on 384 virtual cores)

(@v1.12) pkg> st
Status `~/.julia/environments/v1.12/Project.toml`
  [ab4f0b2a] BFloat16s v0.5.0 `https://github.com/JuliaMath/BFloat16s.jl.git#b5312dd`
  [6e4b80f9] BenchmarkTools v1.5.0
  [3821ddf9] FixedSizeArrays v0.1.0 `https://github.com/JuliaArrays/FixedSizeArrays.jl#main`

Note that this processor has the avx512_bf16 extension.

[giordano]

Reshaping FixedSizeArrays vs Arrays

Taken from #41 (comment)

julia> using FixedSizeArrays

julia> @noinline f(v::AbstractVector{Float64}) = reshape(v, 2, 2)
f (generic function with 1 method)

julia> g3() = f(FixedSizeVector{Float64}(undef, 3))
g3 (generic function with 1 method)

julia> g4() = f(FixedSizeVector{Float64}(undef, 4))
g4 (generic function with 1 method)

julia> h3() = f(Vector{Float64}(undef, 3))
h3 (generic function with 1 method)

julia> h4() = f(Vector{Float64}(undef, 4))
h4 (generic function with 1 method)

julia> code_llvm(g3, (); debuginfo=:none)

; Function Signature: g3()
; Function Attrs: noreturn
define void @julia_g3_6466() #0 {
top:
  %gcframe1 = alloca [4 x ptr], align 16
  call void @llvm.memset.p0.i64(ptr align 16 %gcframe1, i8 0, i64 32, i1 true)
  %gc_slot_addr1 = getelementptr inbounds ptr, ptr %gcframe1, i64 3
  %0 = getelementptr inbounds ptr, ptr %gcframe1, i64 2
  %1 = alloca { ptr, [2 x i64] }, align 8
  %2 = alloca { ptr, [1 x i64] }, align 8
  %pgcstack = call ptr inttoptr (i64 6483926436 to ptr)(i64 262) #9
  store i64 8, ptr %gcframe1, align 8
  %task.gcstack = load ptr, ptr %pgcstack, align 8
  %frame.prev = getelementptr inbounds ptr, ptr %gcframe1, i64 1
  store ptr %task.gcstack, ptr %frame.prev, align 8
  store ptr %gcframe1, ptr %pgcstack, align 8
  %"Memory{Float64}[]" = call ptr @jl_alloc_genericmemory(ptr nonnull @"+Core.GenericMemory#6468.jit", i64 3)
  store ptr %"Memory{Float64}[]", ptr %gc_slot_addr1, align 8
  store ptr %"Memory{Float64}[]", ptr %2, align 8
  %.fca.1.0.gep = getelementptr inbounds { ptr, [1 x i64] }, ptr %2, i64 0, i32 1, i64 0
  store i64 3, ptr %.fca.1.0.gep, align 8
  call void @j_f_6470(ptr noalias nocapture noundef nonnull sret({ ptr, [2 x i64] }) %1, ptr noalias nocapture noundef nonnull %0, ptr nocapture nonnull readonly %2)
  call void @llvm.trap()
  unreachable
}

julia> code_llvm(g4, (); debuginfo=:none)

; Function Signature: g4()
define void @julia_g4_6479(ptr noalias nocapture noundef nonnull sret({ ptr, [2 x i64] }) align 8 dereferenceable(24) %sret_return, ptr noalias nocapture noundef nonnull align 8 dereferenceable(8) %return_roots) #0 {
top:
  %gcframe1 = alloca [4 x ptr], align 16
  call void @llvm.memset.p0.i64(ptr align 16 %gcframe1, i8 0, i64 32, i1 true)
  %gc_slot_addr1 = getelementptr inbounds ptr, ptr %gcframe1, i64 3
  %0 = getelementptr inbounds ptr, ptr %gcframe1, i64 2
  %1 = alloca { ptr, [2 x i64] }, align 8
  %2 = alloca { ptr, [1 x i64] }, align 8
  %pgcstack = call ptr inttoptr (i64 6483926436 to ptr)(i64 262) #11
  store i64 8, ptr %gcframe1, align 8
  %task.gcstack = load ptr, ptr %pgcstack, align 8
  %frame.prev = getelementptr inbounds ptr, ptr %gcframe1, i64 1
  store ptr %task.gcstack, ptr %frame.prev, align 8
  store ptr %gcframe1, ptr %pgcstack, align 8
  %"Memory{Float64}[]" = call ptr @jl_alloc_genericmemory(ptr nonnull @"+Core.GenericMemory#6482.jit", i64 4)
  store ptr %"Memory{Float64}[]", ptr %gc_slot_addr1, align 8
  store ptr %"Memory{Float64}[]", ptr %2, align 8
  %.fca.1.0.gep = getelementptr inbounds { ptr, [1 x i64] }, ptr %2, i64 0, i32 1, i64 0
  store i64 4, ptr %.fca.1.0.gep, align 8
  call void @j_f_6484(ptr noalias nocapture noundef nonnull sret({ ptr, [2 x i64] }) %1, ptr noalias nocapture noundef nonnull %0, ptr nocapture nonnull readonly %2)
  %3 = load ptr, ptr %1, align 8
  store ptr %3, ptr %return_roots, align 8
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(24) %sret_return, ptr noundef nonnull align 8 dereferenceable(24) %1, i64 24, i1 false)
  %frame.prev5 = load ptr, ptr %frame.prev, align 8
  store ptr %frame.prev5, ptr %pgcstack, align 8
  ret void
}

julia> code_llvm(h3, (); debuginfo=:none)

; Function Signature: h3()
define nonnull ptr @julia_h3_6493() #0 {
top:
  %gcframe1 = alloca [3 x ptr], align 16
  call void @llvm.memset.p0.i64(ptr align 16 %gcframe1, i8 0, i64 24, i1 true)
  %pgcstack = call ptr inttoptr (i64 6483926436 to ptr)(i64 262) #9
  store i64 4, ptr %gcframe1, align 8
  %task.gcstack = load ptr, ptr %pgcstack, align 8
  %frame.prev = getelementptr inbounds ptr, ptr %gcframe1, i64 1
  store ptr %task.gcstack, ptr %frame.prev, align 8
  store ptr %gcframe1, ptr %pgcstack, align 8
  %"Memory{Float64}[]" = call ptr @jl_alloc_genericmemory(ptr nonnull @"+Core.GenericMemory#6495.jit", i64 3)
  %.data_ptr = getelementptr inbounds { i64, ptr }, ptr %"Memory{Float64}[]", i64 0, i32 1
  %0 = load ptr, ptr %.data_ptr, align 8
  %gc_slot_addr_0 = getelementptr inbounds ptr, ptr %gcframe1, i64 2
  store ptr %"Memory{Float64}[]", ptr %gc_slot_addr_0, align 8
  %ptls_field = getelementptr inbounds ptr, ptr %pgcstack, i64 2
  %ptls_load = load ptr, ptr %ptls_field, align 8
  %"new::Array" = call noalias nonnull align 8 dereferenceable(32) ptr @ijl_gc_small_alloc(ptr %ptls_load, i32 616, i32 32, i64 4659479392) #7
  %"new::Array.tag_addr" = getelementptr inbounds i64, ptr %"new::Array", i64 -1
  store atomic i64 4659479392, ptr %"new::Array.tag_addr" unordered, align 8
  %1 = getelementptr inbounds ptr, ptr %"new::Array", i64 1
  store ptr %0, ptr %"new::Array", align 8
  store ptr %"Memory{Float64}[]", ptr %1, align 8
  %"new::Array.size_ptr" = getelementptr inbounds i8, ptr %"new::Array", i64 16
  store i64 3, ptr %"new::Array.size_ptr", align 8
  store ptr %"new::Array", ptr %gc_slot_addr_0, align 8
  %2 = call nonnull ptr @j_f_6499(ptr nonnull %"new::Array")
  %frame.prev10 = load ptr, ptr %frame.prev, align 8
  store ptr %frame.prev10, ptr %pgcstack, align 8
  ret ptr %2
}

julia> code_llvm(h4, (); debuginfo=:none)

; Function Signature: h4()
define nonnull ptr @julia_h4_6500() #0 {
top:
  %gcframe1 = alloca [3 x ptr], align 16
  call void @llvm.memset.p0.i64(ptr align 16 %gcframe1, i8 0, i64 24, i1 true)
  %pgcstack = call ptr inttoptr (i64 6483926436 to ptr)(i64 262) #9
  store i64 4, ptr %gcframe1, align 8
  %task.gcstack = load ptr, ptr %pgcstack, align 8
  %frame.prev = getelementptr inbounds ptr, ptr %gcframe1, i64 1
  store ptr %task.gcstack, ptr %frame.prev, align 8
  store ptr %gcframe1, ptr %pgcstack, align 8
  %"Memory{Float64}[]" = call ptr @jl_alloc_genericmemory(ptr nonnull @"+Core.GenericMemory#6502.jit", i64 4)
  %.data_ptr = getelementptr inbounds { i64, ptr }, ptr %"Memory{Float64}[]", i64 0, i32 1
  %0 = load ptr, ptr %.data_ptr, align 8
  %gc_slot_addr_0 = getelementptr inbounds ptr, ptr %gcframe1, i64 2
  store ptr %"Memory{Float64}[]", ptr %gc_slot_addr_0, align 8
  %ptls_field = getelementptr inbounds ptr, ptr %pgcstack, i64 2
  %ptls_load = load ptr, ptr %ptls_field, align 8
  %"new::Array" = call noalias nonnull align 8 dereferenceable(32) ptr @ijl_gc_small_alloc(ptr %ptls_load, i32 616, i32 32, i64 4659479392) #7
  %"new::Array.tag_addr" = getelementptr inbounds i64, ptr %"new::Array", i64 -1
  store atomic i64 4659479392, ptr %"new::Array.tag_addr" unordered, align 8
  %1 = getelementptr inbounds ptr, ptr %"new::Array", i64 1
  store ptr %0, ptr %"new::Array", align 8
  store ptr %"Memory{Float64}[]", ptr %1, align 8
  %"new::Array.size_ptr" = getelementptr inbounds i8, ptr %"new::Array", i64 16
  store i64 4, ptr %"new::Array.size_ptr", align 8
  store ptr %"new::Array", ptr %gc_slot_addr_0, align 8
  %2 = call nonnull ptr @j_f_6506(ptr nonnull %"new::Array")
  %frame.prev10 = load ptr, ptr %frame.prev, align 8
  store ptr %frame.prev10, ptr %pgcstack, align 8
  ret ptr %2
}

Julia correctly realises that g3 throws, although it doesn't remove the memory allocation.

Also, inferred effects are much better:

julia> Base.infer_effects(g3, ())
(+c,+e,!n,+t,+s,+m,+u,+o,+r)

julia> Base.infer_effects(g4, ())
(?c,+e,+n,+t,+s,+m,+u,+o,+r)

julia> Base.infer_effects(h3, ())
(!c,!e,!n,!t,!s,!m,!u,+o,!r)

julia> Base.infer_effects(h4, ())
(!c,!e,!n,!t,!s,!m,!u,+o,!r)

System:

julia> versioninfo()
Julia Version 1.12.0-DEV.1082
Commit 58c7186d19* (2024-08-22 02:53 UTC)
Platform Info:
  OS: macOS (arm64-apple-darwin23.4.0)
  CPU: 8 × Apple M1
  WORD_SIZE: 64
  LLVM: libLLVM-18.1.7 (ORCJIT, apple-m1)
Threads: 1 default, 0 interactive, 1 GC (on 4 virtual cores)

[giordano]

Reduced allocations in a function with side effects

julia> using FixedSizeArrays, BenchmarkTools, Random

julia> function f(T=Vector{Float64})
           v = T(undef, 8)
           rand!(v)
           return length(v)
       end
f (generic function with 2 methods)

julia> @code_llvm debuginfo=:none f(Vector{Float64})

; Function Signature: f(Type{Array{Float64, 1}})
define i64 @julia_f_1471() local_unnamed_addr #0 {
top:
  %gcframe1 = alloca [3 x ptr], align 16
  call void @llvm.memset.p0.i64(ptr align 16 %gcframe1, i8 0, i64 24, i1 true)
  %thread_ptr = call ptr asm "movq %fs:0, $0", "=r"() #12
  %tls_ppgcstack = getelementptr inbounds i8, ptr %thread_ptr, i64 -8
  %tls_pgcstack = load ptr, ptr %tls_ppgcstack, align 8
  store i64 4, ptr %gcframe1, align 8
  %frame.prev = getelementptr inbounds nuw i8, ptr %gcframe1, i64 8
  %task.gcstack = load ptr, ptr %tls_pgcstack, align 8
  store ptr %task.gcstack, ptr %frame.prev, align 8
  store ptr %gcframe1, ptr %tls_pgcstack, align 8
  %ptls_field = getelementptr inbounds nuw i8, ptr %tls_pgcstack, i64 16
  %ptls_load = load ptr, ptr %ptls_field, align 8
  %"Memory{Float64}[]" = call noalias nonnull align 8 dereferenceable(96) ptr @ijl_gc_small_alloc(ptr %ptls_load, i32 600, i32 96, i64 133044644450816) #8
  %"Memory{Float64}[].tag_addr" = getelementptr inbounds i8, ptr %"Memory{Float64}[]", i64 -8
  store atomic i64 133044644450816, ptr %"Memory{Float64}[].tag_addr" unordered, align 8
  %memory_ptr = getelementptr inbounds nuw i8, ptr %"Memory{Float64}[]", i64 8
  %memory_data = getelementptr inbounds nuw i8, ptr %"Memory{Float64}[]", i64 16
  store ptr %memory_data, ptr %memory_ptr, align 8
  store i64 8, ptr %"Memory{Float64}[]", align 8
  %gc_slot_addr_0 = getelementptr inbounds nuw i8, ptr %gcframe1, i64 16
  store ptr %"Memory{Float64}[]", ptr %gc_slot_addr_0, align 8
  %ptls_load16 = load ptr, ptr %ptls_field, align 8
  %"new::Array" = call noalias nonnull align 8 dereferenceable(32) ptr @ijl_gc_small_alloc(ptr %ptls_load16, i32 408, i32 32, i64 133044570275280) #8
  %"new::Array.tag_addr" = getelementptr inbounds i8, ptr %"new::Array", i64 -8
  store atomic i64 133044570275280, ptr %"new::Array.tag_addr" unordered, align 8
  %0 = getelementptr inbounds nuw i8, ptr %"new::Array", i64 8
  store ptr %memory_data, ptr %"new::Array", align 8
  store ptr %"Memory{Float64}[]", ptr %0, align 8
  %"new::Array.size_ptr" = getelementptr inbounds nuw i8, ptr %"new::Array", i64 16
  store i64 8, ptr %"new::Array.size_ptr", align 8
  store ptr %"new::Array", ptr %gc_slot_addr_0, align 8
  %1 = call i64 @j_xoshiro_bulk_simd_1475(ptr nonnull %memory_data, i64 signext 64)
  %2 = sub i64 64, %1
  %3 = getelementptr i8, ptr %memory_data, i64 %1
  %4 = icmp eq i64 %1, 64
  br i1 %4, label %L26, label %L24

L24:                                              ; preds = %top
  store ptr %"new::Array", ptr %gc_slot_addr_0, align 8
  call void @j_xoshiro_bulk_nosimd_1476(ptr %3, i64 signext %2)
  br label %L26

L26:                                              ; preds = %L24, %top
  %"new::Array.size6.0.copyload" = load i64, ptr %"new::Array.size_ptr", align 8
  %frame.prev20 = load ptr, ptr %frame.prev, align 8
  store ptr %frame.prev20, ptr %tls_pgcstack, align 8
  ret i64 %"new::Array.size6.0.copyload"
}

julia> @code_llvm debuginfo=:none f(FixedSizeVectorDefault{Float64})

; Function Signature: f(Type{FixedSizeArrays.FixedSizeArray{Float64, 1, Memory{Float64}}})
define i64 @julia_f_1488() local_unnamed_addr #0 {
top:
  %"Memory{Float64}[]" = alloca [80 x i8], align 16
  call void @llvm.lifetime.start.p0(i64 80, ptr nonnull %"Memory{Float64}[]")
  %0 = getelementptr inbounds nuw i8, ptr %"Memory{Float64}[]", i64 16
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(80) %0, i8 0, i64 64, i1 false)
  %memory_ptr = getelementptr inbounds nuw i8, ptr %"Memory{Float64}[]", i64 8
  store ptr %0, ptr %memory_ptr, align 8
  store i64 8, ptr %"Memory{Float64}[]", align 8
  %1 = call i64 @j_xoshiro_bulk_simd_1491(ptr nonnull %0, i64 signext 64)
  %2 = icmp eq i64 %1, 64
  br i1 %2, label %L14, label %L13

L13:                                              ; preds = %top
  %3 = sub i64 64, %1
  %4 = getelementptr i8, ptr %0, i64 %1
  call void @j_xoshiro_bulk_nosimd_1492(ptr %4, i64 signext %3)
  br label %L14

L14:                                              ; preds = %L13, %top
  ret i64 8
}

julia> @benchmark f(Vector{Float64})
BenchmarkTools.Trial: 10000 samples with 995 evaluations per sample.
 Range (min … max):  29.652 ns …  3.009 μs  ┊ GC (min … max): 0.00% … 97.53%
 Time  (median):     31.515 ns              ┊ GC (median):    0.00%
 Time  (mean ± σ):   34.936 ns ± 44.664 ns  ┊ GC (mean ± σ):  7.26% ±  8.08%

   ███
  ▃███▇▃▄▄▅▄▃▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▁▂▁▂▁▁▁▁▁▁▁▁▂▁▁▁▁▁▁▁▁▂▂▂▂▂▂▂▂▂▂▂ ▃
  29.7 ns         Histogram: frequency by time        64.5 ns <

 Memory estimate: 128 bytes, allocs estimate: 2.

julia> @benchmark f(FixedSizeVectorDefault{Float64})
BenchmarkTools.Trial: 10000 samples with 996 evaluations per sample.
 Range (min … max):  22.383 ns … 39.769 ns  ┊ GC (min … max): 0.00% … 0.00%
 Time  (median):     23.932 ns              ┊ GC (median):    0.00%
 Time  (mean ± σ):   24.145 ns ±  0.913 ns  ┊ GC (mean ± σ):  0.00% ± 0.00%

        ▁▂▃▃▄▅▆▇███▇▇▇▆▆▅▄▃▃▂▁      ▁▂▂▂▁▁▁                   ▃
  ▆▇▇▆█████████████████████████▆▆▇▇███████████▇█▆▇▇▆██▇▇▇▇▆▆▆ █
  22.4 ns      Histogram: log(frequency) by time      27.9 ns <

 Memory estimate: 0 bytes, allocs estimate: 0.

julia> versioninfo()
Julia Version 1.13.0-DEV.596
Commit 7df60f480df (2025-05-14 21:36 UTC)
Build Info:
  Official https://julialang.org release
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 192 × AMD Ryzen Threadripper PRO 7995WX 96-Cores
  WORD_SIZE: 64
  LLVM: libLLVM-20.1.2 (ORCJIT, znver4)
  GC: Built with stock GC
Threads: 1 default, 1 interactive, 1 GC (on 192 virtual cores)

The return value is fully statically inferred, the memory allocations are fully removed (at least for length < 250, otherwise they're still less than Vector), and performance is slightly better.

[giordano]

Slight variation: return the sum of the vector, so that the intermediate computation can't possibly be removed: for small vectors (< 16 elements) the memory allocation can be entirely removed (this is on e4d221a):

julia> using BenchmarkTools, FixedSizeArrays, Random

julia> function g(T)
           v = T(undef, 15)
           rand!(v)
           return sum(v)
       end
g (generic function with 1 method)

julia> @code_llvm debuginfo=:none g(Vector{Float64})

; Function Signature: g(Type{Array{Float64, 1}})
define double @julia_g_2453() local_unnamed_addr #0 {
top:
  %gcframe1 = alloca [3 x ptr], align 16
  call void @llvm.memset.p0.i64(ptr align 16 %gcframe1, i8 0, i64 24, i1 true)
  %thread_ptr = call ptr asm "movq %fs:0, $0", "=r"() #13
  %tls_ppgcstack = getelementptr inbounds i8, ptr %thread_ptr, i64 -8
  %tls_pgcstack = load ptr, ptr %tls_ppgcstack, align 8
  store i64 4, ptr %gcframe1, align 8
  %frame.prev = getelementptr inbounds i8, ptr %gcframe1, i64 8
  %task.gcstack = load ptr, ptr %tls_pgcstack, align 8
  store ptr %task.gcstack, ptr %frame.prev, align 8
  store ptr %gcframe1, ptr %tls_pgcstack, align 8
  %ptls_field = getelementptr inbounds i8, ptr %tls_pgcstack, i64 16
  %ptls_load = load ptr, ptr %ptls_field, align 8
  %"Memory{Float64}[]" = call noalias nonnull align 8 dereferenceable(144) ptr @ijl_gc_small_alloc(ptr %ptls_load, i32 744, i32 144, i64 140047806108800) #8
  %"Memory{Float64}[].tag_addr" = getelementptr inbounds i8, ptr %"Memory{Float64}[]", i64 -8
  store atomic i64 140047806108800, ptr %"Memory{Float64}[].tag_addr" unordered, align 8
  %memory_ptr = getelementptr inbounds i8, ptr %"Memory{Float64}[]", i64 8
  %memory_data = getelementptr inbounds i8, ptr %"Memory{Float64}[]", i64 16
  store ptr %memory_data, ptr %memory_ptr, align 8
  store i64 15, ptr %"Memory{Float64}[]", align 8
  %gc_slot_addr_0 = getelementptr inbounds i8, ptr %gcframe1, i64 16
  store ptr %"Memory{Float64}[]", ptr %gc_slot_addr_0, align 8
  %ptls_load78 = load ptr, ptr %ptls_field, align 8
  %"new::Array" = call noalias nonnull align 8 dereferenceable(32) ptr @ijl_gc_small_alloc(ptr %ptls_load78, i32 408, i32 32, i64 140047732352032) #8
  %"new::Array.tag_addr" = getelementptr inbounds i8, ptr %"new::Array", i64 -8
  store atomic i64 140047732352032, ptr %"new::Array.tag_addr" unordered, align 8
  %0 = getelementptr inbounds i8, ptr %"new::Array", i64 8
  store ptr %memory_data, ptr %"new::Array", align 8
  store ptr %"Memory{Float64}[]", ptr %0, align 8
  %"new::Array.size_ptr" = getelementptr inbounds i8, ptr %"new::Array", i64 16
  store i64 15, ptr %"new::Array.size_ptr", align 8
  store ptr %"new::Array", ptr %gc_slot_addr_0, align 8
  %1 = call i64 @j_xoshiro_bulk_simd_2458(ptr nonnull %memory_data, i64 signext 120)
  %2 = sub i64 120, %1
  %3 = getelementptr i8, ptr %memory_data, i64 %1
  %4 = icmp eq i64 %1, 120
  br i1 %4, label %L26, label %L24

L24:                                              ; preds = %top
  store ptr %"new::Array", ptr %gc_slot_addr_0, align 8
  call void @j_xoshiro_bulk_nosimd_2459(ptr %3, i64 signext %2)
  br label %L26

L26:                                              ; preds = %L24, %top
  %"new::Array.size6.0.copyload" = load i64, ptr %"new::Array.size_ptr", align 8
  switch i64 %"new::Array.size6.0.copyload", label %L58 [
    i64 0, label %L135
    i64 1, label %L53
  ]

L53:                                              ; preds = %L26
  %memoryref_data = load ptr, ptr %"new::Array", align 8
  %5 = load double, ptr %memoryref_data, align 8
  br label %L135

L58:                                              ; preds = %L26
  %6 = icmp sgt i64 %"new::Array.size6.0.copyload", 15
  br i1 %6, label %L123, label %L74

L74:                                              ; preds = %L58
  %memoryref_data19 = load ptr, ptr %"new::Array", align 8
  %7 = load double, ptr %memoryref_data19, align 8
  %memoryref_data36 = getelementptr inbounds i8, ptr %memoryref_data19, i64 8
  %8 = load double, ptr %memoryref_data36, align 8
  %9 = fadd double %7, %8
  %.not6566 = icmp sgt i64 %"new::Array.size6.0.copyload", 2
  br i1 %.not6566, label %L101.preheader, label %L135

L101.preheader:                                   ; preds = %L74
  %10 = add nsw i64 %"new::Array.size6.0.copyload", -2
  %11 = add nsw i64 %"new::Array.size6.0.copyload", -3
  %xtraiter = and i64 %10, 7
  %12 = icmp ult i64 %11, 7
  br i1 %12, label %L135.loopexit.unr-lcssa, label %L101.preheader.new

L101.preheader.new:                               ; preds = %L101.preheader
  %unroll_iter = and i64 %10, -8
  br label %L101

L101:                                             ; preds = %L101, %L101.preheader.new
  %value_phi3868 = phi i64 [ 2, %L101.preheader.new ], [ %28, %L101 ]
  %value_phi3767 = phi double [ %9, %L101.preheader.new ], [ %30, %L101 ]
  %niter = phi i64 [ 0, %L101.preheader.new ], [ %niter.next.7, %L101 ]
  %13 = or disjoint i64 %value_phi3868, 1
  %memoryref_data50 = getelementptr inbounds double, ptr %memoryref_data19, i64 %value_phi3868
  %14 = load double, ptr %memoryref_data50, align 8
  %15 = fadd double %value_phi3767, %14
  %memoryref_data50.1 = getelementptr inbounds double, ptr %memoryref_data19, i64 %13
  %16 = load double, ptr %memoryref_data50.1, align 8
  %17 = fadd double %15, %16
  %memoryref_data50.2 = getelementptr inbounds i8, ptr %memoryref_data50, i64 16
  %18 = load double, ptr %memoryref_data50.2, align 8
  %19 = fadd double %17, %18
  %memoryref_data50.3 = getelementptr inbounds i8, ptr %memoryref_data50, i64 24
  %20 = load double, ptr %memoryref_data50.3, align 8
  %21 = fadd double %19, %20
  %memoryref_data50.4 = getelementptr inbounds i8, ptr %memoryref_data50, i64 32
  %22 = load double, ptr %memoryref_data50.4, align 8
  %23 = fadd double %21, %22
  %memoryref_data50.5 = getelementptr inbounds i8, ptr %memoryref_data50, i64 40
  %24 = load double, ptr %memoryref_data50.5, align 8
  %25 = fadd double %23, %24
  %memoryref_data50.6 = getelementptr inbounds i8, ptr %memoryref_data50, i64 48
  %26 = load double, ptr %memoryref_data50.6, align 8
  %27 = fadd double %25, %26
  %28 = add nuw nsw i64 %value_phi3868, 8
  %memoryref_data50.7 = getelementptr inbounds i8, ptr %memoryref_data50, i64 56
  %29 = load double, ptr %memoryref_data50.7, align 8
  %30 = fadd double %27, %29
  %niter.next.7 = add i64 %niter, 8
  %niter.ncmp.7 = icmp eq i64 %niter.next.7, %unroll_iter
  br i1 %niter.ncmp.7, label %L135.loopexit.unr-lcssa, label %L101

L123:                                             ; preds = %L58
  store ptr %"new::Array", ptr %gc_slot_addr_0, align 8
  %31 = call double @j_mapreduce_impl_2461(ptr nonnull %"new::Array", i64 signext 1, i64 signext %"new::Array.size6.0.copyload", i64 signext 1024)
  br label %L135

L135.loopexit.unr-lcssa:                          ; preds = %L101, %L101.preheader
  %.lcssa.ph = phi double [ poison, %L101.preheader ], [ %30, %L101 ]
  %value_phi3868.unr = phi i64 [ 2, %L101.preheader ], [ %28, %L101 ]
  %value_phi3767.unr = phi double [ %9, %L101.preheader ], [ %30, %L101 ]
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br i1 %lcmp.mod.not, label %L135, label %L101.epil

L101.epil:                                        ; preds = %L101.epil, %L135.loopexit.unr-lcssa
  %value_phi3868.epil = phi i64 [ %32, %L101.epil ], [ %value_phi3868.unr, %L135.loopexit.unr-lcssa ]
  %value_phi3767.epil = phi double [ %34, %L101.epil ], [ %value_phi3767.unr, %L135.loopexit.unr-lcssa ]
  %epil.iter = phi i64 [ %epil.iter.next, %L101.epil ], [ 0, %L135.loopexit.unr-lcssa ]
  %32 = add nuw nsw i64 %value_phi3868.epil, 1
  %memoryref_data50.epil = getelementptr inbounds double, ptr %memoryref_data19, i64 %value_phi3868.epil
  %33 = load double, ptr %memoryref_data50.epil, align 8
  %34 = fadd double %value_phi3767.epil, %33
  %epil.iter.next = add i64 %epil.iter, 1
  %epil.iter.cmp.not = icmp eq i64 %epil.iter.next, %xtraiter
  br i1 %epil.iter.cmp.not, label %L135, label %L101.epil

L135:                                             ; preds = %L101.epil, %L135.loopexit.unr-lcssa, %L123, %L74, %L53, %L26
  %value_phi7 = phi double [ %5, %L53 ], [ %31, %L123 ], [ 0.000000e+00, %L26 ], [ %9, %L74 ], [ %.lcssa.ph, %L135.loopexit.unr-lcssa ], [ %34, %L101.epil ]
  %frame.prev83 = load ptr, ptr %frame.prev, align 8
  store ptr %frame.prev83, ptr %tls_pgcstack, align 8
  ret double %value_phi7
}

julia> @code_llvm debuginfo=:none g(FixedSizeVectorDefault{Float64})

; Function Signature: g(Type{FixedSizeArrays.FixedSizeArray{Float64, 1, Memory{Float64}}})
define double @julia_g_2466() local_unnamed_addr #0 {
top:
  %memoryref_mem = alloca [136 x i8], align 16
  call void @llvm.lifetime.start.p0(i64 136, ptr nonnull %memoryref_mem)
  %0 = getelementptr inbounds i8, ptr %memoryref_mem, i64 16
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(136) %0, i8 0, i64 120, i1 false)
  %memory_ptr = getelementptr inbounds i8, ptr %memoryref_mem, i64 8
  store ptr %0, ptr %memory_ptr, align 8
  store i64 15, ptr %memoryref_mem, align 8
  %1 = call i64 @j_xoshiro_bulk_simd_2470(ptr nonnull %0, i64 signext 120)
  %2 = icmp eq i64 %1, 120
  br i1 %2, label %L14, label %L13

L13:                                              ; preds = %top
  %3 = sub i64 120, %1
  %4 = getelementptr i8, ptr %0, i64 %1
  call void @j_xoshiro_bulk_nosimd_2471(ptr %4, i64 signext %3)
  br label %L14

L14:                                              ; preds = %L13, %top
  %memoryref_data = load ptr, ptr %memory_ptr, align 8
  %5 = load double, ptr %memoryref_data, align 8
  %memoryref_data11 = getelementptr inbounds i8, ptr %memoryref_data, i64 8
  %6 = load double, ptr %memoryref_data11, align 8
  %7 = fadd double %5, %6
  %memoryref_data20 = getelementptr inbounds i8, ptr %memoryref_data, i64 16
  %8 = load double, ptr %memoryref_data20, align 8
  %9 = fadd double %7, %8
  %memoryref_data20.1 = getelementptr inbounds i8, ptr %memoryref_data, i64 24
  %10 = load double, ptr %memoryref_data20.1, align 8
  %11 = fadd double %9, %10
  %memoryref_data20.2 = getelementptr inbounds i8, ptr %memoryref_data, i64 32
  %12 = load double, ptr %memoryref_data20.2, align 8
  %13 = fadd double %11, %12
  %memoryref_data20.3 = getelementptr inbounds i8, ptr %memoryref_data, i64 40
  %14 = load double, ptr %memoryref_data20.3, align 8
  %15 = fadd double %13, %14
  %memoryref_data20.4 = getelementptr inbounds i8, ptr %memoryref_data, i64 48
  %16 = load double, ptr %memoryref_data20.4, align 8
  %17 = fadd double %15, %16
  %memoryref_data20.5 = getelementptr inbounds i8, ptr %memoryref_data, i64 56
  %18 = load double, ptr %memoryref_data20.5, align 8
  %19 = fadd double %17, %18
  %memoryref_data20.6 = getelementptr inbounds i8, ptr %memoryref_data, i64 64
  %20 = load double, ptr %memoryref_data20.6, align 8
  %21 = fadd double %19, %20
  %memoryref_data20.7 = getelementptr inbounds i8, ptr %memoryref_data, i64 72
  %22 = load double, ptr %memoryref_data20.7, align 8
  %23 = fadd double %21, %22
  %memoryref_data20.8 = getelementptr inbounds i8, ptr %memoryref_data, i64 80
  %24 = load double, ptr %memoryref_data20.8, align 8
  %25 = fadd double %23, %24
  %memoryref_data20.9 = getelementptr inbounds i8, ptr %memoryref_data, i64 88
  %26 = load double, ptr %memoryref_data20.9, align 8
  %27 = fadd double %25, %26
  %memoryref_data20.10 = getelementptr inbounds i8, ptr %memoryref_data, i64 96
  %28 = load double, ptr %memoryref_data20.10, align 8
  %29 = fadd double %27, %28
  %memoryref_data20.11 = getelementptr inbounds i8, ptr %memoryref_data, i64 104
  %30 = load double, ptr %memoryref_data20.11, align 8
  %31 = fadd double %29, %30
  %memoryref_data20.12 = getelementptr inbounds i8, ptr %memoryref_data, i64 112
  %32 = load double, ptr %memoryref_data20.12, align 8
  %33 = fadd double %31, %32
  ret double %33
}

julia> @benchmark g(Vector{Float64})
BenchmarkTools.Trial: 10000 samples with 989 evaluations per sample.
 Range (min … max):  46.993 ns …  2.497 μs  ┊ GC (min … max):  0.00% … 97.02%
 Time  (median):     49.564 ns              ┊ GC (median):     0.00%
 Time  (mean ± σ):   55.808 ns ± 50.544 ns  ┊ GC (mean ± σ):  10.07% ± 11.26%

  █▃▂                                                         ▁
  ████▇▆▆▅▅▄▃▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▅▆▆▄▄▃▅▆▆▆▅ █
  47 ns        Histogram: log(frequency) by time       319 ns <

 Memory estimate: 176 bytes, allocs estimate: 2.

julia> @benchmark g(FixedSizeVectorDefault{Float64})
BenchmarkTools.Trial: 10000 samples with 991 evaluations per sample.
 Range (min … max):  41.569 ns … 111.563 ns  ┊ GC (min … max): 0.00% … 0.00%
 Time  (median):     43.630 ns               ┊ GC (median):    0.00%
 Time  (mean ± σ):   43.753 ns ±   2.780 ns  ┊ GC (mean ± σ):  0.00% ± 0.00%

  ▅▇▄▃▂▂▂▂█▇▄▂▂▁▂▁            ▁                                ▂
  ██████████████████▇▇██▇▇▇▆▆▆██▆▆▅▆▅▅▅▆▅▄▅▅▆▄▅▅▅▅▅▆▅▅▆▅▄▄▄▅▄▅ █
  41.6 ns       Histogram: log(frequency) by time      55.6 ns <

 Memory estimate: 0 bytes, allocs estimate: 0.

julia> versioninfo()
Julia Version 1.13.0-DEV.571
Commit c13ea2b4f0f (2025-05-10 14:30 UTC)
Build Info:
  Official https://julialang.org release
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 22 × Intel(R) Core(TM) Ultra 7 155H
  WORD_SIZE: 64
  LLVM: libLLVM-19.1.7 (ORCJIT, alderlake)
  GC: Built with stock GC
Threads: 1 default, 1 interactive, 1 GC (on 22 virtual cores)

[giordano]

Another variation, enabled by #116:

julia> using BenchmarkTools, FixedSizeArrays, Random

julia> function g(T)
           v = T(undef, 250)
           rand!(v)
           return v[end]
       end
g (generic function with 1 method)

julia> @btime g(Vector{Float64})
  194.273 ns (2 allocations: 2.02 KiB)
0.30736114401277237

julia> @btime g(FixedSizeVectorDefault{Float64})
  194.861 ns (0 allocations: 0 bytes)
0.22256642529140258

In certain cases allocations for a much larger vector can also be elided (from #116 (comment)).

Edit: small variation, computing the sum of the whole array (using foldl because it uses a simpler infrastructure than sum and can more effectively remove small allocations, from https://discourse.julialang.org/t/ann-fixedsizearrays-jl-what-array-probably-should-have-been/129724):

julia> using BenchmarkTools, FixedSizeArrays, Random

julia> function g(T)
           v = T(undef, 250)
           rand!(v)
           return foldl(+, v)
       end
g (generic function with 1 method)

julia> @btime g(Vector{Float64}) setup=(Random.seed!(1))
  223.163 ns (2 allocations: 2.02 KiB)
131.05489829603343

julia> @btime g(FixedSizeVectorDefault{Float64}) setup=(Random.seed!(1))
  221.137 ns (0 allocations: 0 bytes)
131.05489829603343

[giordano]

Creating a FixedSizeArray is faster and uses less memory than Array

On e4d221a:

julia> using BenchmarkTools, FixedSizeArrays

julia> for n in (0, 2^0, 2^5, 2^10, 2^15, 2^20, 2^25)
           @info "n = $(n)"
           @btime Vector{Float64}(undef, $(n))
           @btime FixedSizeVectorDefault{Float64}(undef, $(n))
       end;
[ Info: n = 0
  5.042 ns (1 allocation: 32 bytes)
  3.041 ns (0 allocations: 0 bytes)
[ Info: n = 1
  9.083 ns (2 allocations: 64 bytes)
  6.833 ns (1 allocation: 32 bytes)
[ Info: n = 32
  9.500 ns (2 allocations: 320 bytes)
  7.458 ns (1 allocation: 288 bytes)
[ Info: n = 1024
  50.034 ns (3 allocations: 8.06 KiB)
  46.538 ns (2 allocations: 8.03 KiB)
[ Info: n = 32768
  557.292 ns (3 allocations: 256.06 KiB)
  554.344 ns (2 allocations: 256.03 KiB)
[ Info: n = 1048576
  19.232 μs (3 allocations: 8.00 MiB)
  16.875 μs (2 allocations: 8.00 MiB)
[ Info: n = 33554432
  500.000 ns (3 allocations: 256.00 MiB)
  458.000 ns (2 allocations: 256.00 MiB)

julia> versioninfo()
Julia Version 1.13.0-DEV.593
Commit dbc38d6d34* (2025-05-14 11:40 UTC)
Platform Info:
  OS: macOS (arm64-apple-darwin23.4.0)
  CPU: 8 × Apple M1
  WORD_SIZE: 64
  LLVM: libLLVM-20.1.2 (ORCJIT, apple-m1)
  GC: Built with stock GC
Threads: 1 default, 1 interactive, 1 GC (on 4 virtual cores)

[giordano]

Similar results for when initialising the vectors (same version of Julia and FixedSizeArrays.jl:

julia> for n in (0, 2^0, 2^5, 2^10, 2^15, 2^20, 2^25)
           @info "n = $(n)"
           @btime fill!(Vector{Float64}(undef, $(n)), 0.0)
           @btime fill!(FixedSizeVectorDefault{Float64}(undef, $(n)), 0.0)
       end
[ Info: n = 0
  5.292 ns (1 allocation: 32 bytes)
  2.708 ns (0 allocations: 0 bytes)
[ Info: n = 1
  10.927 ns (2 allocations: 64 bytes)
  8.708 ns (1 allocation: 32 bytes)
[ Info: n = 32
  12.846 ns (2 allocations: 320 bytes)
  10.595 ns (1 allocation: 288 bytes)
[ Info: n = 1024
  186.857 ns (3 allocations: 8.06 KiB)
  187.775 ns (2 allocations: 8.03 KiB)
[ Info: n = 32768
  2.298 μs (3 allocations: 256.06 KiB)
  2.107 μs (2 allocations: 256.03 KiB)
[ Info: n = 1048576
  304.459 μs (3 allocations: 8.00 MiB)
  303.125 μs (2 allocations: 8.00 MiB)
[ Info: n = 33554432
  17.429 ms (3 allocations: 256.00 MiB)
  16.966 ms (2 allocations: 256.00 MiB)

[giordano]

Faster gradients with Enzyme

julia> using BenchmarkTools, FixedSizeArrays, Enzyme, Random

julia> function g(x::AbstractVector{T}, y::AbstractVector{T}) where {T}
           sum = zero(float(T))
           for idx in eachindex(x, y)
               sum += sin(x[idx]) ^ 2 + cos(y[idx]) ^ 2
           end
           return sum
       end
g (generic function with 1 method)

julia> @btime gradient(Forward, g, x, y) setup=(Random.seed!(1); x = randn(3); y = randn(3));
  753.210 ns (28 allocations: 1.09 KiB)

julia> @btime gradient(Forward, g, x, y) setup=(Random.seed!(1); x = FixedSizeArray(randn(3)); y = FixedSizeArray(randn(3)));
  487.737 ns (20 allocations: 880 bytes)

julia> versioninfo()
Julia Version 1.11.5
Commit 760b2e5b739 (2025-04-14 06:53 UTC)
Build Info:
  Official https://julialang.org/ release
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 22 × Intel(R) Core(TM) Ultra 7 155H
  WORD_SIZE: 64
  LLVM: libLLVM-16.0.6 (ORCJIT, alderlake)
Threads: 1 default, 0 interactive, 1 GC (on 22 virtual cores)

Inspired by EnzymeAD/Enzyme.jl#2454

[nsajko]

Allocation elimination due to being friendlier to the compiler's escape analysis

Benchmark script:

const evals = parse(Int, ARGS[1])
const samples = parse(Int, ARGS[2])
const vector_length = parse(Int, ARGS[3])

@show evals
@show samples
@show vector_length
println()

function f(typ::Type{<:AbstractArray}, n, d)
    @inline let
        a = typ{Float32}(undef, vector_length)
        for i ∈ eachindex(a)
            a[i] = n + i
        end
        a[d] = 0
        reduce(+, a)
    end
end

using FixedSizeArrays: FixedSizeVectorDefault

f_Memory(n, d) = @inline f(Memory, n, d)
f_Array(n, d) = @inline f(Vector, n, d)
f_FSA(n, d) = @inline f(FixedSizeVectorDefault, n, d)

using BenchmarkTools: @btime

for g ∈ (f_Memory, f_Array, f_FSA)
    @eval const h = $g
    @show h
    @btime h(n, d) evals=evals samples=samples seconds=Inf setup=(n = rand((-1000):1000); d = rand(1:vector_length);)
end

using Pkg: status
using InteractiveUtils: versioninfo
println()
status("FixedSizeArrays")
versioninfo()

Result:

evals = 10
samples = 10000
vector_length = 15

h = Main.f_Memory
  28.000 ns (1 allocation: 96 bytes)
h = Main.f_Array
  36.000 ns (2 allocations: 128 bytes)
h = Main.f_FSA
  20.000 ns (0 allocations: 0 bytes)

Status `~/.julia/environments/v1.14/Project.toml`
  [3821ddf9] FixedSizeArrays v1.3.0
Julia Version 1.14.0-DEV.1720
Commit f38c537ec6a (2026-02-14 16:10 UTC)
Build Info:
  Official https://julialang.org release
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 8 × AMD Ryzen 3 5300U with Radeon Graphics
  WORD_SIZE: 64
  LLVM: libLLVM-20.1.8 (ORCJIT, znver2)
  GC: Built with stock GC
Threads: 1 default, 1 interactive, 1 GC (on 8 virtual cores)
Environment:
  JULIA_NUM_PRECOMPILE_TASKS = 2
  JULIA_PKG_PRECOMPILE_AUTO = 0

[nsajko]

• LLVM can tell that the FSA code never throws BoundsError, so it replaces the heap allocation by a stack allocation.

• Julia itself (before the LLVM stage) is not able to eliminate the BoundsError throw. However LLVM still eliminates the throw and the heap allocation.

• The same should be achievable for Memory or Array when @inbounds is used, so the benefit of FixedSizeArray is that it does not require @inbounds for the allocation to be eliminated.