Redo ArrayInterface to use extension packages

* ArrayInterfaceCore -> ArrayInterface
* ArrayInterface -> ArrayInterfaceStaticExt
* All lib packages are extensions

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

@@ -14,14 +14,7 @@ jobs:
       fail-fast: false
       matrix:
         group:
-          - ArrayInterface
-          - ArrayInterfaceCore
-          - ArrayInterfaceBandedMatrices
-          - ArrayInterfaceBlockBandedMatrices
-          - ArrayInterfaceOffsetArrays
-          - ArrayInterfaceStaticArrays
-          - ArrayInterfaceStaticArraysCore
-          - ArrayInterfaceTracker
+          - Core
         version:
           - '1'
           - '1.6'

.github/workflows/ci.yml

@@ -3,24 +3,56 @@ uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
 version = "6.0.25"
 
 [deps]
-ArrayInterfaceCore = "30b0a656-2188-435a-8636-2ec0e6a096e2"
 Compat = "34da2185-b29b-5c13-b0c7-acf172513d20"
-IfElse = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 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"
 julia = "1.6"
 
+[extensions]
+ArrayInterfaceBandedMatricesExt = "BandedMatrices"
+ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices"
+ArrayInterfaceCUDAExt = "CUDA"
+ArrayInterfaceGPUArraysExt = "GPUArraysCore"
+ArrayInterfaceOffsetArraysExt = "OffsetArrays"
+ArrayInterfaceStaticArraysExt = "StaticArrays"
+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"
+IfElse = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+SuiteSparse = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9"
+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 = ["Pkg", "Test", "Aqua", "IfElse", "Random", "SparseArrays", "SuiteSparse", "Static", "BandedMatrices"]
+
+[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,9 +1,9 @@
-module ArrayInterfaceBandedMatrices
+module ArrayInterfaceBandedMatricesExt
 
-using ArrayInterfaceCore
+using ArrayInterface
 using BandedMatrices
 
-struct BandedMatrixIndex <: ArrayInterfaceCore.MatrixIndex
+struct BandedMatrixIndex <: ArrayInterface.MatrixIndex
     count::Int
     rowsize::Int
     colsize::Int
@@ -50,22 +50,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/ArrayInterfaceBandedMatrices.jl

@@ -1,11 +1,11 @@
-module ArrayInterfaceBlockBandedMatrices
+module ArrayInterfaceBlockBandedMatricesExt
 
-using ArrayInterfaceCore
+using ArrayInterface
 using ArrayInterfaceBandedMatrices
-using BlockArrays
 using BlockBandedMatrices
+using BlockBandedMatrices.BlockArrays
 
-struct BlockBandedMatrixIndex <: ArrayInterfaceCore.MatrixIndex
+struct BlockBandedMatrixIndex <: ArrayInterface.MatrixIndex
     count::Int
     refinds::Array{Int,1}
     refcoords::Array{Int,1}# storing col or row inds at ref points
@@ -81,7 +81,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,7 +96,7 @@ 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
@@ -178,7 +178,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 +197,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 +221,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 +237,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/ArrayInterfaceBlockBandedMatrices.jl

@@ -1,7 +1,7 @@
-module ArrayInterfaceCUDA
+module ArrayInterfaceCUDAExt
 
 using Adapt
-using ArrayInterface, ArrayInterfaceGPUArrays
+using ArrayInterface
 using CUDA
 using CUDA.CUSOLVER
 

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

@@ -0,0 +1,29 @@
+module ArrayInterfaceGPUArraysExt
+
+using Adapt
+using ArrayInterface
+using GPUArraysCore
+using LinearAlgebra: lu
+
+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

ext/ArrayInterfaceGPUArrays.jl

@@ -1,4 +1,4 @@
-module ArrayInterfaceOffsetArrays
+module ArrayInterfaceOffsetArraysExt
 
 using ArrayInterface
 using OffsetArrays

lib/ArrayInterfaceOffsetArrays/src/ArrayInterfaceOffsetArrays.jl renamed to ext/ArrayInterfaceOffsetArrays.jl

@@ -1,4 +1,4 @@
-module ArrayInterfaceStaticArrays
+module ArrayInterfaceStaticArraysExt
 
 using Adapt
 using ArrayInterface