using CUDA

full_cpu_arr = collect(1:128)
partial_cpu_arr = view(full_cpu_arr, 1:16)

# Preallocate the 
a_gpu = CUDA.zeros(Int, length(partial_cpu_arr))

# The following causing scalar indexing?
copyto!(a_gpu, partial_cpu_arr)

Base.copyto!(dest::CuArray{T}, src::SubArray{T, 1, Vector{T}}) where {T<:Int} =
    copyto!(dest, 1, src, 1, length(src))
function Base.copyto!(dest::CuArray{T}, doffs::Integer, src::SubArray{T, 1, Vector{T}}, soffs::Integer,
                      n::Integer) where {T<:Int}
  n==0 && return dest
  @boundscheck checkbounds(dest, doffs)
  @boundscheck checkbounds(dest, doffs+n-1)
  @boundscheck checkbounds(src, soffs)
  @boundscheck checkbounds(src, soffs+n-1)
  unsafe_copyto!(dest, doffs, src, soffs, n)
  return dest
end
function Base.unsafe_copyto!(dest::CuArray{T}, doffs,
                             src::SubArray{T, 1, Vector{T}}, soffs, n) where {T<:Int}
  CUDA.context!(CUDA.context(dest)) do
    # operations on unpinned memory cannot be executed asynchronously, and synchronize
    # without yielding back to the Julia scheduler. prevent that by eagerly synchronizing.
    s = CUDA.stream()
    CUDA.is_pinned(pointer(src)) || CUDA.nonblocking_synchronize(s)

    GC.@preserve src dest begin
      CUDA.unsafe_copyto!(pointer(dest, doffs), pointer(src, soffs), n; async=true)
    end
  end
  return dest
end