Merge pull request #373 from JuliaArrays/redo

Redo ArrayInterface to use extension packages

Author: ChrisRackauckas

.buildkite/pipeline.yml

@@ -4,13 +4,15 @@ steps:
       - JuliaCI/julia#v1:
           version: "1"
       - JuliaCI/julia-test#v1:
-      - JuliaCI/julia-coverage#v1:
-          codecov: true
+           coverage: false # 1000x slowdown
     agents:
       queue: "juliagpu"
       cuda: "*"
     timeout_in_minutes: 60
+    # Don't run Buildkite if the commit message includes the text [skip tests]
+    if: build.message !~ /\[skip tests\]/
 
 env:
+  GROUP: GPU
   JULIA_PKG_SERVER: "" # it often struggles with our large artifacts
-  SECRET_CODECOV_TOKEN: "b3VnbGgFLwQ5JLdP+RtluFzff8Iq7OdCr1mQiXIcrRz6w1gH1ZBO74lh5/G8G0DCZ8FcDPExcAU15Bgg1fnuKBUD+pM5+lh75Omd8sIQwy04KuFjya8LYRYTg9Jpi9LiUVFke/EpXnii84WkWGfvNMpLQedLvuM8FUzInFnuXicMgrbcIQQO0M7va/Efwn7yRiBLmgGv8jI5hphHsjF7joU1tnNeJEPTZ/oKzubxta0DlLW4DYaaRZc9RmsXGH2bg1el+ujouf8YZ4ncO7okvsgjSXzKxdGqN74WqlgzLZRtvtDkDRT8jTlugDq9C+oeUDnCfc6VJcSaNw1Kmk5OyQ==;U2FsdGVkX1+l463STh4TdVc8OUkIO2uf1pWXUtVHDZHgxILX1+40v9kVYUGznEE/flndA4dOk6PrND8KnISGsA=="
+  # SECRET_CODECOV_TOKEN: "..."

.ci/test.jl

@@ -9,19 +9,10 @@ on:
 jobs:
   test:
     runs-on: ubuntu-latest
-    continue-on-error: ${{ matrix.group == 'Downstream' }}
     strategy:
-      fail-fast: false
       matrix:
         group:
-          - ArrayInterface
-          - ArrayInterfaceCore
-          - ArrayInterfaceBandedMatrices
-          - ArrayInterfaceBlockBandedMatrices
-          - ArrayInterfaceOffsetArrays
-          - ArrayInterfaceStaticArrays
-          - ArrayInterfaceStaticArraysCore
-          - ArrayInterfaceTracker
+          - Core
         version:
           - '1'
           - '1.6'
@@ -40,10 +31,11 @@ jobs:
             ${{ runner.os }}-test-${{ env.cache-name }}-
             ${{ runner.os }}-test-
             ${{ runner.os }}-
-      - run: julia .ci/test.jl
+      - uses: julia-actions/julia-buildpkg@v1
+      - uses: julia-actions/julia-runtest@v1
         env:
           GROUP: ${{ matrix.group }}
       - uses: julia-actions/julia-processcoverage@v1
       - uses: codecov/codecov-action@v1
         with:
-          file: lcov.info
+          file: lcov.info

.github/workflows/ci.yml

@@ -3,24 +3,60 @@ uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
 version = "6.0.25"
 
 [deps]
-ArrayInterfaceCore = "30b0a656-2188-435a-8636-2ec0e6a096e2"
+Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
 Compat = "34da2185-b29b-5c13-b0c7-acf172513d20"
 IfElse = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 SnoopPrecompile = "66db9d55-30c0-4569-8b51-7e840670fc0c"
-Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3"
+SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+SuiteSparse = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9"
 
 [compat]
-ArrayInterfaceCore = "0.1.3"
-Compat = "3, 4"
-IfElse = "0.1"
+Compat = "4"
 SnoopPrecompile = "1"
-Static = "0.8"
+Requires = "1"
 julia = "1.6"
 
+[extensions]
+ArrayInterfaceBandedMatricesExt = "BandedMatrices"
+ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices"
+ArrayInterfaceCUDAExt = "CUDA"
+ArrayInterfaceGPUArraysExt = "GPUArraysCore"
+ArrayInterfaceOffsetArraysExt = ["OffsetArrays","Static"]
+ArrayInterfaceStaticArraysExt = ["StaticArrays","Static"]
+ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore"
+ArrayInterfaceStaticExt = "Static"
+ArrayInterfaceTrackerExt = "Tracker"
+
 [extras]
 Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
