wrapping with an OffsetArray results in slow scalar indexing :(

[bjarthur]

with just a DiskArray the index count is 1 (which is good):

julia> using DiskArrays

julia> using DiskArrays.TestTypes

julia> a = AccessCountDiskArray(reshape(1:24, 2, 3, 4), chunksize=(2, 3, 2))
2×3×4 AccessCountDiskArray{Int64, 3, Base.ReshapedArray{Int64, 3, UnitRange{Int64}, Tuple{}}, DiskArrays.ChunkRead{DiskArrays.NoStepRange}}

Chunked: (
    [2]
    [3]
    [2, 2]
)

julia> getindex_count(a)
0

julia> a[:,:,1]
2×3 Matrix{Int64}:
 1  3  5
 2  4  6

julia> getindex_count(a)
1

but wrap it in an OffsetArray and it is 6 (very bad!):

julia> using OffsetArrays

julia> o = OffsetArray(a, 1,2,3)
2×3×4 OffsetArray(::AccessCountDiskArray{Int64, 3, Base.ReshapedArray{Int64, 3, UnitRange{Int64}, Tuple{}}, DiskArrays.ChunkRead{DiskArrays.NoStepRange}}, 2:3, 3:5, 4:7) with eltype Int64 with indices 2:3×3:5×4:7:
[:, :, 4] =
 1  3  5
 2  4  6

[:, :, 5] =
 7   9  11
 8  10  12

[:, :, 6] =
 13  15  17
 14  16  18

[:, :, 7] =
 19  21  23
 20  22  24

julia> getindex_count(a)
97

julia> o[:,:,4]
2×3 OffsetArray(::Matrix{Int64}, 2:3, 3:5) with eltype Int64 with indices 2:3×3:5:
 1  3  5
 2  4  6

julia> getindex_count(a)    ### 6!  when ideally should be 1
103

because somehow it doesn't chunk the access:

julia> allow_scalar(false)
false

julia> a[:,:,1]
2×3 Matrix{Int64}:
 1  3  5
 2  4  6

julia> o[:,:,4]
ERROR: Scalar indexing with `Int` is very slow, and currently is disallowed. Run DiskArrays.allowscalar(true) to allow
Stacktrace:
  [1] error(s::String)
    @ Base ./error.jl:44
  [2] _scalar_error()
    @ DiskArrays ~/.julia/packages/DiskArrays/uMiMX/src/scalar.jl:34
  [3] checkscalar(A::AccessCountDiskArray{…}, I::Tuple{…})
    @ DiskArrays ~/.julia/packages/DiskArrays/uMiMX/src/scalar.jl:30
  [4] getindex_disk(::AccessCountDiskArray{…}, ::Int64, ::Int64, ::Vararg{…})
    @ DiskArrays ~/.julia/packages/DiskArrays/uMiMX/src/indexing.jl:32
  [5] getindex
    @ ~/.julia/packages/DiskArrays/uMiMX/src/indexing.jl:312 [inlined]
  [6] getindex
    @ ~/.julia/packages/OffsetArrays/b7qpm/src/OffsetArrays.jl:421 [inlined]
  [7] macro expansion
    @ ./multidimensional.jl:981 [inlined]
  [8] macro expansion
    @ ./cartesian.jl:64 [inlined]
  [9] macro expansion
    @ ./multidimensional.jl:979 [inlined]
 [10] _unsafe_getindex!
    @ ./multidimensional.jl:989 [inlined]
 [11] _unsafe_getindex(::IndexCartesian, ::OffsetArray{…}, ::Base.Slice{…}, ::Base.Slice{…}, ::Int64)
    @ Base ./multidimensional.jl:970
 [12] _getindex
    @ ./multidimensional.jl:956 [inlined]
 [13] getindex(::OffsetArray{Int64, 3, AccessCountDiskArray{…}}, ::Function, ::Function, ::Int64)
    @ Base ./abstractarray.jl:1342
 [14] top-level scope
    @ REPL[14]:1
Some type information was truncated. Use `show(err)` to see complete types.

happy to help fix this issue given a little guidance!

[asinghvi17]

It could be that OffsetArrays does not have a good batched indexing method for slices. See
https://github.com/JuliaArrays/OffsetArrays.jl/blob/f9fd311d7e9ff772316e33b29720bb28d50c36d5/src/OffsetArrays.jl#L418-L422

and lines around there. You can see that it is hitting a getindex_disk(arr, :::Int, ::Int, ::Int) which means at some point higher in the stack the colon got decomposed into a set of indices.

[bjarthur]

yea, i got that far on my own, but, i am not familiar enough with julia's array API to add a method to OffsetArrays to deal efficiently with ranges.

[meggart]

I don't think there is anything we do do about this from the DiskArrays side. The AbstractArray interface is designed to rely on fast scalar indexing, so whenever you wrap a DiskArray in a non-disk AbstractArray, you will get bad performance. This reminds me a bit on the discussion we had about PermutedDimsArray #42 and related. Of course one could make an OffsetDiskArray with or similar with appropriate indexing rules and simply overload OffsetArray constructors, but I am not sure if that would be the right thing to do.

In an ideal world we would have a functioning array trait system where we would not need all these competing systems of array types.