src/nditeration.jl

@@ -29,7 +29,7 @@ end
 @inline function Base.getindex(iter::FastCartesianIndices{N}, I::Vararg{Int, N}) where {N}
     @boundscheck checkbounds(iter, I...)
     index = map(iter.inverses, I) do inv, i
-        @inbounds getindex(Base.OneTo(inv.divisor), i)
+        @inbounds getindex(Base.OneTo(inv.divisor), i%Int32)
     end
     CartesianIndex(index)
 end
@@ -42,14 +42,16 @@ end
 
 function _ind2sub_recurse(inds, ind)
     Base.@_inline_meta
+    assume(ind >= 0)
     inv = inds[1]
     indnext, f, l = _div(ind, inv)
     (ind - l * indnext + f, _ind2sub_recurse(Base.tail(inds), indnext)...)
 end
 
 _lookup(ind, inv::SignedMultiplicativeInverse) = ind + 1
 function _div(ind, inv::SignedMultiplicativeInverse)
-    inv.divisor == 0 && throw(DivideError())
+    # inv.divisor == 0 && throw(DivideError())
+    assume(ind >= 0)
     div(ind % Int32, inv), 1, inv.divisor
 end
 
@@ -198,4 +200,20 @@ needs to perform dynamic bounds-checking.
     end
 end
 
+
+
+"""
+    assume(cond::Bool)
+Assume that the condition `cond` is true. This is a hint to the compiler, possibly enabling
+it to optimize more aggressively.
+"""
+@inline assume(cond::Bool) = Base.llvmcall(("""
+        declare void @llvm.assume(i1)
+        define void @entry(i8) #0 {
+            %cond = icmp eq i8 %0, 1
+            call void @llvm.assume(i1 %cond)
+            ret void
+        }
+        attributes #0 = { alwaysinline }""", "entry"),
+    Nothing, Tuple{Bool}, cond)
 end #module

test/private.jl

@@ -73,7 +73,7 @@ function private_testsuite(backend, ArrayT)
 
         A = ArrayT{Int}(undef, 64, 64)
         A .= 1
-        forloop(backend(),  size(A, 1))(A, Val(size(A, 2)), ndrange = size(A, 1), workgroupsize = size(A, 1))
+        forloop(backend(), size(A, 1))(A, Val(size(A, 2)), ndrange = size(A, 1), workgroupsize = size(A, 1))
         synchronize(backend())
         @test all(Array(A)[:, 1] .== 64)
         @test all(Array(A)[:, 2:end] .== 1)