What is the most efficient way to convert a Matrix into Vector of SVectors in Julia? - julia

Question

I'm looking for the most efficient and fastest way to create a vector of SVectors from a 2D Matrix in Julia, dynamically. Suppose I have the following Matrix:
julia> r = rand(1000, 5);
Then I want to convert it to the exact type Vector{SVector{5, Float64}}. I tried the following, but I'm looking for a faster way:
julia> using StaticArrays
julia> function create_VSVec(data::Matrix{T}) where T
ldim, mdim = argmin(size(data)), argmax(size(data))
len_sv = size(data, ldim)
sv = Vector{SVector{len_sv, T}}(undef, size(data, mdim))
for idx in axes(sv, 1)
sv[idx] = SVector{len_sv, T}(selectdim(data, mdim, idx))
end
return sv
end;
julia> #benchmark create_VSVec($r)
BenchmarkTools.Trial: 2993 samples with 1 evaluation.
Range (min … max): 1.415 ms … 22.241 ms ┊ GC (min … max): 0.00% … 91.78%
Time (median): 1.518 ms ┊ GC (median): 0.00%
Time (mean ± σ): 1.665 ms ± 1.275 ms ┊ GC (mean ± σ): 4.76% ± 5.78%
█▃
▂▃▆▇██▇▆▅▄▃▄▃▃▃▃▄▃▃▃▃▄▄▃▃▃▃▃▃▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▁▂▂▂▂ ▃
1.41 ms Histogram: frequency by time 2.31 ms <
Memory estimate: 703.19 KiB, allocs estimate: 14480.
julia> a = create_VSVec(r);
julia> a[1] == r[1, :]
true

Answer 1

A list-comprehension is 2X faster than create_VSVec2.
julia> r = rand(1000, 5);
julia> #benchmark create_VSVec2($r)
BenchmarkTools.Trial: 10000 samples with 1 evaluation.
Range (min … max): 12.500 μs … 4.741 ms ┊ GC (min … max): 0.00% … 98.95%
Time (median): 21.750 μs ┊ GC (median): 0.00%
Time (mean ± σ): 21.849 μs ± 96.395 μs ┊ GC (mean ± σ): 11.44% ± 2.93%
▆█▄ ▁▃▄▅▆▄▅▄▂▁ ▁ ▂ ▂
███▇▅▃▄▂▂▄▃▄▅▄▄▄▃▃▅▄█████████████▇▇▆▆▅▅▃▅▇▇▇███▆▅▆▅▆▆▆▇▆▆▆▇ █
12.5 μs Histogram: log(frequency) by time 39.9 μs <
Memory estimate: 39.78 KiB, allocs estimate: 15.
julia> #benchmark [SVector{5,Float64}(i) for i in eachrow($r)]
BenchmarkTools.Trial: 10000 samples with 8 evaluations.
Range (min … max): 2.400 μs … 716.087 μs ┊ GC (min … max): 0.00% … 97.09%
Time (median): 6.094 μs ┊ GC (median): 0.00%
Time (mean ± σ): 12.261 μs ± 34.098 μs ┊ GC (mean ± σ): 19.12% ± 7.80%
▆█▅▅▂ ▄▅▆▅▄▄▄▃▃▃▂▂▂▁▂▁ ▂
▆▄▅██████▇▆▆▄▄▆▄▄▅▄▃▄▃▆▄▄▄▅▅▆██████████████████▇▇▇▆▇▆▆▆▅▄▅▄▄ █
2.4 μs Histogram: log(frequency) by time 24.8 μs <
Memory estimate: 39.11 KiB, allocs estimate: 2.

Answer 2

