Implement issorted for AbstractGPUArray without scalar indexing. (#678)

Author: shreyas-omkar

src/host/base.jl

@@ -1,6 +1,47 @@
 # common Base functionality
 import Base: _RepeatInnerOuter
 
+@kernel function issorted_kernel!(
+        data,
+        violations,
+        ord,
+    )
+    i = @index(Global)
+    if i <= length(violations)
+        @inbounds begin
+            a = data[i]
+            b = data[i + 1]
+            violations[i] = Base.Order.lt(ord, b, a)
+        end
+    end
+end
+
+function Base.issorted(A::AbstractGPUArray; lt::Function = isless, by::Function = identity, rev::Bool = false, order = Base.Order.Forward)
+    if order === Base.Order.Reverse
+        rev = !rev
+        order = Base.Order.Forward
+    elseif order !== Base.Order.Forward
+        throw(ArgumentError("custom orderings are not supported on GPU"))
+    end
+
+    n = length(A)
+    n ≤ 1 && return true
+
+    ord = Base.Order.ord(lt, by, rev, order)
+
+    violations = similar(A, Bool, n - 1)
+    backend = get_backend(A)
+
+    issorted_kernel!(backend)(
+        A,
+        violations,
+        ord,
+        ndrange = n - 1,
+    )
+
+    return !any(Array(violations))
+end
+
 # Handle `out = repeat(x; inner)` by parallelizing over `out` array This can benchmark
 # faster if repeating elements along the first axis (i.e. `inner=(n, ones...)`), as data
 # access can be contiguous on write.

test/testsuite/base.jl

@@ -29,6 +29,50 @@ end
         end
     end
 
+    @testset "issorted" begin
+        # basic sorted / unsorted
+        @test compare(issorted, AT, [1, 2, 3, 4])
+        @test compare(x -> !issorted(x), AT, [1, 3, 2, 4])
+
+        # reverse ordering
+        @test compare(x -> issorted(x; rev = true), AT, [4, 3, 2, 1])
+        @test compare(x -> !issorted(x; rev = true), AT, [1, 2, 3])
+
+        # custom lt
+        @test compare(x -> issorted(x; lt = >), AT, [3, 2, 1])
+        @test compare(x -> !issorted(x; lt = >), AT, [1, 2, 3])
+
+        # by = abs
+        @test compare(x -> issorted(x; by = abs), AT, [-1, -2, -3])
+        @test compare(x -> !issorted(x; by = abs), AT, [-1, -3, -2])
+
+        # order keyword normalization
+        @test compare(
+            x -> issorted(x; order = Base.Order.Reverse),
+            AT,
+            [3, 2, 1],
+        )
+
+        @test compare(
+            x -> !issorted(x; order = Base.Order.Reverse),
+            AT,
+            [1, 2, 3],
+        )
+
+        # edge cases
+        @test compare(issorted, AT, Int[])
+        @test compare(issorted, AT, [42])
+
+        # unsupported custom orderings
+        AT <: AbstractGPUArray && @testset "unsupported orderings" begin
+            x = AT([1, 2, 3])
+            @test_throws ArgumentError issorted(
+                x;
+                order = Base.Order.By(identity),
+            )
+        end
+    end
+
     @testset "copy!" begin
         for (dst, src,) in (
                             (rand(Float32, (10,)),   rand(Float32, (10,))),   # vectors