specialize copyto! for performance (#23)

The fallback generic implementation of `copyto!` uses `setindex!` in an
elementwise manner. Instead base the implementation on
`unsafe_copyto!`. This improves the performance of `copyto!`, thus it
also improves the performance of `copy!`, `copy` and of broadcasted
operations.

This change only applies when copying between two `FixedSizeArray`s,
or between a `Memory` and a `FixedSizeArray`.

Fixes #19

Author: nsajko

src/FixedSizeArrays.jl

@@ -51,7 +51,12 @@ function Base.similar(
     similar(FixedSizeArray{E}, axes(bc))
 end
 
-# one-based indexing check
+# helper functions
+
+memory_of(m::Memory) = m
+memory_of(f::FixedSizeArray) = f.mem
+
+first_linear_index(a) = first(eachindex(IndexLinear(), a))
 
 axes_are_one_based(axes) = all(isone ∘ first, axes)
 
@@ -77,4 +82,36 @@ FixedSizeArray(a::AbstractArray{T,N})          where {T,N} = FixedSizeArray{T,N}
 Base.convert(::Type{T}, a::T) where {T<:FixedSizeArray} = a
 Base.convert(::Type{T}, a::AbstractArray) where {T<:FixedSizeArray} = T(a)::T
 
+# `copyto!` between `FixedSizeArray` and `Memory`
+
+Base.@propagate_inbounds function copyto5!(dst, doff, src, soff, n)
+    if !iszero(n)
+        (n < false) &&
+            throw(ArgumentError("the number of elements to copy must be nonnegative"))
+        @boundscheck checkbounds(dst, doff:doff+n-1)
+        @boundscheck checkbounds(src, soff:soff+n-1)
+        @inbounds let d, s
+            d = GenericMemoryRef(memory_of(dst), doff)
+            s = GenericMemoryRef(memory_of(src), soff)
+            unsafe_copyto!(d, s, n)
+        end
+    end
+    dst
+end
+
+Base.@propagate_inbounds function copyto2!(dst::T, src) where {T}
+    fd = first_linear_index(dst)
+    fs = first_linear_index(src)
+    len = length(src)
+    copyto5!(dst, fd, src, fs, len)::T
+end
+
+Base.@propagate_inbounds Base.copyto!(dst::FixedSizeArray, doff::Integer, src::FixedSizeArray, soff::Integer, n::Integer) = copyto5!(dst, doff, src, soff, n)
+Base.@propagate_inbounds Base.copyto!(dst::FixedSizeArray, doff::Integer, src::Memory        , soff::Integer, n::Integer) = copyto5!(dst, doff, src, soff, n)
+Base.@propagate_inbounds Base.copyto!(dst::Memory        , doff::Integer, src::FixedSizeArray, soff::Integer, n::Integer) = copyto5!(dst, doff, src, soff, n)
+
+Base.@propagate_inbounds Base.copyto!(dst::FixedSizeArray, src::FixedSizeArray) = copyto2!(dst, src)
+Base.@propagate_inbounds Base.copyto!(dst::FixedSizeArray, src::Memory        ) = copyto2!(dst, src)
+Base.@propagate_inbounds Base.copyto!(dst::Memory        , src::FixedSizeArray) = copyto2!(dst, src)
+
 end # module FixedSizeArrays

test/runtests.jl

@@ -131,4 +131,22 @@ import Aqua
             end
         end
     end
+
+    @testset "`copyto!`" begin
+        for (D, S) ∈ (
+            (Memory, FixedSizeVector),
+            (FixedSizeVector, Memory),
+            (FixedSizeVector, FixedSizeVector),
+        )
+            for E ∈ (Float64, Int)
+                s = S{E}(undef, 5)
+                s .= 1:5
+                d = D{Float64}(undef, 5)
+                @test copyto!(d, s) isa D{Float64}
+                @test copyto!(d, s) == 1:5
+                @test copyto!(d, 1, s, 1, length(s)) isa D{Float64}
+                @test copyto!(d, 1, s, 1, length(s)) == 1:5
+            end
+        end
+    end
 end