Move core functionality to GPUArraysCore.

Manifest.toml

@@ -28,6 +28,12 @@ uuid = "ade2ca70-3891-5945-98fb-dc099432e06a"
 deps = ["ArgTools", "LibCURL", "NetworkOptions"]
 uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6"
 
+[[GPUArraysCore]]
+deps = ["Adapt"]
+path = "lib/GPUArraysCore"
+uuid = "46192b85-c4d5-4398-a991-12ede77f4527"
+version = "0.1.0"
+
 [[InteractiveUtils]]
 deps = ["Markdown"]
 uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
@@ -46,9 +52,9 @@ version = "4.7.1"
 
 [[LLVMExtra_jll]]
 deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
-git-tree-sha1 = "62115afed394c016c2d3096c5b85c407b48be96b"
+git-tree-sha1 = "67cc5406b15bd04ff72a45f628bec61d36078908"
 uuid = "dad2f222-ce93-54a1-a47d-0025e8a3acab"
-version = "0.0.13+1"
+version = "0.0.13+3"
 
 [[LibCURL]]
 deps = ["LibCURL_jll", "MozillaCACerts_jll"]
@@ -112,6 +118,11 @@ uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
 deps = ["Serialization"]
 uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 
+[[Reexport]]
+git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b"
+uuid = "189a3867-3050-52da-a836-e630ba90ab69"
+version = "1.2.2"
+
 [[SHA]]
 uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce"
 

Project.toml

@@ -4,10 +4,12 @@ version = "8.3.2"
 
 [deps]
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
+GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527"
 LLVM = "929cbde3-209d-540e-8aea-75f648917ca0"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 

lib/GPUArraysCore/Manifest.toml

@@ -0,0 +1,14 @@
+# This file is machine-generated - editing it directly is not advised
+
+[[Adapt]]
+deps = ["LinearAlgebra"]
+git-tree-sha1 = "af92965fb30777147966f58acb05da51c5616b5f"
+uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
+version = "3.3.3"
+
+[[Libdl]]
+uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
+
+[[LinearAlgebra]]
+deps = ["Libdl"]
+uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"

lib/GPUArraysCore/Project.toml

@@ -0,0 +1,7 @@
+name = "GPUArraysCore"
+uuid = "46192b85-c4d5-4398-a991-12ede77f4527"
+authors = ["Tim Besard <[email protected]>"]
+version = "0.1.0"
+
+[deps]
+Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"

lib/GPUArraysCore/src/GPUArraysCore.jl

@@ -0,0 +1,106 @@
+module GPUArraysCore
+
+using Adapt
+
+
+## essential types
+
+export AbstractGPUArray, AbstractGPUVector, AbstractGPUMatrix, AbstractGPUVecOrMat,
+       WrappedGPUArray, AnyGPUArray
+
+"""
+    AbstractGPUArray{T, N} <: DenseArray{T, N}
+
+Supertype for `N`-dimensional GPU arrays (or array-like types) with elements of type `T`.
+Instances of this type are expected to live on the host, see [`AbstractDeviceArray`](@ref)
+for device-side objects.
+"""
+abstract type AbstractGPUArray{T, N} <: DenseArray{T, N} end
+
+const AbstractGPUVector{T} = AbstractGPUArray{T, 1}
+const AbstractGPUMatrix{T} = AbstractGPUArray{T, 2}
+const AbstractGPUVecOrMat{T} = Union{AbstractGPUArray{T, 1}, AbstractGPUArray{T, 2}}
+
+# convenience aliases for working with wrapped arrays
+const WrappedGPUArray{T,N} = WrappedArray{T,N,AbstractGPUArray,AbstractGPUArray{T,N}}
+const AnyGPUArray{T,N} = Union{AbstractGPUArray{T,N}, WrappedGPUArray{T,N}}
+
+
+## scalar iteration
+
+export allowscalar, @allowscalar, assertscalar
+
+@enum ScalarIndexing ScalarAllowed ScalarWarn ScalarWarned ScalarDisallowed
+
+# if the user explicitly calls allowscalar, use that setting for all new tasks
+# XXX: use context variables to inherit the parent task's setting, once available.
+const default_scalar_indexing = Ref{Union{Nothing,ScalarIndexing}}(nothing)
+
+"""
+    allowscalar() do
+        # code that can use scalar indexing
+    end
+
+Denote which operations can use scalar indexing.
+
+See also: [`@allowscalar`](@ref).
+"""
+function allowscalar(f::Base.Callable)
+    task_local_storage(f, :ScalarIndexing, ScalarAllowed)
+end
+
+function allowscalar(allow::Bool=true)
+    if allow
+        Base.depwarn("allowscalar([true]) is deprecated, use `allowscalar() do end` or `@allowscalar` to denote exactly which operations can use scalar operations.", :allowscalar)
+    end
+    setting = allow ? ScalarAllowed : ScalarDisallowed
+    task_local_storage(:ScalarIndexing, setting)
+    default_scalar_indexing[] = setting
+    return
+end
+
+"""
+    assertscalar(op::String)
+
+Assert that a certain operation `op` performs scalar indexing. If this is not allowed, an
+error will be thrown ([`allowscalar`](@ref)).
+"""
+function assertscalar(op = "operation")
+    val = get!(task_local_storage(), :ScalarIndexing) do
+        something(default_scalar_indexing[], isinteractive() ? ScalarWarn : ScalarDisallowed)
+    end
+    desc = """Invocation of $op resulted in scalar indexing of a GPU array.
+              This is typically caused by calling an iterating implementation of a method.
+              Such implementations *do not* execute on the GPU, but very slowly on the CPU,
+              and therefore are only permitted from the REPL for prototyping purposes.
+              If you did intend to index this array, annotate the caller with @allowscalar."""
+    if val == ScalarDisallowed
+        error("""Scalar indexing is disallowed.
+                 $desc""")
+    elseif val == ScalarWarn
+        @warn("""Performing scalar indexing on task $(current_task()).
+                 $desc""")
+        task_local_storage(:ScalarIndexing, ScalarWarned)
+    end
+    return
+end
+
+"""
+    @allowscalar() begin
+        # code that can use scalar indexing
+    end
+
+Denote which operations can use scalar indexing.
+
+See also: [`allowscalar`](@ref).
+"""
+macro allowscalar(ex)
+    quote
+        task_local_storage(:ScalarIndexing, ScalarAllowed) do
+            $(esc(ex))
+        end
+    end
+end
+
+
+end # module GPUArraysCore

