Emit our intrinsics as :calls instead of :invoke. #85
Conversation
That avoids CIs, allowing easier spoofing of effects through efuncs.
src/compiler/intrinsics/atomics.jl
Outdated
| @noinline function atomic_xchg(array::TileArray{T, N}, index, val, | ||
| memory_order::Int, memory_scope::Int) where {T, N} | ||
| donotdelete() | ||
| compilerbarrier(:const, zero(T)) | ||
| end |
There was a problem hiding this comment.
Do we actually need to implement this method at all? Or can we leave it at function atomic_xchg end
There was a problem hiding this comment.
Let me try for the ones with a compiler barrier, but for others we need a valid implementation
cuTile.jl/src/compiler/intrinsics.jl
Lines 15 to 21 in 84b14b5
Or did this change break constprop? I should verify..
|
Going to minimize some of the intrinsic definitions still, removing bodies where possible. |
|
Unsure if you need it, but if you add the lattice (the weird L) as an argument to your tfunc, you can also participate in the extended lattice and as an example implement the correct behavior when you get a PartialConst |
| function tfunc(𝕃, ::typeof(Intrinsics.cmpi), @nospecialize(x), @nospecialize(y), @nospecialize(pred), @nospecialize(s)) | ||
| t = CC.widenconst(x) | ||
| if t <: Tile | ||
| S = t.parameters[2] | ||
| return Tile{Bool, S} | ||
| end | ||
| return nothing | ||
| return Bool | ||
| end |
There was a problem hiding this comment.
@nospecs and_int_tfunc(𝕃::AbstractLattice, x, y) = and_int_tfunc(widenlattice(𝕃), x, y)
@nospecs function and_int_tfunc(𝕃::ConstsLattice, x, y)
if isa(x, Const) && x.val === false && widenconst(y) === Bool
return Const(false)
elseif isa(y, Const) && y.val === false && widenconst(x) === Bool
return Const(false)
end
return and_int_tfunc(widenlattice(𝕃), x, y)
end
@nospecs and_int_tfunc(::JLTypeLattice, x, y) = widenconst(x)
So you could use something similar perhaps to return Const(true) if the cmp predicate and the arguments are all const
There was a problem hiding this comment.
Altough Julia seems to have gone away from that a bit, and instead is relying on concrete eval much more
There was a problem hiding this comment.
Yeah, fair point. I was going to punt on constant propagation of the intrinsics themselves for now, since most of them are called by overlay methods, which Julia (should) constant propagate using the original, non-overlay definitions. So AFAIU having proper constant propagation tfuncs doesn't really matter much for cuTile intrinsics, no?
2 participants
That avoids CIs, allowing easier spoofing of effects through efuncs.
Implements #79 (comment); credit to @vchuravy for the idea.