Aliased vector slices

[gummif]

What I think is a missing feature in Julia is the ability to work with unit-stride slices of Arrays, like Matrix columns or sections of Vectors, as Vectors with perfect compatibility and equal performance as Vectors. SubArrays and ArrayViews are more general and don't quite have the compatibility or performance yet.

I could make a PR if there is interest. Sample code:

# return aliased vector slice A[i:i-1+n]
function vectorslice(A::Array, i::Int, n::Int)
    @assert 0 < i <= length(A)
    @assert 0 <= n
    @assert i-1+n <= length(A)
    return pointer_to_array(pointer(A, i), n, true)::Vector
end

julia> x = randn(3,4)
3x4 Array{Float64,2}:
 -1.0475    1.44511    -0.103864   -0.395006
 -1.20736   0.935344    0.0891084   1.18014 
  0.725243  0.0379082   0.986568   -0.204709

julia> y = vectorslice(x,4,3)
3-element Array{Float64,1}:
 1.44511  
 0.935344 
 0.0379082

julia> scale!(2,y)
3-element Array{Float64,1}:
 2.89022  
 1.87069  
 0.0758164

julia> x
3x4 Array{Float64,2}:
 -1.0475    2.89022    -0.103864   -0.395006
 -1.20736   1.87069     0.0891084   1.18014 
  0.725243  0.0758164   0.986568   -0.204709

[JeffBezanson]

This particular implementation is not memory safe, but it's true that our Array type could support contiguous views similar to how they support reshaping with shared data.

[gummif]

I see, so with the own=true in pointer_to_array Julia will free parts of the same memory twice? Would own=false have any memory problems?

Well, anyways a more specialized function like the following can be very useful

# return aliased vector slice A[i:i-1+n], safe as long as A is referenced and has not been freed
function unsafe_vectorslice(A::Array, i::Int, n::Int)
    @assert 0 < i <= length(A)
    @assert 0 <= n
    @assert i-1+n <= length(A)
    return pointer_to_array(pointer(A, i), n, false)::Vector
end

[simonster]

own=false is can still be problematic because the Array that owns the memory could free it but the Array that doesn't own the memory might stick around. It's useful in cases where you know that the view won't be accessed after the parent falls out of scope, but it's not safe in general.

ArrayViews' ContiguousViews are intended to satisfy this case safely. In my quick testing the performance is very nearly equivalent to pointer_to_array, although ContiguousViews are more expensive to construct because they involve more allocation.

Ideally, we'd have safe contiguous views that don't allocate any memory at all unless they escape. That's not yet possible, but #8134 should help us get there.

[mlubin]

I recently ran into this, needing a zero-allocation vector view. I had to go with an unsafe version in the spirit of this.

[simonster]

pointer_to_array is not zero-allocation either, although it allocates less. I think the only way to get a zero allocation view at present is to create an immutable that inherits from AbstractArray and wraps a pointer and then use unsafe_load/unsafe_store! to implement getindex/setindex!.

[mlubin]

Right: mlubin/ReverseDiffSparse.jl@8e3ade8

[gummif]

@mlubin Your VectorView is actually slightly faster than Arrays for @inbounds for-loops according to my tests.
@simonster This pointer_to_array method is a bit faster than ContiguousViews currently. But the biggest advantage is that any and all methods for Arrays can be used without any performance loss. Safe usage of course depends on the code in question, like the usage of @inbounds.
These kind of tricks for those having a need for speed are maybe better suited for something like PerformanceHacks.jl?

Edit: A safety feature might can be added using a macro, not very pretty, but should work.

function check_vectorslice(A::Array, i::Int, n::Int)
    @assert 0 < i <= length(A)
    @assert 0 <= n
    @assert i-1+n <= length(A)
    return nothing
end
function unsafe_vectorslice(A::Array, i::Int, n::Int)
    return pointer_to_array(pointer(A, i), n, false)::Vector
end
macro safe_vectorslice(A)
    a=gensym()
    :($(esc(a)) = $(esc(A))[1])
end

function foo(a)
    check_vectorslice(a,2,2)
    b = unsafe_vectorslice(a,2,2)
    scale!(3,b)
    # use this macro at the end of usage for safety
    @safe_vectorslice a
    return 0
end

[JeffBezanson]

All you need is for b to hold a reference to a. We can do this already, since we use it in reshape and reinterpret.

[gummif]

@JeffBezanson If I understand you correctly, what would be needed is adding a function like

jl_array_t *jl_ptr_to_array_1d(jl_value_t *atype, void *data, size_t nel, 
                                void *owndata)
{
    jl_array_t *a = jl_ptr_to_array_1d(atype, data, nel, 0)
    jl_array_data_owner(a) = (jl_value_t*)owndata;
    a->how = 3;
    return a
}

to array.c? The two lines before return are like it is done in jl_reshape_array.

[JeffBezanson]

Yes, that's right.