better name for IdentityOp

The original name `IdentityOp` could be misleading representation for TileIR Op. New name better represent that its rather a value.
- IdentityOp -> IdentityVal

Author: arhik

src/bytecode/encodings.jl

@@ -1291,7 +1291,7 @@ function encode_ReduceOp!(body::Function, cb::CodeBuilder,
                           result_types::Vector{TypeId},
                           operands::Vector{Value},
                           dim::Int,
-                          identities::Vector{<:IdentityOp},
+                          identities::Vector{<:IdentityVal},
                           body_scalar_types::Vector{TypeId})
     encode_varint!(cb.buf, Opcode.ReduceOp)
 

src/bytecode/writer.jl

@@ -234,41 +234,41 @@ end
 =============================================================================#
 
 """
-    IdentityOp
+    IdentityVal
 
 Abstract type for binary operation identity attributes (reduce, scan, etc.).
 """
-abstract type IdentityOp end
+abstract type IdentityVal end
 
 """
-    FloatIdentityOp(value, type_id, dtype)
+    FloatIdentityVal(value, type_id, dtype)
 
 Float identity value for binary operations.
 """
-struct FloatIdentityOp <: IdentityOp
+struct FloatIdentityVal <: IdentityVal
     value::Float64
     type_id::TypeId
     dtype::Type  # Float16, Float32, Float64, etc.
 end
 
 """
-    IntegerIdentityOp(value, type_id, dtype)
+    IntegerIdentityVal(value, type_id, dtype)
 
 Integer identity value for binary operations.
 """
-struct IntegerIdentityOp <: IdentityOp
+struct IntegerIdentityVal <: IdentityVal
     value::UInt128  # Store as UInt128 to handle all unsigned values up to 64 bits
     type_id::TypeId
     dtype::Type   # Int8, Int16, Int32, Int64, UInt8, etc. (signedness inferred from dtype)
 end
 
 """
-    encode_tagged_float!(cb, identity::FloatIdentityOp)
+    encode_tagged_float!(cb, identity::FloatIdentityVal)
 
 Encode a tagged float attribute for reduce identity.
 Format: tag(Float=0x02) + typeid + ap_int(value_bits)
 """
-function encode_tagged_float!(cb::CodeBuilder, identity::FloatIdentityOp)
+function encode_tagged_float!(cb::CodeBuilder, identity::FloatIdentityVal)
     # Tag for Float attribute
     push!(cb.buf, 0x02)
     # Type ID
@@ -279,12 +279,12 @@ function encode_tagged_float!(cb::CodeBuilder, identity::FloatIdentityOp)
 end
 
 """
-    encode_tagged_int!(cb, identity::IntegerIdentityOp)
+    encode_tagged_int!(cb, identity::IntegerIdentityVal)
 
 Encode a tagged integer identity attribute.
 Format: tag(Int=0x01) + typeid + ap_int(value)
 """
-function encode_tagged_int!(cb::CodeBuilder, identity::IntegerIdentityOp)
+function encode_tagged_int!(cb::CodeBuilder, identity::IntegerIdentityVal)
     # Tag for Int attribute
     push!(cb.buf, 0x01)
     # Type ID
@@ -347,7 +347,7 @@ end
 Encode an array of binary operation identity attributes.
 Dispatches on identity type to encode correctly.
 """
-function encode_identity_array!(cb::CodeBuilder, identities::Vector{<:IdentityOp})
+function encode_identity_array!(cb::CodeBuilder, identities::Vector{<:IdentityVal})
     encode_varint!(cb.buf, length(identities))
     for identity in identities
         encode_identity!(cb, identity)
@@ -359,8 +359,8 @@ end
 
 Encode a single identity attribute, dispatching on type.
 """
-encode_identity!(cb::CodeBuilder, identity::FloatIdentityOp) = encode_tagged_float!(cb, identity)
-encode_identity!(cb::CodeBuilder, identity::IntegerIdentityOp) = encode_tagged_int!(cb, identity)
+encode_identity!(cb::CodeBuilder, identity::FloatIdentityVal) = encode_tagged_float!(cb, identity)
+encode_identity!(cb::CodeBuilder, identity::IntegerIdentityVal) = encode_tagged_int!(cb, identity)
 
 """
     BytecodeWriter

src/compiler/intrinsics.jl

@@ -8,7 +8,7 @@ using Base: compilerbarrier, donotdelete
 using ..cuTile: Tile, TileArray, Constant, TensorView, PartitionView
 using ..cuTile: Signedness, SignednessSigned, SignednessUnsigned
 using ..cuTile: ComparisonPredicate, CmpLessThan, CmpLessThanOrEqual, CmpGreaterThan, CmpGreaterThanOrEqual, CmpEqual, CmpNotEqual
-using ..cuTile: IdentityOp, FloatIdentityOp, IntegerIdentityOp
+using ..cuTile: IdentityVal, FloatIdentityVal, IntegerIdentityVal
 
 end
 

src/compiler/intrinsics/core.jl

@@ -581,10 +581,10 @@ end
 #=============================================================================#
 
 """
-    operation_identity(fn, dtype, elem_type) -> IdentityOp
+    operation_identity(fn, dtype, elem_type) -> IdentityVal
     to_uint128(value)
 
-Convert an integer value to UInt128 for storage in IntegerIdentityOp.
+Convert an integer value to UInt128 for storage in IntegerIdentityVal.
 For signed types, this returns the two's complement bit representation.
 """
 # Unsigned types: directly convert
@@ -599,23 +599,23 @@ to_uint128(value::Int16) = UInt128(reinterpret(UInt16, value))
 to_uint128(value::Int8) = UInt128(reinterpret(UInt8, value))
 
 """
-    operation_identity(fn, dtype, elem_type) -> IdentityOp
+    operation_identity(fn, dtype, elem_type) -> IdentityVal
 
 Return the identity value for a binary operation (reduce, scan, etc.).
 Identity must satisfy: identity ⊕ x = x for the operation.
 """
 
 # Addition identity: 0 + x = x
 operation_identity(::Val{:add}, dtype, ::Type{T}) where T <: AbstractFloat =
-    FloatIdentityOp(zero(T), dtype, T)
+    FloatIdentityVal(zero(T), dtype, T)
 operation_identity(::Val{:add}, dtype, ::Type{T}) where T <: Integer =
-    IntegerIdentityOp(to_uint128(zero(T)), dtype, T)
+    IntegerIdentityVal(to_uint128(zero(T)), dtype, T)
 
 # Maximum identity: max(typemin(T), x) = x
 operation_identity(::Val{:max}, dtype, ::Type{T}) where T <: AbstractFloat =
-    FloatIdentityOp(typemin(T), dtype, T)
+    FloatIdentityVal(typemin(T), dtype, T)
 operation_identity(::Val{:max}, dtype, ::Type{T}) where T <: Integer =
-    IntegerIdentityOp(to_uint128(typemin(T)), dtype, T)
+    IntegerIdentityVal(to_uint128(typemin(T)), dtype, T)
 
 #=============================================================================#
 # Reduce Body Operations

src/cuTile.jl

@@ -42,6 +42,6 @@ public launch
 launch() = error("Please import CUDA.jl before using `cuTile.launch`.")
 
 # Export identity types for reduction operations
-public IdentityOp, FloatIdentityOp, IntegerIdentityOp
+public IdentityVal, FloatIdentityVal, IntegerIdentityVal
 
 end # module cuTile