src/GPUArrays.jl

@@ -11,6 +11,9 @@ using Base.Cartesian
 using Adapt
 using LLVM.Interop
 
+using Reexport
+@reexport using GPUArraysCore
+
 # device functionality
 include("device/execution.jl")
 ## executed on-device

src/host/abstractarray.jl

@@ -1,27 +1,5 @@
 # core definition of the AbstractGPUArray type
 
-export AbstractGPUArray
-
-"""
-    AbstractGPUArray{T, N} <: DenseArray{T, N}
-
-Supertype for `N`-dimensional GPU arrays (or array-like types) with elements of type `T`.
-Instances of this type are expected to live on the host, see [`AbstractDeviceArray`](@ref)
-for device-side objects.
-"""
-abstract type AbstractGPUArray{T, N} <: DenseArray{T, N} end
-
-const AbstractGPUVector{T} = AbstractGPUArray{T, 1}
-const AbstractGPUMatrix{T} = AbstractGPUArray{T, 2}
-const AbstractGPUVecOrMat{T} = Union{AbstractGPUArray{T, 1}, AbstractGPUArray{T, 2}}
-
-
-# convenience aliases for working with wrapped arrays
-
-const WrappedGPUArray{T,N} = WrappedArray{T,N,AbstractGPUArray,AbstractGPUArray{T,N}}
-
-const AnyGPUArray{T,N} = Union{AbstractGPUArray{T,N}, WrappedGPUArray{T,N}}
-
 
 # input/output
 

src/host/indexing.jl

@@ -1,82 +1,5 @@
 # host-level indexing
 
-export allowscalar, @allowscalar, assertscalar
-
-
-# mechanism to disallow scalar operations
-
-@enum ScalarIndexing ScalarAllowed ScalarWarn ScalarWarned ScalarDisallowed
-
-# if the user explicitly calls allowscalar, use that setting for all new tasks
-# XXX: use context variables to inherit the parent task's setting, once available.
-const default_scalar_indexing = Ref{Union{Nothing,ScalarIndexing}}(nothing)
-
-"""
-    allowscalar() do
-        # code that can use scalar indexing
-    end
-
-Denote which operations can use scalar indexing.
-
-See also: [`@allowscalar`](@ref).
-"""
-function allowscalar(f::Base.Callable)
-    task_local_storage(f, :ScalarIndexing, ScalarAllowed)
-end
-
-function allowscalar(allow::Bool=true)
-    if allow
-        Base.depwarn("allowscalar([true]) is deprecated, use `allowscalar() do end` or `@allowscalar` to denote exactly which operations can use scalar operations.", :allowscalar)
-    end
-    setting = allow ? ScalarAllowed : ScalarDisallowed
-    task_local_storage(:ScalarIndexing, setting)
-    default_scalar_indexing[] = setting
-    return
-end
-
-"""
-    assertscalar(op::String)
-
-Assert that a certain operation `op` performs scalar indexing. If this is not allowed, an
-error will be thrown ([`allowscalar`](@ref)).
-"""
-function assertscalar(op = "operation")
-    val = get!(task_local_storage(), :ScalarIndexing) do
-        something(default_scalar_indexing[], isinteractive() ? ScalarWarn : ScalarDisallowed)
-    end
-    desc = """Invocation of $op resulted in scalar indexing of a GPU array.
-              This is typically caused by calling an iterating implementation of a method.
-              Such implementations *do not* execute on the GPU, but very slowly on the CPU,
-              and therefore are only permitted from the REPL for prototyping purposes.
-              If you did intend to index this array, annotate the caller with @allowscalar."""
-    if val == ScalarDisallowed
-        error("""Scalar indexing is disallowed.
-                 $desc""")
-    elseif val == ScalarWarn
-        @warn("""Performing scalar indexing on task $(current_task()).
-                 $desc""")
-        task_local_storage(:ScalarIndexing, ScalarWarned)
-    end
-    return
-end
-
-"""
-    @allowscalar() begin
-        # code that can use scalar indexing
-    end
-
-Denote which operations can use scalar indexing.
-
-See also: [`allowscalar`](@ref).
-"""
-macro allowscalar(ex)
-    quote
-        task_local_storage(:ScalarIndexing, ScalarAllowed) do
-            $(esc(ex))
-        end
-    end
-end
-
 
 # basic indexing with integers