Merge branch 'gpu-support' of https://github.com/darsnack/CircularArrayBuffers.jl into gpu-support

Author: darsnack

.github/workflows/ci.yml

@@ -10,7 +10,7 @@ jobs:
       fail-fast: false
       matrix:
         version:
-          - '1.0'
+          # - '1.0'  # incompatible with CUDA.jl
           - '1'
           - 'nightly'
         os:

test/runtests.jl

@@ -169,175 +169,177 @@ CUDA.allowscalar(false)
     end
 end
 
-@testset "CircularArrayBuffers (CuArray)" begin
-    A = CUDA.ones(2, 2)
-    Ac = adapt(Array, A)
-    C = CUDA.ones(Float32, 2, 2)
-
-    @testset "Adapt" begin
-        X = CircularArrayBuffer(rand(2, 3))
-        Xc = adapt(CuArray, X)
-        @test Xc isa CircularArrayBuffer{Float64, 2, <:CuArray}
-        @test adapt(Array, Xc) == X
-    end
-
-    # https://github.com/JuliaReinforcementLearning/ReinforcementLearning.jl/issues/551
-    @testset "1D with 0d data" begin
-        b = adapt(CuArray, CircularArrayBuffer{Int}(3))
-        CUDA.@allowscalar push!(b, CUDA.zeros(Int, ()))
-        @test length(b) == 1
-        @test CUDA.@allowscalar b[1] == 0
-    end
-
-    @testset "1D Int" begin
-        b = adapt(CuArray, CircularArrayBuffer{Int}(3))
-
-        @test eltype(b) == Int
-        @test capacity(b) == 3
-        @test isfull(b) == false
-        @test isempty(b) == true
-        @test length(b) == 0
-        @test size(b) == (0,)
-        # element must has the exact same length with the element of buffer
-        @test_throws Exception push!(b, [1, 2])
-
-        for x in 1:3
-            push!(b, x)
+if CUDA.functional()
+    @testset "CircularArrayBuffers (CuArray)" begin
+        A = CUDA.ones(2, 2)
+        Ac = adapt(Array, A)
+        C = CUDA.ones(Float32, 2, 2)
+
+        @testset "Adapt" begin
+            X = CircularArrayBuffer(rand(2, 3))
+            Xc = adapt(CuArray, X)
+            @test Xc isa CircularArrayBuffer{Float64,2,<:CuArray}
+            @test adapt(Array, Xc) == X
         end
 
-        @test capacity(b) == 3
-        @test isfull(b) == true
-        @test length(b) == 3
-        @test size(b) == (3,)
-        # scalar indexing is not allowed
-        @test_throws ErrorException b[1]
-        @test_throws ErrorException b[end]
-        @test CUDA.@allowscalar b[1:end] == cu([1, 2, 3])
-
-        for x in 4:5
-            push!(b, x)
+        # https://github.com/JuliaReinforcementLearning/ReinforcementLearning.jl/issues/551
+        @testset "1D with 0d data" begin
+            b = adapt(CuArray, CircularArrayBuffer{Int}(3))
+            CUDA.@allowscalar push!(b, CUDA.zeros(Int, ()))
+            @test length(b) == 1
+            @test CUDA.@allowscalar b[1] == 0
         end
 