Following the approach in the OP, and considering the important note that #DNF mentioned in the comments, using reinterpret in the following way would make it ~90X faster and 18X lower in memory allocation:
julia> function create_VSVec2(data::Matrix{T}) where T
ldim = argmin(size(data))
ldim == 1 ? d = data : d = data'
sv = identity.(reinterpret(SVector{5, Float64}, vec(d)))
return sv
end;
julia> #benchmark create_VSVec2($r)
BenchmarkTools.Trial: 10000 samples with 6 evaluations.
Range (min … max): 4.167 μs … 1.611 ms ┊ GC (min … max): 0.00% … 98.04%
Time (median): 22.283 μs ┊ GC (median): 0.00%
Time (mean ± σ): 21.380 μs ± 55.021 μs ┊ GC (mean ± σ): 16.17% ± 6.87%
▁█▆▄▁▁ ▃▄▄▄▄▆▆▆▅▃▂▁▁▂▂▂▁▁▁ ▂
██████▇▇▆▄▅▅▃▅▅▃▅▄▇███████████████████████▇▇▇▇▇▇▇▆▅▆▆▆▆▆▅▅▆ █
4.17 μs Histogram: log(frequency) by time 50 μs <
Memory estimate: 39.19 KiB, allocs estimate: 4.
julia> a = create_VSVec2(r);
julia> a[1] == r[1, :]
true
julia> typeof(a)
Vector{SVector{5, Float64}} (alias for Array{SArray{Tuple{5}, Float64, 1, 5}, 1})
But, if I use the reinterpret without any other calculations, I get the best performance:
julia> r = rand(5, 1000);
julia> #benchmark reinterpret(SVector{5, Float64}, $r)
BenchmarkTools.Trial: 10000 samples with 1000 evaluations.
Range (min … max): 9.600 ns … 51.800 ns ┊ GC (min … max): 0.00% … 0.00%
Time (median): 9.800 ns ┊ GC (median): 0.00%
Time (mean ± σ): 9.898 ns ± 0.767 ns ┊ GC (mean ± σ): 0.00% ± 0.00%
█ ▆ ▄ ▇ ▂ ▂
▆▁▁▁█▁▁▁█▁▁▁▁█▁▁▁█▁▁▁▁█▁▁▁█▁▁▁▁▆▁▁▁▃▁▁▁▁▃▁▁▁▁▁▁▁▁▃▁▁▁▇▁▁▁▇ █
9.6 ns Histogram: log(frequency) by time 10.9 ns <
Memory estimate: 0 bytes, allocs estimate: 0.
julia> #benchmark [SVector{5,Float64}(i) for i in eachcol($r)]
BenchmarkTools.Trial: 10000 samples with 7 evaluations.
Range (min … max): 3.500 μs … 915.714 μs ┊ GC (min … max): 0.00% … 96.56%
Time (median): 24.486 μs ┊ GC (median): 0.00%
Time (mean ± σ): 22.559 μs ± 47.537 μs ┊ GC (mean ± σ): 15.27% ± 7.51%
▄█▄▁▁▁ ▂▂▂▄▃▃▅▆▅█▆▃▁▁▁▁▁▁ ▁ ▂
▇███████▅▆▆▇▄▄▃▆▅▁▃▆▆▃▅▇▆▆██████████████████████▇█▇▇▆█▆█▇███ █
3.5 μs Histogram: log(frequency) by time 41.4 μs <
Memory estimate: 39.11 KiB, allocs estimate: 2.
julia> r = rand(1000, 5);
julia> #benchmark reinterpret(SVector{5, Float64}, $r)
BenchmarkTools.Trial: 10000 samples with 1000 evaluations.
Range (min … max): 9.300 ns … 58.300 ns ┊ GC (min … max): 0.00% … 0.00%
Time (median): 9.400 ns ┊ GC (median): 0.00%
Time (mean ± σ): 9.545 ns ± 1.078 ns ┊ GC (mean ± σ): 0.00% ± 0.00%
█ █ ▁ ▇ ▅ ▂
█▁▁█▁▁▁█▁▁▁█▁▁▁█▁▁▁█▁▁▁█▁▁▁▆▁▁▃▁▁▁▁▁▁▁▁▁▁▁▇▁▁▁█▁▁▁▅▁▁▁▄▁▁▆ █
9.3 ns Histogram: log(frequency) by time 10.8 ns <
Memory estimate: 0 bytes, allocs estimate: 0.
julia> #benchmark [SVector{5,Float64}(i) for i in eachrow($r)]
BenchmarkTools.Trial: 10000 samples with 7 evaluations.
Range (min … max): 3.814 μs … 867.043 μs ┊ GC (min … max): 0.00% … 96.02%
Time (median): 24.071 μs ┊ GC (median): 0.00%
Time (mean ± σ): 21.553 μs ± 47.004 μs ┊ GC (mean ± σ): 15.52% ± 7.48%
▂▇█▅▃▃▂ ▁▁▃▃▃▆▇▅▇▇▄▃▂▂▁▁▁▁ ▃
██████████▇▆▅▃▇▅▁▅▆▇▅▅▆▆▄▇████████████████████████▇▇▆▇▇█▇██▇ █
3.81 μs Histogram: log(frequency) by time 41.7 μs <
Memory estimate: 39.11 KiB, allocs estimate: 2.