Support type ctors/trunc/round through unsafe_trunc.

Author: maleadt

README.md

@@ -416,11 +416,17 @@ b = ct.load(B, (expert_id, k, bid_n), (1, TILE_K, TILE_N))
 
 ## Differences from Julia
 
-### Float-to-integer conversion truncates
+### Some operations are non-throwing
 
-Inside cuTile kernels, `Int32(x::Float32)` and similar float-to-integer constructors
-truncate toward zero (like C-style casts), rather than throwing `InexactError` as in
-standard Julia. This matches the behavior of GPU hardware and cuTile Python's `ct.astype`.
+cuTile kernels cannot throw Julia exceptions. Operations that would throw in
+standard Julia silently produce truncated or wrapped results instead:
+
+- **Float-to-integer conversions:** `Int32(x)`, `trunc(Int32, x)`, and
+  `round(Int32, x, RoundToZero)` silently truncate toward zero rather than
+  throwing `InexactError` for non-integer or out-of-range values. Use
+  `unsafe_trunc` for the explicit non-throwing primitive.
+
+Assertions may be added in the future for testing purposes.
 
 
 ## Limitations

src/language/overlays.jl

@@ -59,13 +59,13 @@ end
     sizeof(S) > sizeof(T) ? Intrinsics.exti(x, S, SignednessUnsigned) :
     sizeof(S) < sizeof(T) ? Intrinsics.trunci(x, S) : x
 
-# Float to float (specific type pairs)
+# Float to float
 for T in Floats, S in Floats
     T === S && continue
     @eval @overlay $T(x::$S) = Intrinsics.ftof(x, $T)
 end
 
-# Integer to float (specific type pairs)
+# Integer to float
 for F in Floats
     for I in SignedInts
         @eval @overlay $F(x::$I) = Intrinsics.itof(x, $F, SignednessSigned)
@@ -86,12 +86,26 @@ for F in Floats
     end
 end
 
-# Float to integer (direct constructor - truncates like C-style cast)
+# Float to integer (round with RoundToZero)
+for F in Floats, I in (SignedInts..., UnsignedInts...)
+    @eval @overlay function Base.round(::Type{$I}, x::$F, ::Base.Rounding.RoundingMode{:ToZero})
+        # TODO: assert that x is within bounds etc
+        unsafe_trunc($I, x)
+    end
+end
+
+# Float to integer (direct constructor)
 for F in Floats
     for I in SignedInts
-        @eval @overlay $I(x::$F) = Intrinsics.ftoi(x, $I, SignednessSigned)
+        @eval @overlay function $I(x::$F)
+            # TODO: assert that x is within bounds etc
+            unsafe_trunc($I, x)
+        end
     end
     for I in UnsignedInts
-        @eval @overlay $I(x::$F) = Intrinsics.ftoi(x, $I, SignednessUnsigned)
+        @eval @overlay function $I(x::$F)
+            # TODO: assert that x is within bounds etc
+            unsafe_trunc($I, x)
+        end
     end
 end

test/codegen/operations.jl

@@ -875,6 +875,18 @@
                 end
             end
 
+            # unsafe_trunc.(Int32, float32_tile) — ftoi via Type arg
+            @test @filecheck begin
+                @check_label "entry"
+                code_tiled(Tuple{ct.TileArray{Float32,1,spec1d}, ct.TileArray{Int32,1,spec1d}}) do a, b
+                    pid = ct.bid(1)
+                    tile = ct.load(a, pid, (16,))
+                    @check "ftoi"
+                    ct.store(b, pid, unsafe_trunc.(Int32, tile))
+                    return
+                end
+            end
+
         end
     end
 

test/execution/broadcast.jl

@@ -721,6 +721,23 @@ end
     @test Array(b) == Float32.(Array(a))
 end
 
+@testset "unsafe_trunc.(Int32, float_tile)" begin
+    function unsafe_trunc_i32_kernel(a::ct.TileArray{Float32,1}, b::ct.TileArray{Int32,1})
+        pid = ct.bid(1)
+        tile = ct.load(a, pid, (16,))
+        ct.store(b, pid, unsafe_trunc.(Int32, tile))
+        return
+    end
+
+    n = 1024
+    a = CuArray(Float32.(rand(-100:100, n)) .+ 0.7f0)
+    b = CUDA.zeros(Int32, n)
+
+    ct.launch(unsafe_trunc_i32_kernel, cld(n, 16), a, b)
+
+    @test Array(b) == unsafe_trunc.(Int32, Array(a))
+end
+
 end # type argument broadcasting
 
 @testset "multi-arg map" begin