-        @test capacity(b) == 3
-        @test length(b) == 3
-        @test size(b) == (3,)
-        @test CUDA.@allowscalar b[1:end] == [3, 4, 5]
-
-        empty!(b)
-        @test isfull(b) == false
-        @test isempty(b) == true
-        @test length(b) == 0
-        @test size(b) == (0,)
-
-        push!(b, 6)
-        @test isfull(b) == false
-        @test isempty(b) == false
-        @test length(b) == 1
-        @test size(b) == (1,)
-        @test CUDA.@allowscalar b[1] == 6
-
-        push!(b, 7)
-        push!(b, 8)
-        @test isfull(b) == true
-        @test isempty(b) == false
-        @test length(b) == 3
-        @test size(b) == (3,)
-        @test CUDA.@allowscalar b[1:3] == cu([6, 7, 8])
-
-        push!(b, 9)
-        @test isfull(b) == true
-        @test isempty(b) == false
-        @test length(b) == 3
-        @test size(b) == (3,)
-        @test CUDA.@allowscalar b[1:3] == cu([7, 8, 9])
-
-        x = CUDA.@allowscalar pop!(b)
-        @test x == 9
-        @test length(b) == 2
-        @test CUDA.@allowscalar b[1:2] == cu([7, 8])
-
-        x = CUDA.@allowscalar popfirst!(b)
-        @test x == 7
-        @test length(b) == 1
-        @test CUDA.@allowscalar b[1] == 8
-
-        x = CUDA.@allowscalar pop!(b)
-        @test x == 8
-        @test length(b) == 0
-
-        @test_throws ArgumentError pop!(b)
-        @test_throws ArgumentError popfirst!(b)
-    end
-
-    @testset "2D Float64" begin
-        b = adapt(CuArray, CircularArrayBuffer{Float64}(2, 2, 3))
-
-        @test eltype(b) == Float64
-        @test capacity(b) == 3
-        @test isfull(b) == false
-        @test length(b) == 0
-        @test size(b) == (2, 2, 0)
-
-        for x in 1:3
-            push!(b, x * A)
+        @testset "1D Int" begin
+            b = adapt(CuArray, CircularArrayBuffer{Int}(3))
+
+            @test eltype(b) == Int
+            @test capacity(b) == 3
+            @test isfull(b) == false
+            @test isempty(b) == true
+            @test length(b) == 0
+            @test size(b) == (0,)
+            # element must has the exact same length with the element of buffer
+            @test_throws Exception push!(b, [1, 2])
+
+            for x in 1:3
+                push!(b, x)
+            end
+
+            @test capacity(b) == 3
+            @test isfull(b) == true
+            @test length(b) == 3
+            @test size(b) == (3,)
+            # scalar indexing is not allowed
+            @test_throws ErrorException b[1]
+            @test_throws ErrorException b[end]
+            @test CUDA.@allowscalar b[1:end] == cu([1, 2, 3])
+
+            for x in 4:5
+                push!(b, x)
+            end
+
+            @test capacity(b) == 3
+            @test length(b) == 3
+            @test size(b) == (3,)
+            @test CUDA.@allowscalar b[1:end] == [3, 4, 5]
+
+            empty!(b)
+            @test isfull(b) == false
+            @test isempty(b) == true
+            @test length(b) == 0
+            @test size(b) == (0,)
+
+            push!(b, 6)
+            @test isfull(b) == false
+            @test isempty(b) == false
+            @test length(b) == 1
+            @test size(b) == (1,)
+            @test CUDA.@allowscalar b[1] == 6
+
+            push!(b, 7)
+            push!(b, 8)
+            @test isfull(b) == true
+            @test isempty(b) == false
+            @test length(b) == 3
+            @test size(b) == (3,)
+            @test CUDA.@allowscalar b[1:3] == cu([6, 7, 8])
+
+            push!(b, 9)
+            @test isfull(b) == true
+            @test isempty(b) == false
+            @test length(b) == 3
+            @test size(b) == (3,)
+            @test CUDA.@allowscalar b[1:3] == cu([7, 8, 9])
+
+            x = CUDA.@allowscalar pop!(b)
+            @test x == 9
+            @test length(b) == 2
+            @test CUDA.@allowscalar b[1:2] == cu([7, 8])
+
+            x = CUDA.@allowscalar popfirst!(b)
+            @test x == 7
+            @test length(b) == 1
+            @test CUDA.@allowscalar b[1] == 8
+
+            x = CUDA.@allowscalar pop!(b)
+            @test x == 8
+            @test length(b) == 0
+
+            @test_throws ArgumentError pop!(b)
+            @test_throws ArgumentError popfirst!(b)
         end
 