+BandedMatrices = "aae01518-5342-5314-be14-df237901396f"
+BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0"
+CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
+GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527"
+OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
+Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+SuiteSparse = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9"
+SafeTestsets = "1bc83da4-3b8d-516f-aca4-4fe02f6d838f"
+StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
+StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c"
+Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3"
+Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Pkg", "Test"]
+test = ["SafeTestsets", "Pkg", "Test", "Aqua", "Random", "SparseArrays", "SuiteSparse", "Static", "BandedMatrices", "BlockBandedMatrices", "GPUArraysCore", "OffsetArrays", "StaticArrays", "StaticArraysCore", "Tracker"]
+
+[weakdeps]
+BandedMatrices = "aae01518-5342-5314-be14-df237901396f"
+BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0"
+GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527"
+OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
+StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
+StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c"
+CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
+Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c"
+Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3"

Project.toml

@@ -1,16 +1,8 @@
-module ArrayInterfaceBandedMatrices
+module ArrayInterfaceBandedMatricesExt
 
-using ArrayInterfaceCore
-using BandedMatrices
-
-struct BandedMatrixIndex <: ArrayInterfaceCore.MatrixIndex
-    count::Int
-    rowsize::Int
-    colsize::Int
-    bandinds::Array{Int,1}
-    bandsizes::Array{Int,1}
-    isrow::Bool
-end
+using ArrayInterface
+using ArrayInterface: BandedMatrixIndex
+isdefined(Base, :get_extension) ? (using BandedMatrices) : (using ..BandedMatrices)
 
 Base.firstindex(i::BandedMatrixIndex) = 1
 Base.lastindex(i::BandedMatrixIndex) = i.count
