Merge branch 'master' into test_for_no_invalidations

Author: nsajko

Compiler/src/ssair/inlining.jl

@@ -126,10 +126,11 @@ function cfg_inline_item!(ir::IRCode, idx::Int, todo::InliningTodo, state::CFGIn
     block = block_for_inst(ir, idx)
     inline_into_block!(state, block)
 
-    if !isempty(inlinee_cfg.blocks[1].preds)
+    if length(inlinee_cfg.blocks[1].preds) > 1
         need_split_before = true
+    else
+        @assert inlinee_cfg.blocks[1].preds[1] == 0
     end
-
     last_block_idx = last(state.cfg.blocks[block].stmts)
     if false # TODO: ((idx+1) == last_block_idx && isa(ir[SSAValue(last_block_idx)], GotoNode))
         need_split = false
@@ -166,12 +167,18 @@ function cfg_inline_item!(ir::IRCode, idx::Int, todo::InliningTodo, state::CFGIn
     end
     new_block_range = (length(state.new_cfg_blocks)-length(inlinee_cfg.blocks)+1):length(state.new_cfg_blocks)
 
-    # Fixup the edges of the newely added blocks
+    # Fixup the edges of the newly added blocks
     for (old_block, new_block) in enumerate(bb_rename_range)
         if old_block != 1 || need_split_before
             p = state.new_cfg_blocks[new_block].preds
             let bb_rename_range = bb_rename_range
                 map!(p, p) do old_pred_block
+                    # the meaning of predecessor 0 depends on the block we encounter it:
+                    #   - in the first block, it represents the function entry and so needs to be re-mapped
+                    if old_block == 1 && old_pred_block == 0
+                        return first(bb_rename_range) - 1
+                    end
+                    #   - elsewhere, it represents external control-flow from a caught exception which is un-affected by inlining
                     return old_pred_block == 0 ? 0 : bb_rename_range[old_pred_block]
                 end
             end
@@ -186,10 +193,6 @@ function cfg_inline_item!(ir::IRCode, idx::Int, todo::InliningTodo, state::CFGIn
         end
     end
 
-    if need_split_before
-        push!(state.new_cfg_blocks[first(bb_rename_range)].preds, first(bb_rename_range)-1)
-    end
-
     any_edges = false
     for (old_block, new_block) in enumerate(bb_rename_range)
         if (length(state.new_cfg_blocks[new_block].succs) == 0)
@@ -399,7 +402,7 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
     else
         bb_offset, post_bb_id = popfirst!(todo_bbs)
         # This implements the need_split_before flag above
-        need_split_before = !isempty(item.ir.cfg.blocks[1].preds)
+        need_split_before = length(item.ir.cfg.blocks[1].preds) > 1
         if need_split_before
             finish_current_bb!(compact, 0)
         end

Compiler/src/ssair/ir.jl

@@ -105,6 +105,9 @@ function compute_basic_blocks(stmts::Vector{Any})
     end
     # Compute successors/predecessors
     for (num, b) in enumerate(blocks)
+        if b.stmts.start == 1
+            push!(b.preds, 0) # the entry block has a virtual predecessor
+        end
         terminator = stmts[last(b.stmts)]
         if isa(terminator, ReturnNode)
             # return never has any successors

Compiler/test/ssair.jl

@@ -825,3 +825,23 @@ end
 
 @test_throws ErrorException Base.code_ircode(+, (Float64, Float64); optimize_until = "nonexisting pass name")
 @test_throws ErrorException Base.code_ircode(+, (Float64, Float64); optimize_until = typemax(Int))
+
+#57153 check that the CFG has a #0 block predecessor and that we don't fail to compile code that observes that
+function _worker_task57153()
+    while true
+        r = let
+        try
+            if @noinline rand(Bool)
+                return nothing
+            end
+            q, m
+        finally
+            missing
+        end
+        end
+        r[1]::Bool
+    end
+end
+let ir = Base.code_ircode(_worker_task57153, (), optimize_until="CC: COMPACT_2")[1].first
+    @test findfirst(x->x==0, ir.cfg.blocks[1].preds) !== nothing
+end

HISTORY.md

@@ -134,6 +134,8 @@ New library features
 * `Timer` now has readable `timeout` and `interval` properties, and a more descriptive `show` method ([#57081]).
 * `sort` now supports `NTuple`s ([#54494]).
 * `map!(f, A)` now stores the results in `A`, like `map!(f, A, A)` or `A .= f.(A)` ([#40632]).
+* `setprecision` with a function argument (typically a `do` block) is now thread safe. Other forms
+  should be avoided, and types should switch to an implementation using `ScopedValue` ([#51362]).
 
 Standard library changes
 ------------------------

NEWS.md

@@ -61,6 +61,10 @@ Standard library changes
 
 #### Profile
 
+#### Random
+
+* `randperm!` and `randcycle!` now support non-`Array` `AbstractArray` inputs, assuming they are mutable and their indices are one-based ([#58596]).
+
 #### REPL
 
 * The display of `AbstractChar`s in the main REPL mode now includes LaTeX input information like what is shown in help mode ([#58181]).

base/abstractarray.jl

@@ -1234,11 +1234,19 @@ oneunit(x::AbstractMatrix{T}) where {T} = _one(oneunit(T), x)
 # While the definitions for IndexLinear are all simple enough to inline on their
 # own, IndexCartesian's CartesianIndices is more complicated and requires explicit
 # inlining.
-function iterate(A::AbstractArray, state=(eachindex(A),))
+iterate_starting_state(A) = iterate_starting_state(A, IndexStyle(A))
+iterate_starting_state(A, ::IndexLinear) = firstindex(A)
+iterate_starting_state(A, ::IndexStyle) = (eachindex(A),)
+iterate(A::AbstractArray, state = iterate_starting_state(A)) = _iterate(A, state)
+function _iterate(A::AbstractArray, state::Tuple)
     y = iterate(state...)
     y === nothing && return nothing
     A[y[1]], (state[1], tail(y)...)
 end
+function _iterate(A::AbstractArray, state::Integer)
+    checkbounds(Bool, A, state) || return nothing
+    @inbounds(A[state]), state + one(state)
+end
 
 isempty(a::AbstractArray) = (length(a) == 0)
 

base/gmp.jl

@@ -843,24 +843,29 @@ Base.deepcopy_internal(x::BigInt, stackdict::IdDict) = get!(() -> MPZ.set(x), st
 
 ## streamlined hashing for BigInt, by avoiding allocation from shifts ##
 
+Base._hash_shl!(x::BigInt, n) = MPZ.mul_2exp!(x, n)
+
 if Limb === UInt64 === UInt
     # On 64 bit systems we can define
     # an optimized version for BigInt of hash_integer (used e.g. for Rational{BigInt}),
     # and of hash
 
-    using .Base: hash_finalizer
+    using .Base: HASH_SECRET, hash_bytes, hash_finalizer
 
     function hash_integer(n::BigInt, h::UInt)
+        iszero(n) && return hash_integer(0, h)
         GC.@preserve n begin
             s = n.size
-            s == 0 && return hash_integer(0, h)
-            p = convert(Ptr{UInt64}, n.d)
-            b = unsafe_load(p)
-            h ⊻= hash_finalizer(ifelse(s < 0, -b, b) ⊻ h)
-            for k = 2:abs(s)
-                h ⊻= hash_finalizer(unsafe_load(p, k) ⊻ h)
-            end
-            return h
+            h ⊻= (s < 0)
+
+            us = abs(s)
+            leading_zero_bytes = div(leading_zeros(unsafe_load(n.d, us)), 8)
+            hash_bytes(
+                Ptr{UInt8}(n.d),
+                8 * us - leading_zero_bytes,
+                h,
+                HASH_SECRET
+            )
         end
     end
 
@@ -892,23 +897,16 @@ if Limb === UInt64 === UInt
                 return hash(ldexp(flipsign(Float64(limb), sz), pow), h)
             end
             h = hash_integer(pow, h)
-            h ⊻= hash_finalizer(flipsign(limb, sz) ⊻ h)
-            for idx = idx+1:asz
-                if shift == 0
-                    limb = unsafe_load(ptr, idx)
-                else
-                    limb1 = limb2
-                    if idx == asz
-                        limb = limb1 >> shift
-                        limb == 0 && break # don't hash leading zeros
-                    else
-                        limb2 = unsafe_load(ptr, idx+1)
-                        limb = limb2 << upshift | limb1 >> shift
-                    end
-                end
-                h ⊻= hash_finalizer(limb ⊻ h)
-            end
-            return h
+
+            h ⊻= (sz < 0)
+            leading_zero_bytes = div(leading_zeros(unsafe_load(x.d, asz)), 8)
+            trailing_zero_bytes = div(pow, 8)
+            return hash_bytes(
+                Ptr{UInt8}(x.d) + trailing_zero_bytes,
+                8 * asz - (leading_zero_bytes + trailing_zero_bytes),
+                h,
+                HASH_SECRET
+            )
         end
     end
 end

base/hashing.jl

@@ -69,17 +69,81 @@ hash(x::UInt64, h::UInt) = hash_uint64(hash_mix_linear(x, h))
 hash(x::Int64, h::UInt) = hash(bitcast(UInt64, x), h)
 hash(x::Union{Bool, Int8, UInt8, Int16, UInt16, Int32, UInt32}, h::UInt) = hash(Int64(x), h)
 
-function hash_integer(n::Integer, h::UInt)
-    h ⊻= hash_uint((n % UInt) ⊻ h)
-    n = abs(n)
-    n >>>= sizeof(UInt) << 3
-    while n != 0
-        h ⊻= hash_uint((n % UInt) ⊻ h)
-        n >>>= sizeof(UInt) << 3
+hash_integer(x::Integer, h::UInt) = _hash_integer(x, UInt64(h)) % UInt
+function _hash_integer(
+        x::Integer,
+        seed::UInt64 = HASH_SEED,
+        secret::NTuple{3, UInt64} = HASH_SECRET
+    )
+    seed ⊻= (x < 0)
+    u = abs(x)
+
+    # always left-pad to full byte
+    buflen = UInt(max(cld(top_set_bit(u), 8), 1))
+    seed = seed ⊻ (hash_mix(seed ⊻ secret[1], secret[2]) ⊻ buflen)
+
+    a = zero(UInt64)
+    b = zero(UInt64)
+
+    if buflen ≤ 16
+        if buflen ≥ 4
+            a = (UInt64(u % UInt32) << 32) |
+                UInt64((u >>> ((buflen - 4) * 8)) % UInt32)
+
+            delta = (buflen & 24) >>> (buflen >>> 3)
+
+            b = (UInt64((u >>> (8 * delta)) % UInt32) << 32) |
+                UInt64((u >>> (8 * (buflen - 4 - delta))) % UInt32)
+        else # buflen > 0
+            b0 = u % UInt8
+            b1 = (u >>> (8 * div(buflen, 2))) % UInt8
+            b2 = (u >>> (8 * (buflen - 1))) % UInt8
+            a = (UInt64(b0) << 56) |
+                (UInt64(b1) << 32) |
+                UInt64(b2)
+        end
+    else
+        a = (u >>> 8(buflen - 16)) % UInt
+        b = (u >>> 8(buflen - 8)) % UInt
+
+        i = buflen
+        if i > 48
+            see1 = seed
+            see2 = seed
+            while i ≥ 48
+                l0 = u % UInt; u >>>= 64
+                l1 = u % UInt; u >>>= 64
+                l2 = u % UInt; u >>>= 64
+                l3 = u % UInt; u >>>= 64
+                l4 = u % UInt; u >>>= 64
+                l5 = u % UInt; u >>>= 64
+
+                seed = hash_mix(l0 ⊻ secret[1], l1 ⊻ seed)
+                see1 = hash_mix(l2 ⊻ secret[2], l3 ⊻ see1)
+                see2 = hash_mix(l4 ⊻ secret[3], l5 ⊻ see2)
+                i -= 48
+            end
+            seed = seed ⊻ see1 ⊻ see2
+        end
+        if i > 16
+            l0 = u % UInt; u >>>= 64
+            l1 = u % UInt; u >>>= 64
+            seed = hash_mix(l0 ⊻ secret[3], l1 ⊻ seed ⊻ secret[2])
+            if i > 32
+                l2 = u % UInt; u >>>= 64
+                l3 = u % UInt; u >>>= 64
+                seed = hash_mix(l2 ⊻ secret[3], l3 ⊻ seed)
+            end
+        end
     end
-    return h
+
+    a = a ⊻ secret[2]
+    b = b ⊻ seed
+    b, a = mul_parts(a, b)
+    return hash_mix(a ⊻ secret[1] ⊻ buflen, b ⊻ secret[2])
 end
 
+
 ## efficient value-based hashing of floats ##
 
 const hx_NaN = hash(reinterpret(UInt64, NaN))
@@ -117,6 +181,7 @@ function hash(x::Float16, h::UInt)
 end
 
 ## generic hashing for rational values ##
+_hash_shl!(x, n) = (x << n)
 function hash(x::Real, h::UInt)
     # decompose x as num*2^pow/den
     num, pow, den = decompose(x)
@@ -132,6 +197,7 @@ function hash(x::Real, h::UInt)
         den = -den
     end
     num_z = trailing_zeros(num)
+
     num >>= num_z
     den_z = trailing_zeros(den)
     den >>= den_z
@@ -156,7 +222,10 @@ function hash(x::Real, h::UInt)
     end
     # handle generic rational values
     h = hash_integer(pow, h)
-    h = hash_integer(num, h)
+
+    # trimming only whole bytes of trailing zeros simplifies greatly
+    # some specializations for memory-backed bitintegers
+    h = hash_integer((pow > 0) ? _hash_shl!(num, pow % 8) : num, h)
     return h
 end
 
@@ -209,7 +278,7 @@ end
     else
         pos = 1
         i = buflen
-        while i ≥ 48
+        if i > 48
             see1 = seed
             see2 = seed
             while i ≥ 48

base/irrationals.jl

@@ -182,7 +182,7 @@ isinteger(::AbstractIrrational) = false
 iszero(::AbstractIrrational) = false
 isone(::AbstractIrrational) = false
 
-hash(x::Irrational, h::UInt) = 3*objectid(x) - h
+hash(x::Irrational, h::UInt) = 3h - objectid(x)
 
 widen(::Type{T}) where {T<:Irrational} = T
 

base/mpfr.jl

@@ -1183,9 +1183,29 @@ Often used as `setprecision(T, precision) do ... end`
 Note: `nextfloat()`, `prevfloat()` do not use the precision mentioned by
 `setprecision`.
 
+!!! warning
+    There is a fallback implementation of this method that calls `precision`
+    and `setprecision`, but it should no longer be relied on. Instead, you
+    should define the 3-argument form directly in a way that uses `ScopedValue`,
+    or recommend that callers use `ScopedValue` and `@with` themselves.
+
 !!! compat "Julia 1.8"
     The `base` keyword requires at least Julia 1.8.
 """
+function setprecision(f::Function, ::Type{T}, prec::Integer; kws...) where T
+    depwarn("""
+            The fallback `setprecision(::Function, ...)` method is deprecated. Packages overloading this method should
+            implement their own specialization using `ScopedValue` instead.
+            """, :setprecision)
+    old_prec = precision(T)
+    setprecision(T, prec; kws...)
+    try
+        return f()
+    finally
+        setprecision(T, old_prec)
+    end
+end
+
 function setprecision(f::Function, ::Type{BigFloat}, prec::Integer; base::Integer=2)
     Base.ScopedValues.@with(CURRENT_PRECISION => _convert_precision_from_base(prec, base), f())
 end