Using constants generates compilation error

[maleadt]

I define const INV_LOG_2 = Float32(1 / log(2)). If I use it without wrapping in Float32 within the kernel I get:

ERROR: LoadError: MethodError: no method matching encode_MulFOp!(::cuTile.CodeBuilder, ::cuTile.TypeId, ::cuTile.Value, ::Nothing)
The function `encode_MulFOp!` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  encode_MulFOp!(::cuTile.CodeBuilder, ::cuTile.TypeId, ::cuTile.Value, ::cuTile.Value; rounding_mode, flush_to_zero)
   @ cuTile ~/.julia/dev/cuTile/src/bytecode/encodings.jl:720

Originally posted by @AntonOresten in #16 (comment)

[AntonOresten]

Hm.. I'm still seeing this error. Here's a MWE:

julia> const base_scale = 2.0f0;

julia> function dynamic_scale_kernel(
           A::ct.TileArray{<:Any,1},
           TILE::ct.Constant{Int},
           scale::Float32
       )
           a = ct.load(A, (1,), (TILE[],))
           total_scale = scale * base_scale
           new_a = a .* total_scale
           ct.store(A, (1,), new_a)
           return
       end
dynamic_scale_kernel (generic function with 1 method)

julia> A = CUDA.rand(16);

julia> TILE = 16;

julia> ct.launch(dynamic_scale_kernel, 1, A, ct.Constant(TILE), 3.0f0)
ERROR: MethodError: no method matching encode_MulFOp!(::cuTile.CodeBuilder, ::cuTile.TypeId, ::cuTile.Value, ::Nothing)
The function `encode_MulFOp!` exists, but no method is defined for this combination of argument types.

MulF with a tile and global constant works fine:

julia> function global_scale_kernel(
           A::ct.TileArray{<:Any,1},
           TILE::ct.Constant{Int}
       )
           a = ct.load(A, (1,), (TILE[],))
           new_a = a * base_scale
           ct.store(A, (1,), new_a)
           return
       end
global_scale_kernel (generic function with 2 methods)

julia> A = CUDA.rand(16);

julia> TILE = 16;

julia> ct.launch(global_scale_kernel, 1, A, ct.Constant(TILE))

julia> maximum(A)
1.9550031f0

MulF between two (of the same at least) globals seems to work:

julia> function squared_global_scale_kernel(
           A::ct.TileArray{<:Any,1},
           TILE::ct.Constant{Int},
       )
           a = ct.load(A, (1,), (TILE[],))
           total_scale = base_scale * base_scale
           new_a = a .* total_scale
           ct.store(A, (1,), new_a)
           return
       end
squared_global_scale_kernel (generic function with 1 method)

julia> A = CUDA.rand(16);

julia> TILE = 16;

julia> ct.launch(squared_global_scale_kernel, 1, A, ct.Constant(TILE))

julia> maximum(A)
3.564968f0

and so does MulF between two arguments:

julia> function squared_dynamic_scale_kernel(
           A::ct.TileArray{<:Any,1},
           TILE::ct.Constant{Int},
           scale::Float32
       )
           a = ct.load(A, (1,), (TILE[],))
           total_scale = scale * scale
           new_a = a .* total_scale
           ct.store(A, (1,), new_a)
           return
       end
squared_dynamic_scale_kernel (generic function with 1 method)

julia> A = CUDA.rand(16);

julia> TILE = 16;

julia> ct.launch(squared_dynamic_scale_kernel, 1, A, ct.Constant(TILE), 3.0f0)

julia> maximum(A)
8.831598f0