-        @test capacity(b) == 3
-        @test isfull(b) == true
-        @test length(b) == 2 * 2 * 3
-        @test size(b) == (2, 2, 3)
-        for i in 1:3
-            @test b[:, :, i] == i * A
+        @testset "2D Float64" begin
+            b = adapt(CuArray, CircularArrayBuffer{Float64}(2, 2, 3))
+
+            @test eltype(b) == Float64
+            @test capacity(b) == 3
+            @test isfull(b) == false
+            @test length(b) == 0
+            @test size(b) == (2, 2, 0)
+
+            for x in 1:3
+                push!(b, x * A)
+            end
+
+            @test capacity(b) == 3
+            @test isfull(b) == true
+            @test length(b) == 2 * 2 * 3
+            @test size(b) == (2, 2, 3)
+            for i in 1:3
+                @test b[:, :, i] == i * A
+            end
+            @test b[:, :, end] == 3 * A
+
+            for x in 4:5
+                push!(b, x * CUDA.ones(Float64, 2, 2))
+            end
+
+            @test capacity(b) == 3
+            @test length(b) == 2 * 2 * 3
+            @test size(b) == (2, 2, 3)
+            @test b[:, :, 1] == 3 * A
+            @test b[:, :, end] == 5 * A
+
+            # doing b == ... triggers scalar indexing
+            @test CUDA.@allowscalar b == cu(reshape([c for x in 3:5 for c in x * Ac], 2, 2, 3))
+
+            push!(b, 6 * CUDA.ones(Float32, 2, 2))
+            push!(b, 7 * CUDA.ones(Int, 2, 2))
+            @test CUDA.@allowscalar b == cu(reshape([c for x in 5:7 for c in x * Ac], 2, 2, 3))
+
+            x = pop!(b)
+            @test x == 7 * CUDA.ones(Float64, 2, 2)
+            @test CUDA.@allowscalar b == cu(reshape([c for x in 5:6 for c in x * Ac], 2, 2, 2))
         end
-        @test b[:, :, end] == 3 * A
 
-        for x in 4:5
-            push!(b, x * CUDA.ones(Float64, 2, 2))
+        @testset "append!" begin
+            b = adapt(CuArray, CircularArrayBuffer{Int}(2, 3))
+            append!(b, CUDA.zeros(2))
+            append!(b, 1:4)
+            @test CUDA.@allowscalar b == cu([
+                0 1 3
+                0 2 4
+            ])
+
+
+            b = adapt(CuArray, CircularArrayBuffer{Int}(2, 3))
+            for i in 1:5
+                push!(b, CUDA.fill(i, 2))
+            end
+            empty!(b)
+            append!(b, 1:4)
+            @test CUDA.@allowscalar b == cu([
+                1 3
+                2 4
+            ])
+
+            append!(b, 5:8)
+            @test CUDA.@allowscalar b == cu([
+                3 5 7
+                4 6 8
+            ])
         end
-
-        @test capacity(b) == 3
-        @test length(b) == 2 * 2 * 3
-        @test size(b) == (2, 2, 3)
-        @test b[:, :, 1] == 3 * A
-        @test b[:, :, end] == 5 * A
-
-        # doing b == ... triggers scalar indexing
-        @test CUDA.@allowscalar b == cu(reshape([c for x in 3:5 for c in x * Ac], 2, 2, 3))
-
-        push!(b, 6 * CUDA.ones(Float32, 2, 2))
-        push!(b, 7 * CUDA.ones(Int, 2, 2))
-        @test CUDA.@allowscalar b == cu(reshape([c for x in 5:7 for c in x * Ac], 2, 2, 3))
-
-        x = pop!(b)
-        @test x == 7 * CUDA.ones(Float64, 2, 2)
-        @test CUDA.@allowscalar b == cu(reshape([c for x in 5:6 for c in x * Ac], 2, 2, 2))
-    end
-
-    @testset "append!" begin
-        b = adapt(CuArray, CircularArrayBuffer{Int}(2, 3))
-        append!(b, CUDA.zeros(2))
-        append!(b, 1:4)
-        @test CUDA.@allowscalar b == cu([
-            0 1 3
-            0 2 4
-        ])
-
-
-        b = adapt(CuArray, CircularArrayBuffer{Int}(2, 3))
-        for i in 1:5
-            push!(b, CUDA.fill(i, 2))
-        end
-        empty!(b)
-        append!(b, 1:4)
-        @test CUDA.@allowscalar b == cu([
-            1 3
-            2 4
-        ])
-
-        append!(b, 5:8)
-        @test CUDA.@allowscalar b == cu([
-            3 5 7
-            4 6 8
-        ])
     end
 end