@@ -50,22 +42,22 @@ function BandedMatrixIndex(rowsize, colsize, lowerbandwidth, upperbandwidth, isr
     BandedMatrixIndex(sum(bandsizes), rowsize, colsize, bandinds, bandsizes, isrow)
 end
 
-function ArrayInterfaceCore.findstructralnz(x::BandedMatrices.BandedMatrix)
+function ArrayInterface.findstructralnz(x::BandedMatrices.BandedMatrix)
     l, u = BandedMatrices.bandwidths(x)
     rowsize, colsize = Base.size(x)
     rowind = BandedMatrixIndex(rowsize, colsize, l, u, true)
     colind = BandedMatrixIndex(rowsize, colsize, l, u, false)
     return (rowind, colind)
 end
 
-ArrayInterfaceCore.has_sparsestruct(::Type{<:BandedMatrices.BandedMatrix}) = true
-ArrayInterfaceCore.isstructured(::Type{<:BandedMatrices.BandedMatrix}) = true
-ArrayInterfaceCore.fast_matrix_colors(::Type{<:BandedMatrices.BandedMatrix}) = true
+ArrayInterface.has_sparsestruct(::Type{<:BandedMatrices.BandedMatrix}) = true
+ArrayInterface.isstructured(::Type{<:BandedMatrices.BandedMatrix}) = true
+ArrayInterface.fast_matrix_colors(::Type{<:BandedMatrices.BandedMatrix}) = true
 
-function ArrayInterfaceCore.matrix_colors(A::BandedMatrices.BandedMatrix)
+function ArrayInterface.matrix_colors(A::BandedMatrices.BandedMatrix)
     l, u = BandedMatrices.bandwidths(A)
     width = u + l + 1
-    return ArrayInterfaceCore._cycle(1:width, Base.size(A, 2))
+    return ArrayInterface._cycle(1:width, Base.size(A, 2))
 end
 
 end # module

lib/ArrayInterfaceBandedMatrices/src/ArrayInterfaceBandedMatrices.jl renamed to ext/ArrayInterfaceBandedMatricesExt.jl

@@ -1,11 +1,17 @@
-module ArrayInterfaceBlockBandedMatrices
+module ArrayInterfaceBlockBandedMatricesExt
 
-using ArrayInterfaceCore
-using ArrayInterfaceBandedMatrices
-using BlockArrays
-using BlockBandedMatrices
+using ArrayInterface
+using ArrayInterface: BandedMatrixIndex
 
-struct BlockBandedMatrixIndex <: ArrayInterfaceCore.MatrixIndex
+if isdefined(Base, :get_extension) 
+    using BlockBandedMatrices
+    using BlockBandedMatrices.BlockArrays
+else
+    using ..BlockBandedMatrices
+    using ..BlockBandedMatrices.BlockArrays
+end
+
+struct BlockBandedMatrixIndex <: ArrayInterface.MatrixIndex
     count::Int
     refinds::Array{Int,1}
     refcoords::Array{Int,1}# storing col or row inds at ref points
@@ -15,8 +21,8 @@ Base.firstindex(i::BlockBandedMatrixIndex) = 1
 Base.lastindex(i::BlockBandedMatrixIndex) = i.count
 Base.length(i::BlockBandedMatrixIndex) = lastindex(i)
 function BlockBandedMatrixIndex(nrowblock, ncolblock, rowsizes, colsizes, l, u)
-    blockrowind = ArrayInterfaceBandedMatrices.BandedMatrixIndex(nrowblock, ncolblock, l, u, true)
-    blockcolind = ArrayInterfaceBandedMatrices.BandedMatrixIndex(nrowblock, ncolblock, l, u, false)
+    blockrowind = BandedMatrixIndex(nrowblock, ncolblock, l, u, true)
+    blockcolind = BandedMatrixIndex(nrowblock, ncolblock, l, u, false)
     sortedinds = sort(
         [(blockrowind[i], blockcolind[i]) for i = 1:length(blockrowind)],
         by=x -> x[1],
@@ -81,7 +87,7 @@ Base.@propagate_inbounds function Base.getindex(ind::BlockBandedMatrixIndex, i::
     end
 end
 
-function ArrayInterfaceCore.findstructralnz(x::BlockBandedMatrices.BlockBandedMatrix)
+function ArrayInterface.findstructralnz(x::BlockBandedMatrices.BlockBandedMatrix)
     l, u = BlockBandedMatrices.blockbandwidths(x)
     nrowblock = BlockBandedMatrices.blocksize(x, 1)
     ncolblock = BlockBandedMatrices.blocksize(x, 2)
@@ -96,11 +102,11 @@ function ArrayInterfaceCore.findstructralnz(x::BlockBandedMatrices.BlockBandedMa
         u,
     )
 end
-struct BandedBlockBandedMatrixIndex <: ArrayInterfaceCore.MatrixIndex
+struct BandedBlockBandedMatrixIndex <: ArrayInterface.MatrixIndex
     count::Int
     refinds::Array{Int,1}
     refcoords::Array{Int,1}# storing col or row inds at ref points
-    reflocalinds::Array{ArrayInterfaceBandedMatrices.BandedMatrixIndex,1}
+    reflocalinds::Array{BandedMatrixIndex,1}
     isrow::Bool
 end
 Base.firstindex(i::BandedBlockBandedMatrixIndex) = 1
@@ -128,8 +134,8 @@ function BandedBlockBandedMatrixIndex(
     lambda,
     mu,
 )
-    blockrowind = ArrayInterfaceBandedMatrices.BandedMatrixIndex(nrowblock, ncolblock, l, u, true)
-    blockcolind = ArrayInterfaceBandedMatrices.BandedMatrixIndex(nrowblock, ncolblock, l, u, false)
+    blockrowind = BandedMatrixIndex(nrowblock, ncolblock, l, u, true)
+    blockcolind = BandedMatrixIndex(nrowblock, ncolblock, l, u, false)
     sortedinds = sort(
         [(blockrowind[i], blockcolind[i]) for i = 1:length(blockrowind)],
         by=x -> x[1],
@@ -143,14 +149,14 @@ function BandedBlockBandedMatrixIndex(
     refinds = Array{Int,1}()
     refrowcoords = Array{Int,1}()
     refcolcoords = Array{Int,1}()
-    reflocalrowinds = Array{ArrayInterfaceBandedMatrices.BandedMatrixIndex,1}()
-    reflocalcolinds = Array{ArrayInterfaceBandedMatrices.BandedMatrixIndex,1}()
+    reflocalrowinds = Array{BandedMatrixIndex,1}()
+    reflocalcolinds = Array{BandedMatrixIndex,1}()
     for ind in sortedinds
         rowind, colind = ind
         localrowind =
-            ArrayInterfaceBandedMatrices.BandedMatrixIndex(rowsizes[rowind], colsizes[colind], lambda, mu, true)
+            BandedMatrixIndex(rowsizes[rowind], colsizes[colind], lambda, mu, true)
         localcolind =
-            ArrayInterfaceBandedMatrices.BandedMatrixIndex(rowsizes[rowind], colsizes[colind], lambda, mu, false)
+            BandedMatrixIndex(rowsizes[rowind], colsizes[colind], lambda, mu, false)
         push!(refinds, currenti)
         push!(refrowcoords, rowheights[rowind])
         push!(refcolcoords, colwidths[colind])
@@ -178,7 +184,7 @@ function BandedBlockBandedMatrixIndex(
     rowindobj, colindobj
 end
 
-function ArrayInterfaceCore.findstructralnz(x::BlockBandedMatrices.BandedBlockBandedMatrix)
+function ArrayInterface.findstructralnz(x::BlockBandedMatrices.BandedBlockBandedMatrix)
     l, u = BlockBandedMatrices.blockbandwidths(x)
     lambda, mu = BlockBandedMatrices.subblockbandwidths(x)
     nrowblock = BlockBandedMatrices.blocksize(x, 1)
@@ -197,19 +203,19 @@ function ArrayInterfaceCore.findstructralnz(x::BlockBandedMatrices.BandedBlockBa
     )
 end
 
-ArrayInterfaceCore.has_sparsestruct(::Type{<:BlockBandedMatrices.BlockBandedMatrix}) = true
-ArrayInterfaceCore.has_sparsestruct(::Type{<:BlockBandedMatrices.BandedBlockBandedMatrix}) = true
-ArrayInterfaceCore.isstructured(::Type{<:BlockBandedMatrices.BlockBandedMatrix}) = true
-ArrayInterfaceCore.isstructured(::Type{<:BlockBandedMatrices.BandedBlockBandedMatrix}) = true
-ArrayInterfaceCore.fast_matrix_colors(::Type{<:BlockBandedMatrices.BlockBandedMatrix}) = true
-ArrayInterfaceCore.fast_matrix_colors(::Type{<:BlockBandedMatrices.BandedBlockBandedMatrix}) = true
+ArrayInterface.has_sparsestruct(::Type{<:BlockBandedMatrices.BlockBandedMatrix}) = true
+ArrayInterface.has_sparsestruct(::Type{<:BlockBandedMatrices.BandedBlockBandedMatrix}) = true
+ArrayInterface.isstructured(::Type{<:BlockBandedMatrices.BlockBandedMatrix}) = true
+ArrayInterface.isstructured(::Type{<:BlockBandedMatrices.BandedBlockBandedMatrix}) = true
+ArrayInterface.fast_matrix_colors(::Type{<:BlockBandedMatrices.BlockBandedMatrix}) = true
+ArrayInterface.fast_matrix_colors(::Type{<:BlockBandedMatrices.BandedBlockBandedMatrix}) = true
 
-function ArrayInterfaceCore.matrix_colors(A::BlockBandedMatrices.BlockBandedMatrix)
+function ArrayInterface.matrix_colors(A::BlockBandedMatrices.BlockBandedMatrix)
     l, u = BlockBandedMatrices.blockbandwidths(A)
     blockwidth = l + u + 1
     nblock = BlockBandedMatrices.blocksize(A, 2)
     cols = BlockArrays.blocklengths(axes(A, 2))
-    blockcolors = ArrayInterfaceCore._cycle(1:blockwidth, nblock)
+    blockcolors = ArrayInterface._cycle(1:blockwidth, nblock)
     # the reserved number of colors of a block is the maximum length of columns of blocks with the same block color
     ncolors = [maximum(cols[i:blockwidth:nblock]) for i = 1:blockwidth]
     endinds = cumsum(ncolors)
@@ -221,14 +227,14 @@ function ArrayInterfaceCore.matrix_colors(A::BlockBandedMatrices.BlockBandedMatr
     return reduce(vcat, colors)
 end
 
-function ArrayInterfaceCore.matrix_colors(A::BlockBandedMatrices.BandedBlockBandedMatrix)
+function ArrayInterface.matrix_colors(A::BlockBandedMatrices.BandedBlockBandedMatrix)
     l, u = BlockBandedMatrices.blockbandwidths(A)
     lambda, mu = BlockBandedMatrices.subblockbandwidths(A)
     blockwidth = l + u + 1
     subblockwidth = lambda + mu + 1
     nblock = BlockBandedMatrices.blocksize(A, 2)
     cols = BlockArrays.blocklengths(axes(A, 2))
-    blockcolors = ArrayInterfaceCore._cycle(1:blockwidth, nblock)
+    blockcolors = ArrayInterface._cycle(1:blockwidth, nblock)
     # the reserved number of colors of a block is the min of subblockwidth and the largest length of columns of blocks with the same block color
     ncolors = [
         min(subblockwidth, maximum(cols[i:blockwidth:nblock]))
@@ -237,7 +243,7 @@ function ArrayInterfaceCore.matrix_colors(A::BlockBandedMatrices.BandedBlockBand
     endinds = cumsum(ncolors)
     startinds = [endinds[i] - ncolors[i] + 1 for i = 1:min(blockwidth, nblock)]
     colors = [
-        ArrayInterfaceCore._cycle(startinds[blockcolors[i]]:endinds[blockcolors[i]], cols[i])
+        ArrayInterface._cycle(startinds[blockcolors[i]]:endinds[blockcolors[i]], cols[i])
         for i = 1:nblock
     ]
     return reduce(vcat, colors)

lib/ArrayInterfaceBlockBandedMatrices/src/ArrayInterfaceBlockBandedMatrices.jl renamed to ext/ArrayInterfaceBlockBandedMatricesExt.jl

@@ -1,9 +1,15 @@
-module ArrayInterfaceCUDA
+module ArrayInterfaceCUDAExt
 
 using Adapt
-using ArrayInterface, ArrayInterfaceGPUArrays
-using CUDA
-using CUDA.CUSOLVER
+using ArrayInterface
+
+if isdefined(Base, :get_extension) 
+    using CUDA
+    using CUDA.CUSOLVER
+else 
+    using ..CUDA
+    using ..CUDA.CUSOLVER
+end
 
 using LinearAlgebra
 

lib/ArrayInterfaceCUDA/src/ArrayInterfaceCUDA.jl renamed to ext/ArrayInterfaceCUDAExt.jl

@@ -0,0 +1,29 @@
+module ArrayInterfaceGPUArraysExt
+
+using Adapt
+using ArrayInterface
+using LinearAlgebra: lu
+isdefined(Base, :get_extension) ? (import GPUArraysCore) : (import ..GPUArraysCore)
+
+ArrayInterface.fast_scalar_indexing(::Type{<:GPUArraysCore.AbstractGPUArray}) = false
+@inline ArrayInterface.allowed_getindex(x::GPUArraysCore.AbstractGPUArray, i...) = GPUArraysCore.@allowscalar(x[i...])
+@inline ArrayInterface.allowed_setindex!(x::GPUArraysCore.AbstractGPUArray, v, i...) = (GPUArraysCore.@allowscalar(x[i...] = v))
+
+function Base.setindex(x::GPUArraysCore.AbstractGPUArray, v, i::Int)
+    _x = copy(x)
+    ArrayInterface.allowed_setindex!(_x, v, i)
+    return _x
+end
+
+function ArrayInterface.restructure(x::GPUArraysCore.AbstractGPUArray, y)
+    reshape(Adapt.adapt(ArrayInterface.parameterless_type(x), y), Base.size(x)...)
+end
+
+function ArrayInterface.lu_instance(A::GPUArraysCore.AbstractGPUMatrix{T}) where {T}
+    lu(Adapt.adapt(ArrayInterface.parameterless_type(A), ones(T, 0, 0)))
+end
+
+# Doesn't do much, but makes a gigantic change to the dependency chain.
+# ArrayInterface.device(::Type{<:GPUArraysCore.AbstractGPUArray}) = ArrayInterface.GPU()
+
+end