Revision a121721f975fc4105ed24ebd0ad1020d08d07a38 authored by Shuhei Kadowaki on 01 November 2021, 10:49:07 UTC, committed by GitHub on 01 November 2021, 10:49:07 UTC
* inference: form `PartialStruct` for extra type information propagation This commit forms `PartialStruct` whenever there is any type-level refinement available about a field, even if it's not "constant" information. In Julia "definitions" are allowed to be abstract whereas "usages" (i.e. callsites) are often concrete. The basic idea is to allow inference to make more use of such precise callsite type information by encoding it as `PartialStruct`. This may increase optimization possibilities of "unidiomatic" Julia code, which may contain poorly-typed definitions, like this very contrived example: ```julia struct Problem n; s; c; t end function main(args...) prob = Problem(args...) s = 0 for i in 1:prob.n m = mod(i, 3) s += m == 0 ? sin(prob.s) : m == 1 ? cos(prob.c) : tan(prob.t) end return prob, s end main(10000, 1, 2, 3) ``` One of the obvious limitation is that this extra type information can be propagated inter-procedurally only as a const-propagation. I'm not sure this kind of "just a type-level" refinement can often make constant-prop' successful (i.e. shape-up a method body and allow it to be inlined, encoding the extra type information into the generated code), thus I didn't not modify any part of const-prop' heuristics. So the improvements from this change might not be very useful for general inter-procedural analysis currently, but they should definitely improve the accuracy of local analysis and very simple inter-procedural analysis.
1 parent 6c274ed
locks-mt.jl
# This file is a part of Julia. License is MIT: https://julialang.org/license
import .Base: unsafe_convert, lock, trylock, unlock, islocked, wait, notify, AbstractLock
export SpinLock
# Important Note: these low-level primitives defined here
# are typically not for general usage
##########################################
# Atomic Locks
##########################################
"""
SpinLock()
Create a non-reentrant, test-and-test-and-set spin lock.
Recursive use will result in a deadlock.
This kind of lock should only be used around code that takes little time
to execute and does not block (e.g. perform I/O).
In general, [`ReentrantLock`](@ref) should be used instead.
Each [`lock`](@ref) must be matched with an [`unlock`](@ref).
Test-and-test-and-set spin locks are quickest up to about 30ish
contending threads. If you have more contention than that, different
synchronization approaches should be considered.
"""
mutable struct SpinLock <: AbstractLock
owned::Int
SpinLock() = new(0)
end
import Base.Sys.WORD_SIZE
@eval _xchg!(x::SpinLock, v::Int) =
llvmcall($"""
%ptr = inttoptr i$WORD_SIZE %0 to i$WORD_SIZE*
%rv = atomicrmw xchg i$WORD_SIZE* %ptr, i$WORD_SIZE %1 acq_rel
ret i$WORD_SIZE %rv
""", Int, Tuple{Ptr{Int}, Int}, unsafe_convert(Ptr{Int}, pointer_from_objref(x)), v)
@eval _get(x::SpinLock) =
llvmcall($"""
%ptr = inttoptr i$WORD_SIZE %0 to i$WORD_SIZE*
%rv = load atomic i$WORD_SIZE, i$WORD_SIZE* %ptr monotonic, align $(gc_alignment(Int))
ret i$WORD_SIZE %rv
""", Int, Tuple{Ptr{Int}}, unsafe_convert(Ptr{Int}, pointer_from_objref(x)))
@eval _set!(x::SpinLock, v::Int) =
llvmcall($"""
%ptr = inttoptr i$WORD_SIZE %0 to i$WORD_SIZE*
store atomic i$WORD_SIZE %1, i$WORD_SIZE* %ptr release, align $(gc_alignment(Int))
ret void
""", Cvoid, Tuple{Ptr{Int}, Int}, unsafe_convert(Ptr{Int}, pointer_from_objref(x)), v)
# Note: this cannot assert that the lock is held by the correct thread, because we do not
# track which thread locked it. Users beware.
Base.assert_havelock(l::SpinLock) = islocked(l) ? nothing : Base.concurrency_violation()
function lock(l::SpinLock)
while true
if _get(l) == 0
GC.disable_finalizers()
p = _xchg!(l, 1)
if p == 0
return
end
GC.enable_finalizers()
end
ccall(:jl_cpu_pause, Cvoid, ())
# Temporary solution before we have gc transition support in codegen.
ccall(:jl_gc_safepoint, Cvoid, ())
end
end
function trylock(l::SpinLock)
if _get(l) == 0
GC.disable_finalizers()
p = _xchg!(l, 1)
if p == 0
return true
end
GC.enable_finalizers()
end
return false
end
function unlock(l::SpinLock)
_get(l) == 0 && error("unlock count must match lock count")
_set!(l, 0)
GC.enable_finalizers()
ccall(:jl_cpu_wake, Cvoid, ())
return
end
function islocked(l::SpinLock)
return _get(l) != 0
end
![swh spinner](/static/img/swh-spinner.gif)
Computing file changes ...