cleanup

Author: AntonOresten

ext/MicrofloatsExt.jl

@@ -15,11 +15,8 @@ ct.julia_to_tile_dtype!(table::ct.TypeTable, ::Type{Float8_E5M2})   = ct.F8E5M2(
 ct.julia_to_tile_dtype!(table::ct.TypeTable, ::Type{Float8_E8M0FNU}) = ct.F8E8M0FNU(table)
 ct.julia_to_tile_dtype!(table::ct.TypeTable, ::Type{Float4_E2M1FN})  = ct.F4E2M1FN(table)
 
-# Microfloats are byte-storage primitives (`sizeof == 1`), so cuTile's default
-# `bitwidth` (8 * sizeof) over-counts the sub-byte formats. Forward to
-# `Microfloats.bitwidth`, which derives the true width from the format's bit
-# fields (e.g. `Float4_E2M1FN` → 4), so whole-tile `reinterpret` packs/unpacks
-# them through `UInt8` correctly.
+# Microfloats are byte-storage primitives, so cuTile's default
+# `bitwidth` (8 * sizeof) over-counts the sub-byte formats.
 ct.bitwidth(::Type{T}) where {T<:Microfloats.Microfloat} = Microfloats.bitwidth(T)
 
 # E8M0FNU has no sign bit and represents a power of two; tileiras rejects

src/compiler/intrinsics/conversions.jl

@@ -56,15 +56,6 @@ end
 @inline lookup_bitwidth(@nospecialize(T::Type)) =
     Base.invokelatest(bitwidth, T)::Int
 
-# ── Low-level pack / unpack intrinsics (1:1 with cuda_tile.pack / unpack) ──────
-#
-# Both Tile IR ops are rank-1 → rank-1 and reinterpret the *whole tile* as a byte
-# array (not element-wise like bitcast). They are the primitives that the
-# whole-tile `Base.reinterpret` below composes (with `reshape`/`bitcast`) into a
-# Julia-semantics reinterpret of any rank. The 8-bit element types are handled by
-# `bitcast`, never pack/unpack — matching cutile-python's `pack_to_bytes` /
-# `unpack_from_bytes`.
-
 """
     Intrinsics.pack(x::Tile{S,Tuple{N}}) -> Tile{UInt8,Tuple{N*bitwidth(S)÷8}}
 
@@ -161,17 +152,6 @@ function emit_intrinsic!(ctx::CGCtx, ::typeof(Intrinsics.unpack), args)
     CGVal(result_v, result_type_id, Tile{target_type, Tuple{new_n}}, new_shape)
 end
 
-# ── Whole-tile reinterpret (Julia semantics, any rank) ────────────────────────
-#
-# A tile's row-major byte stream equals the column-major stream of its Julia
-# shape (we store the reversed shape), so flatten → width-convert → reshape
-# reproduces `Base.reinterpret` element-for-element. Equal widths bitcast;
-# crossing 8 bits goes through `pack`/`unpack`; a non-byte → non-byte change
-# routes through bytes (pack then unpack). All the shape arithmetic is
-# compile-time constant, so the intermediate `reshape`s fold away (identity
-# reshapes are eliminated by the canonicalizer) — a rank-1 FP4 reinterpret lowers
-# to a single pack/unpack.
-
 # Width-convert a rank-1 tile to element type `T` (rank-1 in, rank-1 out).
 @inline function reinterpret_width(::Type{T}, flat::Tile{S}) where {T, S}
     bs = bitwidth(S)

test/codegen/operations.jl

@@ -1181,15 +1181,36 @@ end
         end
 
         # pack/unpack require v13.3 — older bytecode rejects with a clear error.
-        let kernel = (a, b) -> begin
+        # (`literal` since the `+` in the message is a regex metachar to FileCheck.)
+        @test @filecheck throws=ct.IRError begin
+            @check literal=true "v13.3+"
+            code_tiled(Tuple{ct.TileArray{UInt8,1,spec1d}, ct.TileArray{UInt16,1,spec1d}};
+                       bytecode_version=v"13.2") do a, b
                 pid = ct.bid(1)
                 tile = ct.load(a, pid, (16,))
                 ct.store(b, pid, reinterpret(UInt16, tile))
                 return
             end
-            @test_throws "v13.3+" code_tiled(devnull, kernel,
-                Tuple{ct.TileArray{UInt8,1,spec1d}, ct.TileArray{UInt16,1,spec1d}};
-                bytecode_version=v"13.2")
+        end
+
+        # Rank-1 scaled: one UInt8 (8 bits) can't fill a UInt16; caught by unpack.
+        @test @filecheck throws=ct.IRError begin
+            @check "do not evenly divide"
+            code_tiled(Tuple{ct.TileArray{UInt8,1,spec1d}, ct.TileArray{UInt16,1,spec1d}}) do a, b
+                pid = ct.bid(1)
+                ct.store(b, pid, reinterpret(UInt16, ct.load(a, pid, (1,))))
+                return
+            end
+        end
+
+        # reshape-widen: leading dim must equal the ratio (2); 1 fails the final reshape.
+        @test @filecheck throws=ct.IRError begin
+            @check "same number of elements"
+            code_tiled(Tuple{ct.TileArray{UInt8,2,spec2d}, ct.TileArray{UInt16,2,spec2d}}) do a, b
+                pid = ct.bid(1)
+                ct.store(b, pid, reinterpret(reshape, UInt16, ct.load(a, pid, (1, 4))))
+                return
+            end
         end
     end
 

test/device/tile.jl

@@ -1164,78 +1164,89 @@ end
     end
 end
 
-# Whole-tile `reinterpret` (cuda_tile.pack/unpack, 13.3+) must match Julia's own
-# `reinterpret` element-for-element — not merely round-trip. An asymmetric check
-# (kernel result vs host `reinterpret`) is what actually pins down the byte order
-# and the column-major dimension scaling; a symmetric X→Y→X round-trip would pass
-# under any self-consistent convention.
 @testset "reinterpret matches Base.reinterpret" begin
-    # 2-D widen→narrow: UInt16 (2,4) → UInt8 (4,4). Exercises both the column-major
-    # leading-dim scaling and the within-element (little-endian) byte order.
-    function u16_to_u8(a::ct.TileArray{UInt16,2}, b::ct.TileArray{UInt8,2})
-        pid = ct.bid(1)
-        ct.store(b, pid, reinterpret(UInt8, ct.load(a, pid, (2, 4))))
-        return
-    end
-    let M = reshape(UInt16[0x0102, 0x0304, 0x0506, 0x0708,
-                           0x090a, 0x0b0c, 0x0d0e, 0x0f10], 2, 4)
-        a = CuArray(M)
-        b = CUDA.zeros(UInt8, 4, 4)
-        @cuda backend=cuTile blocks=1 u16_to_u8(a, b)
-        @test Array(b) == Array(reinterpret(UInt8, M))
+    @testset "2D narrowing" begin
+        function u16_to_u8(a::ct.TileArray{UInt16,2}, b::ct.TileArray{UInt8,2})
+            pid = ct.bid(1)
+            ct.store(b, pid, reinterpret(UInt8, ct.load(a, pid, (2, 4))))
+            return
+        end
+        let M = reshape(UInt16[0x0102, 0x0304, 0x0506, 0x0708,
+                            0x090a, 0x0b0c, 0x0d0e, 0x0f10], 2, 4)
+            a = CuArray(M)
+            b = CUDA.zeros(UInt8, 4, 4)
+            @cuda backend=cuTile blocks=1 u16_to_u8(a, b)
+            @test Array(b) == Array(reinterpret(UInt8, M))
+        end
     end
 
-    # 1-D narrow→widen the other direction: UInt8 (8,) → UInt16 (4,).
-    function u8_to_u16(a::ct.TileArray{UInt8,1}, b::ct.TileArray{UInt16,1})
-        pid = ct.bid(1)
-        ct.store(b, pid, reinterpret(UInt16, ct.load(a, pid, (8,))))
-        return
-    end
-    let v = UInt8[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]
-        a = CuArray(v)
-        b = CUDA.zeros(UInt16, 4)
-        @cuda backend=cuTile blocks=1 u8_to_u16(a, b)
-        @test Array(b) == reinterpret(UInt16, v)
+    @testset "1D widening" begin
+        function u8_to_u16(a::ct.TileArray{UInt8,1}, b::ct.TileArray{UInt16,1})
+            pid = ct.bid(1)
+            ct.store(b, pid, reinterpret(UInt16, ct.load(a, pid, (8,))))
+            return
+        end
+        let v = UInt8[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]
+            a = CuArray(v)
+            b = CUDA.zeros(UInt16, 4)
+            @cuda backend=cuTile blocks=1 u8_to_u16(a, b)
+            @test Array(b) == reinterpret(UInt16, v)
+        end
     end
 
-    # `reshape`-form: widening drops the leading dim. UInt8 (2,4) → UInt16 (4,).
-    function u8_reshape_u16(a::ct.TileArray{UInt8,2}, b::ct.TileArray{UInt16,1})
-        pid = ct.bid(1)
-        ct.store(b, pid, reinterpret(reshape, UInt16, ct.load(a, pid, (2, 4))))
-        return
-    end
-    let M = reshape(UInt8[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08], 2, 4)
-        a = CuArray(M)
-        b = CUDA.zeros(UInt16, 4)
-        @cuda backend=cuTile blocks=1 u8_reshape_u16(a, b)
-        @test Array(b) == reinterpret(reshape, UInt16, M)
+    @testset "narrowing: reshape argument drops dim" begin
+        function u8_reshape_u16(a::ct.TileArray{UInt8,2}, b::ct.TileArray{UInt16,1})
+            pid = ct.bid(1)
+            ct.store(b, pid, reinterpret(reshape, UInt16, ct.load(a, pid, (2, 4))))
+            return
+        end
+        let M = reshape(UInt8[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08], 2, 4)
+            a = CuArray(M)
+            b = CUDA.zeros(UInt16, 4)
+            @cuda backend=cuTile blocks=1 u8_reshape_u16(a, b)
+            @test Array(b) == reinterpret(reshape, UInt16, M)
+        end
     end
 
-    # Equal-width route lowers to `bitcast` (shape preserved), not pack/unpack.
-    # UInt32 → Float32 is a real bitcast (distinct Tile IR dtypes i32 vs f32).
-    function u32_to_f32(a::ct.TileArray{UInt32,1}, b::ct.TileArray{Float32,1})
-        pid = ct.bid(1)
-        ct.store(b, pid, reinterpret(Float32, ct.load(a, pid, (16,))))
-        return
-    end
-    let v = rand(UInt32, 16)
-        a = CuArray(v)
-        b = CUDA.zeros(Float32, 16)
-        @cuda backend=cuTile blocks=1 u32_to_f32(a, b)
-        @test reinterpret(UInt32, Array(b)) == v   # bit-exact (avoids NaN ≠ NaN)
+    @testset "widening: reshape argument inserts dim" begin
+        function u16_reshape_u8(a::ct.TileArray{UInt16,1}, b::ct.TileArray{UInt8,2})
+            pid = ct.bid(1)
+            ct.store(b, pid, reinterpret(reshape, UInt8, ct.load(a, pid, (4,))))
+            return
+        end
+        let M = UInt16[0x0201, 0x0403, 0x0605, 0x0807]
+            a = CuArray(M)
+            b = CUDA.zeros(UInt8, 2, 4)
+            @cuda backend=cuTile blocks=1 u16_reshape_u8(a, b)
+            @test Array(b) == reinterpret(reshape, UInt8, M)
+        end
     end
 
-    # Signless integer no-op (Int32 ↔ UInt32 are both i32): emits no op, but the
-    # result must still equal Julia's reinterpret, with the 2-D shape preserved.
-    function i32_to_u32_2d(a::ct.TileArray{Int32,2}, b::ct.TileArray{UInt32,2})
-        pid = ct.bid(1)
-        ct.store(b, pid, reinterpret(UInt32, ct.load(a, pid, (4, 4))))
-        return
+    @testset "Equal-with round-trip preserves values and shape" begin
+        function u32_to_f32(a::ct.TileArray{UInt32,1}, b::ct.TileArray{Float32,1})
+            pid = ct.bid(1)
+            ct.store(b, pid, reinterpret(Float32, ct.load(a, pid, (16,))))
+            return
+        end
+        let v = rand(UInt32, 16)
+            a = CuArray(v)
+            b = CUDA.zeros(Float32, 16)
+            @cuda backend=cuTile blocks=1 u32_to_f32(a, b)
+            @test reinterpret(UInt32, Array(b)) == v   # bit-exact (avoids NaN ≠ NaN)
+        end
     end
-    let M = reshape(Int32.(-8:7), 4, 4)
-        a = CuArray(M)
-        b = CUDA.zeros(UInt32, 4, 4)
-        @cuda backend=cuTile blocks=1 i32_to_u32_2d(a, b)
-        @test Array(b) == reinterpret(UInt32, M)
+
+    @testset "Int32 to UInt32" begin
+        function i32_to_u32_2d(a::ct.TileArray{Int32,2}, b::ct.TileArray{UInt32,2})
+            pid = ct.bid(1)
+            ct.store(b, pid, reinterpret(UInt32, ct.load(a, pid, (4, 4))))
+            return
+        end
+        let M = reshape(Int32.(-8:7), 4, 4)
+            a = CuArray(M)
+            b = CUDA.zeros(UInt32, 4, 4)
+            @cuda backend=cuTile blocks=1 i32_to_u32_2d(a, b)
+            @test Array(b) == reinterpret(UInt32, M)
+        end
     end
 end