From a2e405413cc4d7b486262d81c72f50eeaa1cc503 Mon Sep 17 00:00:00 2001 From: Jishnu Bhattacharya Date: Mon, 25 Dec 2023 18:21:49 +0530 Subject: [PATCH 01/42] Don't access parent of triangular matrix in powm (#52583) Since the values stored in the parent corresponding to the structural zeros of a tridiagonal matrix aren't well-defined, using it in `ldiv!` is a footgun that may lead to heisenbugs (one seen in https://buildkite.com/julialang/julia-master/builds/31285#018c7cc7-6c77-41ac-a01b-1c7d14cb1b15). This PR changes it to using the tridiagonal matrix directly in `ldiv!`, which should lead to predictable results, and be bug-free. The failing tests for #52571 pass locally with this change. (cherry picked from commit ef549aef46c52ea616d99a3717a55656894c81cf) --- stdlib/LinearAlgebra/src/triangular.jl | 8 ++++---- stdlib/LinearAlgebra/test/dense.jl | 5 +++++ 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl index 07a28f7f575a0..20353d25ff9d3 100644 --- a/stdlib/LinearAlgebra/src/triangular.jl +++ b/stdlib/LinearAlgebra/src/triangular.jl @@ -1551,7 +1551,7 @@ end # Higham and Lin, "An improved Schur-Padé algorithm for fractional powers of # a matrix and their Fréchet derivatives", SIAM. J. Matrix Anal. & Appl., # 34(3), (2013) 1341–1360. -function powm!(A0::UpperTriangular{<:BlasFloat}, p::Real) +function powm!(A0::UpperTriangular, p::Real) if abs(p) >= 1 throw(ArgumentError("p must be a real number in (-1,1), got $p")) end @@ -1583,7 +1583,7 @@ function powm!(A0::UpperTriangular{<:BlasFloat}, p::Real) end copyto!(Stmp, S) mul!(S, A, c) - ldiv!(Stmp, S.data) + ldiv!(Stmp, S) c = (p - j) / (j4 - 2) for i = 1:n @@ -1591,14 +1591,14 @@ function powm!(A0::UpperTriangular{<:BlasFloat}, p::Real) end copyto!(Stmp, S) mul!(S, A, c) - ldiv!(Stmp, S.data) + ldiv!(Stmp, S) end for i = 1:n S[i, i] = S[i, i] + 1 end copyto!(Stmp, S) mul!(S, A, -p) - ldiv!(Stmp, S.data) + ldiv!(Stmp, S) for i = 1:n @inbounds S[i, i] = S[i, i] + 1 end diff --git a/stdlib/LinearAlgebra/test/dense.jl b/stdlib/LinearAlgebra/test/dense.jl index efeedf93ebd1f..ad887dd85a0d3 100644 --- a/stdlib/LinearAlgebra/test/dense.jl +++ b/stdlib/LinearAlgebra/test/dense.jl @@ -1067,6 +1067,11 @@ end end end +@testset "BigFloat triangular real power" begin + A = Float64[3 1; 0 3] + @test A^(3/4) ≈ big.(A)^(3/4) +end + @testset "diagonal integer matrix to real power" begin A = Matrix(Diagonal([1, 2, 3])) @test A^2.3 ≈ float(A)^2.3 From 5de62a42511367fd521f87224240e2e955a437a5 Mon Sep 17 00:00:00 2001 From: Diogo Netto <61364108+d-netto@users.noreply.github.com> Date: Wed, 27 Dec 2023 15:59:53 -0300 Subject: [PATCH 02/42] update --gcthreads section in command line options (#52645) Make these consistent with what's shown by `julia --help`. Fixes https://github.com/JuliaLang/www.julialang.org/issues/1997. (cherry picked from commit e7e8b8900d471f38f90d7150c5123c503aa1ac36) --- doc/man/julia.1 | 6 +++--- doc/src/manual/command-line-interface.md | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/doc/man/julia.1 b/doc/man/julia.1 index fa9f641b1e76f..b112cb80d94c3 100644 --- a/doc/man/julia.1 +++ b/doc/man/julia.1 @@ -119,9 +119,9 @@ process affinity is not configured, it uses the number of CPU threads. .TP ---gcthreads -Enable n GC threads; If unspecified is set to half of the -compute worker threads. +--gcthreads=N[,M] +Use N threads for the mark phase of GC and M (0 or 1) threads for the concurrent sweeping phase of GC. +N is set to half of the number of compute threads and M is set to 0 if unspecified. .TP -p, --procs {N|auto} diff --git a/doc/src/manual/command-line-interface.md b/doc/src/manual/command-line-interface.md index e1651c61a3ec3..0210e81520998 100644 --- a/doc/src/manual/command-line-interface.md +++ b/doc/src/manual/command-line-interface.md @@ -107,7 +107,7 @@ The following is a complete list of command-line switches available when launchi |`-E`, `--print ` |Evaluate `` and display the result| |`-L`, `--load ` |Load `` immediately on all processors| |`-t`, `--threads {N\|auto}` |Enable N threads; `auto` tries to infer a useful default number of threads to use but the exact behavior might change in the future. Currently, `auto` uses the number of CPUs assigned to this julia process based on the OS-specific affinity assignment interface, if supported (Linux and Windows). If this is not supported (macOS) or process affinity is not configured, it uses the number of CPU threads.| -| `--gcthreads {N}` |Enable N GC threads; If unspecified is set to half of the compute worker threads.| +| `--gcthreads=N[,M]` |Use N threads for the mark phase of GC and M (0 or 1) threads for the concurrent sweeping phase of GC. N is set to half of the number of compute threads and M is set to 0 if unspecified.| |`-p`, `--procs {N\|auto}` |Integer value N launches N additional local worker processes; `auto` launches as many workers as the number of local CPU threads (logical cores)| |`--machine-file ` |Run processes on hosts listed in ``| |`-i` |Interactive mode; REPL runs and `isinteractive()` is true| From 79684ad60f2da0e5d38aa9e0693f77b9da202a48 Mon Sep 17 00:00:00 2001 From: Ian Butterworth Date: Thu, 28 Dec 2023 07:42:28 -0500 Subject: [PATCH 03/42] update nthreads info in versioninfo (#52423) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fixes https://github.com/JuliaLang/julia/issues/52404 @nilshg I opted to make it one line as it fits. ``` julia> versioninfo() Julia Version 1.11.0-DEV.1011 Commit bb7091c6f2* (2023-12-04 14:58 UTC) Platform Info: OS: macOS (arm64-apple-darwin23.0.0) CPU: 10 × Apple M2 Pro WORD_SIZE: 64 LLVM: libLLVM-15.0.7 (ORCJIT, apple-m1) Threads: 1 default, 0 interactive, 1 GC (on 6 virtual cores) Environment: JULIA_EDITOR = code ``` (cherry picked from commit e96c13aa5b2e2b41e618ac009d43e1fdea0a70d4) --- stdlib/InteractiveUtils/src/InteractiveUtils.jl | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/stdlib/InteractiveUtils/src/InteractiveUtils.jl b/stdlib/InteractiveUtils/src/InteractiveUtils.jl index 6cbfc23ac905d..f4557689122c6 100644 --- a/stdlib/InteractiveUtils/src/InteractiveUtils.jl +++ b/stdlib/InteractiveUtils/src/InteractiveUtils.jl @@ -161,7 +161,8 @@ function versioninfo(io::IO=stdout; verbose::Bool=false) println(io, " WORD_SIZE: ", Sys.WORD_SIZE) println(io, " LIBM: ",Base.libm_name) println(io, " LLVM: libLLVM-",Base.libllvm_version," (", Sys.JIT, ", ", Sys.CPU_NAME, ")") - println(io, " Threads: ", Threads.maxthreadid(), " on ", Sys.CPU_THREADS, " virtual cores") + println(io, """Threads: $(Threads.nthreads(:default)) default, $(Threads.nthreads(:interactive)) interactive, \ + $(Threads.ngcthreads()) GC (on $(Sys.CPU_THREADS) virtual cores)""") function is_nonverbose_env(k::String) return occursin(r"^JULIA_|^DYLD_|^LD_", k) From 6eb535dc97dfc6561157a4edb85274728c63b3a2 Mon Sep 17 00:00:00 2001 From: Keno Fischer Date: Thu, 4 Jan 2024 16:51:49 +0100 Subject: [PATCH 04/42] inference: Guard TypeVar special case against vararg (#52721) Fix #52613 by making the TypeVar special case in inference check for vararg first. There's nothing the special case can really do with vararg anyway, so fall back to the ordinary abstract call handling. --- base/compiler/abstractinterpretation.jl | 4 ++-- test/compiler/inference.jl | 3 +++ 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl index 0ef21bc28fb50..58002602d95a5 100644 --- a/base/compiler/abstractinterpretation.jl +++ b/base/compiler/abstractinterpretation.jl @@ -2021,10 +2021,10 @@ function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f), elseif isa(f, Core.OpaqueClosure) # calling an OpaqueClosure about which we have no information returns no information return CallMeta(typeof(f).parameters[2], Effects(), NoCallInfo()) - elseif f === TypeVar + elseif f === TypeVar && !isvarargtype(argtypes[end]) # Manually look through the definition of TypeVar to # make sure to be able to get `PartialTypeVar`s out. - (la < 2 || la > 4) && return CallMeta(Bottom, EFFECTS_THROWS, NoCallInfo()) + 2 ≤ la ≤ 4 || return CallMeta(Bottom, EFFECTS_THROWS, NoCallInfo()) n = argtypes[2] ub_var = Const(Any) lb_var = Const(Union{}) diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl index 393d8cfd47548..cd883bb70884e 100644 --- a/test/compiler/inference.jl +++ b/test/compiler/inference.jl @@ -5134,3 +5134,6 @@ end let 𝕃 = Core.Compiler.fallback_lattice @test apply_type_tfunc(𝕃, Const(Tuple{Vararg{Any,N}} where N), Int) == Type{NTuple{_A, Any}} where _A end + +# Issue #52613 +@test (code_typed((Any,)) do x; TypeVar(x...); end)[1][2] === TypeVar From 6a107d082cd403fbb42cd7585acc021be39611e3 Mon Sep 17 00:00:00 2001 From: Tim Holy Date: Sat, 6 Jan 2024 00:09:43 -0600 Subject: [PATCH 05/42] Use `jl_types_egal` in `equiv_field_types` (#52748) Fixes #52686 Fixes https://github.com/timholy/Revise.jl/issues/770 --------- Co-authored-by: Jameson Nash Co-authored-by: Kristoffer Carlsson Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com> --- src/builtins.c | 2 +- test/core.jl | 15 +++++++++++++++ 2 files changed, 16 insertions(+), 1 deletion(-) diff --git a/src/builtins.c b/src/builtins.c index e2169abb704fc..6d32c439d5b6e 100644 --- a/src/builtins.c +++ b/src/builtins.c @@ -1678,7 +1678,7 @@ static int equiv_field_types(jl_value_t *old, jl_value_t *ft) jl_value_t *ta = jl_svecref(old, i); jl_value_t *tb = jl_svecref(ft, i); if (jl_has_free_typevars(ta)) { - if (!jl_has_free_typevars(tb) || !jl_egal(ta, tb)) + if (!jl_has_free_typevars(tb) || !jl_types_egal(ta, tb)) return 0; } else if (jl_has_free_typevars(tb) || jl_typetagof(ta) != jl_typetagof(tb) || diff --git a/test/core.jl b/test/core.jl index 0e58b7e157fde..34d0e762e2ec1 100644 --- a/test/core.jl +++ b/test/core.jl @@ -107,6 +107,21 @@ let abcd = ABCDconst(1, 2, 3, 4) abcd.d = nothing) @test (1, 2, "not constant", 4) === (abcd.a, abcd.b, abcd.c, abcd.d) end +# Issue #52686 +struct A52686{T} end +struct B52686{T, S} + a::A52686{<:T} +end +function func52686() + @eval begin + struct A52686{T} end + struct B52686{T, S} + a::A52686{<:T} + end + end + return true +end +@test func52686() # test `===` handling null pointer in struct #44712 struct N44712 From 5c0a2a61cbc182baccba60313565ead01f179ef0 Mon Sep 17 00:00:00 2001 From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com> Date: Sun, 7 Jan 2024 19:26:18 +0900 Subject: [PATCH 06/42] release 1.10: backport the lattice fix for array op type checks (#52773) (#52774) --- .../compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl | 4 ++-- base/compiler/tfuncs.jl | 13 +++++++------ 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl index 2469507fd3699..a7778f0ef1381 100644 --- a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl +++ b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl @@ -1615,7 +1615,7 @@ function escape_builtin!(::typeof(arrayref), astate::AnalysisState, pc::Int, arg argtypes = Any[argextype(args[i], astate.ir) for i in 2:length(args)] boundcheckt = argtypes[1] aryt = argtypes[2] - if !array_builtin_common_typecheck(boundcheckt, aryt, argtypes, 3) + if !array_builtin_common_typecheck(𝕃ₒ, boundcheckt, aryt, argtypes, 3) add_thrown_escapes!(astate, pc, args, 2) end ary = args[3] @@ -1679,7 +1679,7 @@ function escape_builtin!(::typeof(arrayset), astate::AnalysisState, pc::Int, arg boundcheckt = argtypes[1] aryt = argtypes[2] valt = argtypes[3] - if !(array_builtin_common_typecheck(boundcheckt, aryt, argtypes, 4) && + if !(array_builtin_common_typecheck(𝕃ₒ, boundcheckt, aryt, argtypes, 4) && arrayset_typecheck(aryt, valt)) add_thrown_escapes!(astate, pc, args, 2) end diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl index 9dfda5f1e4eea..708db9c98d814 100644 --- a/base/compiler/tfuncs.jl +++ b/base/compiler/tfuncs.jl @@ -2034,12 +2034,12 @@ function array_type_undefable(@nospecialize(arytype)) end end -function array_builtin_common_nothrow(argtypes::Vector{Any}, isarrayref::Bool) +function array_builtin_common_nothrow(𝕃::AbstractLattice, argtypes::Vector{Any}, isarrayref::Bool) first_idx_idx = isarrayref ? 3 : 4 length(argtypes) ≥ first_idx_idx || return false boundscheck = argtypes[1] arytype = argtypes[2] - array_builtin_common_typecheck(boundscheck, arytype, argtypes, first_idx_idx) || return false + array_builtin_common_typecheck(𝕃, boundscheck, arytype, argtypes, first_idx_idx) || return false if isarrayref # If we could potentially throw undef ref errors, bail out now. arytype = widenconst(arytype) @@ -2056,8 +2056,9 @@ function array_builtin_common_nothrow(argtypes::Vector{Any}, isarrayref::Bool) return false end -@nospecs function array_builtin_common_typecheck(boundscheck, arytype, - argtypes::Vector{Any}, first_idx_idx::Int) +@nospecs function array_builtin_common_typecheck(𝕃::AbstractLattice, + boundscheck, arytype, argtypes::Vector{Any}, first_idx_idx::Int) + ⊑ = Core.Compiler.:⊑(𝕃) (boundscheck ⊑ Bool && arytype ⊑ Array) || return false for i = first_idx_idx:length(argtypes) argtypes[i] ⊑ Int || return false @@ -2080,11 +2081,11 @@ end @nospecs function _builtin_nothrow(𝕃::AbstractLattice, f, argtypes::Vector{Any}, rt) ⊑ = Core.Compiler.:⊑(𝕃) if f === arrayset - array_builtin_common_nothrow(argtypes, #=isarrayref=#false) || return false + array_builtin_common_nothrow(𝕃, argtypes, #=isarrayref=#false) || return false # Additionally check element type compatibility return arrayset_typecheck(argtypes[2], argtypes[3]) elseif f === arrayref || f === const_arrayref - return array_builtin_common_nothrow(argtypes, #=isarrayref=#true) + return array_builtin_common_nothrow(𝕃, argtypes, #=isarrayref=#true) elseif f === Core._expr length(argtypes) >= 1 || return false return argtypes[1] ⊑ Symbol From fd13cf006733b650938319a4772885909bc8da5e Mon Sep 17 00:00:00 2001 From: Shuhei Kadowaki Date: Thu, 11 Jan 2024 17:52:56 +0900 Subject: [PATCH 07/42] effects: fix #52843, account for mutable values directly embedded to IR Fixes another variant of #52531. --- base/compiler/abstractinterpretation.jl | 12 ++++++------ test/compiler/effects.jl | 6 ++++++ 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl index 58002602d95a5..9acddad45721a 100644 --- a/base/compiler/abstractinterpretation.jl +++ b/base/compiler/abstractinterpretation.jl @@ -2267,11 +2267,7 @@ function abstract_eval_value_expr(interp::AbstractInterpreter, e::Expr, vtypes:: end function abstract_eval_special_value(interp::AbstractInterpreter, @nospecialize(e), vtypes::Union{VarTable,Nothing}, sv::AbsIntState) - if isa(e, QuoteNode) - merge_effects!(interp, sv, Effects(EFFECTS_TOTAL; - inaccessiblememonly = is_mutation_free_argtype(typeof(e.value)) ? ALWAYS_TRUE : ALWAYS_FALSE)) - return Const(e.value) - elseif isa(e, SSAValue) + if isa(e, SSAValue) return abstract_eval_ssavalue(e, sv) elseif isa(e, SlotNumber) if vtypes !== nothing @@ -2293,7 +2289,11 @@ function abstract_eval_special_value(interp::AbstractInterpreter, @nospecialize( elseif isa(e, GlobalRef) return abstract_eval_globalref(interp, e, sv) end - + if isa(e, QuoteNode) + e = e.value + end + merge_effects!(interp, sv, Effects(EFFECTS_TOTAL; + inaccessiblememonly = is_mutation_free_argtype(typeof(e)) ? ALWAYS_TRUE : ALWAYS_FALSE)) return Const(e) end diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl index 8370cecddccad..6ad9ad0ba4f8a 100644 --- a/test/compiler/effects.jl +++ b/test/compiler/effects.jl @@ -1052,3 +1052,9 @@ top_52531(_) = (set_initialized52531!(true); nothing) @test !is_initialized52531() top_52531(0) @test is_initialized52531() + +const ref52843 = Ref{Int}() +@eval func52843() = ($ref52843[] = 1; nothing) +@test !Core.Compiler.is_foldable(Base.infer_effects(func52843)) +let; Base.Experimental.@force_compile; func52843(); end +@test ref52843[] == 1 From 0cea48eb21520bc95aafcc8c868482abc4e73bed Mon Sep 17 00:00:00 2001 From: Ian Butterworth Date: Fri, 12 Jan 2024 22:27:05 -0500 Subject: [PATCH 08/42] change Downloads branch to release-1.10 --- stdlib/Downloads.version | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stdlib/Downloads.version b/stdlib/Downloads.version index c6db08779e947..0320fb2c09c0e 100644 --- a/stdlib/Downloads.version +++ b/stdlib/Downloads.version @@ -1,4 +1,4 @@ -DOWNLOADS_BRANCH = master +DOWNLOADS_BRANCH = release-1.10 DOWNLOADS_SHA1 = f97c72fbd726e208a04c53791b35cc34c747569f DOWNLOADS_GIT_URL := https://github.com/JuliaLang/Downloads.jl.git DOWNLOADS_TAR_URL = https://api.github.com/repos/JuliaLang/Downloads.jl/tarball/$1 From df9062baa4ae959773705d67152263ff49fec9ce Mon Sep 17 00:00:00 2001 From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com> Date: Sat, 13 Jan 2024 17:48:12 +0900 Subject: [PATCH 09/42] lowering: remove `QuoteNode` wrapping for captured variables (#52878) Issues like #52531 were more broadly fixed by #52856. This commit partially reverts #52596, while leaving the added tests. --- src/julia-syntax.scm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm index 251a041438a6b..b5705c55b6e61 100644 --- a/src/julia-syntax.scm +++ b/src/julia-syntax.scm @@ -3580,7 +3580,7 @@ f(x) = yt(x) (rhs (convert-for-type-decl rhs1 (cl-convert vt fname lam #f #f #f interp opaq (table) locals) #t lam)) (ex (cond (closed `(call (core setfield!) ,(if interp - `($ (call (core QuoteNode) ,var)) + `($ ,var) (capt-var-access var fname opaq)) (inert contents) ,rhs)) From 813bfacfbe59a8a5656432e32508870f6482d87b Mon Sep 17 00:00:00 2001 From: Nicholas Bauer Date: Sat, 13 Jan 2024 21:54:05 -0500 Subject: [PATCH 10/42] Revert inlined method signature stacktrace lookup code (#52754) The fallback code that was written for #41099 is causing unintended issues with some inlined stack frames (one previous #51405, new #52709), since the main piece, linetable storage and lookup, was removed in #50546. Probably better to strip it all back to how it was previously, until it can all be revisited more fully. Should be backported to 1.10. --- base/stacktraces.jl | 99 +-------------------------------------------- 1 file changed, 2 insertions(+), 97 deletions(-) diff --git a/base/stacktraces.jl b/base/stacktraces.jl index bb70b7ea1c099..e82fd8118b2d7 100644 --- a/base/stacktraces.jl +++ b/base/stacktraces.jl @@ -97,87 +97,6 @@ function hash(frame::StackFrame, h::UInt) return h end -get_inlinetable(::Any) = nothing -function get_inlinetable(mi::MethodInstance) - isdefined(mi, :def) && mi.def isa Method && isdefined(mi, :cache) && isdefined(mi.cache, :inferred) && - mi.cache.inferred !== nothing || return nothing - linetable = ccall(:jl_uncompress_ir, Any, (Any, Any, Any), mi.def, mi.cache, mi.cache.inferred).linetable - return filter!(x -> x.inlined_at > 0, linetable) -end - -get_method_instance_roots(::Any) = nothing -function get_method_instance_roots(mi::Union{Method, MethodInstance}) - m = mi isa MethodInstance ? mi.def : mi - m isa Method && isdefined(m, :roots) || return nothing - return filter(x -> x isa MethodInstance, m.roots) -end - -function lookup_inline_frame_info(func::Symbol, file::Symbol, linenum::Int, inlinetable::Vector{Core.LineInfoNode}) - #REPL frames and some base files lack this prefix while others have it; should fix? - filestripped = Symbol(lstrip(string(file), ('.', '\\', '/'))) - linfo = nothing - #= - Some matching entries contain the MethodInstance directly. - Other matching entries contain only a Method or Symbol (function name); such entries - are located after the entry with the MethodInstance, so backtracking is required. - If backtracking fails, the Method or Module is stored for return, but we continue - the search in case a MethodInstance is found later. - TODO: If a backtrack has failed, do we need to backtrack again later if another Method - or Symbol match is found? Or can a limit on the subsequent backtracks be placed? - =# - for (i, line) in enumerate(inlinetable) - Base.IRShow.method_name(line) === func && line.file ∈ (file, filestripped) && line.line == linenum || continue - if line.method isa MethodInstance - linfo = line.method - break - elseif line.method isa Method || line.method isa Symbol - linfo = line.method isa Method ? line.method : line.module - # backtrack to find the matching MethodInstance, if possible - for j in (i - 1):-1:1 - nextline = inlinetable[j] - nextline.inlined_at == line.inlined_at && Base.IRShow.method_name(line) === Base.IRShow.method_name(nextline) && line.file === nextline.file || break - if nextline.method isa MethodInstance - linfo = nextline.method - break - end - end - end - end - return linfo -end - -function lookup_inline_frame_info(func::Symbol, file::Symbol, miroots::Vector{Any}) - # REPL frames and some base files lack this prefix while others have it; should fix? - filestripped = Symbol(lstrip(string(file), ('.', '\\', '/'))) - matches = filter(miroots) do x - x.def isa Method || return false - m = x.def::Method - return m.name == func && m.file ∈ (file, filestripped) - end - if length(matches) > 1 - # ambiguous, check if method is same and return that instead - all_matched = true - for m in matches - all_matched = m.def.line == matches[1].def.line && - m.def.module == matches[1].def.module - all_matched || break - end - if all_matched - return matches[1].def - end - # all else fails, return module if they match, or give up - all_matched = true - for m in matches - all_matched = m.def.module == matches[1].def.module - all_matched || break - end - return all_matched ? matches[1].def.module : nothing - elseif length(matches) == 1 - return matches[1] - end - return nothing -end - """ lookup(pointer::Ptr{Cvoid}) -> Vector{StackFrame} @@ -189,25 +108,11 @@ Base.@constprop :none function lookup(pointer::Ptr{Cvoid}) infos = ccall(:jl_lookup_code_address, Any, (Ptr{Cvoid}, Cint), pointer, false)::Core.SimpleVector pointer = convert(UInt64, pointer) isempty(infos) && return [StackFrame(empty_sym, empty_sym, -1, nothing, true, false, pointer)] # this is equal to UNKNOWN - parent_linfo = infos[end][4] - inlinetable = get_inlinetable(parent_linfo) - miroots = inlinetable === nothing ? get_method_instance_roots(parent_linfo) : nothing # fallback if linetable missing res = Vector{StackFrame}(undef, length(infos)) - for i in reverse(1:length(infos)) + for i in 1:length(infos) info = infos[i]::Core.SimpleVector @assert(length(info) == 6) - func = info[1]::Symbol - file = info[2]::Symbol - linenum = info[3]::Int - linfo = info[4] - if i < length(infos) - if inlinetable !== nothing - linfo = lookup_inline_frame_info(func, file, linenum, inlinetable) - elseif miroots !== nothing - linfo = lookup_inline_frame_info(func, file, miroots) - end - end - res[i] = StackFrame(func, file, linenum, linfo, info[5]::Bool, info[6]::Bool, pointer) + res[i] = StackFrame(info[1]::Symbol, info[2]::Symbol, info[3]::Int, info[4], info[5]::Bool, info[6]::Bool, pointer) end return res end From e5ccc447ccbb15a80a1491fd4337b1c0239b405c Mon Sep 17 00:00:00 2001 From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com> Date: Tue, 16 Jan 2024 10:15:22 +0900 Subject: [PATCH 11/42] inference: always bail out const-prop' with non-const result limited (#52836) Investigating into #52763, I've found that `AbstractInterpreters` which enables the `aggressive_constprop` option, such as `REPLInterpreter`, might perform const-prop' even if the result of a non-const call is `LimitedAccuracy`. This can lead to an unintended infinite loop with a custom aggressive const-prop' implementation. This commit restricts const-prop' for such cases where the non-const call result is limited to avoid the issue. This fix is conservative, but given that accurate inference is mostly impossible when there are unresolvable cycles (which is indicated by limited result), aggressive const-prop' isn't necessary for such cases, and I don't anticipate this leading to any obvious regression. fix #52763 --- base/compiler/abstractinterpretation.jl | 54 +++++++++++++------------ test/compiler/inference.jl | 13 +++++- 2 files changed, 41 insertions(+), 26 deletions(-) diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl index 9acddad45721a..ab1d8c7c570f9 100644 --- a/base/compiler/abstractinterpretation.jl +++ b/base/compiler/abstractinterpretation.jl @@ -785,11 +785,7 @@ end function abstract_call_method_with_const_args(interp::AbstractInterpreter, result::MethodCallResult, @nospecialize(f), arginfo::ArgInfo, si::StmtInfo, match::MethodMatch, sv::AbsIntState, invokecall::Union{Nothing,InvokeCall}=nothing) - if !const_prop_enabled(interp, sv, match) - return nothing - end - if bail_out_const_call(interp, result, si) - add_remark!(interp, sv, "[constprop] No more information to be gained") + if !const_prop_enabled(interp, match, sv) || bail_out_const_call(interp, result, si, sv) return nothing end eligibility = concrete_eval_eligible(interp, f, result, arginfo, sv) @@ -822,7 +818,7 @@ function abstract_call_method_with_const_args(interp::AbstractInterpreter, return const_prop_call(interp, mi, result, arginfo, sv, concrete_eval_result) end -function const_prop_enabled(interp::AbstractInterpreter, sv::AbsIntState, match::MethodMatch) +function const_prop_enabled(interp::AbstractInterpreter, match::MethodMatch, sv::AbsIntState) if !InferenceParams(interp).ipo_constant_propagation add_remark!(interp, sv, "[constprop] Disabled by parameter") return false @@ -834,9 +830,11 @@ function const_prop_enabled(interp::AbstractInterpreter, sv::AbsIntState, match: return true end -function bail_out_const_call(interp::AbstractInterpreter, result::MethodCallResult, si::StmtInfo) +function bail_out_const_call(interp::AbstractInterpreter, result::MethodCallResult, + si::StmtInfo, sv::AbsIntState) if is_removable_if_unused(result.effects) if isa(result.rt, Const) || call_result_unused(si) + add_remark!(interp, sv, "[constprop] No more information to be gained (const)") return true end end @@ -937,7 +935,10 @@ function maybe_get_const_prop_profitable(interp::AbstractInterpreter, match::MethodMatch, sv::AbsIntState) method = match.method force = force_const_prop(interp, f, method) - force || const_prop_entry_heuristic(interp, result, si, sv) || return nothing + if !const_prop_entry_heuristic(interp, result, si, sv, force) + # N.B. remarks are emitted within `const_prop_entry_heuristic` + return nothing + end nargs::Int = method.nargs method.isva && (nargs -= 1) length(arginfo.argtypes) < nargs && return nothing @@ -964,8 +965,17 @@ function maybe_get_const_prop_profitable(interp::AbstractInterpreter, return mi end -function const_prop_entry_heuristic(interp::AbstractInterpreter, result::MethodCallResult, si::StmtInfo, sv::AbsIntState) - if call_result_unused(si) && result.edgecycle +function const_prop_entry_heuristic(interp::AbstractInterpreter, result::MethodCallResult, + si::StmtInfo, sv::AbsIntState, force::Bool) + if result.rt isa LimitedAccuracy + # optimizations like inlining are disabled for limited frames, + # thus there won't be much benefit in constant-prop' here + # N.B. don't allow forced constprop' for safety (xref #52763) + add_remark!(interp, sv, "[constprop] Disabled by entry heuristic (limited accuracy)") + return false + elseif force + return true + elseif call_result_unused(si) && result.edgecycle add_remark!(interp, sv, "[constprop] Disabled by entry heuristic (edgecycle with unused result)") return false end @@ -978,27 +988,21 @@ function const_prop_entry_heuristic(interp::AbstractInterpreter, result::MethodC if rt === Bottom add_remark!(interp, sv, "[constprop] Disabled by entry heuristic (erroneous result)") return false - else - return true end + return true elseif isa(rt, PartialStruct) || isa(rt, InterConditional) || isa(rt, InterMustAlias) # could be improved to `Const` or a more precise wrapper return true - elseif isa(rt, LimitedAccuracy) - # optimizations like inlining are disabled for limited frames, - # thus there won't be much benefit in constant-prop' here - add_remark!(interp, sv, "[constprop] Disabled by entry heuristic (limited accuracy)") - return false - else - if isa(rt, Const) - if !is_nothrow(result.effects) - # Could still be improved to Bottom (or at least could see the effects improved) - return true - end + elseif isa(rt, Const) + if is_nothrow(result.effects) + add_remark!(interp, sv, "[constprop] Disabled by entry heuristic (nothrow const)") + return false end - add_remark!(interp, sv, "[constprop] Disabled by entry heuristic (unimprovable result)") - return false + # Could still be improved to Bottom (or at least could see the effects improved) + return true end + add_remark!(interp, sv, "[constprop] Disabled by entry heuristic (unimprovable result)") + return false end # determines heuristically whether if constant propagation can be worthwhile diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl index cd883bb70884e..0fbf4e9b0fd7d 100644 --- a/test/compiler/inference.jl +++ b/test/compiler/inference.jl @@ -4845,10 +4845,21 @@ g() = empty_nt_values(Base.inferencebarrier(Tuple{})) # This is somewhat sensitive to the exact recursion level that inference is willing to do, but the intention # is to test the case where inference limited a recursion, but then a forced constprop nevertheless managed # to terminate the call. +@newinterp RecurseInterpreter +let CC = Core.Compiler + function CC.const_prop_entry_heuristic(interp::RecurseInterpreter, result::CC.MethodCallResult, + si::CC.StmtInfo, sv::CC.AbsIntState, force::Bool) + if result.rt isa CC.LimitedAccuracy + return force # allow forced constprop to recurse into unresolved cycles + end + return @invoke CC.const_prop_entry_heuristic(interp::CC.AbstractInterpreter, result::CC.MethodCallResult, + si::CC.StmtInfo, sv::CC.AbsIntState, force::Bool) + end +end Base.@constprop :aggressive type_level_recurse1(x...) = x[1] == 2 ? 1 : (length(x) > 100 ? x : type_level_recurse2(x[1] + 1, x..., x...)) Base.@constprop :aggressive type_level_recurse2(x...) = type_level_recurse1(x...) type_level_recurse_entry() = Val{type_level_recurse1(1)}() -@test Base.return_types(type_level_recurse_entry, ()) |> only == Val{1} +@test only(Base.return_types(type_level_recurse_entry, (); interp=RecurseInterpreter())) == Val{1} # Test that inference doesn't give up if it can potentially refine effects, # even if the return type is Any. From aaaf5de5e690f782c22d42109cdf70387c1fa99b Mon Sep 17 00:00:00 2001 From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com> Date: Tue, 16 Jan 2024 05:10:18 -0500 Subject: [PATCH 12/42] =?UTF-8?q?=F0=9F=A4=96=20[backports-release-1.10]?= =?UTF-8?q?=20Bump=20the=20Downloads=20stdlib=20from=20f97c72f=20to=20ead2?= =?UTF-8?q?89a=20(#52886)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Stdlib: Downloads URL: https://github.com/JuliaLang/Downloads.jl.git Stdlib branch: release-1.10 Julia branch: backports-release-1.10 Old commit: f97c72f New commit: ead289a Julia version: 1.10.0 Downloads version: 1.6.0(It's okay that it doesn't match) Bump invoked by: @IanButterworth Powered by: [BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl) Diff: https://github.com/JuliaLang/Downloads.jl/compare/f97c72fbd726e208a04c53791b35cc34c747569f...ead289a7f1be7689738aaea9b12d919424a106ef ``` $ git log --oneline f97c72f..ead289a ead289a Close Multi timers atexit. Add 1.6 CI (#234) 8a614d5 Skip flakey "concurrent requests" tests on windows (#228) 246504e add a small precompile workload (#226) 3ed0f08 Document how to bypass the 20-second timeout (#222) ``` Co-authored-by: Dilum Aluthge --- .../md5 | 1 + .../sha512 | 1 + .../md5 | 1 - .../sha512 | 1 - stdlib/Downloads.version | 2 +- 5 files changed, 3 insertions(+), 3 deletions(-) create mode 100644 deps/checksums/Downloads-ead289a7f1be7689738aaea9b12d919424a106ef.tar.gz/md5 create mode 100644 deps/checksums/Downloads-ead289a7f1be7689738aaea9b12d919424a106ef.tar.gz/sha512 delete mode 100644 deps/checksums/Downloads-f97c72fbd726e208a04c53791b35cc34c747569f.tar.gz/md5 delete mode 100644 deps/checksums/Downloads-f97c72fbd726e208a04c53791b35cc34c747569f.tar.gz/sha512 diff --git a/deps/checksums/Downloads-ead289a7f1be7689738aaea9b12d919424a106ef.tar.gz/md5 b/deps/checksums/Downloads-ead289a7f1be7689738aaea9b12d919424a106ef.tar.gz/md5 new file mode 100644 index 0000000000000..f1a816385c931 --- /dev/null +++ b/deps/checksums/Downloads-ead289a7f1be7689738aaea9b12d919424a106ef.tar.gz/md5 @@ -0,0 +1 @@ +da2061b0d47363871498a106db7dd87c diff --git a/deps/checksums/Downloads-ead289a7f1be7689738aaea9b12d919424a106ef.tar.gz/sha512 b/deps/checksums/Downloads-ead289a7f1be7689738aaea9b12d919424a106ef.tar.gz/sha512 new file mode 100644 index 0000000000000..746d7d92d77be --- /dev/null +++ b/deps/checksums/Downloads-ead289a7f1be7689738aaea9b12d919424a106ef.tar.gz/sha512 @@ -0,0 +1 @@ +15a82d0afd7661a0d003af8ff23e92982221e53d886239550e05a4202a646f13f00d86325023f1dccc9dbb871152a54e4977fd5be3c5bf3aa27e5439e1b265df diff --git a/deps/checksums/Downloads-f97c72fbd726e208a04c53791b35cc34c747569f.tar.gz/md5 b/deps/checksums/Downloads-f97c72fbd726e208a04c53791b35cc34c747569f.tar.gz/md5 deleted file mode 100644 index 4e70641a4a08b..0000000000000 --- a/deps/checksums/Downloads-f97c72fbd726e208a04c53791b35cc34c747569f.tar.gz/md5 +++ /dev/null @@ -1 +0,0 @@ -fa2c90db0e7aa73186c491aa2f03bb2b diff --git a/deps/checksums/Downloads-f97c72fbd726e208a04c53791b35cc34c747569f.tar.gz/sha512 b/deps/checksums/Downloads-f97c72fbd726e208a04c53791b35cc34c747569f.tar.gz/sha512 deleted file mode 100644 index 3f54f39d35ac6..0000000000000 --- a/deps/checksums/Downloads-f97c72fbd726e208a04c53791b35cc34c747569f.tar.gz/sha512 +++ /dev/null @@ -1 +0,0 @@ -d36737b946af5e720402ce4f25e4c69c740bdbdc174385d6448c3660b26fffe34c14af7c4dd4d26ad864ad12771cabdf922c8b3cf4423167a46cdf3001ede125 diff --git a/stdlib/Downloads.version b/stdlib/Downloads.version index 0320fb2c09c0e..5196584fb229c 100644 --- a/stdlib/Downloads.version +++ b/stdlib/Downloads.version @@ -1,4 +1,4 @@ DOWNLOADS_BRANCH = release-1.10 -DOWNLOADS_SHA1 = f97c72fbd726e208a04c53791b35cc34c747569f +DOWNLOADS_SHA1 = ead289a7f1be7689738aaea9b12d919424a106ef DOWNLOADS_GIT_URL := https://github.com/JuliaLang/Downloads.jl.git DOWNLOADS_TAR_URL = https://api.github.com/repos/JuliaLang/Downloads.jl/tarball/$1 From 788eff9a609edc840ca8f05d4e6932b6f6afc20a Mon Sep 17 00:00:00 2001 From: Gabriel Baraldi Date: Tue, 16 Jan 2024 18:16:45 -0300 Subject: [PATCH 13/42] Correctly port realloc from 1.9 to 1.10 (#52929) I think when we backed off the new heuristics for 1.10 this got missed in the meanwhile. Should fix https://github.com/JuliaLang/julia/issues/52923 --- src/gc.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/src/gc.c b/src/gc.c index daf00a441fae0..beb4b7e96f1a8 100644 --- a/src/gc.c +++ b/src/gc.c @@ -3729,7 +3729,10 @@ JL_DLLEXPORT void *jl_gc_counted_realloc_with_old_size(void *p, size_t old, size if (data != NULL && pgcstack != NULL && ct->world_age) { jl_ptls_t ptls = ct->ptls; maybe_collect(ptls); - if (!(sz < old)) + if (sz < old) + jl_atomic_store_relaxed(&ptls->gc_num.freed, + jl_atomic_load_relaxed(&ptls->gc_num.freed) + (old - sz)); + else jl_atomic_store_relaxed(&ptls->gc_num.allocd, jl_atomic_load_relaxed(&ptls->gc_num.allocd) + (sz - old)); jl_atomic_store_relaxed(&ptls->gc_num.realloc, @@ -3856,7 +3859,10 @@ static void *gc_managed_realloc_(jl_ptls_t ptls, void *d, size_t sz, size_t olds ptls->gc_cache.perm_scanned_bytes += allocsz - oldsz; inc_live_bytes(allocsz - oldsz); } - else if (!(allocsz < oldsz)) + else if (allocsz < oldsz) + jl_atomic_store_relaxed(&ptls->gc_num.freed, + jl_atomic_load_relaxed(&ptls->gc_num.freed) + (oldsz - allocsz)); + else jl_atomic_store_relaxed(&ptls->gc_num.allocd, jl_atomic_load_relaxed(&ptls->gc_num.allocd) + (allocsz - oldsz)); jl_atomic_store_relaxed(&ptls->gc_num.realloc, From f9c2461a70b6c51b1363652d709da396d9fed0e8 Mon Sep 17 00:00:00 2001 From: N5N3 <2642243996@qq.com> Date: Sun, 19 Nov 2023 02:00:46 +0800 Subject: [PATCH 14/42] Widen diagonal var during `Type` unwrapping in `instanceof_tfunc` (#52228) --- base/compiler/tfuncs.jl | 14 ++- base/essentials.jl | 5 + src/subtype.c | 206 +++++++++++++++++++++++++++++++++++++ test/compiler/inference.jl | 13 +++ test/core.jl | 11 ++ 5 files changed, 245 insertions(+), 4 deletions(-) diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl index 708db9c98d814..24b4c00250b80 100644 --- a/base/compiler/tfuncs.jl +++ b/base/compiler/tfuncs.jl @@ -95,7 +95,7 @@ add_tfunc(throw, 1, 1, @nospecs((𝕃::AbstractLattice, x)->Bottom), 0) # if isexact is false, the actual runtime type may (will) be a subtype of t # if isconcrete is true, the actual runtime type is definitely concrete (unreachable if not valid as a typeof) # if istype is true, the actual runtime value will definitely be a type (e.g. this is false for Union{Type{Int}, Int}) -function instanceof_tfunc(@nospecialize(t)) +function instanceof_tfunc(@nospecialize(t), @nospecialize(troot) = t) if isa(t, Const) if isa(t.val, Type) && valid_as_lattice(t.val) return t.val, true, isconcretetype(t.val), true @@ -103,6 +103,7 @@ function instanceof_tfunc(@nospecialize(t)) return Bottom, true, false, false # runtime throws on non-Type end t = widenconst(t) + troot = widenconst(troot) if t === Bottom return Bottom, true, true, false # runtime unreachable elseif t === typeof(Bottom) || !hasintersect(t, Type) @@ -110,10 +111,15 @@ function instanceof_tfunc(@nospecialize(t)) elseif isType(t) tp = t.parameters[1] valid_as_lattice(tp) || return Bottom, true, false, false # runtime unreachable / throws on non-Type + if troot isa UnionAll + # Free `TypeVar`s inside `Type` has violated the "diagonal" rule. + # Widen them before `UnionAll` rewraping to relax concrete constraint. + tp = widen_diagonal(tp, troot) + end return tp, !has_free_typevars(tp), isconcretetype(tp), true elseif isa(t, UnionAll) t′ = unwrap_unionall(t) - t′′, isexact, isconcrete, istype = instanceof_tfunc(t′) + t′′, isexact, isconcrete, istype = instanceof_tfunc(t′, rewrap_unionall(t, troot)) tr = rewrap_unionall(t′′, t) if t′′ isa DataType && t′′.name !== Tuple.name && !has_free_typevars(tr) # a real instance must be within the declared bounds of the type, @@ -128,8 +134,8 @@ function instanceof_tfunc(@nospecialize(t)) end return tr, isexact, isconcrete, istype elseif isa(t, Union) - ta, isexact_a, isconcrete_a, istype_a = instanceof_tfunc(t.a) - tb, isexact_b, isconcrete_b, istype_b = instanceof_tfunc(t.b) + ta, isexact_a, isconcrete_a, istype_a = instanceof_tfunc(t.a, troot) + tb, isexact_b, isconcrete_b, istype_b = instanceof_tfunc(t.b, troot) isconcrete = isconcrete_a && isconcrete_b istype = istype_a && istype_b # most users already handle the Union case, so here we assume that diff --git a/base/essentials.jl b/base/essentials.jl index ad6e02cab145c..f7c2a1429e374 100644 --- a/base/essentials.jl +++ b/base/essentials.jl @@ -411,6 +411,11 @@ function rename_unionall(@nospecialize(u)) return UnionAll(nv, body{nv}) end +# remove concrete constraint on diagonal TypeVar if it comes from troot +function widen_diagonal(@nospecialize(t), troot::UnionAll) + body = ccall(:jl_widen_diagonal, Any, (Any, Any), t, troot) +end + function isvarargtype(@nospecialize(t)) return isa(t, Core.TypeofVararg) end diff --git a/src/subtype.c b/src/subtype.c index efff6218dfb71..74c82e72b8002 100644 --- a/src/subtype.c +++ b/src/subtype.c @@ -4304,6 +4304,212 @@ int jl_subtype_matching(jl_value_t *a, jl_value_t *b, jl_svec_t **penv) return sub; } +// type utils +static void check_diagonal(jl_value_t *t, jl_varbinding_t *troot, int param) +{ + if (jl_is_uniontype(t)) { + int i, len = 0; + jl_varbinding_t *v; + for (v = troot; v != NULL; v = v->prev) + len++; + int8_t *occurs = (int8_t *)alloca(len); + for (v = troot, i = 0; v != NULL; v = v->prev, i++) + occurs[i] = v->occurs_inv | (v->occurs_cov << 2); + check_diagonal(((jl_uniontype_t *)t)->a, troot, param); + for (v = troot, i = 0; v != NULL; v = v->prev, i++) { + int8_t occurs_inv = occurs[i] & 3; + int8_t occurs_cov = occurs[i] >> 2; + occurs[i] = v->occurs_inv | (v->occurs_cov << 2); + v->occurs_inv = occurs_inv; + v->occurs_cov = occurs_cov; + } + check_diagonal(((jl_uniontype_t *)t)->b, troot, param); + for (v = troot, i = 0; v != NULL; v = v->prev, i++) { + if (v->occurs_inv < (occurs[i] & 3)) + v->occurs_inv = occurs[i] & 3; + if (v->occurs_cov < (occurs[i] >> 2)) + v->occurs_cov = occurs[i] >> 2; + } + } + else if (jl_is_unionall(t)) { + assert(troot != NULL); + jl_varbinding_t *v1 = troot, *v2 = troot->prev; + while (v2 != NULL) { + if (v2->var == ((jl_unionall_t *)t)->var) { + v1->prev = v2->prev; + break; + } + v1 = v2; + v2 = v2->prev; + } + check_diagonal(((jl_unionall_t *)t)->body, troot, param); + v1->prev = v2; + } + else if (jl_is_datatype(t)) { + int nparam = jl_is_tuple_type(t) ? 1 : 2; + if (nparam < param) nparam = param; + for (size_t i = 0; i < jl_nparams(t); i++) { + check_diagonal(jl_tparam(t, i), troot, nparam); + } + } + else if (jl_is_vararg(t)) { + jl_value_t *T = jl_unwrap_vararg(t); + jl_value_t *N = jl_unwrap_vararg_num(t); + int n = (N && jl_is_long(N)) ? jl_unbox_long(N) : 2; + if (T && n > 0) check_diagonal(T, troot, param); + if (T && n > 1) check_diagonal(T, troot, param); + if (N) check_diagonal(N, troot, 2); + } + else if (jl_is_typevar(t)) { + jl_varbinding_t *v = troot; + for (; v != NULL; v = v->prev) { + if (v->var == (jl_tvar_t *)t) { + if (param == 1 && v->occurs_cov < 2) v->occurs_cov++; + if (param == 2 && v->occurs_inv < 2) v->occurs_inv++; + break; + } + } + if (v == NULL) + check_diagonal(((jl_tvar_t *)t)->ub, troot, 0); + } +} + +static jl_value_t *insert_nondiagonal(jl_value_t *type, jl_varbinding_t *troot, int widen2ub) +{ + if (jl_is_typevar(type)) { + int concretekind = widen2ub > 1 ? 0 : 1; + jl_varbinding_t *v = troot; + for (; v != NULL; v = v->prev) { + if (v->occurs_inv == 0 && + v->occurs_cov > concretekind && + v->var == (jl_tvar_t *)type) + break; + } + if (v != NULL) { + if (widen2ub) { + type = insert_nondiagonal(((jl_tvar_t *)type)->ub, troot, 2); + } + else { + // we must replace each covariant occurrence of newvar with a different newvar2<:newvar (diagonal rule) + if (v->innervars == NULL) + v->innervars = jl_alloc_array_1d(jl_array_any_type, 0); + jl_value_t *newvar = NULL, *lb = v->var->lb, *ub = (jl_value_t *)v->var; + jl_array_t *innervars = v->innervars; + JL_GC_PUSH4(&newvar, &lb, &ub, &innervars); + newvar = (jl_value_t *)jl_new_typevar(v->var->name, lb, ub); + jl_array_ptr_1d_push(innervars, newvar); + JL_GC_POP(); + type = newvar; + } + } + } + else if (jl_is_unionall(type)) { + jl_value_t *body = ((jl_unionall_t*)type)->body; + jl_tvar_t *var = ((jl_unionall_t*)type)->var; + jl_varbinding_t *v = troot; + for (; v != NULL; v = v->prev) { + if (v->var == var) + break; + } + if (v) v->var = NULL; // Temporarily remove `type->var` from binding list. + jl_value_t *newbody = insert_nondiagonal(body, troot, widen2ub); + if (v) v->var = var; // And restore it after inner insertation. + jl_value_t *newvar = NULL; + JL_GC_PUSH2(&newbody, &newvar); + if (body == newbody || jl_has_typevar(newbody, var)) { + if (body != newbody) + newbody = jl_new_struct(jl_unionall_type, var, newbody); + // n.b. we do not widen lb, since that would be the wrong direction + newvar = insert_nondiagonal(var->ub, troot, widen2ub); + if (newvar != var->ub) { + newvar = (jl_value_t*)jl_new_typevar(var->name, var->lb, newvar); + newbody = jl_apply_type1(newbody, newvar); + newbody = jl_type_unionall((jl_tvar_t*)newvar, newbody); + } + } + type = newbody; + JL_GC_POP(); + } + else if (jl_is_uniontype(type)) { + jl_value_t *a = ((jl_uniontype_t*)type)->a; + jl_value_t *b = ((jl_uniontype_t*)type)->b; + jl_value_t *newa = NULL; + jl_value_t *newb = NULL; + JL_GC_PUSH2(&newa, &newb); + newa = insert_nondiagonal(a, troot, widen2ub); + newb = insert_nondiagonal(b, troot, widen2ub); + if (newa != a || newb != b) + type = simple_union(newa, newb); + JL_GC_POP(); + } + else if (jl_is_vararg(type)) { + // As for Vararg we'd better widen it's var to ub as otherwise they are still diagonal + jl_value_t *t = jl_unwrap_vararg(type); + jl_value_t *n = jl_unwrap_vararg_num(type); + if (widen2ub == 0) + widen2ub = !(n && jl_is_long(n)) || jl_unbox_long(n) > 1; + jl_value_t *newt; + JL_GC_PUSH2(&newt, &n); + newt = insert_nondiagonal(t, troot, widen2ub); + if (t != newt) + type = (jl_value_t *)jl_wrap_vararg(newt, n, 0); + JL_GC_POP(); + } + else if (jl_is_datatype(type)) { + if (jl_is_tuple_type(type)) { + jl_svec_t *newparams = NULL; + jl_value_t *newelt = NULL; + JL_GC_PUSH2(&newparams, &newelt); + for (size_t i = 0; i < jl_nparams(type); i++) { + jl_value_t *elt = jl_tparam(type, i); + newelt = insert_nondiagonal(elt, troot, widen2ub); + if (elt != newelt) { + if (!newparams) + newparams = jl_svec_copy(((jl_datatype_t*)type)->parameters); + jl_svecset(newparams, i, newelt); + } + } + if (newparams) + type = (jl_value_t*)jl_apply_tuple_type(newparams); + JL_GC_POP(); + } + } + return type; +} + +static jl_value_t *_widen_diagonal(jl_value_t *t, jl_varbinding_t *troot) { + check_diagonal(t, troot, 0); + int any_concrete = 0; + for (jl_varbinding_t *v = troot; v != NULL; v = v->prev) + any_concrete |= v->occurs_cov > 1 && v->occurs_inv == 0; + if (!any_concrete) + return t; // no diagonal + return insert_nondiagonal(t, troot, 0); +} + +static jl_value_t *widen_diagonal(jl_value_t *t, jl_unionall_t *u, jl_varbinding_t *troot) +{ + jl_varbinding_t vb = { u->var, NULL, NULL, 1, 0, 0, 0, 0, 0, 0, 0, 0, NULL, troot }; + jl_value_t *nt; + JL_GC_PUSH2(&vb.innervars, &nt); + if (jl_is_unionall(u->body)) + nt = widen_diagonal(t, (jl_unionall_t *)u->body, &vb); + else + nt = _widen_diagonal(t, &vb); + if (vb.innervars != NULL) { + for (size_t i = 0; i < jl_array_nrows(vb.innervars); i++) { + jl_tvar_t *var = (jl_tvar_t*)jl_array_ptr_ref(vb.innervars, i); + nt = jl_type_unionall(var, nt); + } + } + JL_GC_POP(); + return nt; +} + +JL_DLLEXPORT jl_value_t *jl_widen_diagonal(jl_value_t *t, jl_unionall_t *ua) +{ + return widen_diagonal(t, ua, NULL); +} // specificity comparison diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl index 0fbf4e9b0fd7d..106abc695247e 100644 --- a/test/compiler/inference.jl +++ b/test/compiler/inference.jl @@ -5148,3 +5148,16 @@ end # Issue #52613 @test (code_typed((Any,)) do x; TypeVar(x...); end)[1][2] === TypeVar + +# Issue #52168 +f52168(x, t::Type) = x::NTuple{2, Base.inferencebarrier(t)::Type} +@test f52168((1, 2.), Any) === (1, 2.) + +# Issue #27031 +let x = 1, _Any = Any + @noinline bar27031(tt::Tuple{T,T}, ::Type{Val{T}}) where {T} = notsame27031(tt) + @noinline notsame27031(tt::Tuple{T, T}) where {T} = error() + @noinline notsame27031(tt::Tuple{T, S}) where {T, S} = "OK" + foo27031() = bar27031((x, 1.0), Val{_Any}) + @test foo27031() == "OK" +end diff --git a/test/core.jl b/test/core.jl index 34d0e762e2ec1..2f5c6f734a9a1 100644 --- a/test/core.jl +++ b/test/core.jl @@ -8072,3 +8072,14 @@ end # `SimpleVector`-operations should be concrete-eval eligible @test Core.Compiler.is_foldable(Base.infer_effects(length, (Core.SimpleVector,))) @test Core.Compiler.is_foldable(Base.infer_effects(getindex, (Core.SimpleVector,Int))) + +# Test correctness of widen_diagonal +let widen_diagonal(x::UnionAll) = Base.rewrap_unionall(Base.widen_diagonal(Base.unwrap_unionall(x), x), x), + check_widen_diagonal(x, y) = !<:(x, y) && x <: widen_diagonal(y) + @test Tuple{Int,Float64} <: widen_diagonal(NTuple) + @test Tuple{Int,Float64} <: widen_diagonal(Tuple{T,T} where {T}) + @test Tuple{Real,Int,Float64} <: widen_diagonal(Tuple{S,Vararg{T}} where {S, T<:S}) + @test Tuple{Int,Int,Float64,Float64} <: widen_diagonal(Tuple{S,S,Vararg{T}} where {S, T<:S}) + @test Union{Tuple{T}, Tuple{T,Int}} where {T} === widen_diagonal(Union{Tuple{T}, Tuple{T,Int}} where {T}) + @test Tuple === widen_diagonal(Union{Tuple{Vararg{S}}, Tuple{Vararg{T}}} where {S, T}) +end From 47999ab81ac959b3cc441415229667eb1aeced22 Mon Sep 17 00:00:00 2001 From: N5N3 <2642243996@qq.com> Date: Tue, 16 Jan 2024 21:04:54 +0800 Subject: [PATCH 15/42] Fix `widen_diagonal` bug for nested `UnionAll` (#52924) --- src/subtype.c | 9 ++++----- test/core.jl | 4 ++-- 2 files changed, 6 insertions(+), 7 deletions(-) diff --git a/src/subtype.c b/src/subtype.c index 74c82e72b8002..86b441f9aaec0 100644 --- a/src/subtype.c +++ b/src/subtype.c @@ -4415,19 +4415,18 @@ static jl_value_t *insert_nondiagonal(jl_value_t *type, jl_varbinding_t *troot, jl_value_t *newbody = insert_nondiagonal(body, troot, widen2ub); if (v) v->var = var; // And restore it after inner insertation. jl_value_t *newvar = NULL; - JL_GC_PUSH2(&newbody, &newvar); + JL_GC_PUSH3(&newbody, &newvar, &type); if (body == newbody || jl_has_typevar(newbody, var)) { if (body != newbody) - newbody = jl_new_struct(jl_unionall_type, var, newbody); + type = jl_new_struct(jl_unionall_type, var, newbody); // n.b. we do not widen lb, since that would be the wrong direction newvar = insert_nondiagonal(var->ub, troot, widen2ub); if (newvar != var->ub) { newvar = (jl_value_t*)jl_new_typevar(var->name, var->lb, newvar); - newbody = jl_apply_type1(newbody, newvar); - newbody = jl_type_unionall((jl_tvar_t*)newvar, newbody); + newbody = jl_apply_type1(type, newvar); + type = jl_type_unionall((jl_tvar_t*)newvar, newbody); } } - type = newbody; JL_GC_POP(); } else if (jl_is_uniontype(type)) { diff --git a/test/core.jl b/test/core.jl index 2f5c6f734a9a1..eefeeb8d1240d 100644 --- a/test/core.jl +++ b/test/core.jl @@ -8074,12 +8074,12 @@ end @test Core.Compiler.is_foldable(Base.infer_effects(getindex, (Core.SimpleVector,Int))) # Test correctness of widen_diagonal -let widen_diagonal(x::UnionAll) = Base.rewrap_unionall(Base.widen_diagonal(Base.unwrap_unionall(x), x), x), - check_widen_diagonal(x, y) = !<:(x, y) && x <: widen_diagonal(y) +let widen_diagonal(x::UnionAll) = Base.rewrap_unionall(Base.widen_diagonal(Base.unwrap_unionall(x), x), x) @test Tuple{Int,Float64} <: widen_diagonal(NTuple) @test Tuple{Int,Float64} <: widen_diagonal(Tuple{T,T} where {T}) @test Tuple{Real,Int,Float64} <: widen_diagonal(Tuple{S,Vararg{T}} where {S, T<:S}) @test Tuple{Int,Int,Float64,Float64} <: widen_diagonal(Tuple{S,S,Vararg{T}} where {S, T<:S}) @test Union{Tuple{T}, Tuple{T,Int}} where {T} === widen_diagonal(Union{Tuple{T}, Tuple{T,Int}} where {T}) @test Tuple === widen_diagonal(Union{Tuple{Vararg{S}}, Tuple{Vararg{T}}} where {S, T}) + @test Tuple{Vararg{Val{<:Set}}} == widen_diagonal(Tuple{Vararg{T}} where T<:Val{<:Set}) end From ddb9d0d6bebaa3d09bf5c2215b421b30ecb7943b Mon Sep 17 00:00:00 2001 From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com> Date: Mon, 22 Jan 2024 15:34:34 -0500 Subject: [PATCH 16/42] =?UTF-8?q?=F0=9F=A4=96=20[backports-release-1.10]?= =?UTF-8?q?=20Bump=20the=20Pkg=20stdlib=20from=20563a3387a=20to=2011cf00df?= =?UTF-8?q?7=20(#53008)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/md5 | 1 + .../Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/sha512 | 1 + .../Pkg-563a3387acddad6c427b2f675aa70531c4324cc2.tar.gz/md5 | 1 - .../Pkg-563a3387acddad6c427b2f675aa70531c4324cc2.tar.gz/sha512 | 1 - stdlib/Pkg.version | 2 +- 5 files changed, 3 insertions(+), 3 deletions(-) create mode 100644 deps/checksums/Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/md5 create mode 100644 deps/checksums/Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/sha512 delete mode 100644 deps/checksums/Pkg-563a3387acddad6c427b2f675aa70531c4324cc2.tar.gz/md5 delete mode 100644 deps/checksums/Pkg-563a3387acddad6c427b2f675aa70531c4324cc2.tar.gz/sha512 diff --git a/deps/checksums/Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/md5 b/deps/checksums/Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/md5 new file mode 100644 index 0000000000000..574c4f7c76d11 --- /dev/null +++ b/deps/checksums/Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/md5 @@ -0,0 +1 @@ +ec3d53a5eca90356146dbbaa44658dcb diff --git a/deps/checksums/Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/sha512 b/deps/checksums/Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/sha512 new file mode 100644 index 0000000000000..f986511d696ab --- /dev/null +++ b/deps/checksums/Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/sha512 @@ -0,0 +1 @@ +7398e2a5b2b148aa1cbe96c0874cccdd24f7c380351013c05dc11be1ae7fd8cb829d0b8ab696eb516373c46e1cb5cfc29afb12b2c31e7e71a64fad4bc37bb6ff diff --git a/deps/checksums/Pkg-563a3387acddad6c427b2f675aa70531c4324cc2.tar.gz/md5 b/deps/checksums/Pkg-563a3387acddad6c427b2f675aa70531c4324cc2.tar.gz/md5 deleted file mode 100644 index 985e7ef06f2a5..0000000000000 --- a/deps/checksums/Pkg-563a3387acddad6c427b2f675aa70531c4324cc2.tar.gz/md5 +++ /dev/null @@ -1 +0,0 @@ -769c5379f1ded5529d82d83e092e954c diff --git a/deps/checksums/Pkg-563a3387acddad6c427b2f675aa70531c4324cc2.tar.gz/sha512 b/deps/checksums/Pkg-563a3387acddad6c427b2f675aa70531c4324cc2.tar.gz/sha512 deleted file mode 100644 index d5f705de6d9d9..0000000000000 --- a/deps/checksums/Pkg-563a3387acddad6c427b2f675aa70531c4324cc2.tar.gz/sha512 +++ /dev/null @@ -1 +0,0 @@ -585760a1c104391bb08f920b6944b88762e942388fd6ca6bf3bfa6a0bf050f99d304c21165a3b82c96dea5a6711af3ddf0cf9b83bf5fd5f015b26f412b24015a diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version index b43eb592268ab..ce5c816b40d31 100644 --- a/stdlib/Pkg.version +++ b/stdlib/Pkg.version @@ -1,4 +1,4 @@ PKG_BRANCH = release-1.10 -PKG_SHA1 = 563a3387acddad6c427b2f675aa70531c4324cc2 +PKG_SHA1 = 11cf00df71dca76ccb34320ad11ad64ea015fe25 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1 From 3552d3606d5ee047f5b0798b202d72a27ad2499a Mon Sep 17 00:00:00 2001 From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com> Date: Tue, 23 Jan 2024 23:39:14 -0500 Subject: [PATCH 17/42] =?UTF-8?q?=F0=9F=A4=96=20[backports-release-1.10]?= =?UTF-8?q?=20Bump=20the=20Pkg=20stdlib=20from=2011cf00df7=20to=2070525539?= =?UTF-8?q?d=20(#53028)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Stdlib: Pkg URL: https://github.com/JuliaLang/Pkg.jl.git Stdlib branch: release-1.10 Julia branch: backports-release-1.10 Old commit: 11cf00df7 New commit: 70525539d Julia version: 1.10.0 Pkg version: 1.10.0 Bump invoked by: @IanButterworth Powered by: [BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl) Diff: https://github.com/JuliaLang/Pkg.jl/compare/11cf00df71dca76ccb34320ad11ad64ea015fe25...70525539d3157891445abe806962f780f64143cd ``` $ git log --oneline 11cf00df7..70525539d 70525539d Merge pull request #3770 from JuliaLang/backports-release-1.10 729ebe1e3 Avoid deleting existing artifacts when ignoring hashes. (#3768) ``` Co-authored-by: Dilum Aluthge --- .../Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/md5 | 1 - .../Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/sha512 | 1 - .../Pkg-70525539d3157891445abe806962f780f64143cd.tar.gz/md5 | 1 + .../Pkg-70525539d3157891445abe806962f780f64143cd.tar.gz/sha512 | 1 + stdlib/Pkg.version | 2 +- 5 files changed, 3 insertions(+), 3 deletions(-) delete mode 100644 deps/checksums/Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/md5 delete mode 100644 deps/checksums/Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/sha512 create mode 100644 deps/checksums/Pkg-70525539d3157891445abe806962f780f64143cd.tar.gz/md5 create mode 100644 deps/checksums/Pkg-70525539d3157891445abe806962f780f64143cd.tar.gz/sha512 diff --git a/deps/checksums/Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/md5 b/deps/checksums/Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/md5 deleted file mode 100644 index 574c4f7c76d11..0000000000000 --- a/deps/checksums/Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/md5 +++ /dev/null @@ -1 +0,0 @@ -ec3d53a5eca90356146dbbaa44658dcb diff --git a/deps/checksums/Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/sha512 b/deps/checksums/Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/sha512 deleted file mode 100644 index f986511d696ab..0000000000000 --- a/deps/checksums/Pkg-11cf00df71dca76ccb34320ad11ad64ea015fe25.tar.gz/sha512 +++ /dev/null @@ -1 +0,0 @@ -7398e2a5b2b148aa1cbe96c0874cccdd24f7c380351013c05dc11be1ae7fd8cb829d0b8ab696eb516373c46e1cb5cfc29afb12b2c31e7e71a64fad4bc37bb6ff diff --git a/deps/checksums/Pkg-70525539d3157891445abe806962f780f64143cd.tar.gz/md5 b/deps/checksums/Pkg-70525539d3157891445abe806962f780f64143cd.tar.gz/md5 new file mode 100644 index 0000000000000..59643e2d8da35 --- /dev/null +++ b/deps/checksums/Pkg-70525539d3157891445abe806962f780f64143cd.tar.gz/md5 @@ -0,0 +1 @@ +8a7db649c8ee8f4506925d1364af66ce diff --git a/deps/checksums/Pkg-70525539d3157891445abe806962f780f64143cd.tar.gz/sha512 b/deps/checksums/Pkg-70525539d3157891445abe806962f780f64143cd.tar.gz/sha512 new file mode 100644 index 0000000000000..eb8207f429689 --- /dev/null +++ b/deps/checksums/Pkg-70525539d3157891445abe806962f780f64143cd.tar.gz/sha512 @@ -0,0 +1 @@ +53c74a0630e1e57e7cf1dac0de84297de6a623ff913affbaf2a887c5b6ea68782985dff5f453a4fddc662b12e8b3a11e61a2a29bb72afde3bbc5d1f5c00bb0bd diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version index ce5c816b40d31..c3a452c1bd32f 100644 --- a/stdlib/Pkg.version +++ b/stdlib/Pkg.version @@ -1,4 +1,4 @@ PKG_BRANCH = release-1.10 -PKG_SHA1 = 11cf00df71dca76ccb34320ad11ad64ea015fe25 +PKG_SHA1 = 70525539d3157891445abe806962f780f64143cd PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1 From 7d3c68e4b9bcbced00b9689bbcaf5a35ea902219 Mon Sep 17 00:00:00 2001 From: Lilith Orion Hafner Date: Wed, 30 Aug 2023 14:38:21 -0500 Subject: [PATCH 18/42] Fix edge cases where inexact conversions to UInt don't throw (#51095) (cherry picked from commit fb7613635cab77cf269790335e8121f513c9ea96) --- base/float.jl | 5 ++++- test/floatfuncs.jl | 31 +++++++++++++++++++++++++++++++ 2 files changed, 35 insertions(+), 1 deletion(-) diff --git a/base/float.jl b/base/float.jl index fc4cef09b48ad..aa61f2c8449e3 100644 --- a/base/float.jl +++ b/base/float.jl @@ -882,7 +882,10 @@ for Ti in (Int8, Int16, Int32, Int64, Int128, UInt8, UInt16, UInt32, UInt64, UIn end end function (::Type{$Ti})(x::$Tf) - if ($(Tf(typemin(Ti))) <= x <= $(Tf(typemax(Ti)))) && isinteger(x) + # When typemax(Ti) is not representable by Tf but typemax(Ti) + 1 is, + # then < Tf(typemax(Ti) + 1) is stricter than <= Tf(typemax(Ti)). Using + # the former causes us to throw on UInt64(Float64(typemax(UInt64))+1) + if ($(Tf(typemin(Ti))) <= x < $(Tf(typemax(Ti))+one(Tf))) && isinteger(x) return unsafe_trunc($Ti,x) else throw(InexactError($(Expr(:quote,Ti.name.name)), $Ti, x)) diff --git a/test/floatfuncs.jl b/test/floatfuncs.jl index a0d6e8743514b..268d699684cbb 100644 --- a/test/floatfuncs.jl +++ b/test/floatfuncs.jl @@ -256,3 +256,34 @@ end @test isapprox(typemin(T), 0.0, rtol=1) end end + +@testset "Conversion from floating point to unsigned integer near extremes (#51063)" begin + @test_throws InexactError UInt32(4.2949673f9) + @test_throws InexactError UInt64(1.8446744f19) + @test_throws InexactError UInt64(1.8446744073709552e19) + @test_throws InexactError UInt128(3.402823669209385e38) +end + +@testset "Conversion from floating point to integer near extremes (exhaustive)" begin + for Ti in Base.BitInteger_types, Tf in (Float16, Float32, Float64), x in (typemin(Ti), typemax(Ti)) + y = Tf(x) + for i in -3:3 + z = nextfloat(y, i) + + result = isfinite(z) ? round(BigInt, z) : error + result = result !== error && typemin(Ti) <= result <= typemax(Ti) ? result : error + + if result === error + # @test_throws InexactError round(Ti, z) Broken because of #51113 + @test_throws InexactError Ti(z) + else + @test result == round(Ti, z) + if isinteger(z) + @test result == Ti(z) + else + @test_throws InexactError Ti(z) + end + end + end + end +end From 2481fdf95c687799b28640c7cc863deb7d942181 Mon Sep 17 00:00:00 2001 From: Kristoffer Carlsson Date: Fri, 5 Jan 2024 16:45:09 +0100 Subject: [PATCH 19/42] loading: fix finding bundled stdlibs even if they are e.g. devved in an environment higher in the load path (#52637) I noticed this when seeing some weird precompile issues when I had SparseArrays devved in my main environment but it was with the standard stdlib format in the current environment: ``` (NearestNeighbors) pkg> st -m Project NearestNeighbors v0.4.15 Status `~/JuliaPkgs/NearestNeighbors.jl/Manifest.toml` ... [2f01184e] SparseArrays v1.10.0 ... ``` But even so, `locate_package` claims that the path to SparseArrays is the one in the main environment: ``` julia> pkg = Base.PkgId(Base.UUID("2f01184e-e22b-5df5-ae63-d93ebab69eaf"), "SparseArrays") SparseArrays [2f01184e-e22b-5df5-ae63-d93ebab69eaf] julia> Base.locate_package(pkg) "/home/kc/JuliaPkgs/SparseArrays.jl/src/SparseArrays.jl" ``` This correctly fixes it so that packages without a `git-tree-sha1` (and without a `path`) are resolved to the stdlib path. (cherry picked from commit c9bc2ffd52e558aecf228b17d55e3eb0e4d5f693) --- base/loading.jl | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/base/loading.jl b/base/loading.jl index bbc14c3f1d591..b652e56c922e0 100644 --- a/base/loading.jl +++ b/base/loading.jl @@ -933,7 +933,13 @@ function explicit_manifest_entry_path(manifest_file::String, pkg::PkgId, entry:: return path end hash = get(entry, "git-tree-sha1", nothing)::Union{Nothing, String} - hash === nothing && return nothing + if hash === nothing + mbypath = manifest_uuid_path(Sys.STDLIB, pkg) + if mbypath isa String + return entry_path(mbypath, pkg.name) + end + return nothing + end hash = SHA1(hash) # Keep the 4 since it used to be the default uuid = pkg.uuid::UUID # checked within `explicit_manifest_uuid_path` From cc2600427f32318f6140949f342f4919e0c44218 Mon Sep 17 00:00:00 2001 From: Jameson Nash Date: Fri, 5 Jan 2024 15:42:40 -0500 Subject: [PATCH 20/42] staticdata: handle cycles in datatypes (#52752) Handle any sort of cycle encountered in the datatype super fields by always deferring that field until later and setting a deferred mechanism for updating the field only after the supertype is ready. Fix #52660 (cherry picked from commit c94b1a3cd810efd35b66ca4f5a60839989e18692) --- src/staticdata.c | 147 +++++++++++++++++++++++------------------ src/staticdata_utils.c | 13 ++-- test/precompile.jl | 6 +- 3 files changed, 95 insertions(+), 71 deletions(-) diff --git a/src/staticdata.c b/src/staticdata.c index 36961b58f375a..c130c2e7569fe 100644 --- a/src/staticdata.c +++ b/src/staticdata.c @@ -295,7 +295,6 @@ static arraylist_t deser_sym; static htable_t external_objects; static htable_t serialization_order; // to break cycles, mark all objects that are serialized -static htable_t unique_ready; // as we serialize types, we need to know if all reachable objects are also already serialized. This tracks whether `immediate` has been set for all of them. static htable_t nullptrs; // FIFO queue for objects to be serialized. Anything requiring fixup upon deserialization // must be "toplevel" in this queue. For types, parameters and field types must appear @@ -463,6 +462,7 @@ typedef struct { arraylist_t relocs_list; // a list of (location, target) pairs, see description at top arraylist_t gctags_list; // " arraylist_t uniquing_types; // a list of locations that reference types that must be de-duplicated + arraylist_t uniquing_super; // a list of datatypes, used in super fields, that need to be marked in uniquing_types once they are reached, for handling unique-ing of them on deserialization arraylist_t uniquing_objs; // a list of locations that reference non-types that must be de-duplicated arraylist_t fixup_types; // a list of locations of types requiring (re)caching arraylist_t fixup_objs; // a list of locations of objects requiring (re)caching @@ -726,14 +726,13 @@ static void jl_insert_into_serialization_queue(jl_serializer_state *s, jl_value_ { jl_datatype_t *t = (jl_datatype_t*)jl_typeof(v); jl_queue_for_serialization_(s, (jl_value_t*)t, 1, immediate); + const jl_datatype_layout_t *layout = t->layout; if (!recursive) goto done_fields; if (s->incremental && jl_is_datatype(v) && immediate) { jl_datatype_t *dt = (jl_datatype_t*)v; - // ensure super is queued (though possibly not yet handled, since it may have cycles) - jl_queue_for_serialization_(s, (jl_value_t*)dt->super, 1, 1); // ensure all type parameters are recached jl_queue_for_serialization_(s, (jl_value_t*)dt->parameters, 1, 1); jl_value_t *singleton = dt->instance; @@ -743,7 +742,7 @@ static void jl_insert_into_serialization_queue(jl_serializer_state *s, jl_value_ // (it may get serialized from elsewhere though) record_field_change(&dt->instance, jl_nothing); } - immediate = 0; // do not handle remaining fields immediately (just field types remains) + goto done_fields; // for now } if (s->incremental && jl_is_method_instance(v)) { jl_method_instance_t *mi = (jl_method_instance_t*)v; @@ -800,11 +799,9 @@ static void jl_insert_into_serialization_queue(jl_serializer_state *s, jl_value_ } } - if (immediate) // must be things that can be recursively handled, and valid as type parameters assert(jl_is_immutable(t) || jl_is_typevar(v) || jl_is_symbol(v) || jl_is_svec(v)); - const jl_datatype_layout_t *layout = t->layout; if (layout->npointers == 0) { // bitstypes do not require recursion } @@ -860,22 +857,35 @@ done_fields: ; // We've encountered an item we need to cache void **bp = ptrhash_bp(&serialization_order, v); - assert(*bp != (void*)(uintptr_t)-1); - if (s->incremental) { - void **bp2 = ptrhash_bp(&unique_ready, v); - if (*bp2 == HT_NOTFOUND) - assert(*bp == (void*)(uintptr_t)-2); - else if (*bp != (void*)(uintptr_t)-2) - return; - } - else { - assert(*bp == (void*)(uintptr_t)-2); - } + assert(*bp == (void*)(uintptr_t)-2); arraylist_push(&serialization_queue, (void*) v); size_t idx = serialization_queue.len - 1; assert(serialization_queue.len < ((uintptr_t)1 << RELOC_TAG_OFFSET) && "too many items to serialize"); - *bp = (void*)((char*)HT_NOTFOUND + 1 + idx); + + // DataType is very unusual, in that some of the fields need to be pre-order, and some + // (notably super) must not be (even if `jl_queue_for_serialization_` would otherwise + // try to promote itself to be immediate) + if (s->incremental && jl_is_datatype(v) && immediate && recursive) { + jl_datatype_t *dt = (jl_datatype_t*)v; + void **bp = ptrhash_bp(&serialization_order, (void*)dt->super); + if (*bp != (void*)-2) { + // if super is already on the stack of things to handle when this returns, do + // not try to handle it now + jl_queue_for_serialization_(s, (jl_value_t*)dt->super, 1, immediate); + } + immediate = 0; + char *data = (char*)jl_data_ptr(v); + size_t i, np = layout->npointers; + for (i = 0; i < np; i++) { + uint32_t ptr = jl_ptr_offset(t, i); + if (ptr * sizeof(jl_value_t*) == offsetof(jl_datatype_t, super)) + continue; // skip the super field, since it might not be quite validly ordered + int mutabl = 1; + jl_value_t *fld = get_replaceable_field(&((jl_value_t**)data)[ptr], mutabl); + jl_queue_for_serialization_(s, fld, 1, immediate); + } + } } static void jl_queue_for_serialization_(jl_serializer_state *s, jl_value_t *v, int recursive, int immediate) JL_GC_DISABLED @@ -894,28 +904,19 @@ static void jl_queue_for_serialization_(jl_serializer_state *s, jl_value_t *v, i } void **bp = ptrhash_bp(&serialization_order, v); - if (*bp == HT_NOTFOUND) { - *bp = (void*)(uintptr_t)(immediate ? -2 : -1); - } - else { - if (!s->incremental || !immediate || !recursive) - return; - void **bp2 = ptrhash_bp(&unique_ready, v); - if (*bp2 == HT_NOTFOUND) - *bp2 = v; // now is unique_ready - else { - assert(*bp != (void*)(uintptr_t)-1); - return; // already was unique_ready - } - assert(*bp != (void*)(uintptr_t)-2); // should be unique_ready then - if (*bp == (void*)(uintptr_t)-1) - *bp = (void*)(uintptr_t)-2; // now immediate - } + assert(!immediate || *bp != (void*)(uintptr_t)-2); + if (*bp == HT_NOTFOUND) + *bp = (void*)(uintptr_t)-1; // now enqueued + else if (!s->incremental || !immediate || !recursive || *bp != (void*)(uintptr_t)-1) + return; - if (immediate) + if (immediate) { + *bp = (void*)(uintptr_t)-2; // now immediate jl_insert_into_serialization_queue(s, v, recursive, immediate); - else + } + else { arraylist_push(&object_worklist, (void*)v); + } } // Do a pre-order traversal of the to-serialize worklist, in the identical order @@ -1065,8 +1066,10 @@ static void record_uniquing(jl_serializer_state *s, jl_value_t *fld, uintptr_t o if (s->incremental && jl_needs_serialization(s, fld) && needs_uniquing(fld)) { if (jl_is_datatype(fld) || jl_is_datatype_singleton((jl_datatype_t*)jl_typeof(fld))) arraylist_push(&s->uniquing_types, (void*)(uintptr_t)offset); - else + else if (jl_is_method_instance(fld)) arraylist_push(&s->uniquing_objs, (void*)(uintptr_t)offset); + else + assert(0 && "unknown object type with needs_uniquing set"); } } @@ -1224,7 +1227,15 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED write_pointerfield(s, (jl_value_t*)mi->sparam_vals); continue; } - else if (!jl_is_datatype(v)) { + else if (jl_is_datatype(v)) { + for (size_t i = 0; i < s->uniquing_super.len; i++) { + if (s->uniquing_super.items[i] == (void*)v) { + s->uniquing_super.items[i] = arraylist_pop(&s->uniquing_super); + arraylist_push(&s->uniquing_types, (void*)(uintptr_t)(reloc_offset|3)); + } + } + } + else { assert(jl_is_datatype_singleton(t) && "unreachable"); } } @@ -1589,6 +1600,9 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED ios_write(s->const_data, (char*)&dyn, sizeof(jl_fielddescdyn_t)); } } + void *superidx = ptrhash_get(&serialization_order, dt->super); + if (s->incremental && superidx != HT_NOTFOUND && (char*)superidx - 1 - (char*)HT_NOTFOUND > item && needs_uniquing((jl_value_t*)dt->super)) + arraylist_push(&s->uniquing_super, dt->super); } else if (jl_is_typename(v)) { assert(f == s->s); @@ -1633,6 +1647,7 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED } } } + assert(s->uniquing_super.len == 0); } // In deserialization, create Symbols and set up the @@ -2397,7 +2412,6 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array, ptrhash_put(&fptr_to_id, (void*)(uintptr_t)id_to_fptrs[i], (void*)(i + 2)); } htable_new(&serialization_order, 25000); - htable_new(&unique_ready, 0); htable_new(&nullptrs, 0); arraylist_new(&object_worklist, 0); arraylist_new(&serialization_queue, 0); @@ -2420,6 +2434,7 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array, arraylist_new(&s.relocs_list, 0); arraylist_new(&s.gctags_list, 0); arraylist_new(&s.uniquing_types, 0); + arraylist_new(&s.uniquing_super, 0); arraylist_new(&s.uniquing_objs, 0); arraylist_new(&s.fixup_types, 0); arraylist_new(&s.fixup_objs, 0); @@ -2652,6 +2667,11 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array, arraylist_free(&object_worklist); arraylist_free(&serialization_queue); arraylist_free(&layout_table); + arraylist_free(&s.uniquing_types); + arraylist_free(&s.uniquing_super); + arraylist_free(&s.uniquing_objs); + arraylist_free(&s.fixup_types); + arraylist_free(&s.fixup_objs); arraylist_free(&s.ccallable_list); arraylist_free(&s.relocs_list); arraylist_free(&s.gctags_list); @@ -2661,7 +2681,6 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array, if (worklist) htable_free(&external_objects); htable_free(&serialization_order); - htable_free(&unique_ready); htable_free(&nullptrs); htable_free(&symbol_table); htable_free(&fptr_to_id); @@ -3026,31 +3045,43 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl uintptr_t item = (uintptr_t)s.uniquing_types.items[i]; // check whether we are operating on the typetag // (needing to ignore GC bits) or a regular field - int tag = (item & 1) == 1; - // check whether this is a gvar index - int gvar = (item & 2) == 2; + // and check whether this is a gvar index + int tag = (item & 3); item &= ~(uintptr_t)3; uintptr_t *pfld; jl_value_t **obj, *newobj; - if (gvar) { + if (tag == 3) { + obj = (jl_value_t**)(image_base + item); + pfld = NULL; + for (size_t i = 0; i < delay_list.len; i += 2) { + if (obj == (jl_value_t **)delay_list.items[i + 0]) { + pfld = (uintptr_t*)delay_list.items[i + 1]; + delay_list.items[i + 1] = arraylist_pop(&delay_list); + delay_list.items[i + 0] = arraylist_pop(&delay_list); + break; + } + } + assert(pfld); + } + else if (tag == 2) { if (image->gvars_base == NULL) continue; item >>= 2; assert(item < s.gvar_record->size / sizeof(reloc_t)); pfld = sysimg_gvars(image->gvars_base, image->gvars_offsets, item); obj = *(jl_value_t***)pfld; - assert(tag == 0); } else { pfld = (uintptr_t*)(image_base + item); - if (tag) + if (tag == 1) obj = (jl_value_t**)jl_typeof(jl_valueof(pfld)); else obj = *(jl_value_t***)pfld; if ((char*)obj > (char*)pfld) { + // this must be the super field assert(tag == 0); - arraylist_push(&delay_list, pfld); arraylist_push(&delay_list, obj); + arraylist_push(&delay_list, pfld); ptrhash_put(&new_dt_objs, (void*)obj, obj); // mark obj as invalid *pfld = (uintptr_t)NULL; continue; @@ -3100,25 +3131,14 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl assert(newobj != jl_nothing); arraylist_push(&cleanup_list, (void*)obj); } - if (tag) + if (tag == 1) *pfld = (uintptr_t)newobj | GC_OLD | GC_IN_IMAGE; else *pfld = (uintptr_t)newobj; assert(!(image_base < (char*)newobj && (char*)newobj <= image_base + sizeof_sysimg)); assert(jl_typetagis(obj, otyp)); } - // A few fields (reached via super) might be self-recursive. This is rare, but handle them now. - // They cannot be instances though, since the type must fully exist before the singleton field can be allocated - for (size_t i = 0; i < delay_list.len; ) { - uintptr_t *pfld = (uintptr_t*)delay_list.items[i++]; - jl_value_t **obj = (jl_value_t **)delay_list.items[i++]; - assert(jl_is_datatype(obj)); - jl_datatype_t *dt = (jl_datatype_t*)obj[0]; - assert(jl_is_datatype(dt)); - jl_value_t *newobj = (jl_value_t*)dt; - *pfld = (uintptr_t)newobj; - assert(!(image_base < (char*)newobj && (char*)newobj <= image_base + sizeof_sysimg)); - } + assert(delay_list.len == 0); arraylist_free(&delay_list); // now that all the fields of dt are assigned and unique, copy them into // their final newdt memory location: this ensures we do not accidentally @@ -3166,11 +3186,12 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl for (size_t i = 0; i < s.uniquing_objs.len; i++) { uintptr_t item = (uintptr_t)s.uniquing_objs.items[i]; // check whether this is a gvar index - int gvar = (item & 2) == 2; + int tag = (item & 3); + assert(tag == 0 || tag == 2); item &= ~(uintptr_t)3; uintptr_t *pfld; jl_value_t **obj, *newobj; - if (gvar) { + if (tag == 2) { if (image->gvars_base == NULL) continue; item >>= 2; diff --git a/src/staticdata_utils.c b/src/staticdata_utils.c index a4cbc3fd5ebc4..b488934606671 100644 --- a/src/staticdata_utils.c +++ b/src/staticdata_utils.c @@ -45,16 +45,15 @@ int must_be_new_dt(jl_value_t *t, htable_t *news, char *image_base, size_t sizeo jl_datatype_t *dt = (jl_datatype_t*)t; assert(jl_object_in_image((jl_value_t*)dt->name) && "type_in_worklist mistake?"); jl_datatype_t *super = dt->super; - // check if super is news, since then we must be new also - // (it is also possible that super is indeterminate now, wait for `t` - // to be resolved, then will be determined later and fixed up by the - // delay_list, for this and any other references to it). - while (super != jl_any_type) { - assert(super); + // fast-path: check if super is in news, since then we must be new also + // (it is also possible that super is indeterminate or NULL right now, + // waiting for `t` to be resolved, then will be determined later as + // soon as possible afterwards). + while (super != NULL && super != jl_any_type) { if (ptrhash_has(news, (void*)super)) return 1; if (!(image_base < (char*)super && (char*)super <= image_base + sizeof_sysimg)) - break; // fast-path for rejection of super + break; // the rest must all be non-new // otherwise super might be something that was not cached even though a later supertype might be // for example while handling `Type{Mask{4, U} where U}`, if we have `Mask{4, U} <: AbstractSIMDVector{4}` super = super->super; diff --git a/test/precompile.jl b/test/precompile.jl index e10d896da7d3f..d317731b51370 100644 --- a/test/precompile.jl +++ b/test/precompile.jl @@ -115,6 +115,8 @@ precompile_test_harness(false) do dir d = den(a) return h end + abstract type AbstractAlgebraMap{A} end + struct GAPGroupHomomorphism{A, B} <: AbstractAlgebraMap{GAPGroupHomomorphism{B, A}} end end """) write(Foo2_file, @@ -130,7 +132,7 @@ precompile_test_harness(false) do dir write(Foo_file, """ module $Foo_module - import $FooBase_module, $FooBase_module.typeA + import $FooBase_module, $FooBase_module.typeA, $FooBase_module.GAPGroupHomomorphism import $Foo2_module: $Foo2_module, override, overridenc import $FooBase_module.hash import Test @@ -211,6 +213,8 @@ precompile_test_harness(false) do dir Base.convert(::Type{Some{Value18343}}, ::Value18343{Some}) = 2 Base.convert(::Type{Ref}, ::Value18343{T}) where {T} = 3 + const GAPType1 = GAPGroupHomomorphism{Nothing, Nothing} + const GAPType2 = GAPGroupHomomorphism{1, 2} # issue #28297 mutable struct Result From 69d58e0de823af68e9539285fca4996b5dedff8d Mon Sep 17 00:00:00 2001 From: Kristoffer Carlsson Date: Mon, 8 Jan 2024 14:17:47 +0100 Subject: [PATCH 21/42] use a Dict instead of an IdDict for caching of the `cwstring` for Windows env variables (#52758) Should fix https://github.com/JuliaLang/julia/issues/52711. My analysis of the invalidation is as follows: We added code to cache the conversion to `cwstring` in env handling on Windows (https://github.com/JuliaLang/julia/pull/51371): ```julia const env_dict = IdDict{String, Vector{UInt16}}() function memoized_env_lookup(str::AbstractString) ... env_dict[str] = cwstring(str) ... end function access_env(onError::Function, str::AbstractString) var = memoized_env_lookup(str) ... end ``` Since `IdDict` has `@nospecialize` on `setindex!` we compile this method: ```julia setindex!(::IdDict{String, Vector{UInt16}}, ::Any, ::Any) ``` which has an edge to: ```julia convert(Type{Vector{Int64}}, Any}) ``` But then StaticArrays comes along and adds a method ```julia convert(::Type{Array{T, N}}, ::StaticArray) ``` which invalidates the `setindex!` (due to the edge to `convert`) which invalidates the whole env handling on Windows which causes 4k other methods downstream to be invalidated, in particular, the artifact string macro which causes a significant delay in the next jll package you load after loading StaticArrays. There should be no performance penalty to this since strings already does a hash for their `objectid`. (cherry picked from commit b7c24ed67bc42d51ee33da5ed5a97361c49313b8) --- base/env.jl | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/base/env.jl b/base/env.jl index 27594acff6b7f..1bebfd2623e61 100644 --- a/base/env.jl +++ b/base/env.jl @@ -3,7 +3,7 @@ if Sys.iswindows() const ERROR_ENVVAR_NOT_FOUND = UInt32(203) - const env_dict = IdDict{String, Vector{Cwchar_t}}() + const env_dict = Dict{String, Vector{Cwchar_t}}() const env_lock = ReentrantLock() function memoized_env_lookup(str::AbstractString) @@ -11,13 +11,14 @@ if Sys.iswindows() # incurred allocations because we had to convert a String to a Vector{Cwchar_t} each time # an environment variable was looked up. This function memoizes that lookup process, storing # the String => Vector{Cwchar_t} pairs in env_dict - var = get(env_dict, str, nothing) - if isnothing(var) - var = @lock env_lock begin - env_dict[str] = cwstring(str) + @lock env_lock begin + var = get(env_dict, str, nothing) + if isnothing(var) + var = cwstring(str) + env_dict[str] = var end + return var end - var end _getenvlen(var::Vector{UInt16}) = ccall(:GetEnvironmentVariableW,stdcall,UInt32,(Ptr{UInt16},Ptr{UInt16},UInt32),var,C_NULL,0) From d2fd31784c2dab163eb919741241ac55c2954229 Mon Sep 17 00:00:00 2001 From: Lilith Orion Hafner Date: Wed, 17 Jan 2024 05:09:30 +0600 Subject: [PATCH 22/42] Insert hardcoded backlinks to stdlib doc pages (#51375) This is #48814 times 23. It solves most of but not all of #50035. (cherry picked from commit a327a9594fa469a2d5df32a79a86965286968e54) --- stdlib/Artifacts/docs/src/index.md | 4 ++++ stdlib/Base64/docs/src/index.md | 4 ++++ stdlib/CRC32c/docs/src/index.md | 4 ++++ stdlib/FileWatching/docs/src/index.md | 4 ++++ stdlib/Future/docs/src/index.md | 4 ++++ stdlib/InteractiveUtils/docs/src/index.md | 4 ++++ stdlib/LibGit2/docs/src/index.md | 4 ++++ stdlib/Libdl/docs/src/index.md | 4 ++++ stdlib/LinearAlgebra/docs/src/index.md | 4 ++++ stdlib/Logging/docs/src/index.md | 4 ++++ stdlib/Markdown/docs/src/index.md | 4 ++++ stdlib/Mmap/docs/src/index.md | 4 ++++ stdlib/Printf/docs/src/index.md | 4 ++++ stdlib/Profile/docs/src/index.md | 4 ++++ stdlib/REPL/docs/src/index.md | 4 ++++ stdlib/Random/docs/src/index.md | 4 ++++ stdlib/Serialization/docs/src/index.md | 4 ++++ stdlib/SharedArrays/docs/src/index.md | 4 ++++ stdlib/Sockets/docs/src/index.md | 4 ++++ stdlib/TOML/docs/src/index.md | 4 ++++ stdlib/Test/docs/src/index.md | 4 ++++ stdlib/UUIDs/docs/src/index.md | 4 ++++ stdlib/Unicode/docs/src/index.md | 4 ++++ 23 files changed, 92 insertions(+) diff --git a/stdlib/Artifacts/docs/src/index.md b/stdlib/Artifacts/docs/src/index.md index 80f4c62cbf77f..2f6c9a07a8761 100644 --- a/stdlib/Artifacts/docs/src/index.md +++ b/stdlib/Artifacts/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Artifacts/docs/src/index.md" +``` + # Artifacts ```@meta diff --git a/stdlib/Base64/docs/src/index.md b/stdlib/Base64/docs/src/index.md index 6bc647f8a2e67..26e9d70f2ff9f 100644 --- a/stdlib/Base64/docs/src/index.md +++ b/stdlib/Base64/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Base64/docs/src/index.md" +``` + # Base64 ```@docs diff --git a/stdlib/CRC32c/docs/src/index.md b/stdlib/CRC32c/docs/src/index.md index 24a073d1e3938..c00a792232c70 100644 --- a/stdlib/CRC32c/docs/src/index.md +++ b/stdlib/CRC32c/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/CRC32c/docs/src/index.md" +``` + # CRC32c Standard library module for computing the CRC-32c checksum. diff --git a/stdlib/FileWatching/docs/src/index.md b/stdlib/FileWatching/docs/src/index.md index a420d49232345..1b2212fcc5a28 100644 --- a/stdlib/FileWatching/docs/src/index.md +++ b/stdlib/FileWatching/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/FileWatching/docs/src/index.md" +``` + # [File Events](@id lib-filewatching) ```@docs diff --git a/stdlib/Future/docs/src/index.md b/stdlib/Future/docs/src/index.md index dcb1a36541b6e..99250296f2c7d 100644 --- a/stdlib/Future/docs/src/index.md +++ b/stdlib/Future/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Future/docs/src/index.md" +``` + # Future The `Future` module implements future behavior of already existing functions, diff --git a/stdlib/InteractiveUtils/docs/src/index.md b/stdlib/InteractiveUtils/docs/src/index.md index 5ee8e57adc848..d0c46676127e6 100644 --- a/stdlib/InteractiveUtils/docs/src/index.md +++ b/stdlib/InteractiveUtils/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/InteractiveUtils/docs/src/index.md" +``` + # [Interactive Utilities](@id man-interactive-utils) This module is intended for interactive work. It is loaded automatically in [interactive mode](@ref command-line-interface). diff --git a/stdlib/LibGit2/docs/src/index.md b/stdlib/LibGit2/docs/src/index.md index 3205c4c5d6987..aa4ebf2e784b6 100644 --- a/stdlib/LibGit2/docs/src/index.md +++ b/stdlib/LibGit2/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/LibGit2/docs/src/index.md" +``` + # LibGit2 The LibGit2 module provides bindings to [libgit2](https://libgit2.org/), a portable C library that diff --git a/stdlib/Libdl/docs/src/index.md b/stdlib/Libdl/docs/src/index.md index 62f9837831d55..608562cfb410d 100644 --- a/stdlib/Libdl/docs/src/index.md +++ b/stdlib/Libdl/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Libdl/docs/src/index.md" +``` + # Dynamic Linker ```@docs diff --git a/stdlib/LinearAlgebra/docs/src/index.md b/stdlib/LinearAlgebra/docs/src/index.md index 00ce21ed6fcae..d603b983ed401 100644 --- a/stdlib/LinearAlgebra/docs/src/index.md +++ b/stdlib/LinearAlgebra/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/LinearAlgebra/docs/src/index.md" +``` + # [Linear Algebra](@id man-linalg) ```@meta diff --git a/stdlib/Logging/docs/src/index.md b/stdlib/Logging/docs/src/index.md index 9a269ee54571b..d42f02f7c5ea7 100644 --- a/stdlib/Logging/docs/src/index.md +++ b/stdlib/Logging/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Logging/docs/src/index.md" +``` + # [Logging](@id man-logging) The [`Logging`](@ref Logging.Logging) module provides a way to record the history and progress of a diff --git a/stdlib/Markdown/docs/src/index.md b/stdlib/Markdown/docs/src/index.md index a107929d1e838..6147c4fe19a93 100644 --- a/stdlib/Markdown/docs/src/index.md +++ b/stdlib/Markdown/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Markdown/docs/src/index.md" +``` + # [Markdown](@id markdown_stdlib) This section describes Julia's markdown syntax, which is enabled by the diff --git a/stdlib/Mmap/docs/src/index.md b/stdlib/Mmap/docs/src/index.md index 5c40f11db4a4c..5ec2d5064eaf0 100644 --- a/stdlib/Mmap/docs/src/index.md +++ b/stdlib/Mmap/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Mmap/docs/src/index.md" +``` + # Memory-mapped I/O Low level module for mmap (memory mapping of files). diff --git a/stdlib/Printf/docs/src/index.md b/stdlib/Printf/docs/src/index.md index 48e38e2b2ce5b..f56fe04b75224 100644 --- a/stdlib/Printf/docs/src/index.md +++ b/stdlib/Printf/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Printf/docs/src/index.md" +``` + # [Printf](@id man-printf) ```@docs diff --git a/stdlib/Profile/docs/src/index.md b/stdlib/Profile/docs/src/index.md index adb91cebb8c46..85a8452ab06df 100644 --- a/stdlib/Profile/docs/src/index.md +++ b/stdlib/Profile/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Profile/docs/src/index.md" +``` + # [Profiling](@id lib-profiling) ## CPU Profiling diff --git a/stdlib/REPL/docs/src/index.md b/stdlib/REPL/docs/src/index.md index ce594d55863bc..9f2611e24d740 100644 --- a/stdlib/REPL/docs/src/index.md +++ b/stdlib/REPL/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/REPL/docs/src/index.md" +``` + # The Julia REPL Julia comes with a full-featured interactive command-line REPL (read-eval-print loop) built into diff --git a/stdlib/Random/docs/src/index.md b/stdlib/Random/docs/src/index.md index e344e47947440..f54cc5cd235a5 100644 --- a/stdlib/Random/docs/src/index.md +++ b/stdlib/Random/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Random/docs/src/index.md" +``` + # Random Numbers ```@meta diff --git a/stdlib/Serialization/docs/src/index.md b/stdlib/Serialization/docs/src/index.md index 9f593a2e807d9..0d00e47ed84ce 100644 --- a/stdlib/Serialization/docs/src/index.md +++ b/stdlib/Serialization/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Serialization/docs/src/index.md" +``` + # Serialization Provides serialization of Julia objects. diff --git a/stdlib/SharedArrays/docs/src/index.md b/stdlib/SharedArrays/docs/src/index.md index 67ceabf42115a..91ef63bf18aed 100644 --- a/stdlib/SharedArrays/docs/src/index.md +++ b/stdlib/SharedArrays/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/SharedArrays/docs/src/index.md" +``` + # Shared Arrays `SharedArray` represents an array, which is shared across multiple processes, on a single machine. diff --git a/stdlib/Sockets/docs/src/index.md b/stdlib/Sockets/docs/src/index.md index c294461151d7d..feb1744179261 100644 --- a/stdlib/Sockets/docs/src/index.md +++ b/stdlib/Sockets/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Sockets/docs/src/index.md" +``` + # Sockets ```@docs diff --git a/stdlib/TOML/docs/src/index.md b/stdlib/TOML/docs/src/index.md index 36e8ec6248108..364ee808d0a51 100644 --- a/stdlib/TOML/docs/src/index.md +++ b/stdlib/TOML/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/TOML/docs/src/index.md" +``` + # TOML TOML.jl is a Julia standard library for parsing and writing [TOML diff --git a/stdlib/Test/docs/src/index.md b/stdlib/Test/docs/src/index.md index 1c9a55480d2c9..2de9cb239da02 100644 --- a/stdlib/Test/docs/src/index.md +++ b/stdlib/Test/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Test/docs/src/index.md" +``` + # Unit Testing ```@meta diff --git a/stdlib/UUIDs/docs/src/index.md b/stdlib/UUIDs/docs/src/index.md index 1e6c950dd8999..c9529a4a38170 100644 --- a/stdlib/UUIDs/docs/src/index.md +++ b/stdlib/UUIDs/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/UUIDs/docs/src/index.md" +``` + # UUIDs ```@docs diff --git a/stdlib/Unicode/docs/src/index.md b/stdlib/Unicode/docs/src/index.md index 2771c8a9f01cc..52aca55ab76ae 100644 --- a/stdlib/Unicode/docs/src/index.md +++ b/stdlib/Unicode/docs/src/index.md @@ -1,3 +1,7 @@ +```@meta +EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Unicode/docs/src/index.md" +``` + # Unicode ```@docs From 4f3a3ae705a12a397b8d1c5f574baa6e7dcb9a6c Mon Sep 17 00:00:00 2001 From: Diogo Netto <61364108+d-netto@users.noreply.github.com> Date: Tue, 23 Jan 2024 09:20:08 -0300 Subject: [PATCH 23/42] place work-stealing queue indices on different cache lines to avoid false-sharing (#52994) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit For some reason this only shows up in the `many_refs.jl` benchmark, since it's the only one that hammers the work-stealing queue (we also didn't test this benchmark on a large number of GC threads in our [previous analysis](https://github.com/JuliaLang/julia/pull/48600#issuecomment-1518944785)). - master: ``` bench = "many_refs.jl" (gcthreads, threads) = (1, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 4268 │ 3243 │ 3048 │ 194 │ 1126 │ 15 │ 868 │ 76 │ │ median │ 4270 │ 3246 │ 3051 │ 195 │ 1128 │ 17 │ 868 │ 76 │ │ maximum │ 4278 │ 3247 │ 3052 │ 195 │ 1128 │ 18 │ 868 │ 76 │ │ stdev │ 5 │ 2 │ 2 │ 0 │ 1 │ 1 │ 0 │ 0 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ (gcthreads, threads) = (2, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 2728 │ 1692 │ 1551 │ 141 │ 598 │ 23 │ 868 │ 62 │ │ median │ 2732 │ 1709 │ 1567 │ 141 │ 603 │ 23 │ 868 │ 62 │ │ maximum │ 2744 │ 1712 │ 1571 │ 143 │ 607 │ 24 │ 868 │ 63 │ │ stdev │ 6 │ 9 │ 9 │ 1 │ 4 │ 0 │ 0 │ 0 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ (gcthreads, threads) = (4, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 2105 │ 1082 │ 987 │ 95 │ 405 │ 23 │ 875 │ 51 │ │ median │ 2115 │ 1089 │ 994 │ 95 │ 409 │ 23 │ 875 │ 52 │ │ maximum │ 2127 │ 1100 │ 1003 │ 97 │ 417 │ 25 │ 875 │ 52 │ │ stdev │ 8 │ 8 │ 7 │ 1 │ 5 │ 1 │ 0 │ 0 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ (gcthreads, threads) = (8, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 3861 │ 2755 │ 2676 │ 79 │ 1301 │ 22 │ 878 │ 68 │ │ median │ 3864 │ 2835 │ 2756 │ 80 │ 1342 │ 25 │ 879 │ 73 │ │ maximum │ 4032 │ 2877 │ 2797 │ 80 │ 1378 │ 26 │ 880 │ 74 │ │ stdev │ 73 │ 45 │ 45 │ 1 │ 28 │ 2 │ 1 │ 2 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ (gcthreads, threads) = (16, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 7455 │ 6425 │ 6344 │ 80 │ 3262 │ 24 │ 882 │ 86 │ │ median │ 7703 │ 6682 │ 6602 │ 81 │ 3313 │ 25 │ 884 │ 87 │ │ maximum │ 7826 │ 6806 │ 6725 │ 81 │ 3422 │ 27 │ 887 │ 87 │ │ stdev │ 152 │ 153 │ 153 │ 0 │ 68 │ 1 │ 2 │ 0 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ ``` - PR: ``` bench = "many_refs.jl" (gcthreads, threads) = (1, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 4264 │ 3240 │ 3048 │ 192 │ 1127 │ 15 │ 868 │ 76 │ │ median │ 4271 │ 3244 │ 3052 │ 192 │ 1129 │ 17 │ 868 │ 76 │ │ maximum │ 4514 │ 3481 │ 3289 │ 193 │ 1247 │ 18 │ 868 │ 77 │ │ stdev │ 109 │ 106 │ 106 │ 0 │ 53 │ 1 │ 0 │ 1 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ (gcthreads, threads) = (2, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 2712 │ 1680 │ 1541 │ 138 │ 591 │ 22 │ 868 │ 62 │ │ median │ 2713 │ 1691 │ 1552 │ 140 │ 594 │ 24 │ 868 │ 62 │ │ maximum │ 2732 │ 1710 │ 1569 │ 141 │ 606 │ 25 │ 868 │ 63 │ │ stdev │ 11 │ 12 │ 12 │ 1 │ 6 │ 1 │ 0 │ 0 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ (gcthreads, threads) = (4, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 2090 │ 1057 │ 962 │ 95 │ 398 │ 22 │ 874 │ 50 │ │ median │ 2103 │ 1070 │ 974 │ 95 │ 401 │ 24 │ 874 │ 51 │ │ maximum │ 2140 │ 1074 │ 978 │ 96 │ 402 │ 25 │ 875 │ 51 │ │ stdev │ 19 │ 6 │ 6 │ 0 │ 1 │ 1 │ 1 │ 1 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ (gcthreads, threads) = (8, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 2236 │ 1208 │ 1129 │ 79 │ 528 │ 23 │ 880 │ 54 │ │ median │ 2238 │ 1214 │ 1135 │ 79 │ 533 │ 23 │ 880 │ 54 │ │ maximum │ 2246 │ 1218 │ 1138 │ 80 │ 534 │ 35 │ 880 │ 54 │ │ stdev │ 4 │ 4 │ 4 │ 0 │ 3 │ 5 │ 0 │ 0 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ (gcthreads, threads) = (16, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 2326 │ 1297 │ 1216 │ 80 │ 595 │ 24 │ 884 │ 56 │ │ median │ 2348 │ 1325 │ 1245 │ 80 │ 620 │ 25 │ 885 │ 56 │ │ maximum │ 2370 │ 1341 │ 1262 │ 81 │ 631 │ 26 │ 887 │ 57 │ │ stdev │ 17 │ 19 │ 19 │ 0 │ 14 │ 1 │ 1 │ 0 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ ``` (cherry picked from commit 9f36490f02e92302d93e9f993cadbde04c104f9c) --- src/work-stealing-queue.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/work-stealing-queue.h b/src/work-stealing-queue.h index 38429e02886e9..084e421fd58b3 100644 --- a/src/work-stealing-queue.h +++ b/src/work-stealing-queue.h @@ -36,7 +36,8 @@ static inline ws_array_t *create_ws_array(size_t capacity, int32_t eltsz) JL_NOT typedef struct { _Atomic(int64_t) top; - _Atomic(int64_t) bottom; + char _padding[128 - sizeof(int64_t)]; + _Atomic(int64_t) bottom; // put on a separate cache line. conservatively estimate cache line size as 128 bytes _Atomic(ws_array_t *) array; } ws_queue_t; From 8517eb343c62ec1b8856aed8cdee1ccc9ef584ca Mon Sep 17 00:00:00 2001 From: Jishnu Bhattacharya Date: Tue, 23 Jan 2024 20:10:41 +0530 Subject: [PATCH 24/42] Add type assertion in iterate for logicalindex (#53015) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The type-assertion helps convey the information that `iterate(tail(s)...)` would never return `nothing`, which makes JET happy. On master ```julia julia> L = Base.LogicalIndex([true]) 1-element Base.LogicalIndex{Int64, Vector{Bool}}: 1 julia> @report_call iterate(L) ═════ 2 possible errors found ═════ ┌ iterate(L::Base.LogicalIndex{Int64, Vector{Bool}}) @ Base ./multidimensional.jl:778 │┌ iterate(L::Base.LogicalIndex{Int64, Vector{Bool}}, s::Tuple{Int64, LinearIndices{1, Tuple{Base.OneTo{Int64}}}}) @ Base ./multidimensional.jl:789 ││┌ indexed_iterate(I::Nothing, i::Int64) @ Base ./tuple.jl:94 │││ no matching method found `iterate(::Nothing)`: x = iterate(I::Nothing) ││└──────────────────── ││┌ indexed_iterate(I::Nothing, i::Int64, state::Int64) @ Base ./tuple.jl:99 │││ no matching method found `iterate(::Nothing, ::Int64)`: x = iterate(I::Nothing, state::Int64) ``` This PR ```julia julia> @report_call iterate(L) No errors detected ``` Close https://github.com/JuliaArrays/StaticArrays.jl/issues/1225 (cherry picked from commit 32ad80bbdb6d80589e0232221dd66e52a8da205b) --- base/multidimensional.jl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/base/multidimensional.jl b/base/multidimensional.jl index 02f2075919fbd..050e1503d2e58 100644 --- a/base/multidimensional.jl +++ b/base/multidimensional.jl @@ -810,11 +810,11 @@ end n = s[1] n > length(L) && return nothing #unroll once to help inference, cf issue #29418 - idx, i = iterate(tail(s)...) + idx, i = iterate(tail(s)...)::Tuple{Any,Any} s = (n+1, s[2], i) L.mask[idx] && return (idx, s) while true - idx, i = iterate(tail(s)...) + idx, i = iterate(tail(s)...)::Tuple{Any,Any} s = (n+1, s[2], i) L.mask[idx] && return (idx, s) end From fa85fa786c7964a674d0daf8a04b179de7a0cebf Mon Sep 17 00:00:00 2001 From: Max Horn Date: Wed, 24 Jan 2024 13:31:28 +0100 Subject: [PATCH 25/42] Fix a list in GC devdocs (#53032) When splitting a Markdown list item into multiple lines, the following lines must be indented or else a new paragraph starts. (cherry picked from commit 35c0498ceb1668fbc05ff5ae24ac1e696fdfa6a5) --- doc/src/devdocs/gc.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/src/devdocs/gc.md b/doc/src/devdocs/gc.md index d11fafe744f14..0a788f326d69a 100644 --- a/doc/src/devdocs/gc.md +++ b/doc/src/devdocs/gc.md @@ -26,10 +26,10 @@ Julia's pool allocator follows a "tiered" allocation discipline. When requesting - If it failed claiming a page from `page_pool_lazily_freed`, it will try to claim a page from `the page_pool_clean`, which contains pages which were mmaped on a previous page allocation request but never accessed. - If it failed claiming a page from `pool_page_clean` and from `page_pool_lazily_freed`, it will try to claim a page -from `page_pool_freed`, which contains pages which have already been madvised by a concurrent sweeper GC thread and whose underlying virtual address can be recycled. + from `page_pool_freed`, which contains pages which have already been madvised by a concurrent sweeper GC thread and whose underlying virtual address can be recycled. - If it failed in all of the attempts mentioned above, it will mmap a batch of pages, claim one page for itself, and -insert the remaining pages into `page_pool_clean`. + insert the remaining pages into `page_pool_clean`. ![Diagram of tiered pool allocation](./img/gc-tiered-allocation.jpg) From a4cc9205e8391f49d4e4b65e86b2178a7c64912c Mon Sep 17 00:00:00 2001 From: Jameson Nash Date: Wed, 13 Sep 2023 17:36:11 -0400 Subject: [PATCH 26/42] make "dec" and ryu functions faster and simpler (#51273) We had some common code in `Ryu.append_c_digits` that can be combined with Base logic for the same thing. But it turns out all of this duplicated code in Ryu seems to just make it run slightly slower in most cases. The old version had many more branches to check, even though often numbers are small, so only the last check is meaningful. But the assumption that it would be faster even if all of them were used also seems to not hold up in practice. Particularly for a function like `append_nine_digits` which unrolls completely, but the complicated version has slightly more data dependencies because of they way it is written. Similarly, we replace `unsafe_copy` with `@inbounds[]`, since this is better for the optimizer, which doesn't need to treat this operation as an unknown reference escape. Lastly, we use the append_nine_digits trick from Ryu to make printing of arbitrary big numbers much faster. ``` julia> @btime string(typemax(Int128)) 402.345 ns (2 allocations: 120 bytes) # before 151.139 ns (2 allocations: 120 bytes) # after ``` (cherry picked from commit e9d931419c54c21f749bcac0991fc9f5a059d4aa) --- base/intfuncs.jl | 86 ++++++++++++++---- base/ryu/exp.jl | 70 ++++++++------- base/ryu/fixed.jl | 2 +- base/ryu/shortest.jl | 209 ++++++++++++++++++------------------------- base/ryu/utils.jl | 118 +++--------------------- 5 files changed, 200 insertions(+), 285 deletions(-) diff --git a/base/intfuncs.jl b/base/intfuncs.jl index 1b007700f4331..90dc393a0e9b4 100644 --- a/base/intfuncs.jl +++ b/base/intfuncs.jl @@ -558,7 +558,7 @@ function bit_ndigits0z(x::Base.BitUnsigned64) end function bit_ndigits0z(x::UInt128) n = 0 - while x > 0x8ac7230489e80000 + while x > 0x8ac7230489e80000 # 10e18 x = div(x,0x8ac7230489e80000) n += 19 end @@ -724,7 +724,7 @@ function bin(x::Unsigned, pad::Int, neg::Bool) x >>= 0x1 i -= 1 end - if neg; @inbounds a[1]=0x2d; end + neg && (@inbounds a[1] = 0x2d) # UInt8('-') String(a) end @@ -738,29 +738,77 @@ function oct(x::Unsigned, pad::Int, neg::Bool) x >>= 0x3 i -= 1 end - if neg; @inbounds a[1]=0x2d; end + neg && (@inbounds a[1] = 0x2d) # UInt8('-') String(a) end # 2-digit decimal characters ("00":"99") -const _dec_d100 = UInt16[(0x30 + i % 10) << 0x8 + (0x30 + i ÷ 10) for i = 0:99] +const _dec_d100 = UInt16[ +# generating expression: UInt16[(0x30 + i % 10) << 0x8 + (0x30 + i ÷ 10) for i = 0:99] +# 0 0, 0 1, 0 2, 0 3, and so on in little-endian + 0x3030, 0x3130, 0x3230, 0x3330, 0x3430, 0x3530, 0x3630, 0x3730, 0x3830, 0x3930, + 0x3031, 0x3131, 0x3231, 0x3331, 0x3431, 0x3531, 0x3631, 0x3731, 0x3831, 0x3931, + 0x3032, 0x3132, 0x3232, 0x3332, 0x3432, 0x3532, 0x3632, 0x3732, 0x3832, 0x3932, + 0x3033, 0x3133, 0x3233, 0x3333, 0x3433, 0x3533, 0x3633, 0x3733, 0x3833, 0x3933, + 0x3034, 0x3134, 0x3234, 0x3334, 0x3434, 0x3534, 0x3634, 0x3734, 0x3834, 0x3934, + 0x3035, 0x3135, 0x3235, 0x3335, 0x3435, 0x3535, 0x3635, 0x3735, 0x3835, 0x3935, + 0x3036, 0x3136, 0x3236, 0x3336, 0x3436, 0x3536, 0x3636, 0x3736, 0x3836, 0x3936, + 0x3037, 0x3137, 0x3237, 0x3337, 0x3437, 0x3537, 0x3637, 0x3737, 0x3837, 0x3937, + 0x3038, 0x3138, 0x3238, 0x3338, 0x3438, 0x3538, 0x3638, 0x3738, 0x3838, 0x3938, + 0x3039, 0x3139, 0x3239, 0x3339, 0x3439, 0x3539, 0x3639, 0x3739, 0x3839, 0x3939 +] -function dec(x::Unsigned, pad::Int, neg::Bool) - n = neg + ndigits(x, pad=pad) - a = StringVector(n) - i = n - @inbounds while i >= 2 - d, r = divrem(x, 0x64) - d100 = _dec_d100[(r % Int)::Int + 1] - a[i-1] = d100 % UInt8 - a[i] = (d100 >> 0x8) % UInt8 - x = oftype(x, d) +function append_c_digits(olength::Int, digits::Unsigned, buf, pos::Int) + i = olength + while i >= 2 + d, c = divrem(digits, 0x64) + digits = oftype(digits, d) + @inbounds d100 = _dec_d100[(c % Int) + 1] + @inbounds buf[pos + i - 2] = d100 % UInt8 + @inbounds buf[pos + i - 1] = (d100 >> 0x8) % UInt8 i -= 2 end - if i > neg - @inbounds a[i] = 0x30 + (rem(x, 0xa) % UInt8)::UInt8 + if i == 1 + @inbounds buf[pos] = UInt8('0') + rem(digits, 0xa) % UInt8 + i -= 1 end - if neg; @inbounds a[1]=0x2d; end + return pos + olength +end + +function append_nine_digits(digits::Unsigned, buf, pos::Int) + if digits == 0 + for _ = 1:9 + @inbounds buf[pos] = UInt8('0') + pos += 1 + end + return pos + end + return @inline append_c_digits(9, digits, buf, pos) # force loop-unrolling on the length +end + +function append_c_digits_fast(olength::Int, digits::Unsigned, buf, pos::Int) + i = olength + # n.b. olength may be larger than required to print all of `digits` (and will be padded + # with zeros), but the printed number will be undefined if it is smaller, and may include + # bits of both the high and low bytes. + maxpow10 = 0x3b9aca00 # 10e9 as UInt32 + while i > 9 && digits > typemax(UInt) + # do everything in cheap math chunks, using the processor's native math size + d, c = divrem(digits, maxpow10) + digits = oftype(digits, d) + append_nine_digits(c % UInt32, buf, pos + i - 9) + i -= 9 + end + append_c_digits(i, digits % UInt, buf, pos) + return pos + olength +end + + +function dec(x::Unsigned, pad::Int, neg::Bool) + n = neg + ndigits(x, pad=pad) + a = StringVector(n) + append_c_digits_fast(n, x, a, 1) + neg && (@inbounds a[1] = 0x2d) # UInt8('-') String(a) end @@ -781,7 +829,7 @@ function hex(x::Unsigned, pad::Int, neg::Bool) d = (x % UInt8)::UInt8 & 0xf @inbounds a[i] = d + ifelse(d > 0x9, 0x57, 0x30) end - if neg; @inbounds a[1]=0x2d; end + neg && (@inbounds a[1] = 0x2d) # UInt8('-') String(a) end @@ -806,7 +854,7 @@ function _base(base::Integer, x::Integer, pad::Int, neg::Bool) end i -= 1 end - if neg; @inbounds a[1]=0x2d; end + neg && (@inbounds a[1] = 0x2d) # UInt8('-') String(a) end diff --git a/base/ryu/exp.jl b/base/ryu/exp.jl index 90c6869f8847f..b38b2c7ae9a29 100644 --- a/base/ryu/exp.jl +++ b/base/ryu/exp.jl @@ -8,33 +8,33 @@ function writeexp(buf, pos, v::T, # special cases if x == 0 - buf[pos] = UInt8('0') + @inbounds buf[pos] = UInt8('0') pos += 1 if precision > 0 && !trimtrailingzeros - buf[pos] = decchar + @inbounds buf[pos] = decchar pos += 1 for _ = 1:precision - buf[pos] = UInt8('0') + @inbounds buf[pos] = UInt8('0') pos += 1 end elseif hash - buf[pos] = decchar + @inbounds buf[pos] = decchar pos += 1 end - buf[pos] = expchar - buf[pos + 1] = UInt8('+') - buf[pos + 2] = UInt8('0') - buf[pos + 3] = UInt8('0') + @inbounds buf[pos] = expchar + @inbounds buf[pos + 1] = UInt8('+') + @inbounds buf[pos + 2] = UInt8('0') + @inbounds buf[pos + 3] = UInt8('0') return pos + 4 elseif isnan(x) - buf[pos] = UInt8('N') - buf[pos + 1] = UInt8('a') - buf[pos + 2] = UInt8('N') + @inbounds buf[pos] = UInt8('N') + @inbounds buf[pos + 1] = UInt8('a') + @inbounds buf[pos + 2] = UInt8('N') return pos + 3 elseif !isfinite(x) - buf[pos] = UInt8('I') - buf[pos + 1] = UInt8('n') - buf[pos + 2] = UInt8('f') + @inbounds buf[pos] = UInt8('I') + @inbounds buf[pos + 1] = UInt8('n') + @inbounds buf[pos + 2] = UInt8('f') return pos + 3 end @@ -80,10 +80,10 @@ function writeexp(buf, pos, v::T, if precision > 1 pos = append_d_digits(availableDigits, digits, buf, pos, decchar) else - buf[pos] = UInt8('0') + digits + @inbounds buf[pos] = UInt8('0') + digits pos += 1 if hash - buf[pos] = decchar + @inbounds buf[pos] = decchar pos += 1 end end @@ -121,10 +121,10 @@ function writeexp(buf, pos, v::T, if precision > 1 pos = append_d_digits(availableDigits, digits, buf, pos, decchar) else - buf[pos] = UInt8('0') + digits + @inbounds buf[pos] = UInt8('0') + digits pos += 1 if hash - buf[pos] = decchar + @inbounds buf[pos] = decchar pos += 1 end end @@ -162,7 +162,7 @@ function writeexp(buf, pos, v::T, if printedDigits != 0 if digits == 0 for _ = 1:maximum - buf[pos] = UInt8('0') + @inbounds buf[pos] = UInt8('0') pos += 1 end else @@ -172,10 +172,10 @@ function writeexp(buf, pos, v::T, if precision > 1 pos = append_d_digits(maximum, digits, buf, pos, decchar) else - buf[pos] = UInt8('0') + digits + @inbounds buf[pos] = UInt8('0') + digits pos += 1 if hash - buf[pos] = decchar + @inbounds buf[pos] = decchar pos += 1 end end @@ -184,52 +184,56 @@ function writeexp(buf, pos, v::T, roundPos = pos while true roundPos -= 1 - if roundPos == (startpos - 1) || buf[roundPos] == UInt8('-') || (plus && buf[roundPos] == UInt8('+')) || (space && buf[roundPos] == UInt8(' ')) - buf[roundPos + 1] = UInt8('1') + if roundPos == (startpos - 1) || (@inbounds buf[roundPos]) == UInt8('-') || (plus && (@inbounds buf[roundPos]) == UInt8('+')) || (space && (@inbounds buf[roundPos]) == UInt8(' ')) + @inbounds buf[roundPos + 1] = UInt8('1') e += 1 break end - c = roundPos > 0 ? buf[roundPos] : 0x00 + c = roundPos > 0 ? (@inbounds buf[roundPos]) : 0x00 if c == decchar continue elseif c == UInt8('9') - buf[roundPos] = UInt8('0') + @inbounds buf[roundPos] = UInt8('0') roundUp = 1 continue else if roundUp == 2 && UInt8(c) % 2 == 0 break end - buf[roundPos] = c + 1 + @inbounds buf[roundPos] = c + 1 break end end end if trimtrailingzeros - while buf[pos - 1] == UInt8('0') + while @inbounds buf[pos - 1] == UInt8('0') pos -= 1 end - if buf[pos - 1] == decchar && !hash + if @inbounds buf[pos - 1] == decchar && !hash pos -= 1 end end buf[pos] = expchar pos += 1 if e < 0 - buf[pos] = UInt8('-') + @inbounds buf[pos] = UInt8('-') pos += 1 e = -e else - buf[pos] = UInt8('+') + @inbounds buf[pos] = UInt8('+') pos += 1 end if e >= 100 c = e % 10 - unsafe_copyto!(buf, pos, DIGIT_TABLE, 2 * div(e, 10) + 1, 2) - buf[pos + 2] = UInt8('0') + c + @inbounds d100 = DIGIT_TABLE16[div(e, 10) + 1] + @inbounds buf[pos] = d100 % UInt8 + @inbounds buf[pos + 1] = (d100 >> 0x8) % UInt8 + @inbounds buf[pos + 2] = UInt8('0') + c pos += 3 else - unsafe_copyto!(buf, pos, DIGIT_TABLE, 2 * e + 1, 2) + @inbounds d100 = DIGIT_TABLE16[e + 1] + @inbounds buf[pos] = d100 % UInt8 + @inbounds buf[pos + 1] = (d100 >> 0x8) % UInt8 pos += 2 end return pos diff --git a/base/ryu/fixed.jl b/base/ryu/fixed.jl index f0b96fef966f0..96777059bc284 100644 --- a/base/ryu/fixed.jl +++ b/base/ryu/fixed.jl @@ -59,7 +59,7 @@ function writefixed(buf, pos, v::T, pos = append_nine_digits(digits, buf, pos) elseif digits != 0 olength = decimallength(digits) - pos = append_n_digits(olength, digits, buf, pos) + pos = append_c_digits(olength, digits, buf, pos) nonzero = true end i -= 1 diff --git a/base/ryu/shortest.jl b/base/ryu/shortest.jl index aaa62ba33c703..32aa993467e7a 100644 --- a/base/ryu/shortest.jl +++ b/base/ryu/shortest.jl @@ -232,79 +232,79 @@ function writeshortest(buf::Vector{UInt8}, pos, x::T, # special cases if x == 0 if typed && x isa Float16 - buf[pos] = UInt8('F') - buf[pos + 1] = UInt8('l') - buf[pos + 2] = UInt8('o') - buf[pos + 3] = UInt8('a') - buf[pos + 4] = UInt8('t') - buf[pos + 5] = UInt8('1') - buf[pos + 6] = UInt8('6') - buf[pos + 7] = UInt8('(') + @inbounds buf[pos] = UInt8('F') + @inbounds buf[pos + 1] = UInt8('l') + @inbounds buf[pos + 2] = UInt8('o') + @inbounds buf[pos + 3] = UInt8('a') + @inbounds buf[pos + 4] = UInt8('t') + @inbounds buf[pos + 5] = UInt8('1') + @inbounds buf[pos + 6] = UInt8('6') + @inbounds buf[pos + 7] = UInt8('(') pos += 8 end pos = append_sign(x, plus, space, buf, pos) - buf[pos] = UInt8('0') + @inbounds buf[pos] = UInt8('0') pos += 1 if hash - buf[pos] = decchar + @inbounds buf[pos] = decchar pos += 1 end if precision == -1 - buf[pos] = UInt8('0') + @inbounds buf[pos] = UInt8('0') pos += 1 if typed && x isa Float32 - buf[pos] = UInt8('f') - buf[pos + 1] = UInt8('0') + @inbounds buf[pos] = UInt8('f') + @inbounds buf[pos + 1] = UInt8('0') pos += 2 end if typed && x isa Float16 - buf[pos] = UInt8(')') + @inbounds buf[pos] = UInt8(')') pos += 1 end return pos end while hash && precision > 1 - buf[pos] = UInt8('0') + @inbounds buf[pos] = UInt8('0') pos += 1 precision -= 1 end if typed && x isa Float32 - buf[pos] = UInt8('f') - buf[pos + 1] = UInt8('0') + @inbounds buf[pos] = UInt8('f') + @inbounds buf[pos + 1] = UInt8('0') pos += 2 end if typed && x isa Float16 - buf[pos] = UInt8(')') + @inbounds buf[pos] = UInt8(')') pos += 1 end return pos elseif isnan(x) pos = append_sign(x, plus, space, buf, pos) - buf[pos] = UInt8('N') - buf[pos + 1] = UInt8('a') - buf[pos + 2] = UInt8('N') + @inbounds buf[pos] = UInt8('N') + @inbounds buf[pos + 1] = UInt8('a') + @inbounds buf[pos + 2] = UInt8('N') if typed if x isa Float32 - buf[pos + 3] = UInt8('3') - buf[pos + 4] = UInt8('2') + @inbounds buf[pos + 3] = UInt8('3') + @inbounds buf[pos + 4] = UInt8('2') elseif x isa Float16 - buf[pos + 3] = UInt8('1') - buf[pos + 4] = UInt8('6') + @inbounds buf[pos + 3] = UInt8('1') + @inbounds buf[pos + 4] = UInt8('6') end end return pos + 3 + (typed && x isa Union{Float32, Float16} ? 2 : 0) elseif !isfinite(x) pos = append_sign(x, plus, space, buf, pos) - buf[pos] = UInt8('I') - buf[pos + 1] = UInt8('n') - buf[pos + 2] = UInt8('f') + @inbounds buf[pos] = UInt8('I') + @inbounds buf[pos + 1] = UInt8('n') + @inbounds buf[pos + 2] = UInt8('f') if typed if x isa Float32 - buf[pos + 3] = UInt8('3') - buf[pos + 4] = UInt8('2') + @inbounds buf[pos + 3] = UInt8('3') + @inbounds buf[pos + 4] = UInt8('2') elseif x isa Float16 - buf[pos + 3] = UInt8('1') - buf[pos + 4] = UInt8('6') + @inbounds buf[pos + 3] = UInt8('1') + @inbounds buf[pos + 4] = UInt8('6') end end return pos + 3 + (typed && x isa Union{Float32, Float16} ? 2 : 0) @@ -313,14 +313,14 @@ function writeshortest(buf::Vector{UInt8}, pos, x::T, output, nexp = reduce_shortest(x, compact ? 999_999 : nothing) if typed && x isa Float16 - buf[pos] = UInt8('F') - buf[pos + 1] = UInt8('l') - buf[pos + 2] = UInt8('o') - buf[pos + 3] = UInt8('a') - buf[pos + 4] = UInt8('t') - buf[pos + 5] = UInt8('1') - buf[pos + 6] = UInt8('6') - buf[pos + 7] = UInt8('(') + @inbounds buf[pos] = UInt8('F') + @inbounds buf[pos + 1] = UInt8('l') + @inbounds buf[pos + 2] = UInt8('o') + @inbounds buf[pos + 3] = UInt8('a') + @inbounds buf[pos + 4] = UInt8('t') + @inbounds buf[pos + 5] = UInt8('1') + @inbounds buf[pos + 6] = UInt8('6') + @inbounds buf[pos + 7] = UInt8('(') pos += 8 end pos = append_sign(x, plus, space, buf, pos) @@ -332,161 +332,122 @@ function writeshortest(buf::Vector{UInt8}, pos, x::T, !(pt >= olength && abs(mod(x + 0.05, 10^(pt - olength)) - 0.05) > 0.05) exp_form = false if pt <= 0 - buf[pos] = UInt8('0') + @inbounds buf[pos] = UInt8('0') pos += 1 - buf[pos] = decchar + @inbounds buf[pos] = decchar pos += 1 for _ = 1:abs(pt) - buf[pos] = UInt8('0') + @inbounds buf[pos] = UInt8('0') pos += 1 end - # elseif pt >= olength + # elseif pt >= olength # nothing to do at this point - # else + # else # nothing to do at this point end else + # make space for decchar pos += 1 end - i = 0 - ptr = pointer(buf) - ptr2 = pointer(DIGIT_TABLE) - if (output >> 32) != 0 - q = output ÷ 100000000 - output2 = (output % UInt32) - UInt32(100000000) * (q % UInt32) - output = q - c = output2 % UInt32(10000) - output2 = div(output2, UInt32(10000)) - d = output2 % UInt32(10000) - c0 = (c % 100) << 1 - c1 = (c ÷ 100) << 1 - d0 = (d % 100) << 1 - d1 = (d ÷ 100) << 1 - memcpy(ptr + pos + olength - 3, ptr2 + c0, 2) - memcpy(ptr + pos + olength - 5, ptr2 + c1, 2) - memcpy(ptr + pos + olength - 7, ptr2 + d0, 2) - memcpy(ptr + pos + olength - 9, ptr2 + d1, 2) - i += 8 - end - output2 = output % UInt32 - while output2 >= 10000 - c = output2 % UInt32(10000) - output2 = div(output2, UInt32(10000)) - c0 = (c % 100) << 1 - c1 = (c ÷ 100) << 1 - memcpy(ptr + pos + olength - i - 3, ptr2 + c0, 2) - memcpy(ptr + pos + olength - i - 5, ptr2 + c1, 2) - i += 4 - end - if output2 >= 100 - c = (output2 % UInt32(100)) << 1 - output2 = div(output2, UInt32(100)) - memcpy(ptr + pos + olength - i - 3, ptr2 + c, 2) - i += 2 - end - if output2 >= 10 - c = output2 << 1 - buf[pos + 1] = DIGIT_TABLE[c + 2] - buf[pos - exp_form] = DIGIT_TABLE[c + 1] - else - buf[pos - exp_form] = UInt8('0') + (output2 % UInt8) - end + append_c_digits(olength, output, buf, pos) if !exp_form if pt <= 0 pos += olength precision -= olength - while hash && precision > 0 - buf[pos] = UInt8('0') - pos += 1 - precision -= 1 - end elseif pt >= olength pos += olength precision -= olength for _ = 1:nexp - buf[pos] = UInt8('0') + @inbounds buf[pos] = UInt8('0') pos += 1 precision -= 1 end if hash - buf[pos] = decchar + @inbounds buf[pos] = decchar pos += 1 if precision < 0 - buf[pos] = UInt8('0') + @inbounds buf[pos] = UInt8('0') pos += 1 end - while precision > 0 - buf[pos] = UInt8('0') - pos += 1 - precision -= 1 - end end else pointoff = olength - abs(nexp) + # shift bytes after pointoff to make room for decchar + ptr = pointer(buf) memmove(ptr + pos + pointoff, ptr + pos + pointoff - 1, olength - pointoff + 1) - buf[pos + pointoff] = decchar + @inbounds buf[pos + pointoff] = decchar pos += olength + 1 precision -= olength - while hash && precision > 0 - buf[pos] = UInt8('0') + end + if hash + while precision > 0 + @inbounds buf[pos] = UInt8('0') pos += 1 precision -= 1 end end if typed && x isa Float32 - buf[pos] = UInt8('f') - buf[pos + 1] = UInt8('0') + @inbounds buf[pos] = UInt8('f') + @inbounds buf[pos + 1] = UInt8('0') pos += 2 end else + # move leading digit into place + @inbounds buf[pos - 1] = buf[pos] if olength > 1 || hash - buf[pos] = decchar + @inbounds buf[pos] = decchar pos += olength precision -= olength end - if hash && olength == 1 - buf[pos] = UInt8('0') - pos += 1 - end - while hash && precision > 0 - buf[pos] = UInt8('0') - pos += 1 - precision -= 1 + if hash + if olength == 1 + @inbounds buf[pos] = UInt8('0') + pos += 1 + end + while precision > 0 + @inbounds buf[pos] = UInt8('0') + pos += 1 + precision -= 1 + end end - buf[pos] = expchar + @inbounds buf[pos] = expchar pos += 1 exp2 = nexp + olength - 1 if exp2 < 0 - buf[pos] = UInt8('-') + @inbounds buf[pos] = UInt8('-') pos += 1 exp2 = -exp2 elseif padexp - buf[pos] = UInt8('+') + @inbounds buf[pos] = UInt8('+') pos += 1 end if exp2 >= 100 c = exp2 % 10 - memcpy(ptr + pos - 1, ptr2 + 2 * div(exp2, 10), 2) - buf[pos + 2] = UInt8('0') + (c % UInt8) + @inbounds d100 = DIGIT_TABLE16[(div(exp2, 10) % Int) + 1] + @inbounds buf[pos] = d100 % UInt8 + @inbounds buf[pos + 1] = (d100 >> 0x8) % UInt8 + @inbounds buf[pos + 2] = UInt8('0') + (c % UInt8) pos += 3 elseif exp2 >= 10 - memcpy(ptr + pos - 1, ptr2 + 2 * exp2, 2) + @inbounds d100 = DIGIT_TABLE16[(exp2 % Int) + 1] + @inbounds buf[pos] = d100 % UInt8 + @inbounds buf[pos + 1] = (d100 >> 0x8) % UInt8 pos += 2 else if padexp - buf[pos] = UInt8('0') + @inbounds buf[pos] = UInt8('0') pos += 1 end - buf[pos] = UInt8('0') + (exp2 % UInt8) + @inbounds buf[pos] = UInt8('0') + (exp2 % UInt8) pos += 1 end end if typed && x isa Float16 - buf[pos] = UInt8(')') + @inbounds buf[pos] = UInt8(')') pos += 1 end diff --git a/base/ryu/utils.jl b/base/ryu/utils.jl index f5a88c057e2b3..2064dfbefcecd 100644 --- a/base/ryu/utils.jl +++ b/base/ryu/utils.jl @@ -134,7 +134,7 @@ end Compute `p = a*b` where `b = bLo + bHi<<64`, returning the result as `pLo, pHi` where `p = pLo + pHi<<128`. """ -function umul256(a, bHi, bLo) +function umul256(a::UInt128, bHi::UInt64, bLo::UInt64) aLo = a % UInt64 aHi = (a >> 64) % UInt64 @@ -164,7 +164,7 @@ end Compute `pHi = (a*b)>>128` where `b = bLo + bHi<<64`. """ -umul256_hi(a, bHi, bLo) = umul256(a, bHi, bLo)[2] +umul256_hi(a::UInt128, bHi::UInt64, bLo::UInt64) = umul256(a, bHi, bLo)[2] """ Ryu.mulshiftmod1e9(m, mula, mulb, mulc, j)::UInt32 @@ -183,7 +183,7 @@ function mulshiftmod1e9(m, mula, mulb, mulc, j) return (v % UInt32) - UInt32(1000000000) * shifted end -function append_sign(x, plus, space, buf, pos) +function append_sign(x, plus::Bool, space::Bool, buf, pos::Int) if signbit(x) && !isnan(x) # suppress minus sign for signaling NaNs buf[pos] = UInt8('-') pos += 1 @@ -197,101 +197,14 @@ function append_sign(x, plus, space, buf, pos) return pos end -function append_n_digits(olength, digits, buf, pos) - i = 0 - while digits >= 10000 - c = digits % 10000 - digits = div(digits, 10000) - c0 = (c % 100) << 1 - c1 = div(c, 100) << 1 - unsafe_copyto!(buf, pos + olength - i - 2, DIGIT_TABLE, c0 + 1, 2) - unsafe_copyto!(buf, pos + olength - i - 4, DIGIT_TABLE, c1 + 1, 2) - i += 4 - end - if digits >= 100 - c = (digits % 100) << 1 - digits = div(digits, 100) - unsafe_copyto!(buf, pos + olength - i - 2, DIGIT_TABLE, c + 1, 2) - i += 2 - end - if digits >= 10 - c = digits << 1 - unsafe_copyto!(buf, pos + olength - i - 2, DIGIT_TABLE, c + 1, 2) - i += 2 - else - buf[pos] = UInt8('0') + digits - i += 1 - end - return pos + i -end - -function append_d_digits(olength, digits, buf, pos, decchar) - i = 0 - while digits >= 10000 - c = digits % 10000 - digits = div(digits, 10000) - c0 = (c % 100) << 1 - c1 = div(c, 100) << 1 - unsafe_copyto!(buf, pos + olength + 1 - i - 2, DIGIT_TABLE, c0 + 1, 2) - unsafe_copyto!(buf, pos + olength + 1 - i - 4, DIGIT_TABLE, c1 + 1, 2) - i += 4 - end - if digits >= 100 - c = (digits % 100) << 1 - digits = div(digits, 100) - unsafe_copyto!(buf, pos + olength + 1 - i - 2, DIGIT_TABLE, c + 1, 2) - i += 2 - end - if digits >= 10 - c = digits << 1 - buf[pos] = DIGIT_TABLE[c + 1] - buf[pos + 1] = decchar - buf[pos + 2] = DIGIT_TABLE[c + 2] - i += 3 - else - buf[pos] = UInt8('0') + digits - buf[pos + 1] = decchar - i += 2 - end - return pos + i -end -function append_c_digits(count, digits, buf, pos) - i = 0 - while i < count - 1 - c = (digits % 100) << 1 - digits = div(digits, 100) - unsafe_copyto!(buf, pos + count - i - 2, DIGIT_TABLE, c + 1, 2) - i += 2 - end - if i < count - buf[pos + count - i - 1] = UInt8('0') + (digits % 10) - i += 1 - end - return pos + i -end +import Base: append_c_digits_fast as append_c_digits, append_nine_digits -function append_nine_digits(digits, buf, pos) - if digits == 0 - for _ = 1:9 - buf[pos] = UInt8('0') - pos += 1 - end - return pos - end - i = 0 - while i < 5 - c = digits % 10000 - digits = div(digits, 10000) - c0 = (c % 100) << 1 - c1 = div(c, 100) << 1 - unsafe_copyto!(buf, pos + 7 - i, DIGIT_TABLE, c0 + 1, 2) - unsafe_copyto!(buf, pos + 5 - i, DIGIT_TABLE, c1 + 1, 2) - i += 4 - end - buf[pos] = UInt8('0') + digits - i += 1 - return pos + i +function append_d_digits(olength::Int, digits::Unsigned, buf, pos::Int, decchar) + newpos = append_c_digits(olength, digits, buf, pos + 1) + @inbounds buf[pos] = buf[pos + 1] + @inbounds buf[pos + 1] = decchar + return newpos # == pos + olength + 1 end const BIG_MASK = (big(1) << 64) - 1 @@ -390,18 +303,7 @@ for T in (Float64, Float32, Float16) @eval pow5split_lookup(::Type{$T}, i) = @inbounds($table_sym[i+1]) end -const DIGIT_TABLE = UInt8[ - '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9', - '1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9', - '2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9', - '3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9', - '4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9', - '5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9', - '6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9', - '7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9', - '8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9', - '9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9' -] +const DIGIT_TABLE16 = Base._dec_d100 const POW10_OFFSET = UInt16[ 0, 2, 5, 8, 12, 16, 21, 26, 32, 39, From e0e3c63d682387adff58d0ee24b7b8c6f97f9206 Mon Sep 17 00:00:00 2001 From: "Steven G. Johnson" Date: Mon, 8 Jan 2024 08:38:11 -0500 Subject: [PATCH 27/42] fix type-stability bugs in Ryu code (#52781) Fixes #52749. (cherry picked from commit 5643c601f4c9819ed055c111a2d7d14cff6c5f7c) --- base/ryu/exp.jl | 40 +++++++++++++++++----------------- stdlib/Printf/test/runtests.jl | 3 +++ 2 files changed, 23 insertions(+), 20 deletions(-) diff --git a/base/ryu/exp.jl b/base/ryu/exp.jl index b38b2c7ae9a29..4f749668867e2 100644 --- a/base/ryu/exp.jl +++ b/base/ryu/exp.jl @@ -7,7 +7,7 @@ function writeexp(buf, pos, v::T, pos = append_sign(x, plus, space, buf, pos) # special cases - if x == 0 + if iszero(x) @inbounds buf[pos] = UInt8('0') pos += 1 if precision > 0 && !trimtrailingzeros @@ -42,7 +42,7 @@ function writeexp(buf, pos, v::T, mant = bits & MANTISSA_MASK exp = Int((bits >> 52) & EXP_MASK) - if exp == 0 + if iszero(exp) e2 = 1 - 1023 - 52 m2 = mant else @@ -51,7 +51,7 @@ function writeexp(buf, pos, v::T, end nonzero = false precision += 1 - digits = 0 + digits = zero(UInt32) printedDigits = 0 availableDigits = 0 e = 0 @@ -64,14 +64,14 @@ function writeexp(buf, pos, v::T, j = p10bits - e2 #=@inbounds=# mula, mulb, mulc = POW10_SPLIT[POW10_OFFSET[idx + 1] + i + 1] digits = mulshiftmod1e9(m2 << 8, mula, mulb, mulc, j + 8) - if printedDigits != 0 + if !iszero(printedDigits) if printedDigits + 9 > precision availableDigits = 9 break end pos = append_nine_digits(digits, buf, pos) printedDigits += 9 - elseif digits != 0 + elseif !iszero(digits) availableDigits = decimallength(digits) e = i * 9 + availableDigits - 1 if availableDigits > precision @@ -93,26 +93,26 @@ function writeexp(buf, pos, v::T, i -= 1 end end - if e2 < 0 && availableDigits == 0 + if e2 < 0 && iszero(availableDigits) idx = div(-e2, 16) - i = MIN_BLOCK_2[idx + 1] + i = Int(MIN_BLOCK_2[idx + 1]) while i < 200 j = 120 + (-e2 - 16 * idx) p = POW10_OFFSET_2[idx + 1] + i - MIN_BLOCK_2[idx + 1] if p >= POW10_OFFSET_2[idx + 2] - digits = 0 + digits = zero(UInt32) else #=@inbounds=# mula, mulb, mulc = POW10_SPLIT_2[p + 1] digits = mulshiftmod1e9(m2 << 8, mula, mulb, mulc, j + 8) end - if printedDigits != 0 + if !iszero(printedDigits) if printedDigits + 9 > precision availableDigits = 9 break end pos = append_nine_digits(digits, buf, pos) printedDigits += 9 - elseif digits != 0 + elseif !iszero(digits) availableDigits = decimallength(digits) e = -(i + 1) * 9 + availableDigits - 1 if availableDigits > precision @@ -135,14 +135,14 @@ function writeexp(buf, pos, v::T, end end maximum = precision - printedDigits - if availableDigits == 0 - digits = 0 + if iszero(availableDigits) + digits = zero(UInt32) end - lastDigit = 0 + lastDigit = zero(UInt32) if availableDigits > maximum for k = 0:(availableDigits - maximum - 1) - lastDigit = digits % 10 - digits = div(digits, 10) + lastDigit = digits % UInt32(10) + digits = div(digits, UInt32(10)) end end roundUp = 0 @@ -159,8 +159,8 @@ function writeexp(buf, pos, v::T, end roundUp = trailingZeros ? 2 : 1 end - if printedDigits != 0 - if digits == 0 + if !iszero(printedDigits) + if iszero(digits) for _ = 1:maximum @inbounds buf[pos] = UInt8('0') pos += 1 @@ -180,7 +180,7 @@ function writeexp(buf, pos, v::T, end end end - if roundUp != 0 + if !iszero(roundUp) roundPos = pos while true roundPos -= 1 @@ -197,7 +197,7 @@ function writeexp(buf, pos, v::T, roundUp = 1 continue else - if roundUp == 2 && UInt8(c) % 2 == 0 + if roundUp == 2 && iseven(c) break end @inbounds buf[roundPos] = c + 1 @@ -224,7 +224,7 @@ function writeexp(buf, pos, v::T, pos += 1 end if e >= 100 - c = e % 10 + c = (e % 10) % UInt8 @inbounds d100 = DIGIT_TABLE16[div(e, 10) + 1] @inbounds buf[pos] = d100 % UInt8 @inbounds buf[pos + 1] = (d100 >> 0x8) % UInt8 diff --git a/stdlib/Printf/test/runtests.jl b/stdlib/Printf/test/runtests.jl index 33970f78648e2..71ec369af4ef7 100644 --- a/stdlib/Printf/test/runtests.jl +++ b/stdlib/Printf/test/runtests.jl @@ -1145,4 +1145,7 @@ end @test_throws Printf.InvalidFormatStringError Printf.Format("%z") end +# issue #52749 +@test @sprintf("%.160g", 1.38e-23) == "1.380000000000000060010582465734078799297660966782642624395399644741944111814291318296454846858978271484375e-23" + end # @testset "Printf" From f371de8d76a56e59488f32f847d7bc37afc38928 Mon Sep 17 00:00:00 2001 From: Jishnu Bhattacharya Date: Wed, 27 Dec 2023 12:06:08 +0530 Subject: [PATCH 28/42] Default uplo in symmetric/hermitian (#52605) This makes the function signatures match the respective docstrings, as well as that of `Symmetric/Hermitian`. (cherry picked from commit b4eefd0f8afe91fb8e68c79f1a6615de25005529) --- stdlib/LinearAlgebra/src/symmetric.jl | 8 ++++---- stdlib/LinearAlgebra/test/symmetric.jl | 12 ++++++++++-- 2 files changed, 14 insertions(+), 6 deletions(-) diff --git a/stdlib/LinearAlgebra/src/symmetric.jl b/stdlib/LinearAlgebra/src/symmetric.jl index 40e37f7bec22c..3cc146d0bd29d 100644 --- a/stdlib/LinearAlgebra/src/symmetric.jl +++ b/stdlib/LinearAlgebra/src/symmetric.jl @@ -73,8 +73,8 @@ If a symmetric view of a matrix is to be constructed of which the elements are n matrices nor numbers, an appropriate method of `symmetric` has to be implemented. In that case, `symmetric_type` has to be implemented, too. """ -symmetric(A::AbstractMatrix, uplo::Symbol) = Symmetric(A, uplo) -symmetric(A::Number, ::Symbol) = A +symmetric(A::AbstractMatrix, uplo::Symbol=:U) = Symmetric(A, uplo) +symmetric(A::Number, ::Symbol=:U) = A """ symmetric_type(T::Type) @@ -164,8 +164,8 @@ If a hermitian view of a matrix is to be constructed of which the elements are n matrices nor numbers, an appropriate method of `hermitian` has to be implemented. In that case, `hermitian_type` has to be implemented, too. """ -hermitian(A::AbstractMatrix, uplo::Symbol) = Hermitian(A, uplo) -hermitian(A::Number, ::Symbol) = convert(typeof(A), real(A)) +hermitian(A::AbstractMatrix, uplo::Symbol=:U) = Hermitian(A, uplo) +hermitian(A::Number, ::Symbol=:U) = convert(typeof(A), real(A)) """ hermitian_type(T::Type) diff --git a/stdlib/LinearAlgebra/test/symmetric.jl b/stdlib/LinearAlgebra/test/symmetric.jl index 82236c2a677eb..f45ca2def04ff 100644 --- a/stdlib/LinearAlgebra/test/symmetric.jl +++ b/stdlib/LinearAlgebra/test/symmetric.jl @@ -727,9 +727,9 @@ end end @testset "symmetric()/hermitian() for Numbers" begin - @test LinearAlgebra.symmetric(1, :U) == 1 + @test LinearAlgebra.symmetric(1) == LinearAlgebra.symmetric(1, :U) == 1 @test LinearAlgebra.symmetric_type(Int) == Int - @test LinearAlgebra.hermitian(1, :U) == 1 + @test LinearAlgebra.hermitian(1) == LinearAlgebra.hermitian(1, :U) == 1 @test LinearAlgebra.hermitian_type(Int) == Int end @@ -900,4 +900,12 @@ end end end +@testset "symmetric/hermitian for matrices" begin + A = [1 2; 3 4] + @test LinearAlgebra.symmetric(A) === Symmetric(A) + @test LinearAlgebra.symmetric(A, :L) === Symmetric(A, :L) + @test LinearAlgebra.hermitian(A) === Hermitian(A) + @test LinearAlgebra.hermitian(A, :L) === Hermitian(A, :L) +end + end # module TestSymmetric From 8a04df087c1e77cc080936ac6e023cbb67feefdd Mon Sep 17 00:00:00 2001 From: Zentrik Date: Mon, 18 Dec 2023 21:37:22 +0000 Subject: [PATCH 29/42] Fix GC rooting during rehashing of iddict (#52569) Should fix #52558. `a` should be rooted before the alloc call. I removed the comment as it seemed to refer to a write barrier that was removed long ago. (cherry picked from commit 5977cb0a0c1ef98fa0e4019bf1a41380a717be6f) --- src/iddict.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/iddict.c b/src/iddict.c index 1fa8a67d1ae96..3cd39e6aa9433 100644 --- a/src/iddict.c +++ b/src/iddict.c @@ -15,15 +15,14 @@ JL_DLLEXPORT jl_array_t *jl_idtable_rehash(jl_array_t *a, size_t newsz) size_t sz = jl_array_len(a); size_t i; jl_value_t **ol = (jl_value_t **)a->data; - jl_array_t *newa = jl_alloc_vec_any(newsz); + jl_array_t *newa = NULL; // keep the original array in the original slot since we need `ol` // to be valid in the loop below. JL_GC_PUSH2(&newa, &a); + newa = jl_alloc_vec_any(newsz); for (i = 0; i < sz; i += 2) { if (ol[i + 1] != NULL) { jl_table_assign_bp(&newa, ol[i], ol[i + 1]); - // it is however necessary here because allocation - // can (and will) occur in a recursive call inside table_lookup_bp } } JL_GC_POP(); From cfbff1019c720aae0e379982f71e70d8f6cfadb3 Mon Sep 17 00:00:00 2001 From: Jian Fang <131804380+JianFangAtRai@users.noreply.github.com> Date: Sat, 30 Dec 2023 06:46:53 -0800 Subject: [PATCH 30/42] heap snapshot: add gc roots and gc finalist roots to fix unrooted nodes (#52618) (cherry picked from commit fe0db7d9474781ee949c7927f806214c7fc00a9a) --- src/gc-heap-snapshot.cpp | 124 +++++++++++++++++++++++++++++++-------- src/gc-heap-snapshot.h | 33 +++++++++-- src/gc.c | 32 ++++++++-- src/gc.h | 2 +- 4 files changed, 156 insertions(+), 35 deletions(-) diff --git a/src/gc-heap-snapshot.cpp b/src/gc-heap-snapshot.cpp index b1401653d99ff..00b6934386cd0 100644 --- a/src/gc-heap-snapshot.cpp +++ b/src/gc-heap-snapshot.cpp @@ -3,6 +3,7 @@ #include "gc-heap-snapshot.h" #include "julia_internal.h" +#include "julia_assert.h" #include "gc.h" #include "llvm/ADT/StringMap.h" @@ -11,9 +12,12 @@ #include #include #include +#include +#include using std::vector; using std::string; +using std::set; using std::ostringstream; using std::pair; using std::make_pair; @@ -115,6 +119,8 @@ struct HeapSnapshot { DenseMap node_ptr_to_index_map; size_t num_edges = 0; // For metadata, updated as you add each edge. Needed because edges owned by nodes. + size_t _gc_root_idx = 1; // node index of the GC roots node + size_t _gc_finlist_root_idx = 2; // node index of the GC finlist roots node }; // global heap snapshot, mutated by garbage collector @@ -127,13 +133,13 @@ void serialize_heap_snapshot(ios_t *stream, HeapSnapshot &snapshot, char all_one static inline void _record_gc_edge(const char *edge_type, jl_value_t *a, jl_value_t *b, size_t name_or_index) JL_NOTSAFEPOINT; void _record_gc_just_edge(const char *edge_type, Node &from_node, size_t to_idx, size_t name_or_idx) JL_NOTSAFEPOINT; -void _add_internal_root(HeapSnapshot *snapshot); +void _add_synthetic_root_entries(HeapSnapshot *snapshot); JL_DLLEXPORT void jl_gc_take_heap_snapshot(ios_t *stream, char all_one) { HeapSnapshot snapshot; - _add_internal_root(&snapshot); + _add_synthetic_root_entries(&snapshot); jl_mutex_lock(&heapsnapshot_lock); @@ -155,10 +161,12 @@ JL_DLLEXPORT void jl_gc_take_heap_snapshot(ios_t *stream, char all_one) serialize_heap_snapshot((ios_t*)stream, snapshot, all_one); } -// adds a node at id 0 which is the "uber root": -// a synthetic node which points to all the GC roots. -void _add_internal_root(HeapSnapshot *snapshot) +// mimicking https://github.com/nodejs/node/blob/5fd7a72e1c4fbaf37d3723c4c81dce35c149dc84/deps/v8/src/profiler/heap-snapshot-generator.cc#L212 +// add synthetic nodes for the uber root, the GC roots, and the GC finalizer list roots +void _add_synthetic_root_entries(HeapSnapshot *snapshot) { + // adds a node at id 0 which is the "uber root": + // a synthetic node which points to all the GC roots. Node internal_root{ snapshot->node_types.find_or_create_string_id("synthetic"), snapshot->names.find_or_create_string_id(""), // name @@ -169,6 +177,44 @@ void _add_internal_root(HeapSnapshot *snapshot) vector() // outgoing edges }; snapshot->nodes.push_back(internal_root); + + // Add a node for the GC roots + snapshot->_gc_root_idx = snapshot->nodes.size(); + Node gc_roots{ + snapshot->node_types.find_or_create_string_id("synthetic"), + snapshot->names.find_or_create_string_id("GC roots"), // name + snapshot->_gc_root_idx, // id + 0, // size + 0, // size_t trace_node_id (unused) + 0, // int detachedness; // 0 - unknown, 1 - attached; 2 - detached + vector() // outgoing edges + }; + snapshot->nodes.push_back(gc_roots); + snapshot->nodes.front().edges.push_back(Edge{ + snapshot->edge_types.find_or_create_string_id("internal"), + snapshot->names.find_or_create_string_id("GC roots"), // edge label + snapshot->_gc_root_idx // to + }); + snapshot->num_edges += 1; + + // add a node for the gc finalizer list roots + snapshot->_gc_finlist_root_idx = snapshot->nodes.size(); + Node gc_finlist_roots{ + snapshot->node_types.find_or_create_string_id("synthetic"), + snapshot->names.find_or_create_string_id("GC finalizer list roots"), // name + snapshot->_gc_finlist_root_idx, // id + 0, // size + 0, // size_t trace_node_id (unused) + 0, // int detachedness; // 0 - unknown, 1 - attached; 2 - detached + vector() // outgoing edges + }; + snapshot->nodes.push_back(gc_finlist_roots); + snapshot->nodes.front().edges.push_back(Edge{ + snapshot->edge_types.find_or_create_string_id("internal"), + snapshot->names.find_or_create_string_id("GC finlist roots"), // edge label + snapshot->_gc_finlist_root_idx // to + }); + snapshot->num_edges += 1; } // mimicking https://github.com/nodejs/node/blob/5fd7a72e1c4fbaf37d3723c4c81dce35c149dc84/deps/v8/src/profiler/heap-snapshot-generator.cc#L597-L597 @@ -326,6 +372,26 @@ void _gc_heap_snapshot_record_root(jl_value_t *root, char *name) JL_NOTSAFEPOINT _record_gc_just_edge("internal", internal_root, to_node_idx, edge_label); } +void _gc_heap_snapshot_record_gc_roots(jl_value_t *root, char *name) JL_NOTSAFEPOINT +{ + record_node_to_gc_snapshot(root); + + auto from_node_idx = g_snapshot->_gc_root_idx; + auto to_node_idx = record_node_to_gc_snapshot(root); + auto edge_label = g_snapshot->names.find_or_create_string_id(name); + _record_gc_just_edge("internal", g_snapshot->nodes[from_node_idx], to_node_idx, edge_label); +} + +void _gc_heap_snapshot_record_finlist(jl_value_t *obj, size_t index) JL_NOTSAFEPOINT +{ + auto from_node_idx = g_snapshot->_gc_finlist_root_idx; + auto to_node_idx = record_node_to_gc_snapshot(obj); + ostringstream ss; + ss << "finlist-" << index; + auto edge_label = g_snapshot->names.find_or_create_string_id(ss.str()); + _record_gc_just_edge("internal", g_snapshot->nodes[from_node_idx], to_node_idx, edge_label); +} + // Add a node to the heap snapshot representing a Julia stack frame. // Each task points at a stack frame, which points at the stack frame of // the function it's currently calling, forming a linked list. @@ -392,27 +458,19 @@ void _gc_heap_snapshot_record_object_edge(jl_value_t *from, jl_value_t *to, void g_snapshot->names.find_or_create_string_id(path)); } -void _gc_heap_snapshot_record_module_to_binding(jl_module_t *module, jl_binding_t *binding) JL_NOTSAFEPOINT +void _gc_heap_snapshot_record_module_to_binding(jl_module_t *module, jl_value_t *bindings, jl_value_t *bindingkeyset) JL_NOTSAFEPOINT { - jl_globalref_t *globalref = binding->globalref; - jl_sym_t *name = globalref->name; auto from_node_idx = record_node_to_gc_snapshot((jl_value_t*)module); - auto to_node_idx = record_pointer_to_gc_snapshot(binding, sizeof(jl_binding_t), jl_symbol_name(name)); - - jl_value_t *value = jl_atomic_load_relaxed(&binding->value); - auto value_idx = value ? record_node_to_gc_snapshot(value) : 0; - jl_value_t *ty = jl_atomic_load_relaxed(&binding->ty); - auto ty_idx = ty ? record_node_to_gc_snapshot(ty) : 0; - auto globalref_idx = record_node_to_gc_snapshot((jl_value_t*)globalref); - + auto to_bindings_idx = record_node_to_gc_snapshot(bindings); + auto to_bindingkeyset_idx = record_node_to_gc_snapshot(bindingkeyset); auto &from_node = g_snapshot->nodes[from_node_idx]; - auto &to_node = g_snapshot->nodes[to_node_idx]; - - _record_gc_just_edge("property", from_node, to_node_idx, g_snapshot->names.find_or_create_string_id("")); - if (value_idx) _record_gc_just_edge("internal", to_node, value_idx, g_snapshot->names.find_or_create_string_id("value")); - if (ty_idx) _record_gc_just_edge("internal", to_node, ty_idx, g_snapshot->names.find_or_create_string_id("ty")); - if (globalref_idx) _record_gc_just_edge("internal", to_node, globalref_idx, g_snapshot->names.find_or_create_string_id("globalref")); -} + if (to_bindings_idx > 0) { + _record_gc_just_edge("internal", from_node, to_bindings_idx, g_snapshot->names.find_or_create_string_id("bindings")); + } + if (to_bindingkeyset_idx > 0) { + _record_gc_just_edge("internal", from_node, to_bindingkeyset_idx, g_snapshot->names.find_or_create_string_id("bindingkeyset")); + } + } void _gc_heap_snapshot_record_internal_array_edge(jl_value_t *from, jl_value_t *to) JL_NOTSAFEPOINT { @@ -491,6 +549,8 @@ void serialize_heap_snapshot(ios_t *stream, HeapSnapshot &snapshot, char all_one ios_printf(stream, "\"nodes\":["); bool first_node = true; + // use a set to track the nodes that do not have parents + set orphans; for (const auto &from_node : snapshot.nodes) { if (first_node) { first_node = false; @@ -507,6 +567,14 @@ void serialize_heap_snapshot(ios_t *stream, HeapSnapshot &snapshot, char all_one from_node.edges.size(), from_node.trace_node_id, from_node.detachedness); + if (from_node.id != snapshot._gc_root_idx && from_node.id != snapshot._gc_finlist_root_idx) { + // find the node index from the node object pointer + void * ptr = (void*)from_node.id; + size_t n_id = snapshot.node_ptr_to_index_map[ptr]; + orphans.insert(n_id); + } else { + orphans.insert(from_node.id); + } } ios_printf(stream, "],\n"); @@ -524,6 +592,12 @@ void serialize_heap_snapshot(ios_t *stream, HeapSnapshot &snapshot, char all_one edge.type, edge.name_or_index, edge.to_node * k_node_number_of_fields); + auto n_id = edge.to_node; + auto it = orphans.find(n_id); + if (it != orphans.end()) { + // remove the node from the orphans if it has at least one incoming edge + orphans.erase(it); + } } } ios_printf(stream, "],\n"); // end "edges" @@ -533,4 +607,8 @@ void serialize_heap_snapshot(ios_t *stream, HeapSnapshot &snapshot, char all_one snapshot.names.print_json_array(stream, true); ios_printf(stream, "}"); + + // remove the uber node from the orphans + orphans.erase(0); + assert(orphans.size() == 0 && "all nodes except the uber node should have at least one incoming edge"); } diff --git a/src/gc-heap-snapshot.h b/src/gc-heap-snapshot.h index 8c3af5b86bec7..1799063825e83 100644 --- a/src/gc-heap-snapshot.h +++ b/src/gc-heap-snapshot.h @@ -20,7 +20,7 @@ void _gc_heap_snapshot_record_task_to_frame_edge(jl_task_t *from, void *to) JL_N void _gc_heap_snapshot_record_frame_to_frame_edge(jl_gcframe_t *from, jl_gcframe_t *to) JL_NOTSAFEPOINT; void _gc_heap_snapshot_record_array_edge(jl_value_t *from, jl_value_t *to, size_t index) JL_NOTSAFEPOINT; void _gc_heap_snapshot_record_object_edge(jl_value_t *from, jl_value_t *to, void* slot) JL_NOTSAFEPOINT; -void _gc_heap_snapshot_record_module_to_binding(jl_module_t* module, jl_binding_t* binding) JL_NOTSAFEPOINT; +void _gc_heap_snapshot_record_module_to_binding(jl_module_t* module, jl_value_t *bindings, jl_value_t *bindingkeyset) JL_NOTSAFEPOINT; // Used for objects managed by GC, but which aren't exposed in the julia object, so have no // field or index. i.e. they're not reachable from julia code, but we _will_ hit them in // the GC mark phase (so we can check their type tag to get the size). @@ -28,7 +28,10 @@ void _gc_heap_snapshot_record_internal_array_edge(jl_value_t *from, jl_value_t * // Used for objects manually allocated in C (outside julia GC), to still tell the heap snapshot about the // size of the object, even though we're never going to mark that object. void _gc_heap_snapshot_record_hidden_edge(jl_value_t *from, void* to, size_t bytes, uint16_t alloc_type) JL_NOTSAFEPOINT; - +// Used for objects that are reachable from the GC roots +void _gc_heap_snapshot_record_gc_roots(jl_value_t *root, char *name) JL_NOTSAFEPOINT; +// Used for objects that are reachable from the finalizer list +void _gc_heap_snapshot_record_finlist(jl_value_t *finlist, size_t index) JL_NOTSAFEPOINT; extern int gc_heap_snapshot_enabled; extern int prev_sweep_full; @@ -60,6 +63,12 @@ static inline void gc_heap_snapshot_record_root(jl_value_t *root, char *name) JL _gc_heap_snapshot_record_root(root, name); } } +static inline void gc_heap_snapshot_record_array_edge_index(jl_value_t *from, jl_value_t *to, size_t index) JL_NOTSAFEPOINT +{ + if (__unlikely(gc_heap_snapshot_enabled && prev_sweep_full && from != NULL && to != NULL)) { + _gc_heap_snapshot_record_array_edge(from, to, index); + } +} static inline void gc_heap_snapshot_record_array_edge(jl_value_t *from, jl_value_t **to) JL_NOTSAFEPOINT { if (__unlikely(gc_heap_snapshot_enabled && prev_sweep_full)) { @@ -73,10 +82,10 @@ static inline void gc_heap_snapshot_record_object_edge(jl_value_t *from, jl_valu } } -static inline void gc_heap_snapshot_record_module_to_binding(jl_module_t* module, jl_binding_t* binding) JL_NOTSAFEPOINT +static inline void gc_heap_snapshot_record_module_to_binding(jl_module_t* module, jl_value_t *bindings, jl_value_t *bindingkeyset) JL_NOTSAFEPOINT { - if (__unlikely(gc_heap_snapshot_enabled && prev_sweep_full)) { - _gc_heap_snapshot_record_module_to_binding(module, binding); + if (__unlikely(gc_heap_snapshot_enabled && prev_sweep_full) && bindings != NULL && bindingkeyset != NULL) { + _gc_heap_snapshot_record_module_to_binding(module, bindings, bindingkeyset); } } @@ -94,6 +103,20 @@ static inline void gc_heap_snapshot_record_hidden_edge(jl_value_t *from, void* t } } +static inline void gc_heap_snapshot_record_gc_roots(jl_value_t *root, char *name) JL_NOTSAFEPOINT +{ + if (__unlikely(gc_heap_snapshot_enabled && prev_sweep_full && root != NULL)) { + _gc_heap_snapshot_record_gc_roots(root, name); + } +} + +static inline void gc_heap_snapshot_record_finlist(jl_value_t *finlist, size_t index) JL_NOTSAFEPOINT +{ + if (__unlikely(gc_heap_snapshot_enabled && prev_sweep_full && finlist != NULL)) { + _gc_heap_snapshot_record_finlist(finlist, index); + } +} + // --------------------------------------------------------------------- // Functions to call from Julia to take heap snapshot // --------------------------------------------------------------------- diff --git a/src/gc.c b/src/gc.c index beb4b7e96f1a8..272fe42a43958 100644 --- a/src/gc.c +++ b/src/gc.c @@ -2190,9 +2190,10 @@ STATIC_INLINE void gc_mark_chunk(jl_ptls_t ptls, jl_gc_markqueue_t *mq, jl_gc_ch break; } case GC_finlist_chunk: { + jl_value_t *fl_parent = c->parent; jl_value_t **fl_begin = c->begin; jl_value_t **fl_end = c->end; - gc_mark_finlist_(mq, fl_begin, fl_end); + gc_mark_finlist_(mq, fl_parent, fl_begin, fl_end); break; } default: { @@ -2290,6 +2291,7 @@ STATIC_INLINE void gc_mark_module_binding(jl_ptls_t ptls, jl_module_t *mb_parent jl_value_t *bindingkeyset = (jl_value_t *)jl_atomic_load_relaxed(&mb_parent->bindingkeyset); gc_assert_parent_validity((jl_value_t *)mb_parent, bindingkeyset); gc_try_claim_and_push(mq, bindingkeyset, &nptr); + gc_heap_snapshot_record_module_to_binding(mb_parent, bindings, bindingkeyset); gc_assert_parent_validity((jl_value_t *)mb_parent, (jl_value_t *)mb_parent->parent); gc_try_claim_and_push(mq, (jl_value_t *)mb_parent->parent, &nptr); size_t nusings = mb_parent->usings.len; @@ -2308,7 +2310,7 @@ STATIC_INLINE void gc_mark_module_binding(jl_ptls_t ptls, jl_module_t *mb_parent } } -void gc_mark_finlist_(jl_gc_markqueue_t *mq, jl_value_t **fl_begin, jl_value_t **fl_end) +void gc_mark_finlist_(jl_gc_markqueue_t *mq, jl_value_t *fl_parent, jl_value_t **fl_begin, jl_value_t **fl_end) { jl_value_t *new_obj; // Decide whether need to chunk finlist @@ -2318,8 +2320,10 @@ void gc_mark_finlist_(jl_gc_markqueue_t *mq, jl_value_t **fl_begin, jl_value_t * gc_chunkqueue_push(mq, &c); fl_end = fl_begin + GC_CHUNK_BATCH_SIZE; } + size_t i = 0; for (; fl_begin < fl_end; fl_begin++) { - new_obj = *fl_begin; + jl_value_t **slot = fl_begin; + new_obj = *slot; if (__unlikely(new_obj == NULL)) continue; if (gc_ptr_tag(new_obj, 1)) { @@ -2330,6 +2334,13 @@ void gc_mark_finlist_(jl_gc_markqueue_t *mq, jl_value_t **fl_begin, jl_value_t * if (gc_ptr_tag(new_obj, 2)) continue; gc_try_claim_and_push(mq, new_obj, NULL); + if (fl_parent != NULL) { + gc_heap_snapshot_record_array_edge(fl_parent, slot); + } else { + // This is a list of objects following the same format as a finlist + // if `fl_parent` is NULL + gc_heap_snapshot_record_finlist(new_obj, ++i); + } } } @@ -2341,7 +2352,7 @@ void gc_mark_finlist(jl_gc_markqueue_t *mq, arraylist_t *list, size_t start) return; jl_value_t **fl_begin = (jl_value_t **)list->items + start; jl_value_t **fl_end = (jl_value_t **)list->items + len; - gc_mark_finlist_(mq, fl_begin, fl_end); + gc_mark_finlist_(mq, NULL, fl_begin, fl_end); } JL_DLLEXPORT int jl_gc_mark_queue_obj(jl_ptls_t ptls, jl_value_t *obj) @@ -3003,27 +3014,36 @@ static void gc_mark_roots(jl_gc_markqueue_t *mq) { // modules gc_try_claim_and_push(mq, jl_main_module, NULL); - gc_heap_snapshot_record_root((jl_value_t*)jl_main_module, "main_module"); + gc_heap_snapshot_record_gc_roots((jl_value_t*)jl_main_module, "main_module"); // invisible builtin values gc_try_claim_and_push(mq, jl_an_empty_vec_any, NULL); + gc_heap_snapshot_record_gc_roots((jl_value_t*)jl_an_empty_vec_any, "an_empty_vec_any"); gc_try_claim_and_push(mq, jl_module_init_order, NULL); + gc_heap_snapshot_record_gc_roots((jl_value_t*)jl_module_init_order, "module_init_order"); for (size_t i = 0; i < jl_current_modules.size; i += 2) { if (jl_current_modules.table[i + 1] != HT_NOTFOUND) { gc_try_claim_and_push(mq, jl_current_modules.table[i], NULL); - gc_heap_snapshot_record_root((jl_value_t*)jl_current_modules.table[i], "top level module"); + gc_heap_snapshot_record_gc_roots((jl_value_t*)jl_current_modules.table[i], "top level module"); } } gc_try_claim_and_push(mq, jl_anytuple_type_type, NULL); + gc_heap_snapshot_record_gc_roots((jl_value_t*)jl_anytuple_type_type, "anytuple_type_type"); for (size_t i = 0; i < N_CALL_CACHE; i++) { jl_typemap_entry_t *v = jl_atomic_load_relaxed(&call_cache[i]); gc_try_claim_and_push(mq, v, NULL); + gc_heap_snapshot_record_array_edge_index((jl_value_t*)jl_anytuple_type_type, (jl_value_t*)v, i); } gc_try_claim_and_push(mq, jl_all_methods, NULL); + gc_heap_snapshot_record_gc_roots((jl_value_t*)jl_all_methods, "all_methods"); gc_try_claim_and_push(mq, _jl_debug_method_invalidation, NULL); + gc_heap_snapshot_record_gc_roots((jl_value_t*)_jl_debug_method_invalidation, "debug_method_invalidation"); // constants gc_try_claim_and_push(mq, jl_emptytuple_type, NULL); + gc_heap_snapshot_record_gc_roots((jl_value_t*)jl_emptytuple_type, "emptytuple_type"); gc_try_claim_and_push(mq, cmpswap_names, NULL); + gc_heap_snapshot_record_gc_roots((jl_value_t*)cmpswap_names, "cmpswap_names"); gc_try_claim_and_push(mq, jl_global_roots_table, NULL); + gc_heap_snapshot_record_gc_roots((jl_value_t*)jl_global_roots_table, "global_roots_table"); } // find unmarked objects that need to be finalized from the finalizer list "list". diff --git a/src/gc.h b/src/gc.h index fe8aadee71ad8..23e73eced6eb8 100644 --- a/src/gc.h +++ b/src/gc.h @@ -427,7 +427,7 @@ extern uv_cond_t gc_threads_cond; extern uv_sem_t gc_sweep_assists_needed; extern _Atomic(int) gc_n_threads_marking; void gc_mark_queue_all_roots(jl_ptls_t ptls, jl_gc_markqueue_t *mq); -void gc_mark_finlist_(jl_gc_markqueue_t *mq, jl_value_t **fl_begin, jl_value_t **fl_end) JL_NOTSAFEPOINT; +void gc_mark_finlist_(jl_gc_markqueue_t *mq, jl_value_t *fl_parent, jl_value_t **fl_begin, jl_value_t **fl_end) JL_NOTSAFEPOINT; void gc_mark_finlist(jl_gc_markqueue_t *mq, arraylist_t *list, size_t start) JL_NOTSAFEPOINT; void gc_mark_loop_serial_(jl_ptls_t ptls, jl_gc_markqueue_t *mq); void gc_mark_loop_serial(jl_ptls_t ptls); From f06a63deecfba8e4c03524da5afb3ac86d427ac3 Mon Sep 17 00:00:00 2001 From: Gabriel Baraldi Date: Wed, 24 Jan 2024 10:20:40 -0300 Subject: [PATCH 31/42] Apple silicon has 128 byte alignment so fix our defines to match (#52996) https://github.com/JuliaLang/julia/blob/8a69745bdcb06409ab7e4fc84718f34d7d54a7f9/base/lock.jl#L33-L50 this probably also needs a fix, and maybe other places as well (cherry picked from commit 91ec2bb646ca1ef14a86232da2aa80a9c9f46d40) --- src/julia_internal.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/julia_internal.h b/src/julia_internal.h index f96f4db9d611e..7b40f59ae75b0 100644 --- a/src/julia_internal.h +++ b/src/julia_internal.h @@ -458,7 +458,11 @@ STATIC_INLINE uint8_t JL_CONST_FUNC jl_gc_szclass_align8(unsigned sz) JL_NOTSAFE } #define JL_SMALL_BYTE_ALIGNMENT 16 +#if defined(_CPU_AARCH64_) && defined(_OS_DARWIN_) // Apple silicon has 128 cache lines +#define JL_CACHE_BYTE_ALIGNMENT 128 +#else #define JL_CACHE_BYTE_ALIGNMENT 64 +#endif // JL_HEAP_ALIGNMENT is the maximum alignment that the GC can provide #define JL_HEAP_ALIGNMENT JL_SMALL_BYTE_ALIGNMENT #define GC_MAX_SZCLASS (2032-sizeof(void*)) From 6fdf37ea324bb5c19b7693dd42110f656b5ab90b Mon Sep 17 00:00:00 2001 From: Max Horn Date: Wed, 24 Jan 2024 14:20:49 +0100 Subject: [PATCH 32/42] Replace `⇔` by `↔` in documentation (#52078) There is no HTML entity `⇔` and accordingly all the usual browsers (Chrome, Firefox, Safari) don't render it. My guess is that there is confusion because GitHub supports `⇔` and shows it as ⇔ (and `↔` as ↔). But here is for example what Firefox shows: Screen Shot 2023-11-08 at 14 02 01 This patch could be backported to 1.9 and 1.10. (cherry picked from commit 81c4f8e1b3dc16738d136967c1b32f3e1ee969ba) --- doc/src/manual/noteworthy-differences.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/doc/src/manual/noteworthy-differences.md b/doc/src/manual/noteworthy-differences.md index 470ec9a315ce4..e29ac2249ab95 100644 --- a/doc/src/manual/noteworthy-differences.md +++ b/doc/src/manual/noteworthy-differences.md @@ -352,7 +352,7 @@ For users coming to Julia from R, these are some noteworthy differences: it's more general than that since methods are dispatched on every argument type, not only `this`, using the most-specific-declaration rule). -### Julia ⇔ C/C++: Namespaces +### Julia ↔ C/C++: Namespaces * C/C++ `namespace`s correspond roughly to Julia `module`s. * There are no private globals or fields in Julia. Everything is publicly accessible through fully qualified paths (or relative paths, if desired). @@ -364,7 +364,7 @@ For users coming to Julia from R, these are some noteworthy differences: * Caveat: `import`/`using` (Julia) works only at the global scope level (`module`s) * In C++, `using namespace X` works within arbitrary scopes (ex: function scope). -### Julia ⇔ C/C++: Module loading +### Julia ↔ C/C++: Module loading * When you think of a C/C++ "**library**", you are likely looking for a Julia "**package**". * Caveat: C/C++ libraries often house multiple "software modules" whereas Julia "packages" typically house one. @@ -395,7 +395,7 @@ For users coming to Julia from R, these are some noteworthy differences: * Directory-based package repositories are the **quickest solution** to developping local libraries of "software modules". -### Julia ⇔ C/C++: Assembling modules +### Julia ↔ C/C++: Assembling modules * In C/C++, `.c`/`.cpp` files are compiled & added to a library with build/`make` scripts. * In Julia, `import [PkgName]`/`using [PkgName]` statements load `[PkgName].jl` located in a package's `[PkgName]/src/` subdirectory. @@ -412,9 +412,9 @@ For users coming to Julia from R, these are some noteworthy differences: Julia package* ("software module"). It is therefore relatively straightforward to ensure file are `include`d only once (No `#ifdef` confusion). -### Julia ⇔ C/C++: Module interface - * C++ exposes interfaces using "public" `.h`/`.hpp` files whereas Julia `module`s `export` - symbols that are intended for their users. +### Julia ↔ C/C++: Module interface + * C++ exposes interfaces using "public" `.h`/`.hpp` files whereas Julia `module`s mark + specific symbols that are intended for their users as `public`or `export`ed. * Often, Julia `module`s simply add functionality by generating new "methods" to existing functions (ex: `Base.push!`). * Developers of Julia packages therefore cannot rely on header files for interface @@ -425,7 +425,7 @@ For users coming to Julia from R, these are some noteworthy differences: * Users might be expected to access these components by qualifying functions/structs/... with the package/module name (ex: `MyModule.run_this_task(...)`). -### Julia ⇔ C/C++: Quick reference +### Julia ↔ C/C++: Quick reference | Software Concept | Julia | C/C++ | | :--- | :--- | :--- | From ece8b7b05b9a855e225859e1d328e8a4f8718fe2 Mon Sep 17 00:00:00 2001 From: Ian Butterworth Date: Thu, 25 Jan 2024 14:50:47 -0500 Subject: [PATCH 33/42] Profile: use full terminal cols to show function name (#53055) (cherry picked from commit 4919dd79dfd848eb6d9929768666977f374c7f10) --- stdlib/Profile/src/Profile.jl | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/stdlib/Profile/src/Profile.jl b/stdlib/Profile/src/Profile.jl index c37cdd0af0368..716cd7c14b904 100644 --- a/stdlib/Profile/src/Profile.jl +++ b/stdlib/Profile/src/Profile.jl @@ -859,7 +859,6 @@ function tree_format(frames::Vector{<:StackFrameTree}, level::Int, cols::Int, ma ndigline = ndigits(maximum(frame.frame.line for frame in frames)) + 6 ntext = max(30, cols - ndigoverhead - nindent - ndigcounts - ndigline - 6) widthfile = 2*ntext÷5 # min 12 - widthfunc = 3*ntext÷5 # min 18 strs = Vector{String}(undef, length(frames)) showextra = false if level > nindent @@ -901,11 +900,12 @@ function tree_format(frames::Vector{<:StackFrameTree}, level::Int, cols::Int, ma ":", li.line == -1 ? "?" : string(li.line), "; ", - ltruncto(fname, widthfunc)) + fname) end else strs[i] = string(stroverhead, "╎", base, strcount, " [unknown stackframe]") end + strs[i] = ltruncto(strs[i], cols) end return strs end @@ -1161,17 +1161,17 @@ end # Utilities function rtruncto(str::String, w::Int) - if length(str) <= w + if textwidth(str) <= w return str else - return string("...", str[prevind(str, end, w-4):end]) + return string("…", str[prevind(str, end, w-2):end]) end end function ltruncto(str::String, w::Int) - if length(str) <= w + if textwidth(str) <= w return str else - return string(str[1:nextind(str, 1, w-4)], "...") + return string(str[1:nextind(str, 1, w-2)], "…") end end From 2c8ecd359b4993fb84b53ae714329330b2092cc4 Mon Sep 17 00:00:00 2001 From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com> Date: Mon, 29 Jan 2024 15:26:26 +0900 Subject: [PATCH 34/42] 1.10: REPL: fix intermittent REPL test failure (#53096) The earlier test relied on the order of the method match list returned by `_methods_by_ftype`. However, particularly in cases where the `ambig=true` option is used, the match list isn't deterministic. This commit modifies it, similar to other pieces of code, so that it `any` to ensure the code does not depend on the implementation details of `ml_matches`. Fixes #52739. --- stdlib/REPL/test/replcompletions.jl | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl index 0c0ff08f2c3f1..56a96b5a1534c 100644 --- a/stdlib/REPL/test/replcompletions.jl +++ b/stdlib/REPL/test/replcompletions.jl @@ -646,7 +646,7 @@ let s = "CompletionFoo.?([1,2,3], 2.0)" c, r, res = test_complete(s) @test !res @test length(c) == 1 - @test occursin("test(x::AbstractArray{T}, y) where T<:Real", c[1]) + @test occursin("test(x::AbstractArray{T}, y) where T<:Real", only(c)) # In particular, this checks that test(args...) is not a valid completion # since it is strictly less specific than test(x::AbstractArray{T}, y) end @@ -680,15 +680,15 @@ let s = "CompletionFoo.?(false, \"a\", 3, " c, r, res = test_complete(s) @test !res @test length(c) == 2 - @test occursin("test(args...)", c[1]) - @test occursin("test11(a::Integer, b, c)", c[2]) + @test any(s->occursin("test(args...)", s), c) + @test any(s->occursin("test11(a::Integer, b, c)", s), c) end let s = "CompletionFoo.?(false, \"a\", 3, " c, r, res = test_complete_noshift(s) @test !res @test length(c) == 1 - @test occursin("test11(a::Integer, b, c)", c[1]) + @test occursin("test11(a::Integer, b, c)", only(c)) end let s = "CompletionFoo.?(\"a\", 3, " @@ -711,7 +711,7 @@ let s = "CompletionFoo.?()" c, r, res = test_complete_noshift(s) @test !res @test length(c) == 1 - @test occursin("test10(s::String...)", c[1]) + @test occursin("test10(s::String...)", only(c)) end #= TODO: restrict the number of completions when a semicolon is present in ".?(" syntax From a215b3761bef3c25aaefc9a0687d8307dcd8f0fb Mon Sep 17 00:00:00 2001 From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com> Date: Mon, 29 Jan 2024 15:26:42 +0900 Subject: [PATCH 35/42] 1.10: inlining: fix `joint_effects` calculation (#53076) This particular fix was part of #50805, but it wasn't included in version 1.10, leading to situations where an incorrect `:nothrow` could occur in 1.10 (#53062). This commit implements a minimal correction in 1.10 and also added some test cases. Fixes #53062. --- base/compiler/ssair/inlining.jl | 2 +- test/compiler/inline.jl | 17 +++++++++++++++++ 2 files changed, 18 insertions(+), 1 deletion(-) diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl index 639a7fcc09c5b..232112fc4cd1b 100644 --- a/base/compiler/ssair/inlining.jl +++ b/base/compiler/ssair/inlining.jl @@ -1408,7 +1408,7 @@ function compute_inlining_cases(@nospecialize(info::CallInfo), flag::UInt8, sig: fully_covered &= split_fully_covered end - fully_covered || (joint_effects = Effects(joint_effects; nothrow=false)) + (handled_all_cases & fully_covered) || (joint_effects = Effects(joint_effects; nothrow=false)) if handled_all_cases && revisit_idx !== nothing # we handled everything except one match with unmatched sparams, diff --git a/test/compiler/inline.jl b/test/compiler/inline.jl index 65920f16b3da7..780a5424a29c2 100644 --- a/test/compiler/inline.jl +++ b/test/compiler/inline.jl @@ -2096,3 +2096,20 @@ let src = code_typed1() do end @test count(isinvoke(:iterate), src.code) == 0 end + +# JuliaLang/julia#53062: proper `joint_effects` for call with empty method matches +let ir = first(only(Base.code_ircode(setproperty!, (Base.RefValue{Int},Symbol,Base.RefValue{Int})))) + i = findfirst(iscall((ir, convert)), ir.stmts.inst)::Int + @test iszero(ir.stmts.flag[i] & Core.Compiler.IR_FLAG_NOTHROW) +end +function issue53062(cond) + x = Ref{Int}(0) + if cond + x[] = x + else + return -1 + end +end +@test !Core.Compiler.is_nothrow(Base.infer_effects(issue53062, (Bool,))) +@test issue53062(false) == -1 +@test_throws MethodError issue53062(true) From 3c738736ebee9e2aa25f1203aee3ae0c85e5e80a Mon Sep 17 00:00:00 2001 From: KristofferC Date: Mon, 29 Jan 2024 12:55:46 +0100 Subject: [PATCH 36/42] [OpenBLAS] Ugrade to v0.3.23+4 --- deps/checksums/openblas | 184 +++++++++++++++---------------- stdlib/OpenBLAS_jll/Project.toml | 2 +- 2 files changed, 93 insertions(+), 93 deletions(-) diff --git a/deps/checksums/openblas b/deps/checksums/openblas index 19fc9fd32275e..dd7c493c22941 100644 --- a/deps/checksums/openblas +++ b/deps/checksums/openblas @@ -1,94 +1,94 @@ -OpenBLAS.v0.3.23+2.aarch64-apple-darwin-libgfortran5.tar.gz/md5/f4ab1aa718db6ab731179199b48506ad -OpenBLAS.v0.3.23+2.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/5cd6326eab751d087b6638acc256a7c5dfc3a8a4be8949f4e2b5b8079aedc05cd8569774da19912fcbcd2dc1eac6a09d72d19bdbeded1198317992a85ccd605b -OpenBLAS.v0.3.23+2.aarch64-linux-gnu-libgfortran3.tar.gz/md5/57b8903e05998d293d28e70ee6cbc4d8 -OpenBLAS.v0.3.23+2.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/03325728191f88dcfc2bea16d818c0325b4f42019ed9c2e0533233e8e2a4da09a2c70503632fef2ab55ed12b7da39fdab470b801d34a9b6f576bda509f8a8a8d -OpenBLAS.v0.3.23+2.aarch64-linux-gnu-libgfortran4.tar.gz/md5/fe529647382de5693557363f658c71b6 -OpenBLAS.v0.3.23+2.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/77ac56f683a481477fa898d208e67c0c04c1ab8ca9dacb1e4e4ea3795fadb2604faffd1f3fd35d53eecb223c7f92de40cc8b2bdeb9c8a6a1b6a9949965cb9380 -OpenBLAS.v0.3.23+2.aarch64-linux-gnu-libgfortran5.tar.gz/md5/5aea8a00a946273a154110ca7b468214 -OpenBLAS.v0.3.23+2.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/a606933bed17e563d15ac206a4a37d38d75e9bb0bef46ef62485dcd32aa5a0e8501dab01f6887a1e60736c59177c6fbf0ec541fa521a9a8de854f44703f337c3 -OpenBLAS.v0.3.23+2.aarch64-linux-musl-libgfortran3.tar.gz/md5/d81dc2a42a8c0d87f4ee9bad98579f2a -OpenBLAS.v0.3.23+2.aarch64-linux-musl-libgfortran3.tar.gz/sha512/f2bda57546f1b9aa1f8dfe9a07b2243cadc002a9ffefbcfdde344ccc96efb07608a55bf8dbb6de34925af03f01ac5487f9fe293befa84edd9a84c01a9b7409e1 -OpenBLAS.v0.3.23+2.aarch64-linux-musl-libgfortran4.tar.gz/md5/400ba512f73a60420aa0d316bc24db48 -OpenBLAS.v0.3.23+2.aarch64-linux-musl-libgfortran4.tar.gz/sha512/927c711c3950f24e6b4c22c6dd92cd2b212e3df9241c637ff42f5b9135e7bee8f3864868aea594c6e8ba5b40f0563d63a5f8634ea3c3276bec35d480601e76e5 -OpenBLAS.v0.3.23+2.aarch64-linux-musl-libgfortran5.tar.gz/md5/6a91ea53f3aff17b602b324d025309c5 -OpenBLAS.v0.3.23+2.aarch64-linux-musl-libgfortran5.tar.gz/sha512/8ee85883fcc605c16031bafdd0f1a4f4d4a5957a4f85c2022466232f902a4cf64c284537dd2f237221f7d0c154e2b46200501891d3990e94dcf49a74a66c36de -OpenBLAS.v0.3.23+2.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/c653ff340dc25b19ca36309060dd6b1a -OpenBLAS.v0.3.23+2.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/cc77c84538bb0301eaa98ca1a32f024da6242e40e847e71f4a36ab69233590422aea41a32ee67031d8055c929f741617053416e5b9d446affa36e7233e5af48b -OpenBLAS.v0.3.23+2.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/18a914a1df2be07ff6b419617cb6347f -OpenBLAS.v0.3.23+2.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/eafab27655b0c179ad8b9b1dc818e8394d365f19cf75a0d77402951a38e204aa2fbe580037116a28e8e1254b66d15a543ccd0f438f3ae388e8bcad39f5953c64 -OpenBLAS.v0.3.23+2.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/4b8d18500b4bdc6f1081da6f0837340f -OpenBLAS.v0.3.23+2.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/6512bd03d58b7669dba7f9830d3f8654b2747ee66c7bfc05acdbca6c3d2c3750c9d1163768a3f91d56c5a87cb30705ad6f10395652fee4c9cd06cd2920db3027 -OpenBLAS.v0.3.23+2.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/27fd022a3b84c3a92da9d6062d8dafaf -OpenBLAS.v0.3.23+2.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/c0e73f2012df2453cc6231a9e7a644609ba1280c9aea63d2cbbf9594539fb26c8f9ab6976de8ec9870cab483b1fe7e3a1fc81246fa99bbd7526051e74a4733e1 -OpenBLAS.v0.3.23+2.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/e2b0503bf1144f4b6a65ae9f09b25828 -OpenBLAS.v0.3.23+2.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/204678995b9f337e4ddae793762c3a00968faa3da3433ea17578944fd56f33c381150521b6a561d6ff2022693f8d46b9d0f32f330e500036b4bfc08a7dbd8a62 -OpenBLAS.v0.3.23+2.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/3e733c1c668a3efaccfde643092595e5 -OpenBLAS.v0.3.23+2.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/4a37e5de66920f20a648118f62555755b51e6e089e7ee43d2b7b8ec0dc47e68c7705b878158ad83d152cfebf77118f789d1bf7b2ee0702334d4317f0c6a926a1 -OpenBLAS.v0.3.23+2.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/c653ff340dc25b19ca36309060dd6b1a -OpenBLAS.v0.3.23+2.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/cc77c84538bb0301eaa98ca1a32f024da6242e40e847e71f4a36ab69233590422aea41a32ee67031d8055c929f741617053416e5b9d446affa36e7233e5af48b -OpenBLAS.v0.3.23+2.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/18a914a1df2be07ff6b419617cb6347f -OpenBLAS.v0.3.23+2.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/eafab27655b0c179ad8b9b1dc818e8394d365f19cf75a0d77402951a38e204aa2fbe580037116a28e8e1254b66d15a543ccd0f438f3ae388e8bcad39f5953c64 -OpenBLAS.v0.3.23+2.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/4b8d18500b4bdc6f1081da6f0837340f -OpenBLAS.v0.3.23+2.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/6512bd03d58b7669dba7f9830d3f8654b2747ee66c7bfc05acdbca6c3d2c3750c9d1163768a3f91d56c5a87cb30705ad6f10395652fee4c9cd06cd2920db3027 -OpenBLAS.v0.3.23+2.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/27fd022a3b84c3a92da9d6062d8dafaf -OpenBLAS.v0.3.23+2.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/c0e73f2012df2453cc6231a9e7a644609ba1280c9aea63d2cbbf9594539fb26c8f9ab6976de8ec9870cab483b1fe7e3a1fc81246fa99bbd7526051e74a4733e1 -OpenBLAS.v0.3.23+2.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/e2b0503bf1144f4b6a65ae9f09b25828 -OpenBLAS.v0.3.23+2.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/204678995b9f337e4ddae793762c3a00968faa3da3433ea17578944fd56f33c381150521b6a561d6ff2022693f8d46b9d0f32f330e500036b4bfc08a7dbd8a62 -OpenBLAS.v0.3.23+2.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/3e733c1c668a3efaccfde643092595e5 -OpenBLAS.v0.3.23+2.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/4a37e5de66920f20a648118f62555755b51e6e089e7ee43d2b7b8ec0dc47e68c7705b878158ad83d152cfebf77118f789d1bf7b2ee0702334d4317f0c6a926a1 -OpenBLAS.v0.3.23+2.i686-linux-gnu-libgfortran3.tar.gz/md5/639643a12f8018e4be7bb1f9f29e57f6 -OpenBLAS.v0.3.23+2.i686-linux-gnu-libgfortran3.tar.gz/sha512/0993e1967964874a3f90610745d82369ee70fa4313445391fdcb26c4218c6badb18577c67648d2f77f359b163dafde31a3723998e0b006622effeace506b669f -OpenBLAS.v0.3.23+2.i686-linux-gnu-libgfortran4.tar.gz/md5/13ec86d62840258c425b0a5a6824a609 -OpenBLAS.v0.3.23+2.i686-linux-gnu-libgfortran4.tar.gz/sha512/0bc74dac87b8ab5ea244fa5bcd05baf2968b7041c4eb392ff808d0aae897cec4b3082ef7fecda28aea2662b6cd956a5254212740b1802a947dd3f1e5a3dfe2d2 -OpenBLAS.v0.3.23+2.i686-linux-gnu-libgfortran5.tar.gz/md5/413d4eae7b9c409204ab5fb7867dc30f -OpenBLAS.v0.3.23+2.i686-linux-gnu-libgfortran5.tar.gz/sha512/4a484d2aa239d8c1e2733cd9d16bd17549f5048d9958899a4e20039a7efcfd280bba901f3fe63b3b079fd7fae88911f7201a7649a472d47d0148ba8520f350cb -OpenBLAS.v0.3.23+2.i686-linux-musl-libgfortran3.tar.gz/md5/7f342d27a9b193b5d37e2ae4de6e4640 -OpenBLAS.v0.3.23+2.i686-linux-musl-libgfortran3.tar.gz/sha512/2927b18e176e07fe8a05d2eba24f6160680131832094bde9634f0890c1bc3b877c3293163fc65067cea402f3e75871c41b47e4a9999f273e667ac400878aa2b2 -OpenBLAS.v0.3.23+2.i686-linux-musl-libgfortran4.tar.gz/md5/523c007c319adbdde6e8cd7d3d89a9a1 -OpenBLAS.v0.3.23+2.i686-linux-musl-libgfortran4.tar.gz/sha512/ddb7a8d67c9430976ad967e21a6b8717c8a5501e8808fabf6e7b2e7298a0ca56049dcfc12214a5a19dbf7bd52d625b0b2b1bcc6b4c1d921c3ee62fd2766da891 -OpenBLAS.v0.3.23+2.i686-linux-musl-libgfortran5.tar.gz/md5/7dd91db180e59da5f866f73eaccc4d1d -OpenBLAS.v0.3.23+2.i686-linux-musl-libgfortran5.tar.gz/sha512/ff0ee65e536eae5ece7fbc00a0735349d560a142e025084d64f28891bdd3da5914e976640be354d8ad34fd3d89bfb90461eb95f2426d5e292906ed4ead1cfafc -OpenBLAS.v0.3.23+2.i686-w64-mingw32-libgfortran3.tar.gz/md5/98dd37d7921b0a18dfd13d8c17bd4cf9 -OpenBLAS.v0.3.23+2.i686-w64-mingw32-libgfortran3.tar.gz/sha512/dd054c335ce71e52dca9bfa31e1a8d51be4708cc11964425914b36976d6f02ff545e3f583d734c9d8a898773f0dc9d93924afa428ce5e5a276aee28c1acb9bff -OpenBLAS.v0.3.23+2.i686-w64-mingw32-libgfortran4.tar.gz/md5/55e3a7ac93d22cb8dd5b0f1a77ca53a4 -OpenBLAS.v0.3.23+2.i686-w64-mingw32-libgfortran4.tar.gz/sha512/3eae1f9a08b6653c800209681d5dd491f381e1558897a2c2a5330ad67935142a979756911a3a9860b7da6592339d073eba362d6544d988c8b23d8113028b6e5a -OpenBLAS.v0.3.23+2.i686-w64-mingw32-libgfortran5.tar.gz/md5/ce52068bfa5ea392984d2063883241bf -OpenBLAS.v0.3.23+2.i686-w64-mingw32-libgfortran5.tar.gz/sha512/1ea675f145f12de8f3fc9ad573967d384e83b0c41a0503f6e369add12698260b49a880e41bbdd26c9ffe481124f3571b2f95623c3a6b3816b8e4a75253f92f53 -OpenBLAS.v0.3.23+2.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/3059083c8293106486a0f28a3564e499 -OpenBLAS.v0.3.23+2.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/019bb4bc71d7be14f040b36d1b44f653ee89aac680749a6a3b8b72446dffae185dd3d8172ca7ac9aac45cfe564c0fc6cf3221a6f8496b9ba10d04ab44d897b65 -OpenBLAS.v0.3.23+2.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/648167f83536f32921f1208d09cc8f47 -OpenBLAS.v0.3.23+2.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/084346b93a99671967433f4ac6548d7b828aa65c402bac7e68aee78bbf75e5cb06b22f42a7d4876fdea3e838162278ee3fcf011fa18530c8d8b0e853a4c6440c -OpenBLAS.v0.3.23+2.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/9796916fb0acbea2e93747dafa96d496 -OpenBLAS.v0.3.23+2.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/7c3643c3669fea262907bb5c0f27b492adfec910716498a0bd992d705a544b21023d77801f27c967c07be9d5b30bbd936137c8f59f61632fb16cc0e1f2efebd1 -OpenBLAS.v0.3.23+2.x86_64-apple-darwin-libgfortran3.tar.gz/md5/cbf9ad429547ebd1a473f735b6c65442 -OpenBLAS.v0.3.23+2.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/5e98ec17ee35624bf0a286a2dbe01f5ae4fa879274af70b218080c537a325a92fe76331b746e98b3ce3a0d127df2c03f522f554cb43c169a2b7b1890a9a8a81f -OpenBLAS.v0.3.23+2.x86_64-apple-darwin-libgfortran4.tar.gz/md5/28792164b6c34bc627966e338221ff34 -OpenBLAS.v0.3.23+2.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/433dcec661ff2459740c4d1e72d766549135f6f41a7ffb488502d76751fcb00c3d75aaa0e3db182441ef6b5e3b487a9df3e1b8b979da3681496f4ac6c6ce819b -OpenBLAS.v0.3.23+2.x86_64-apple-darwin-libgfortran5.tar.gz/md5/7013b806bfcd2c65582df5f224bd7d86 -OpenBLAS.v0.3.23+2.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/1078cf5583d158af5d38690acf913db378195b79b4743d977e7654c246fecb0ded4ebee96d89f54c5ec5f04af1b9858bcc0700251ccce1bf7c87926ede069b91 -OpenBLAS.v0.3.23+2.x86_64-linux-gnu-libgfortran3.tar.gz/md5/f959117d5c3fd001412c790bd478f7f6 -OpenBLAS.v0.3.23+2.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/e6fbe9fe1b7a92e10760d2b945bcc2c1c5e8399d729fbbb771764e7b72856707629123bc2d2fed2549f551776f8f0a737b0f414ffddc820a655172d933c10af9 -OpenBLAS.v0.3.23+2.x86_64-linux-gnu-libgfortran4.tar.gz/md5/af04d6bd91df5c9bcc63fe06c88a4b79 -OpenBLAS.v0.3.23+2.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/0cd4972d0a44505f9d8d3958bd20e491c986f55f5f84000ab534020dc8d39d788402355fa51bbd521c8c1bf6884d9d35c1db156bd106a98fbde80c104e8dd5a1 -OpenBLAS.v0.3.23+2.x86_64-linux-gnu-libgfortran5.tar.gz/md5/c5e6138630c5b616df1d045e1c388710 -OpenBLAS.v0.3.23+2.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/a54db7cb7e28dd792bd2c4f33945e7d99db1ee9a620bbe77a21cd7fa7f4cddc5c7744d27116951582f00223df09e7dc2258754032cebd57f61a723762743d3fb -OpenBLAS.v0.3.23+2.x86_64-linux-musl-libgfortran3.tar.gz/md5/7d407633f4f59c305896f9132c098cd2 -OpenBLAS.v0.3.23+2.x86_64-linux-musl-libgfortran3.tar.gz/sha512/8a04d46b6dc2eef87d6c4ac43bcdacf5da2b1669bb829c42f07f7f73bc0dba35a6e48f303d1e9cb951062fa2c3a4cce894406c5551c2bac7f57f02d2f92122a3 -OpenBLAS.v0.3.23+2.x86_64-linux-musl-libgfortran4.tar.gz/md5/1d6c7e0b6f3eeedb41ecfea9881d0bac -OpenBLAS.v0.3.23+2.x86_64-linux-musl-libgfortran4.tar.gz/sha512/9152b7f584ecc3f06caf0eaf0a496d9e9c16afe41a4750a9bcce0477cd3cabcdcec5c97c24fa3fba03d603148c8a3dcf7199c171abe10121aaee2f8a68b93c91 -OpenBLAS.v0.3.23+2.x86_64-linux-musl-libgfortran5.tar.gz/md5/fdd5c9e5f746403f7ba4789d8d8c47e1 -OpenBLAS.v0.3.23+2.x86_64-linux-musl-libgfortran5.tar.gz/sha512/2bd980e1e2021b32f3455fb3fdbae407fb672074ca798664c77e063ea6a7503b625eac7655c8cf25307afbfd9abaa64af52fbb3ed811ff8eb6515e3edcf26b1d -OpenBLAS.v0.3.23+2.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/e574046603e2da1ec8893059234f3220 -OpenBLAS.v0.3.23+2.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/8ea6dee8d0958b45f765d5296cdd47d93f739ff9681a7bb12f5549a35967bbac0519d62e0f06e51dbd7e50ccb828dc305afd0a2868cba786f458e53b5fda867b -OpenBLAS.v0.3.23+2.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/8f2233abe6dd7f0ce688131b63073f66 -OpenBLAS.v0.3.23+2.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/7d5296a5c213a99c474228cf7057af0ba38207960d74b5bfe4aa7a5b08b71da60f2cde3ed2a20f06d8526f39661eaa086825678d56b73c03fca6e6a10f64a9b2 -OpenBLAS.v0.3.23+2.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/4467b0b2b5977fe710b270749333dbe9 -OpenBLAS.v0.3.23+2.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/28c315b53d44c1a09fcb9a6a47a45d8e08bf8d5897c85e357ce1544bdf231e66a7d372590b6d67186fa301a499a625400cf4c7776b1a32ebbe65fc6ac63739a4 -OpenBLAS.v0.3.23+2.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/6e5818f491219b4a102790be5703ea8d -OpenBLAS.v0.3.23+2.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/2a5c05c288568a881328cb8b362b864d5d1113ee9570f80c1d84455c4698dc0c34c89934fb6962746350efb99780319a48bec9271f108527c9552aeec1e1365c -OpenBLAS.v0.3.23+2.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/dc6295ac25c2f4616918a07a61230039 -OpenBLAS.v0.3.23+2.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/9f39a8227d692b0d7a4976158a39687f14d8e28f9771de252a74c63b9b28cab4818e0160d3f8fe2b3a66500c0aa9301c4d8bcf6136b26f642db161adcc57f277 -OpenBLAS.v0.3.23+2.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/b3a142aadce39a017d15ce4293c3b86b -OpenBLAS.v0.3.23+2.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/9fd4b2219603c98fa40a5c3d3ab0a48e5e2d0352c984820eda6513aad68e3a25ba36521787704ddf25631e194d512a50ac60cd61aec8483e9273b75e5249579f +OpenBLAS.v0.3.23+4.aarch64-apple-darwin-libgfortran5.tar.gz/md5/4396075a0a35187b500ed7f55254a6bd +OpenBLAS.v0.3.23+4.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/2df0bb2eeb6c2945cd53b0182d00ab09e2cdf1731fe626af501a7632e8995bea21d8453d8e5671d4be9fd77a9ad12facdedf9e803c1fca35c36994dde26a6ac5 +OpenBLAS.v0.3.23+4.aarch64-linux-gnu-libgfortran3.tar.gz/md5/48023d189673623c1cf79cfc73df696b +OpenBLAS.v0.3.23+4.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/ecaaa3f6df848f4c247f4ef5ec9bb6e344c4ccf73b413b43ddaced9ce75a378b8ac59c6a9735a7030c61c7d74ba068329d4f9f60d1200a86df50644b604a15fd +OpenBLAS.v0.3.23+4.aarch64-linux-gnu-libgfortran4.tar.gz/md5/af961e90dc125b29b17868efb4a3ae61 +OpenBLAS.v0.3.23+4.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/30ca662a9ac89b907d9f49743e247a53d60d48be74c7ad4e19973fb7a5de908f4ad4566f08a1b576fe4aac146565c29fbcdc29c2b3f5226a3ede897f441477fd +OpenBLAS.v0.3.23+4.aarch64-linux-gnu-libgfortran5.tar.gz/md5/3b3534a64ca7363f206e4c8fabd69fd8 +OpenBLAS.v0.3.23+4.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/cf2f7b5b0b634f8826ae1ce76fe018b9d2c5d5c1b1bd511ea45c9a9004363adac3339ffd28c62ce7bf9424678c350221c3ed8919a2afbb61d2b3ccbe3283009e +OpenBLAS.v0.3.23+4.aarch64-linux-musl-libgfortran3.tar.gz/md5/e07bfcf56f7765adf431b834f36a1f09 +OpenBLAS.v0.3.23+4.aarch64-linux-musl-libgfortran3.tar.gz/sha512/6953043361c07583ff52074ad0cddb5b7f01b5f35d46435d442b907fc6c213df548fa6c010179355bbfa0a44a97761fec437c64384971821316f1063e909ac4e +OpenBLAS.v0.3.23+4.aarch64-linux-musl-libgfortran4.tar.gz/md5/3c949da2727e857cfa67f21b092d544c +OpenBLAS.v0.3.23+4.aarch64-linux-musl-libgfortran4.tar.gz/sha512/ffc6d956d5a2414324bf8e5db6b5a9c5ada72e2fd4c6f798a3f328ce21ddf5e86d664e2bcefd6e163684e7d5eb4cefeec9a597f3d9c6ab58d555a6d279b06c12 +OpenBLAS.v0.3.23+4.aarch64-linux-musl-libgfortran5.tar.gz/md5/458e31ac7b23846da374cb1593764166 +OpenBLAS.v0.3.23+4.aarch64-linux-musl-libgfortran5.tar.gz/sha512/fe1026095f3734e0540f482989ad62a7bd6f0521049f4f44eee944938b7dc8a8fc7fce744548c947a36b46944b8a7651c4b76ed82499038fc8bc8c5efcdb978e +OpenBLAS.v0.3.23+4.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/386a87787e313db0b5044c36b33dac07 +OpenBLAS.v0.3.23+4.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/f36c2d127adc3f596632e55fa98c1189b29f7efbabf352e96f865f3e6d958ead90707981acf77b10b7fa8efbc3f6d574da984021da6c6c25ef7d427972a484fa +OpenBLAS.v0.3.23+4.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/0e799ed6a5799c02e578ce8e5d179412 +OpenBLAS.v0.3.23+4.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/2036602634120677e86a1bf4aa833f6e5ed75d73751449c0d67fa336647d2f9af4301d5cfe4b1c77582565df95861c34edb83fb1b651b3664647528397e526ce +OpenBLAS.v0.3.23+4.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/f7140fc2824d53b16aeb441e8007e04d +OpenBLAS.v0.3.23+4.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/77f210113aa43b93844cc3e9f545deee27f8ef63379a8b7cab682957e698ab3f97b83741cbcacc0e518503eb6ee822e1578900be9546b63629c9cb3ecee17fd0 +OpenBLAS.v0.3.23+4.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/9d6f99e55e70b5e12aedd0513717f680 +OpenBLAS.v0.3.23+4.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/bddf250e25afc235130e381fe2ded98fbacb0f996bf522a89698776208c206de2c5cbc6f8f3cb60aad91b07a9389ea6b0dc8b8e3e04d9b78ba34282b142e8b77 +OpenBLAS.v0.3.23+4.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/d253d760a8071bff95152718142ddd86 +OpenBLAS.v0.3.23+4.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/62250517ef74b1d5df8e9b0507365f5194a458431819d9d7077a5aa4a922d22b7de72f9704cbd87768cfc8ef1fa9e6007c17529ee22a23bbbf83fada10aee8db +OpenBLAS.v0.3.23+4.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/4f6257915c6567d6fc523ab910667789 +OpenBLAS.v0.3.23+4.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/5a8770e6d60fc6ae10a2763316f5f0e8e08df7d07d3a9db36d0d1e4cf593a4c7aa848699b392d43acffd4d7af5be0ae373476df9bfdd82b82ce08759e05b2843 +OpenBLAS.v0.3.23+4.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/386a87787e313db0b5044c36b33dac07 +OpenBLAS.v0.3.23+4.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/f36c2d127adc3f596632e55fa98c1189b29f7efbabf352e96f865f3e6d958ead90707981acf77b10b7fa8efbc3f6d574da984021da6c6c25ef7d427972a484fa +OpenBLAS.v0.3.23+4.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/0e799ed6a5799c02e578ce8e5d179412 +OpenBLAS.v0.3.23+4.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/2036602634120677e86a1bf4aa833f6e5ed75d73751449c0d67fa336647d2f9af4301d5cfe4b1c77582565df95861c34edb83fb1b651b3664647528397e526ce +OpenBLAS.v0.3.23+4.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/f7140fc2824d53b16aeb441e8007e04d +OpenBLAS.v0.3.23+4.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/77f210113aa43b93844cc3e9f545deee27f8ef63379a8b7cab682957e698ab3f97b83741cbcacc0e518503eb6ee822e1578900be9546b63629c9cb3ecee17fd0 +OpenBLAS.v0.3.23+4.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/9d6f99e55e70b5e12aedd0513717f680 +OpenBLAS.v0.3.23+4.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/bddf250e25afc235130e381fe2ded98fbacb0f996bf522a89698776208c206de2c5cbc6f8f3cb60aad91b07a9389ea6b0dc8b8e3e04d9b78ba34282b142e8b77 +OpenBLAS.v0.3.23+4.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/d253d760a8071bff95152718142ddd86 +OpenBLAS.v0.3.23+4.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/62250517ef74b1d5df8e9b0507365f5194a458431819d9d7077a5aa4a922d22b7de72f9704cbd87768cfc8ef1fa9e6007c17529ee22a23bbbf83fada10aee8db +OpenBLAS.v0.3.23+4.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/4f6257915c6567d6fc523ab910667789 +OpenBLAS.v0.3.23+4.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/5a8770e6d60fc6ae10a2763316f5f0e8e08df7d07d3a9db36d0d1e4cf593a4c7aa848699b392d43acffd4d7af5be0ae373476df9bfdd82b82ce08759e05b2843 +OpenBLAS.v0.3.23+4.i686-linux-gnu-libgfortran3.tar.gz/md5/e7ea6dd9b95e5c527faa4fab39ac8f86 +OpenBLAS.v0.3.23+4.i686-linux-gnu-libgfortran3.tar.gz/sha512/b6ada30e5b80e2460ae3a7396aee066315d01fe918efbc39fda958fe1755ff3549b94a6c774e53f72920f1bb5123181810fcc8c637af847ff3b4ca8ae07a8c10 +OpenBLAS.v0.3.23+4.i686-linux-gnu-libgfortran4.tar.gz/md5/3fab9e79dd80c80bcfc84929db41f13f +OpenBLAS.v0.3.23+4.i686-linux-gnu-libgfortran4.tar.gz/sha512/7e8815ca0fce0e6943e54ccee98acf8ce90c514794394a7975ee3e1e51c02367688991042c34d3dc498d1d9487025c35296640bd2d5676d13fdbaecf9fa8bf19 +OpenBLAS.v0.3.23+4.i686-linux-gnu-libgfortran5.tar.gz/md5/59b82e8d7b93ce3d2b2e5c471d10e12e +OpenBLAS.v0.3.23+4.i686-linux-gnu-libgfortran5.tar.gz/sha512/6266f32518ad9e4322d44ba7536a5d8cf734c4ecd0674f16adba73cc64da944b29cd80b83e6304be408d237e06013881deffdbe89aecd459b52242cf2be6ba7b +OpenBLAS.v0.3.23+4.i686-linux-musl-libgfortran3.tar.gz/md5/f4daa1792329c98b7098119670c81d15 +OpenBLAS.v0.3.23+4.i686-linux-musl-libgfortran3.tar.gz/sha512/d6b5780af9a64df8fb510e158c0fb5da7bca67fc34e55e53891dd704203a4305e9efca865149e5719ecec9d3c202ce3ec0e1071ad2bb1a6f46e19e6a853d9f67 +OpenBLAS.v0.3.23+4.i686-linux-musl-libgfortran4.tar.gz/md5/8c799c1b1e1c8bb343beabb63b86a2d5 +OpenBLAS.v0.3.23+4.i686-linux-musl-libgfortran4.tar.gz/sha512/2ade84eba8f79a3312ca869fb8876b65ce010cbf2b43532bc88da75590ca2b392d7d1e2a2ce5c565d4a9490cf124b10686c0c429793e5ccb1c01640052f6ac4b +OpenBLAS.v0.3.23+4.i686-linux-musl-libgfortran5.tar.gz/md5/a9be243128a45d2243c8bd42289a36f5 +OpenBLAS.v0.3.23+4.i686-linux-musl-libgfortran5.tar.gz/sha512/941b1f63549d725c477ef98282906c706ceca9daf19b7d856ffd6bd83095fb8b45bc2d099576938f4e984c6e737c94b0a79e686eda11474ddfbecdefc3ec637a +OpenBLAS.v0.3.23+4.i686-w64-mingw32-libgfortran3.tar.gz/md5/2aa088a9a41ec94b63aca317ce0a0fdc +OpenBLAS.v0.3.23+4.i686-w64-mingw32-libgfortran3.tar.gz/sha512/7e291fcb11edb95d4e10b725a3acef4cec9d16ffd1e596687c0112ae8f0a298e128e12c0b96c54df98dd1bcb5917b53aad7c55e6325c09abee1153267103a432 +OpenBLAS.v0.3.23+4.i686-w64-mingw32-libgfortran4.tar.gz/md5/9d82aa30a6a08ea6294f935d2f0b05d3 +OpenBLAS.v0.3.23+4.i686-w64-mingw32-libgfortran4.tar.gz/sha512/2ea777015ddbdcac128b3313d091b63ce24504e368089cbd14d966c768e7109c4b94d17e190d9a0be222458f4d01e8542625b69057a30fae8f6cdc985ae70751 +OpenBLAS.v0.3.23+4.i686-w64-mingw32-libgfortran5.tar.gz/md5/409b6ce4af7e85bb6ea2c05d4075db81 +OpenBLAS.v0.3.23+4.i686-w64-mingw32-libgfortran5.tar.gz/sha512/a814c9fb705c4d779fc18a598ee67d68206d93010cc919a0b39b4514ab415c044fa385f1c50fa06fee45d894fa72715ba84d51ef3a11a08fe7a3fc1747348e4f +OpenBLAS.v0.3.23+4.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/3a7c1cc48100da0941e5ce8d85cb3a4f +OpenBLAS.v0.3.23+4.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/296574c54b2dbe3b7995a9661f8e79edbac091174260e44d7e791e225a5488676a9b29b1315c8e38c7d7db4927fb235dbf6b45d06a843fb653b5746a8f3adb7d +OpenBLAS.v0.3.23+4.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/136cd6727be4b3c5d8576faf4ed09b03 +OpenBLAS.v0.3.23+4.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/85f2ce79ca038fb85da85667b0aa79c26d43003543796240a1e5c2f6fc00f24af29d78bb587e66b94015cb973aed33fe0b7a16d5a2d39ad8c2fcf480c63797ab +OpenBLAS.v0.3.23+4.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/f8a6961fd047c73da271f1e4b441fc3f +OpenBLAS.v0.3.23+4.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/d4350fd12b1351060b977658c4483d18fddf18dc59b690b367f32bfa0b6d699ca49651392c49fd7addeef357239c60e17d0978c19acd661fa13ff78a7144e1dd +OpenBLAS.v0.3.23+4.x86_64-apple-darwin-libgfortran3.tar.gz/md5/80e5628c507d2bf82e7098a0666c6c4b +OpenBLAS.v0.3.23+4.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/5582854c2182e5bac5de86d318ba833b4454ce1c2f7d8f7d7f0b3c1effa341f97cb3e43a541cf4197eca0cb93c4da46337f73b153d55fa5283e7d134c2b2660e +OpenBLAS.v0.3.23+4.x86_64-apple-darwin-libgfortran4.tar.gz/md5/f130da7a989b870a930b6dc659112a7b +OpenBLAS.v0.3.23+4.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/0292a32d01b13fa69ed2d7620480611cc9e0a8aa325b4366dca3932971fa3ef989eff02ca14c06adfa7718840803b49fe7bf56982ad6f340569d9c7c1750dac2 +OpenBLAS.v0.3.23+4.x86_64-apple-darwin-libgfortran5.tar.gz/md5/b7d214ade95b63cbd950aa3cb976f679 +OpenBLAS.v0.3.23+4.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/d21f17a713a25983f415de063b3911cf39fc7f15493d41104b9e0b26b3a467f4b37a9dd5c5d0a3883de38e0a16c2a4a6a3bd7634b7f6868fbebdb473a15992d4 +OpenBLAS.v0.3.23+4.x86_64-linux-gnu-libgfortran3.tar.gz/md5/78f95af8bdd31302311fc5a05ec6f895 +OpenBLAS.v0.3.23+4.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/540e02f90f7d844ea3b93bb00de1097b092d46ad710026cfd4a659695f6e1b6ff359c2273c0abe14bb53a20ec1c6343c27bc718f84e8720790906451590d0258 +OpenBLAS.v0.3.23+4.x86_64-linux-gnu-libgfortran4.tar.gz/md5/f4261f43d8ae1fdb38280072dbcaf1ba +OpenBLAS.v0.3.23+4.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/40f69bbbf5e929346a9dcf2f30af00d91874f889137a9664800cb986c9354d0825b4a6a8746e27ef6b14af9611766ee9538daa1c5cbde24736924c8588071941 +OpenBLAS.v0.3.23+4.x86_64-linux-gnu-libgfortran5.tar.gz/md5/474eaed6749628e58bff5893492ad902 +OpenBLAS.v0.3.23+4.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/1fde4b09a4035a5177c60cc05bde8add73a06b3edfd59563ed5e6383e04d2b055bcfcbc989a8b6f7200efc1f862ea1b49ea2cfc7db4b30bf1aeb7dd641a622aa +OpenBLAS.v0.3.23+4.x86_64-linux-musl-libgfortran3.tar.gz/md5/3388a7a9cd0c7bc64ff3dd5bbd6221c1 +OpenBLAS.v0.3.23+4.x86_64-linux-musl-libgfortran3.tar.gz/sha512/5e84afb5cef4d050ae7a0b290556d726fd8e9c59f0a7e9bc778ea1352c1985c7fa942849781dfc3bc14f0a1c51138d858c9bbca9124b434e331fa3a0343e8fd8 +OpenBLAS.v0.3.23+4.x86_64-linux-musl-libgfortran4.tar.gz/md5/bfac12f41bb0d3be8123deb6a032a5aa +OpenBLAS.v0.3.23+4.x86_64-linux-musl-libgfortran4.tar.gz/sha512/30226271a4fa1ec44a01c68cf9d779142563786c19716e74c7a19029ccece71400cc6c9489794cb8f5b28815d8138c98dc3cb2d4011d5c5f7a009aa811b8088f +OpenBLAS.v0.3.23+4.x86_64-linux-musl-libgfortran5.tar.gz/md5/b105fea98718ff0e7fc7cced91e5fa33 +OpenBLAS.v0.3.23+4.x86_64-linux-musl-libgfortran5.tar.gz/sha512/d8a09e174f49a0542a3e87a746338198e3f6e37ed6989f89ae3fe8f95eeef9d6625814cd30abd3927d059b3076f91d3793e1e3292e417edfdbea3171729af68c +OpenBLAS.v0.3.23+4.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/809864b6b4ea73554202f47691e5487d +OpenBLAS.v0.3.23+4.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/42fb2b1a331a9ca86f004e63188153b82a6e4f85ea36b361725fca4b476ccc64f85b35f287bae067f21ea43f6f85642e54915f33b134e7a68dfe64fe33b05200 +OpenBLAS.v0.3.23+4.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/0caba2da8ea3be51848e3e57de5fdc4e +OpenBLAS.v0.3.23+4.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/39c9a9b6c893699491373efad401224eb499e636420545aaeca8c3475955601623abc0f3e10793ab72054b65a68651b663873c073cb9c0bbd89344f4b9496071 +OpenBLAS.v0.3.23+4.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/1735272b015753d79e7539e2c750c291 +OpenBLAS.v0.3.23+4.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/89dd7a92e5f9182abddc9a90f443568818a84a960959599b35d6c6d3fcb4f60d340f6f319510771f7c45123e591460a7a019067d550ac71d9af9a37d824eb123 +OpenBLAS.v0.3.23+4.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/238c184ab1cb65a6e48137859a8a52bb +OpenBLAS.v0.3.23+4.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/a73c4b42b798770e5f08ff83704c5d83bbd1f1101bf7c07effad1cabaf2b665d6e05ee2a73a552933d4bf48085bd4f80f5fd72c709b2012c5cf25c71aace1124 +OpenBLAS.v0.3.23+4.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/127aca06dc9461387cd5d2a91784242e +OpenBLAS.v0.3.23+4.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/03099f50dc81427762c404a27ce4d8eb20c37c9664789cac5640ecf360c4dadf7a759680cd81d00301781d68e5df780ab981cb89fd20c448d72e7f0d1a909bf9 +OpenBLAS.v0.3.23+4.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/92f18261534ceb1e3181c4b6071b0063 +OpenBLAS.v0.3.23+4.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/38894868b7d7638e61a503a30c88ddf910af4e0ff8b9480b97f4ee7598088ba5c4735d1d85575deb1e593d8b6baf8fc549c85c8ba8d1b9683eb58cffb3f9e670 openblas-394a9fbafe9010b76a2615c562204277a956eb52.tar.gz/md5/7ccaaaafc8176b87dc59d4e527ca4d9f openblas-394a9fbafe9010b76a2615c562204277a956eb52.tar.gz/sha512/12235f0459469b483a393844c228be5ad4bc60575bbe4b3238198f2480b7b457e4b0609730ce6d99530bb82e1d16fdd2338ceed6d28c952e6fff0da7f571f863 diff --git a/stdlib/OpenBLAS_jll/Project.toml b/stdlib/OpenBLAS_jll/Project.toml index b4baf955ea04e..92d68acd099f6 100644 --- a/stdlib/OpenBLAS_jll/Project.toml +++ b/stdlib/OpenBLAS_jll/Project.toml @@ -1,6 +1,6 @@ name = "OpenBLAS_jll" uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" -version = "0.3.23+2" +version = "0.3.23+4" [deps] # See note in `src/OpenBLAS_jll.jl` about this dependency. From b0b804ef6fc4b590f4dfcfce2b2d7e0ea70ae9dd Mon Sep 17 00:00:00 2001 From: Diogo Netto <61364108+d-netto@users.noreply.github.com> Date: Wed, 24 Jan 2024 14:08:42 -0300 Subject: [PATCH 37/42] use proper cache-line size variable in work-stealing queue (#53035) (cherry picked from commit 919c3908066da7ac361fa5677a6af11acbdc3153) --- src/julia_atomics.h | 9 +++++++++ src/julia_internal.h | 5 ----- src/work-stealing-queue.h | 2 +- 3 files changed, 10 insertions(+), 6 deletions(-) diff --git a/src/julia_atomics.h b/src/julia_atomics.h index c4488f774c987..76be881067805 100644 --- a/src/julia_atomics.h +++ b/src/julia_atomics.h @@ -56,6 +56,15 @@ enum jl_memory_order { jl_memory_order_seq_cst }; +/** + * Cache line size +*/ +#if defined(_CPU_AARCH64_) && defined(_OS_DARWIN_) // Apple silicon has 128 cache lines +#define JL_CACHE_BYTE_ALIGNMENT 128 +#else +#define JL_CACHE_BYTE_ALIGNMENT 64 +#endif + /** * Thread synchronization primitives: * diff --git a/src/julia_internal.h b/src/julia_internal.h index 7b40f59ae75b0..89f31f1702db7 100644 --- a/src/julia_internal.h +++ b/src/julia_internal.h @@ -458,11 +458,6 @@ STATIC_INLINE uint8_t JL_CONST_FUNC jl_gc_szclass_align8(unsigned sz) JL_NOTSAFE } #define JL_SMALL_BYTE_ALIGNMENT 16 -#if defined(_CPU_AARCH64_) && defined(_OS_DARWIN_) // Apple silicon has 128 cache lines -#define JL_CACHE_BYTE_ALIGNMENT 128 -#else -#define JL_CACHE_BYTE_ALIGNMENT 64 -#endif // JL_HEAP_ALIGNMENT is the maximum alignment that the GC can provide #define JL_HEAP_ALIGNMENT JL_SMALL_BYTE_ALIGNMENT #define GC_MAX_SZCLASS (2032-sizeof(void*)) diff --git a/src/work-stealing-queue.h b/src/work-stealing-queue.h index 084e421fd58b3..5902c2ac6af9f 100644 --- a/src/work-stealing-queue.h +++ b/src/work-stealing-queue.h @@ -36,7 +36,7 @@ static inline ws_array_t *create_ws_array(size_t capacity, int32_t eltsz) JL_NOT typedef struct { _Atomic(int64_t) top; - char _padding[128 - sizeof(int64_t)]; + char _padding[JL_CACHE_BYTE_ALIGNMENT - sizeof(_Atomic(int64_t))]; _Atomic(int64_t) bottom; // put on a separate cache line. conservatively estimate cache line size as 128 bytes _Atomic(ws_array_t *) array; } ws_queue_t; From a45cd5f81c08b69fa2439c307bfc61fe8ed9ca0a Mon Sep 17 00:00:00 2001 From: Max Horn Date: Mon, 29 Jan 2024 02:43:22 +0100 Subject: [PATCH 38/42] doc: replace harr HTML entity by unicode (#53066) Documenter does not support HTML entities. See discussion in PR #52078 for further background. Co-authored-by: Dilum Aluthge (cherry picked from commit 746fad00a4fb11fe34502c1b89e966fa129b645c) --- doc/src/manual/noteworthy-differences.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/doc/src/manual/noteworthy-differences.md b/doc/src/manual/noteworthy-differences.md index e29ac2249ab95..0f97918062fcf 100644 --- a/doc/src/manual/noteworthy-differences.md +++ b/doc/src/manual/noteworthy-differences.md @@ -352,7 +352,7 @@ For users coming to Julia from R, these are some noteworthy differences: it's more general than that since methods are dispatched on every argument type, not only `this`, using the most-specific-declaration rule). -### Julia ↔ C/C++: Namespaces +### Julia ⇔ C/C++: Namespaces * C/C++ `namespace`s correspond roughly to Julia `module`s. * There are no private globals or fields in Julia. Everything is publicly accessible through fully qualified paths (or relative paths, if desired). @@ -364,7 +364,7 @@ For users coming to Julia from R, these are some noteworthy differences: * Caveat: `import`/`using` (Julia) works only at the global scope level (`module`s) * In C++, `using namespace X` works within arbitrary scopes (ex: function scope). -### Julia ↔ C/C++: Module loading +### Julia ⇔ C/C++: Module loading * When you think of a C/C++ "**library**", you are likely looking for a Julia "**package**". * Caveat: C/C++ libraries often house multiple "software modules" whereas Julia "packages" typically house one. @@ -395,7 +395,7 @@ For users coming to Julia from R, these are some noteworthy differences: * Directory-based package repositories are the **quickest solution** to developping local libraries of "software modules". -### Julia ↔ C/C++: Assembling modules +### Julia ⇔ C/C++: Assembling modules * In C/C++, `.c`/`.cpp` files are compiled & added to a library with build/`make` scripts. * In Julia, `import [PkgName]`/`using [PkgName]` statements load `[PkgName].jl` located in a package's `[PkgName]/src/` subdirectory. @@ -412,7 +412,7 @@ For users coming to Julia from R, these are some noteworthy differences: Julia package* ("software module"). It is therefore relatively straightforward to ensure file are `include`d only once (No `#ifdef` confusion). -### Julia ↔ C/C++: Module interface +### Julia ⇔ C/C++: Module interface * C++ exposes interfaces using "public" `.h`/`.hpp` files whereas Julia `module`s mark specific symbols that are intended for their users as `public`or `export`ed. * Often, Julia `module`s simply add functionality by generating new "methods" to existing @@ -425,7 +425,7 @@ For users coming to Julia from R, these are some noteworthy differences: * Users might be expected to access these components by qualifying functions/structs/... with the package/module name (ex: `MyModule.run_this_task(...)`). -### Julia ↔ C/C++: Quick reference +### Julia ⇔ C/C++: Quick reference | Software Concept | Julia | C/C++ | | :--- | :--- | :--- | From c644e8952caaab6021d4f28fccd8b74df666bb45 Mon Sep 17 00:00:00 2001 From: Pablo San-Jose Date: Mon, 29 Jan 2024 15:51:47 +0100 Subject: [PATCH 39/42] apply OpenBLAS_jll v0.3.23+4 patch (#53074) Closes #53054 CC: @giordano @ViralBShah --- deps/openblas.mk | 7 +- deps/patches/openblas-m1-4003.patch | 250 ++++++++++++++++++++++++++++ stdlib/LinearAlgebra/test/blas.jl | 13 ++ 3 files changed, 269 insertions(+), 1 deletion(-) create mode 100644 deps/patches/openblas-m1-4003.patch diff --git a/deps/openblas.mk b/deps/openblas.mk index d890a5be6046a..6be017b967f94 100644 --- a/deps/openblas.mk +++ b/deps/openblas.mk @@ -100,7 +100,12 @@ $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/neoverse-generic-kernels.patch-applied: $(BUILDD patch -p1 -f < $(SRCDIR)/patches/neoverse-generic-kernels.patch echo 1 > $@ -$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-configured: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/neoverse-generic-kernels.patch-applied +$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-m1-4003.patch-applied: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/neoverse-generic-kernels.patch-applied + cd $(BUILDDIR)/$(OPENBLAS_SRC_DIR) && \ + patch -p1 -f < $(SRCDIR)/patches/openblas-m1-4003.patch + echo 1 > $@ + +$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-configured: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-m1-4003.patch-applied echo 1 > $@ $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-compiled: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-configured diff --git a/deps/patches/openblas-m1-4003.patch b/deps/patches/openblas-m1-4003.patch new file mode 100644 index 0000000000000..11e352572d9df --- /dev/null +++ b/deps/patches/openblas-m1-4003.patch @@ -0,0 +1,250 @@ +From caa2945138f3c8a6f3f0dacbaf653c283e3cd2cb Mon Sep 17 00:00:00 2001 +From: Martin Kroeker +Date: Tue, 11 Apr 2023 00:04:09 +0200 +Subject: [PATCH] Support Apple A15/M2 cpus through the existing VORTEX target + +--- + cpuid_arm64.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +diff --git a/cpuid_arm64.c b/cpuid_arm64.c +index 1080ea974..809f48e95 100644 +--- a/cpuid_arm64.c ++++ b/cpuid_arm64.c +@@ -268,7 +268,8 @@ int detect(void) + #else + #ifdef __APPLE__ + sysctlbyname("hw.cpufamily",&value,&length,NULL,0); +- if (value ==131287967|| value == 458787763 ) return CPU_VORTEX; ++ if (value ==131287967|| value == 458787763 ) return CPU_VORTEX; //A12/M1 ++ if (value == 3660830781) return CPU_VORTEX; //A15/M2 + #endif + return CPU_ARMV8; + #endif + +From cda29633a30bf7ecbc64f85e4bcc6517ad954f1c Mon Sep 17 00:00:00 2001 +From: Martin Kroeker +Date: Thu, 13 Apr 2023 17:59:48 +0200 +Subject: [PATCH 1/8] move ALPHA_I out of register 18 (reserved on OSX) + +--- + kernel/arm64/cgemm_kernel_8x4.S | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/kernel/arm64/cgemm_kernel_8x4.S b/kernel/arm64/cgemm_kernel_8x4.S +index 24e08a646a..f100adc7af 100644 +--- a/kernel/arm64/cgemm_kernel_8x4.S ++++ b/kernel/arm64/cgemm_kernel_8x4.S +@@ -49,7 +49,7 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + #define pCRow3 x15 + #define pA x16 + #define alphaR w17 +-#define alphaI w18 ++#define alphaI w19 + + #define alpha0_R s10 + #define alphaV0_R v10.s[0] + +From c7bbad09adf8cdd2fa4b8709ea669e530a0136a4 Mon Sep 17 00:00:00 2001 +From: Martin Kroeker +Date: Thu, 13 Apr 2023 18:00:47 +0200 +Subject: [PATCH 2/8] Move ALPHA_I out of register 18 (reserved on OSX) + +--- + kernel/arm64/cgemm_kernel_8x4_thunderx2t99.S | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/kernel/arm64/cgemm_kernel_8x4_thunderx2t99.S b/kernel/arm64/cgemm_kernel_8x4_thunderx2t99.S +index 29a68ff227..2c63925be2 100644 +--- a/kernel/arm64/cgemm_kernel_8x4_thunderx2t99.S ++++ b/kernel/arm64/cgemm_kernel_8x4_thunderx2t99.S +@@ -49,7 +49,7 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + #define pCRow3 x15 + #define pA x16 + #define alphaR w17 +-#define alphaI w18 ++#define alphaI w19 + + #define alpha0_R s10 + #define alphaV0_R v10.s[0] + +From 0b1acb0ba3aa327fee65bc6bcf596080dfc39f4b Mon Sep 17 00:00:00 2001 +From: Martin Kroeker +Date: Thu, 13 Apr 2023 18:03:35 +0200 +Subject: [PATCH 3/8] Move ALPHA_I out of register 18 (reserved on OSX) + +--- + kernel/arm64/ctrmm_kernel_8x4.S | 8 ++++---- + 1 file changed, 4 insertions(+), 4 deletions(-) + +diff --git a/kernel/arm64/ctrmm_kernel_8x4.S b/kernel/arm64/ctrmm_kernel_8x4.S +index 5c08273975..e8f1d8cf30 100644 +--- a/kernel/arm64/ctrmm_kernel_8x4.S ++++ b/kernel/arm64/ctrmm_kernel_8x4.S +@@ -49,10 +49,10 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + #define pCRow3 x15 + #define pA x16 + #define alphaR w17 +-#define alphaI w18 +-#define temp x19 +-#define tempOffset x20 +-#define tempK x21 ++#define alphaI w19 ++#define temp x20 ++#define tempOffset x21 ++#define tempK x22 + + #define alpha0_R s10 + #define alphaV0_R v10.s[0] + +From 108a21e47a754032a9fb5477afcb76c6c158a146 Mon Sep 17 00:00:00 2001 +From: Martin Kroeker +Date: Thu, 13 Apr 2023 18:05:14 +0200 +Subject: [PATCH 4/8] Move ALPHA out of register 18 (reserved on OSX) + +--- + kernel/arm64/sgemm_kernel_sve_v2x8.S | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/kernel/arm64/sgemm_kernel_sve_v2x8.S b/kernel/arm64/sgemm_kernel_sve_v2x8.S +index c969ed4db4..60e1f347b8 100644 +--- a/kernel/arm64/sgemm_kernel_sve_v2x8.S ++++ b/kernel/arm64/sgemm_kernel_sve_v2x8.S +@@ -55,8 +55,8 @@ With this approach, we can reuse sgemm_n|tcopy_sve_v1.c packing functions. */ + #define lanes x15 + #define pA1 x16 + #define pA2 x17 +-#define alpha w18 +-#define vec_len x19 ++#define alpha w19 ++#define vec_len x20 + #define vec_lenx2 x20 + + #define alpha0 s10 + +From 3727672a74c18938230c3a2db012a5693688bfd6 Mon Sep 17 00:00:00 2001 +From: Martin Kroeker +Date: Thu, 13 Apr 2023 18:07:52 +0200 +Subject: [PATCH 5/8] Improve workaround and keep compilers from optimizing it + out + +--- + kernel/arm64/dznrm2_thunderx2t99.c | 6 ++++-- + 1 file changed, 4 insertions(+), 2 deletions(-) + +diff --git a/kernel/arm64/dznrm2_thunderx2t99.c b/kernel/arm64/dznrm2_thunderx2t99.c +index e342b0b63f..0bd274b3f1 100644 +--- a/kernel/arm64/dznrm2_thunderx2t99.c ++++ b/kernel/arm64/dznrm2_thunderx2t99.c +@@ -27,7 +27,7 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + + #include "common.h" +- ++#include + #include + + #if defined(SMP) +@@ -344,6 +344,7 @@ FLOAT CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x) + FLOAT dummy_alpha[2]; + #endif + FLOAT ssq, scale; ++ volatile FLOAT sca; + + if (n <= 0 || inc_x <= 0) return 0.0; + +@@ -404,7 +405,8 @@ FLOAT CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x) + #else + nrm2_compute(n, x, inc_x, &ssq, &scale); + #endif +- if (fabs(scale) <1.e-300) return 0.; ++ sca = fabs(scale); ++ if (sca < DBL_MIN) return 0.; + ssq = sqrt(ssq) * scale; + + return ssq; + +From f096a339e4a22f4bc6dc454640e5d4007b07368b Mon Sep 17 00:00:00 2001 +From: Martin Kroeker +Date: Thu, 13 Apr 2023 18:16:09 +0200 +Subject: [PATCH 6/8] Use long value fields for cpu ident on OSX + +--- + cpuid_arm64.c | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +diff --git a/cpuid_arm64.c b/cpuid_arm64.c +index 809f48e95a..e586f9a3c2 100644 +--- a/cpuid_arm64.c ++++ b/cpuid_arm64.c +@@ -267,9 +267,9 @@ int detect(void) + } + #else + #ifdef __APPLE__ +- sysctlbyname("hw.cpufamily",&value,&length,NULL,0); +- if (value ==131287967|| value == 458787763 ) return CPU_VORTEX; //A12/M1 +- if (value == 3660830781) return CPU_VORTEX; //A15/M2 ++ sysctlbyname("hw.cpufamily",&value64,&length64,NULL,0); ++ if (value64 ==131287967|| value64 == 458787763 ) return CPU_VORTEX; //A12/M1 ++ if (value64 == 3660830781) return CPU_VORTEX; //A15/M2 + #endif + return CPU_ARMV8; + #endif + +From 8be68fa7f4edfa0c65949faf67f8feea2c7f0f43 Mon Sep 17 00:00:00 2001 +From: Martin Kroeker +Date: Sat, 15 Apr 2023 12:02:39 +0200 +Subject: [PATCH 7/8] move declaration of sca to really keep the compiler from + throwing it out (for now) + +--- + kernel/arm64/dznrm2_thunderx2t99.c | 3 +-- + 1 file changed, 1 insertion(+), 2 deletions(-) + +diff --git a/kernel/arm64/dznrm2_thunderx2t99.c b/kernel/arm64/dznrm2_thunderx2t99.c +index 0bd274b3f1..6077c85dd1 100644 +--- a/kernel/arm64/dznrm2_thunderx2t99.c ++++ b/kernel/arm64/dznrm2_thunderx2t99.c +@@ -344,7 +344,6 @@ FLOAT CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x) + FLOAT dummy_alpha[2]; + #endif + FLOAT ssq, scale; +- volatile FLOAT sca; + + if (n <= 0 || inc_x <= 0) return 0.0; + +@@ -405,7 +404,7 @@ FLOAT CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x) + #else + nrm2_compute(n, x, inc_x, &ssq, &scale); + #endif +- sca = fabs(scale); ++ volatile FLOAT sca = fabs(scale); + if (sca < DBL_MIN) return 0.; + ssq = sqrt(ssq) * scale; + + +From 44164e3a3d7f5c956728596b9f88d43cad0a8c14 Mon Sep 17 00:00:00 2001 +From: Martin Kroeker +Date: Mon, 17 Apr 2023 14:23:13 +0200 +Subject: [PATCH 8/8] revert "move alpha out of register 18" (out of PR scope, + no SVE on Apple hw) + +--- + kernel/arm64/sgemm_kernel_sve_v2x8.S | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/kernel/arm64/sgemm_kernel_sve_v2x8.S b/kernel/arm64/sgemm_kernel_sve_v2x8.S +index 60e1f347b8..c969ed4db4 100644 +--- a/kernel/arm64/sgemm_kernel_sve_v2x8.S ++++ b/kernel/arm64/sgemm_kernel_sve_v2x8.S +@@ -55,8 +55,8 @@ With this approach, we can reuse sgemm_n|tcopy_sve_v1.c packing functions. */ + #define lanes x15 + #define pA1 x16 + #define pA2 x17 +-#define alpha w19 +-#define vec_len x20 ++#define alpha w18 ++#define vec_len x19 + #define vec_lenx2 x20 + + #define alpha0 s10 diff --git a/stdlib/LinearAlgebra/test/blas.jl b/stdlib/LinearAlgebra/test/blas.jl index 4252d9ee7938b..d7f13c9f8a717 100644 --- a/stdlib/LinearAlgebra/test/blas.jl +++ b/stdlib/LinearAlgebra/test/blas.jl @@ -126,6 +126,19 @@ Random.seed!(100) @test BLAS.iamax(b) == findmax(fabs, b)[2] * (step(ind) >= 0) end end + @testset "deterministic mul!" begin + # mul! should be deterministic, see #53054 + function tester_53054() + C = ComplexF32 + mat = zeros(C, 1, 1) + for _ in 1:100 + v = [C(1-0.2im) C(2+0.3im)] + mul!(mat, v, v', C(1+im), 1) + end + return mat + end + @test allequal(tester_53054() for _ in 1:10000) + end @testset "scal" begin α = rand(elty) a = rand(elty,n) From 00aa65ee842958c81de53ff123d811783c92e7a1 Mon Sep 17 00:00:00 2001 From: Kristoffer Date: Tue, 30 Jan 2024 18:19:43 +0100 Subject: [PATCH 40/42] bump NetworkOptions --- .../md5 | 1 + .../sha512 | 1 + .../md5 | 1 - .../sha512 | 1 - stdlib/NetworkOptions.version | 2 +- 5 files changed, 3 insertions(+), 3 deletions(-) create mode 100644 deps/checksums/NetworkOptions-aab83e5dd900c874826d430e25158dff43559d78.tar.gz/md5 create mode 100644 deps/checksums/NetworkOptions-aab83e5dd900c874826d430e25158dff43559d78.tar.gz/sha512 delete mode 100644 deps/checksums/NetworkOptions-f7bbeb66f05fc651adb12758b650e8630a998fbd.tar.gz/md5 delete mode 100644 deps/checksums/NetworkOptions-f7bbeb66f05fc651adb12758b650e8630a998fbd.tar.gz/sha512 diff --git a/deps/checksums/NetworkOptions-aab83e5dd900c874826d430e25158dff43559d78.tar.gz/md5 b/deps/checksums/NetworkOptions-aab83e5dd900c874826d430e25158dff43559d78.tar.gz/md5 new file mode 100644 index 0000000000000..433b89eaedcc2 --- /dev/null +++ b/deps/checksums/NetworkOptions-aab83e5dd900c874826d430e25158dff43559d78.tar.gz/md5 @@ -0,0 +1 @@ +73b81916dc08382ad34b8110983b61ad diff --git a/deps/checksums/NetworkOptions-aab83e5dd900c874826d430e25158dff43559d78.tar.gz/sha512 b/deps/checksums/NetworkOptions-aab83e5dd900c874826d430e25158dff43559d78.tar.gz/sha512 new file mode 100644 index 0000000000000..01f34b83dc80b --- /dev/null +++ b/deps/checksums/NetworkOptions-aab83e5dd900c874826d430e25158dff43559d78.tar.gz/sha512 @@ -0,0 +1 @@ +a860163ef4fa5c2ff8d8712fff5ad5bb16e7697acc53538a0dda4435b910f4ad94f9c206e0d81864762361fdbcfbc57eb2e1708b33326f4f1c8d95997a495fe3 diff --git a/deps/checksums/NetworkOptions-f7bbeb66f05fc651adb12758b650e8630a998fbd.tar.gz/md5 b/deps/checksums/NetworkOptions-f7bbeb66f05fc651adb12758b650e8630a998fbd.tar.gz/md5 deleted file mode 100644 index 9e91b76f9a3c8..0000000000000 --- a/deps/checksums/NetworkOptions-f7bbeb66f05fc651adb12758b650e8630a998fbd.tar.gz/md5 +++ /dev/null @@ -1 +0,0 @@ -16bc9f2eefa3021e19a09ffefc84159b diff --git a/deps/checksums/NetworkOptions-f7bbeb66f05fc651adb12758b650e8630a998fbd.tar.gz/sha512 b/deps/checksums/NetworkOptions-f7bbeb66f05fc651adb12758b650e8630a998fbd.tar.gz/sha512 deleted file mode 100644 index 551f7c8da347c..0000000000000 --- a/deps/checksums/NetworkOptions-f7bbeb66f05fc651adb12758b650e8630a998fbd.tar.gz/sha512 +++ /dev/null @@ -1 +0,0 @@ -5b53c09343e25b5bde7ea12c2119da656040ca5f62ce934f00f57945ce73dfaf26522da6a9a007ba06ac6fd75a285cbcbdf5edaf9113faa7bba0398294fbd684 diff --git a/stdlib/NetworkOptions.version b/stdlib/NetworkOptions.version index 64d3fab9d7bf4..be36f14f526dc 100644 --- a/stdlib/NetworkOptions.version +++ b/stdlib/NetworkOptions.version @@ -1,4 +1,4 @@ NETWORKOPTIONS_BRANCH = master -NETWORKOPTIONS_SHA1 = f7bbeb66f05fc651adb12758b650e8630a998fbd +NETWORKOPTIONS_SHA1 = aab83e5dd900c874826d430e25158dff43559d78 NETWORKOPTIONS_GIT_URL := https://github.com/JuliaLang/NetworkOptions.jl.git NETWORKOPTIONS_TAR_URL = https://api.github.com/repos/JuliaLang/NetworkOptions.jl/tarball/$1 From 6407c3379b9dc38327a759b2f6324f0b3e927695 Mon Sep 17 00:00:00 2001 From: Jameson Nash Date: Tue, 30 Jan 2024 20:28:11 -0500 Subject: [PATCH 41/42] inference: avoid adding duplicate edges as invoke targets (#53121) This was inefficient, though not wrong. Fixes #53020 --- base/compiler/ssair/inlining.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl index 232112fc4cd1b..019df328ab9a1 100644 --- a/base/compiler/ssair/inlining.jl +++ b/base/compiler/ssair/inlining.jl @@ -837,7 +837,7 @@ function compileable_specialization(mi::MethodInstance, effects::Effects, end end add_inlining_backedge!(et, mi) # to the dispatch lookup - push!(et.edges, method.sig, mi_invoke) # add_inlining_backedge to the invoke call + mi_invoke !== mi && push!(et.edges, method.sig, mi_invoke) # add_inlining_backedge to the invoke call, if that is different return InvokeCase(mi_invoke, effects, info) end From 062707695c84674338a523d064b6370bcfc69326 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mos=C3=A8=20Giordano?= Date: Thu, 19 Oct 2023 09:37:16 +0100 Subject: [PATCH 42/42] Put mingw32 `*.a` files in `private_libdir` (#51698) This avoid that these files are picked up during julia's build process, and are instead only used to link pkgimages, as intended. Co-authored-by: Tim Besard (cherry picked from commit 4ef353c6e4ad5156ad65cb40c3a2a61fbd324b59) --- Make.inc | 2 +- Makefile | 9 +- base/linking.jl | 6 +- deps/checksums/compilersupportlibraries | 184 +++++++++--------- deps/csl.mk | 16 ++ .../CompilerSupportLibraries_jll/Project.toml | 4 +- 6 files changed, 117 insertions(+), 104 deletions(-) diff --git a/Make.inc b/Make.inc index 729870fbad860..021508e620cd1 100644 --- a/Make.inc +++ b/Make.inc @@ -1233,7 +1233,7 @@ LIBGFORTRAN_VERSION := $(subst libgfortran,,$(filter libgfortran%,$(subst -,$(SP # shipped with CSL. Although we do not depend on any of the symbols, it is entirely # possible that a user might choose to install a library which depends on symbols provided # by a newer libstdc++. Without runtime detection, those libraries would break. -CSL_NEXT_GLIBCXX_VERSION=GLIBCXX_3\.4\.31|GLIBCXX_3\.5\.|GLIBCXX_4\. +CSL_NEXT_GLIBCXX_VERSION=GLIBCXX_3\.4\.33|GLIBCXX_3\.5\.|GLIBCXX_4\. # This is the set of projects that BinaryBuilder dependencies are hooked up for. diff --git a/Makefile b/Makefile index 1565014a0fa5e..22e0f7e152859 100644 --- a/Makefile +++ b/Makefile @@ -281,16 +281,13 @@ else ifeq ($(JULIA_BUILD_MODE),debug) -$(INSTALL_M) $(build_libdir)/libjulia-debug.dll.a $(DESTDIR)$(libdir)/ -$(INSTALL_M) $(build_libdir)/libjulia-internal-debug.dll.a $(DESTDIR)$(libdir)/ endif + -$(INSTALL_M) $(wildcard $(build_private_libdir)/*.a) $(DESTDIR)$(private_libdir)/ - # We have a single exception; we want 7z.dll to live in private_libexecdir, not bindir, so that 7z.exe can find it. + # We have a single exception; we want 7z.dll to live in private_libexecdir, + # not bindir, so that 7z.exe can find it. -mv $(DESTDIR)$(bindir)/7z.dll $(DESTDIR)$(private_libexecdir)/ -$(INSTALL_M) $(build_bindir)/libopenlibm.dll.a $(DESTDIR)$(libdir)/ -$(INSTALL_M) $(build_libdir)/libssp.dll.a $(DESTDIR)$(libdir)/ - # The rest are compiler dependencies, as an example memcpy is exported by msvcrt - # These are files from mingw32 and required for creating shared libraries like our caches. - -$(INSTALL_M) $(build_libdir)/libgcc_s.a $(DESTDIR)$(libdir)/ - -$(INSTALL_M) $(build_libdir)/libgcc.a $(DESTDIR)$(libdir)/ - -$(INSTALL_M) $(build_libdir)/libmsvcrt.a $(DESTDIR)$(libdir)/ else # Copy over .dSYM directories directly for Darwin diff --git a/base/linking.jl b/base/linking.jl index fd21ce74c9268..2d68ea730c0fb 100644 --- a/base/linking.jl +++ b/base/linking.jl @@ -150,16 +150,16 @@ else end function link_image_cmd(path, out) - LIBDIR = "-L$(libdir())" PRIVATE_LIBDIR = "-L$(private_libdir())" SHLIBDIR = "-L$(shlibdir())" - LIBS = is_debug() ? ("-ljulia-debug", "-ljulia-internal-debug") : ("-ljulia", "-ljulia-internal") + LIBS = is_debug() ? ("-ljulia-debug", "-ljulia-internal-debug") : + ("-ljulia", "-ljulia-internal") @static if Sys.iswindows() LIBS = (LIBS..., "-lopenlibm", "-lssp", "-lgcc_s", "-lgcc", "-lmsvcrt") end V = VERBOSE[] ? "--verbose" : "" - `$(ld()) $V $SHARED -o $out $WHOLE_ARCHIVE $path $NO_WHOLE_ARCHIVE $LIBDIR $PRIVATE_LIBDIR $SHLIBDIR $LIBS` + `$(ld()) $V $SHARED -o $out $WHOLE_ARCHIVE $path $NO_WHOLE_ARCHIVE $PRIVATE_LIBDIR $SHLIBDIR $LIBS` end function link_image(path, out, internal_stderr::IO=stderr, internal_stdout::IO=stdout) diff --git a/deps/checksums/compilersupportlibraries b/deps/checksums/compilersupportlibraries index 0908c34e13a58..2dcfecfb56b26 100644 --- a/deps/checksums/compilersupportlibraries +++ b/deps/checksums/compilersupportlibraries @@ -1,92 +1,92 @@ -CompilerSupportLibraries.v1.0.5+1.aarch64-apple-darwin-libgfortran5.tar.gz/md5/20ebaad57850393b6ac9fa924e511fe4 -CompilerSupportLibraries.v1.0.5+1.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/020de4d8b0ff6bedbadaa305ff8445e6849f12053762ea4aa68412d1ec763dbd86f479587a2fbb862487f1feb04d976c38099ddf3887817a3d32b3f029cf85b1 -CompilerSupportLibraries.v1.0.5+1.aarch64-linux-gnu-libgfortran3.tar.gz/md5/3908fa1a2f739b330e787468c9bfb5c8 -CompilerSupportLibraries.v1.0.5+1.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/1741e3403ac7aa99e7cfd9a01222c4153ed300f47cc1b347e1af1a6cd07a82caaa54b9cfbebae8751440420551621cc6524504413446d104f9493dff2c081853 -CompilerSupportLibraries.v1.0.5+1.aarch64-linux-gnu-libgfortran4.tar.gz/md5/2444dbb7637b32cf543675cc12330878 -CompilerSupportLibraries.v1.0.5+1.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/8537f0b243df8544350c884021b21c585fd302e8dd462a30a6ee84c7a36a049133262e5d1bc362f972066b8e8d6a091c32c3b746bab1feb9fccf2e7cca65756c -CompilerSupportLibraries.v1.0.5+1.aarch64-linux-gnu-libgfortran5.tar.gz/md5/d79c1434594c0c5e7d6be798bf52c99e -CompilerSupportLibraries.v1.0.5+1.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/7e71accc401a45b51b298702fb4c79a2fc856c7b28f0935f6ad3a0db5381c55fe5432daff371842930d718024b7c6c1d80e2bd09d397145203673bebbe3496ae -CompilerSupportLibraries.v1.0.5+1.aarch64-linux-musl-libgfortran3.tar.gz/md5/f212059053d99558a9b0bf54b20180e1 -CompilerSupportLibraries.v1.0.5+1.aarch64-linux-musl-libgfortran3.tar.gz/sha512/5c104b1282cec8a944e5d008f44a4d60f4394fd5d797fec7d1f487d13e7328cd9c88ec4916dabf18596d87160756bda914e4f8c5a356b5577f9349d0d9e976d6 -CompilerSupportLibraries.v1.0.5+1.aarch64-linux-musl-libgfortran4.tar.gz/md5/3e3b3795ee93ef317223050e803a9875 -CompilerSupportLibraries.v1.0.5+1.aarch64-linux-musl-libgfortran4.tar.gz/sha512/85d3c955e15f66bfe8bfec2f28c9160bc03d4d531ea4ffe6bc6b51e0d69ccea3ab67a16ca752dabc870861c407381c4519d75c6be3832e8dccd6122ec8c6ed75 -CompilerSupportLibraries.v1.0.5+1.aarch64-linux-musl-libgfortran5.tar.gz/md5/cf2d1315f6a348af2e6c065e2a286e7a -CompilerSupportLibraries.v1.0.5+1.aarch64-linux-musl-libgfortran5.tar.gz/sha512/58420377bc77aa7678034ee5f708eb6be7db359faef2c2638869765453633da9bf455512bd88e95b38ae0428ecc4053561517b176b2371129bdaef9d8d5dadfd -CompilerSupportLibraries.v1.0.5+1.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/f5c09ed7e0eeb8d345d328f950582f26 -CompilerSupportLibraries.v1.0.5+1.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/9c657f55c8fcdeb404be168a3a63a5e84304730fe34f25673d92cdae4b0a1fcc6a877ee1433f060e1be854c7811d66632e32510a2ed591d88330f1340b9c20de -CompilerSupportLibraries.v1.0.5+1.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/c685518aca4721cd8621d510e2039683 -CompilerSupportLibraries.v1.0.5+1.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/b760468c6377dcd2b8dd50200daaabe604006afc070984d78152b2becd0680b59036c9a6e91dea490121bd85b58d285bfc1e1cf696d29af236528400101de36c -CompilerSupportLibraries.v1.0.5+1.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/8faf5c8ad62ab10f71dd2ec9683053e2 -CompilerSupportLibraries.v1.0.5+1.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/921239f241a5c89710cf07272d7f6c3f10201a7533068ed1e9643f9fb2f439e1bb765a4966d913829866ee0ce4f1589d30d06e4b5c1361e3c016a9473f087177 -CompilerSupportLibraries.v1.0.5+1.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/b38fcb70691ac2621379d298eef8c79e -CompilerSupportLibraries.v1.0.5+1.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/06c7f64257ce721f5941f6e50a0d2717cdc9394fc532ded19ce3eaacd5e92a416969534227562e4fee04d2b6340c650d8bc9779e14519b90038bc41e8d1f5ce3 -CompilerSupportLibraries.v1.0.5+1.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/cdfab2c7bc41765caf4441c3caeed761 -CompilerSupportLibraries.v1.0.5+1.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/7109d4a7b32c00309c42685f54a86fc2cc63c0c00f65584ad296b6e44ad3320eed1aaf49684a8831841cdffa5555d72f89272fb722a780596e27ef020528026b -CompilerSupportLibraries.v1.0.5+1.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/441980ebd23d72772cbe603f1c275336 -CompilerSupportLibraries.v1.0.5+1.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/e273d9f1af259a3080df8f173e1808a1ade976a943aba97216bf59a96178e7c052e7a048b0ceee53ab486ed577a2ecb92579857be2f7b29e76322ee1f13c9d76 -CompilerSupportLibraries.v1.0.5+1.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/f5c09ed7e0eeb8d345d328f950582f26 -CompilerSupportLibraries.v1.0.5+1.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/9c657f55c8fcdeb404be168a3a63a5e84304730fe34f25673d92cdae4b0a1fcc6a877ee1433f060e1be854c7811d66632e32510a2ed591d88330f1340b9c20de -CompilerSupportLibraries.v1.0.5+1.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/c685518aca4721cd8621d510e2039683 -CompilerSupportLibraries.v1.0.5+1.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/b760468c6377dcd2b8dd50200daaabe604006afc070984d78152b2becd0680b59036c9a6e91dea490121bd85b58d285bfc1e1cf696d29af236528400101de36c -CompilerSupportLibraries.v1.0.5+1.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/8faf5c8ad62ab10f71dd2ec9683053e2 -CompilerSupportLibraries.v1.0.5+1.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/921239f241a5c89710cf07272d7f6c3f10201a7533068ed1e9643f9fb2f439e1bb765a4966d913829866ee0ce4f1589d30d06e4b5c1361e3c016a9473f087177 -CompilerSupportLibraries.v1.0.5+1.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/b38fcb70691ac2621379d298eef8c79e -CompilerSupportLibraries.v1.0.5+1.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/06c7f64257ce721f5941f6e50a0d2717cdc9394fc532ded19ce3eaacd5e92a416969534227562e4fee04d2b6340c650d8bc9779e14519b90038bc41e8d1f5ce3 -CompilerSupportLibraries.v1.0.5+1.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/cdfab2c7bc41765caf4441c3caeed761 -CompilerSupportLibraries.v1.0.5+1.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/7109d4a7b32c00309c42685f54a86fc2cc63c0c00f65584ad296b6e44ad3320eed1aaf49684a8831841cdffa5555d72f89272fb722a780596e27ef020528026b -CompilerSupportLibraries.v1.0.5+1.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/441980ebd23d72772cbe603f1c275336 -CompilerSupportLibraries.v1.0.5+1.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/e273d9f1af259a3080df8f173e1808a1ade976a943aba97216bf59a96178e7c052e7a048b0ceee53ab486ed577a2ecb92579857be2f7b29e76322ee1f13c9d76 -CompilerSupportLibraries.v1.0.5+1.i686-linux-gnu-libgfortran3.tar.gz/md5/6decf8fd5afb50451771c761e63a8917 -CompilerSupportLibraries.v1.0.5+1.i686-linux-gnu-libgfortran3.tar.gz/sha512/4984724bcc847724b1bc005b6f760a18b68147f7d5402d0faf4e28fc0d14fa10975368a951f9caf2a8856500046dec8343043274557d58269e77492b929a9e4b -CompilerSupportLibraries.v1.0.5+1.i686-linux-gnu-libgfortran4.tar.gz/md5/39d1e8a3baa144c018d3eaf7f3806482 -CompilerSupportLibraries.v1.0.5+1.i686-linux-gnu-libgfortran4.tar.gz/sha512/fc4d429279c5a93b6c28b6e911b1e7cfd1c1cfe46f11f2e901b3832ce90d45f49d3d29f0ef18518a94af6cc8651f67c4ed81672680f9281ada390440b172a2af -CompilerSupportLibraries.v1.0.5+1.i686-linux-gnu-libgfortran5.tar.gz/md5/37dabd9cd224c9fed9633dedccb6c565 -CompilerSupportLibraries.v1.0.5+1.i686-linux-gnu-libgfortran5.tar.gz/sha512/b253149e72eef9486888fbaace66e9b6945f4477f6b818f64f3047331165b0e2bc17aa6e3fc8c88686a72e478eb62c8f53883415d5419db448d8016fa3a1da5e -CompilerSupportLibraries.v1.0.5+1.i686-linux-musl-libgfortran3.tar.gz/md5/afdd32bfadd465848e6be458817a44ae -CompilerSupportLibraries.v1.0.5+1.i686-linux-musl-libgfortran3.tar.gz/sha512/eebd679c499143014514c7c9d1875dedbbab9e3af51526c4dd445a9e3dbade95d24522da8bbad0a50ab400755e47b018828b324c4ad7705e212ccd990e34439a -CompilerSupportLibraries.v1.0.5+1.i686-linux-musl-libgfortran4.tar.gz/md5/bc4a0f0b7cea328f7e8850583774496b -CompilerSupportLibraries.v1.0.5+1.i686-linux-musl-libgfortran4.tar.gz/sha512/82285b67946212b49cddf6259f2c60ff5469f8c5263ccefe44f1d93ace98ab68e2c152e1b54434b2f075fd8d192c06d5451bc8cca26d951ad15f3453102f02b5 -CompilerSupportLibraries.v1.0.5+1.i686-linux-musl-libgfortran5.tar.gz/md5/177f0232abce8d523882530ed7a93092 -CompilerSupportLibraries.v1.0.5+1.i686-linux-musl-libgfortran5.tar.gz/sha512/db80acf0f2434f28ee7680e1beb34f564940071815d1ad89fb5913cbd9ac24da528e826d0d54be6265a7340ebd661b6d308ed79d96b67fa5d8c98dc3f1bee8d6 -CompilerSupportLibraries.v1.0.5+1.i686-w64-mingw32-libgfortran3.tar.gz/md5/f5795dada5360eb8422f45150b13bae9 -CompilerSupportLibraries.v1.0.5+1.i686-w64-mingw32-libgfortran3.tar.gz/sha512/6acd1bf7c81631cef9b8b0576ccece08723c5ae2f49de2487d3aefd25f9a0ad49df09e3782735267997d40687b04b85c89e00f6889b026af599bf1bbe91803a1 -CompilerSupportLibraries.v1.0.5+1.i686-w64-mingw32-libgfortran4.tar.gz/md5/5e590f83161913f0145ba8d496b2504b -CompilerSupportLibraries.v1.0.5+1.i686-w64-mingw32-libgfortran4.tar.gz/sha512/4a3f36588afcdef26173764597054068e26f2376e6126a9a94c46b258b5d7a29951d47b5e1ba24df6c3d139bbc4decc5c501a266811692d7fadadc7bd7b6960d -CompilerSupportLibraries.v1.0.5+1.i686-w64-mingw32-libgfortran5.tar.gz/md5/27da4a7c890fe1427c33fe214cc5feaf -CompilerSupportLibraries.v1.0.5+1.i686-w64-mingw32-libgfortran5.tar.gz/sha512/310ad00f053f9f3ec715ce2e8d20446f397728dff5acc787ea9c9332346607a3d42b678099c424e6d6e5294acddf2aa26051de657b48d34abfd04486951bf241 -CompilerSupportLibraries.v1.0.5+1.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/4e5e4b23dc87450738da33926a07511d -CompilerSupportLibraries.v1.0.5+1.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/fc09879d94b750e75775d8b64a41ab9924d675fb53c5700467604412928fe7f5cb21911da0f64898d2463fa77ffbaf4c96c397b9060f4746eec152747930cddc -CompilerSupportLibraries.v1.0.5+1.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/9a92138ed69aa317a932a615c6e62d69 -CompilerSupportLibraries.v1.0.5+1.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/0b7785379936a2a209b074177b1424dd7e00b29b5165f564e799b0aa4e06a582e9d616525d97274ba2507cb88192028f1ac485d3f99bdc7ee53fc63c1a7e85de -CompilerSupportLibraries.v1.0.5+1.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/8ffee3d6de5197c7a1f354d72c8238fa -CompilerSupportLibraries.v1.0.5+1.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/deadc4d7224c84f9b82dc956b69e815c44ae036802838365d870ab9f58c8bcf8ce0645f2f387c8ff344ac2108fc8e7e1ee907fa55e93c91aa5d9fd921bf3fdcb -CompilerSupportLibraries.v1.0.5+1.x86_64-apple-darwin-libgfortran3.tar.gz/md5/87449e72e3f33dbb69b7053cdc2649d4 -CompilerSupportLibraries.v1.0.5+1.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/5ce02ad10c6f4686a476eb2a5de2988cd8b482f5e693db2880c84ad1c82f468ef03fe01b9d0feefe5d4ee741d1d16643d36b144e6261ed32311b3b6f312fac2f -CompilerSupportLibraries.v1.0.5+1.x86_64-apple-darwin-libgfortran4.tar.gz/md5/0407cde92cfa42fa89ac83217ca0ec16 -CompilerSupportLibraries.v1.0.5+1.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/032c831f1166a336551138939ac40eb2c68a048ce786c0c1403b879a20c1b706caac16d22560b2c7f2b3d6373986c347188675674116005ca251336ee048d09f -CompilerSupportLibraries.v1.0.5+1.x86_64-apple-darwin-libgfortran5.tar.gz/md5/23418763b808371ee94772a90d501f4d -CompilerSupportLibraries.v1.0.5+1.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/7867b843551457b11bda7821dd384c1c1cf23b80a308b2058a693de7b7da099f0b37eb0a6de2b84c04b625a68c60eea55138e200d5d6ec6f6af09bd7ce406a96 -CompilerSupportLibraries.v1.0.5+1.x86_64-linux-gnu-libgfortran3.tar.gz/md5/e3d33ae03c18affea74699bdc1fabb68 -CompilerSupportLibraries.v1.0.5+1.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/42013f4921de5a69ad857195ce5c19ad1bca3c920d79699e5501f1f4534ab132fabd422362b2b5056f5d182215d6c069db5df460bafa700903faf962cc00f77b -CompilerSupportLibraries.v1.0.5+1.x86_64-linux-gnu-libgfortran4.tar.gz/md5/d40c1e8c0393213c6057c53a12f44175 -CompilerSupportLibraries.v1.0.5+1.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/fe7baa4de7490065ab7b953cc12f41462a24bcb49d0a4a64b23249e98e7569b19bb1cb455af2f76090e34066a7d3cdd7a48cae6515ce6c7a5c8486b0cacc5106 -CompilerSupportLibraries.v1.0.5+1.x86_64-linux-gnu-libgfortran5.tar.gz/md5/48541b90f715c4c86ee4da0570275947 -CompilerSupportLibraries.v1.0.5+1.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/7f2683fb98e80f12629f4ed3bea9fd59d32b7e7a9ed1699e782d8e238ff0915ecc61bf00adaf4597cfe41caf82cdca0f9be250f595f5f0bea6d8f77dba99eaf4 -CompilerSupportLibraries.v1.0.5+1.x86_64-linux-musl-libgfortran3.tar.gz/md5/4547059eb905995667be48bf85d49911 -CompilerSupportLibraries.v1.0.5+1.x86_64-linux-musl-libgfortran3.tar.gz/sha512/7400fdabc924434ab4a4949248c3603887ac06ffd2f205ae33e14495d86cd4f816bbd1999eeafa0257f518df1e7f7c522f596e847a71dbfbfccff4859f50acc7 -CompilerSupportLibraries.v1.0.5+1.x86_64-linux-musl-libgfortran4.tar.gz/md5/46267543cad6584d7b7b9fcc8f18f21d -CompilerSupportLibraries.v1.0.5+1.x86_64-linux-musl-libgfortran4.tar.gz/sha512/0353d7d724be48d4185d3c181692970b7996f53f6a01723072aa5c94b53a8c5055faeed30df51659c252a46f4b941dec0cb24569323e3c85c166f14c5b7c8e9e -CompilerSupportLibraries.v1.0.5+1.x86_64-linux-musl-libgfortran5.tar.gz/md5/14dba2897a6e9d370fa9091c045375fc -CompilerSupportLibraries.v1.0.5+1.x86_64-linux-musl-libgfortran5.tar.gz/sha512/10b79f9c059839f5b57fa8d2a381a034c4067262c4088bd354d14ea56bec097878069383aa9cfadaa09d73bd20fc348fb61662d863a8d62cb25d7af6b8e29858 -CompilerSupportLibraries.v1.0.5+1.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/1f069e9c832fa1e9c7c8d51e3e841f5c -CompilerSupportLibraries.v1.0.5+1.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/877ed9953bc167ade224fc503a2b639c7c333d420804ccf0d3b1637e29bdaf8c608a8f7accb3ec7983d6881c4b00729a1327a121c741022aff1e627cdffb52ce -CompilerSupportLibraries.v1.0.5+1.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/3e542990ca4192dcecf2e8b8b17e8580 -CompilerSupportLibraries.v1.0.5+1.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/0b9cf0f431a5de28bc11af31d965beaf6774d4e83cb3877fdca630d0327312eb966485d6a99d62b0212f505a6714c23fc7ac1ed17ec619baff13941f6ce7519c -CompilerSupportLibraries.v1.0.5+1.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/b09302632fda815a1248884a82a6f95a -CompilerSupportLibraries.v1.0.5+1.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/7a64ae14e40d285bbcd27a0f54ba6ad0a108ee4f4fed7c99d3a876a70578445e0c7108fa945f3f5a0b202cf95e533b96eedaf7641ded6e9869af77db98075709 -CompilerSupportLibraries.v1.0.5+1.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/0c2fc6fae4ebe293a7f0dc1e91f6531a -CompilerSupportLibraries.v1.0.5+1.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/fdb0ad061cacad0557fde3ec216fd3666284f24ad6a86f4a4b6f946dccb112c9704f52edba86f3b17d84c824affbcfef740720348ef227380cf6017811bda80b -CompilerSupportLibraries.v1.0.5+1.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/005e608dbef2b5cdb7624702ccc426be -CompilerSupportLibraries.v1.0.5+1.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/8bb2bcd0a6b1901e8a9be20f505bead5c78ecafbe5a8271cd13385553e5744e0c7bff62976ac9e7d74b8f3bd467603d4c0f5658e6b120bb23066c15e0a644ed4 -CompilerSupportLibraries.v1.0.5+1.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/d6c2c7ad72bff7f7e5c43678d716a57a -CompilerSupportLibraries.v1.0.5+1.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/36f5eba1b0be440797467cb7104652b74709913d2bad1b08ee2dc70f450fb8eab81b28f2b0bc8dfc238b3c46982c69aac831b4fad5bcee4e9dd114852fcb4a0b +CompilerSupportLibraries.v1.1.0+0.aarch64-apple-darwin-libgfortran5.tar.gz/md5/20ebaad57850393b6ac9fa924e511fe4 +CompilerSupportLibraries.v1.1.0+0.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/020de4d8b0ff6bedbadaa305ff8445e6849f12053762ea4aa68412d1ec763dbd86f479587a2fbb862487f1feb04d976c38099ddf3887817a3d32b3f029cf85b1 +CompilerSupportLibraries.v1.1.0+0.aarch64-linux-gnu-libgfortran3.tar.gz/md5/e084a4374be45ba52279682c640449bc +CompilerSupportLibraries.v1.1.0+0.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/d4aedf5c08e13fd9596476330f69e374af64373f7bca0e4df6cbb4d1710d695dce23f2655ee368c3df2049b7b0ca1848c9e01a437fadc0eb08937c6a7cdf2a27 +CompilerSupportLibraries.v1.1.0+0.aarch64-linux-gnu-libgfortran4.tar.gz/md5/6b3975f25be16ea1370ef0bf353ac752 +CompilerSupportLibraries.v1.1.0+0.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/d6298517be1ce350a61d1c1a1bf9b27a541382aa8ccf3e86eeadd7c47e2fe88facd17139a3878adb939df869a330264a942d280e3468d53b61325df7e31daaad +CompilerSupportLibraries.v1.1.0+0.aarch64-linux-gnu-libgfortran5.tar.gz/md5/7134b79b71059d4da79224df1ca0853e +CompilerSupportLibraries.v1.1.0+0.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/e66590a37e756ff33a84514a7ca2bbe2e1517f3e901bc66e40139e8a318d6cd8e329e0c2a7c557ea39e6db2f56802d485ab81b87be1373717b78474b1c7bf7d7 +CompilerSupportLibraries.v1.1.0+0.aarch64-linux-musl-libgfortran3.tar.gz/md5/fd37789f5745a17cc9a85902cebf4698 +CompilerSupportLibraries.v1.1.0+0.aarch64-linux-musl-libgfortran3.tar.gz/sha512/9ff4e9be39f115af2e5bb6a5c88b3940f15a010952cebf39da22e7a5c6744be2f905bebccba092db0a89cf82e8c0e1a3e61b74d4204d2a6648b5469f3ccb0d12 +CompilerSupportLibraries.v1.1.0+0.aarch64-linux-musl-libgfortran4.tar.gz/md5/e9286ae9299c57d5df7b795997b4adf5 +CompilerSupportLibraries.v1.1.0+0.aarch64-linux-musl-libgfortran4.tar.gz/sha512/ea64858481095e0374be330aa2ac84b394bc3e5351b9326137c9cd5d15e6bec47d6e5f672a216572dcb80c3aa6fcb08950cc10157c264f429a93c235028d79a4 +CompilerSupportLibraries.v1.1.0+0.aarch64-linux-musl-libgfortran5.tar.gz/md5/b19c6cbc5b2a62ea76dea64b0f8ae488 +CompilerSupportLibraries.v1.1.0+0.aarch64-linux-musl-libgfortran5.tar.gz/sha512/090d659f7e4a7034117e2bb2dcad0ef544cdca898bf032222cdb81d32af6e6528be842d2cf55839fe397c2ace05dd4ce920cf98cc96324ae18832016516e6cc3 +CompilerSupportLibraries.v1.1.0+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/26fb41031e1b797373aea7a7c4d7be3c +CompilerSupportLibraries.v1.1.0+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/8fd0b6c990681789caec528067b4bcb9661f9c0a5e0268927d4e88565fa7005db3b592fb8e7830cf32b3fb4ce54d6db747dfde896f93bd38f65b7a1290a2399a +CompilerSupportLibraries.v1.1.0+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/6ed3f3e94f662177c3cf3c3734a5c1ec +CompilerSupportLibraries.v1.1.0+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/b8165630cced0f7880cb6fd6263cf39bbbbda668eccc94219720078a85a641c3b1b20648960041aa3a51108ab6df087b909c572d0690aacf8b99dc5496ff7db6 +CompilerSupportLibraries.v1.1.0+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/86060cbbe966a59f18f92a9b2fab95d4 +CompilerSupportLibraries.v1.1.0+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/0aa0ca0ff3a4d541c7a9599ca1adae7391fdd3fa841f3055ecb8635096d0d95a0763758d7533c887b38a655af55174dfcb63f470147b28a256b75a85c8e47801 +CompilerSupportLibraries.v1.1.0+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/4acf6f8929fb8ec9fdb8a0f1af06260d +CompilerSupportLibraries.v1.1.0+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/3b2e0a5f62bd93434d07848c3045479a1a05bd8589dc976a5680e13805db5adcd9abdcca82edee7b28b4c4a9413ce795784a8a0f0a8fb7346a439322c27c96d9 +CompilerSupportLibraries.v1.1.0+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/a75a927c3e14bee6dca29b4907def681 +CompilerSupportLibraries.v1.1.0+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/7853fd187f9289a8282d34112b5277bad13abe9dd9b6c796498db2f1a080b2c81faa6119df9ececd09725a019bf99706894765c9c20f618e359adc153c3181a2 +CompilerSupportLibraries.v1.1.0+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/ba8545cc20e6c602a0526a3b1fc1d2f1 +CompilerSupportLibraries.v1.1.0+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/7a7f3a7761deb068efc00ffc5d4bf4df365cb27674ce73abbe2305b678285161f1526f4facbe27fc11076d99b2079976507f78f5b463bd9057ed008e9d52f9cf +CompilerSupportLibraries.v1.1.0+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/26fb41031e1b797373aea7a7c4d7be3c +CompilerSupportLibraries.v1.1.0+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/8fd0b6c990681789caec528067b4bcb9661f9c0a5e0268927d4e88565fa7005db3b592fb8e7830cf32b3fb4ce54d6db747dfde896f93bd38f65b7a1290a2399a +CompilerSupportLibraries.v1.1.0+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/6ed3f3e94f662177c3cf3c3734a5c1ec +CompilerSupportLibraries.v1.1.0+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/b8165630cced0f7880cb6fd6263cf39bbbbda668eccc94219720078a85a641c3b1b20648960041aa3a51108ab6df087b909c572d0690aacf8b99dc5496ff7db6 +CompilerSupportLibraries.v1.1.0+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/86060cbbe966a59f18f92a9b2fab95d4 +CompilerSupportLibraries.v1.1.0+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/0aa0ca0ff3a4d541c7a9599ca1adae7391fdd3fa841f3055ecb8635096d0d95a0763758d7533c887b38a655af55174dfcb63f470147b28a256b75a85c8e47801 +CompilerSupportLibraries.v1.1.0+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/4acf6f8929fb8ec9fdb8a0f1af06260d +CompilerSupportLibraries.v1.1.0+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/3b2e0a5f62bd93434d07848c3045479a1a05bd8589dc976a5680e13805db5adcd9abdcca82edee7b28b4c4a9413ce795784a8a0f0a8fb7346a439322c27c96d9 +CompilerSupportLibraries.v1.1.0+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/a75a927c3e14bee6dca29b4907def681 +CompilerSupportLibraries.v1.1.0+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/7853fd187f9289a8282d34112b5277bad13abe9dd9b6c796498db2f1a080b2c81faa6119df9ececd09725a019bf99706894765c9c20f618e359adc153c3181a2 +CompilerSupportLibraries.v1.1.0+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/ba8545cc20e6c602a0526a3b1fc1d2f1 +CompilerSupportLibraries.v1.1.0+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/7a7f3a7761deb068efc00ffc5d4bf4df365cb27674ce73abbe2305b678285161f1526f4facbe27fc11076d99b2079976507f78f5b463bd9057ed008e9d52f9cf +CompilerSupportLibraries.v1.1.0+0.i686-linux-gnu-libgfortran3.tar.gz/md5/39dc387fd58ef02c461c7906ceb110e3 +CompilerSupportLibraries.v1.1.0+0.i686-linux-gnu-libgfortran3.tar.gz/sha512/1296ac707fdad620c65256686523f2b027c8359f54d1f8354ef5d1ba514992c7269aad26b706575509b5e29d0ad3dec1c7d32fe3bcff0d723d6a4890819eca46 +CompilerSupportLibraries.v1.1.0+0.i686-linux-gnu-libgfortran4.tar.gz/md5/21a76d54d875ef09db2cdce77d328c2e +CompilerSupportLibraries.v1.1.0+0.i686-linux-gnu-libgfortran4.tar.gz/sha512/9c6bf15338ffbc7113c536e145e53bfaa693007b971f83ee2db820d7d54018bd1cfdbedb6bbce000ee7aaadad1561e91f5ac0e0519bbfccbc3bc57fdfc0eb7e7 +CompilerSupportLibraries.v1.1.0+0.i686-linux-gnu-libgfortran5.tar.gz/md5/f028f2c94f28201701ef6ba4fec9abc9 +CompilerSupportLibraries.v1.1.0+0.i686-linux-gnu-libgfortran5.tar.gz/sha512/c231af1bb0fd4f733278f883837fddf574689bbd7c4dd46cfcd1478d784cbeae1fd785d7cf9f4b0f98cda08819b63a20d5026c6beb892a188fc979b7893697bc +CompilerSupportLibraries.v1.1.0+0.i686-linux-musl-libgfortran3.tar.gz/md5/184436dc05207a653f13aae3d82a2e1b +CompilerSupportLibraries.v1.1.0+0.i686-linux-musl-libgfortran3.tar.gz/sha512/b6e1f969528a168de087f472eebd23a4daf907aa48f7c5b42c35960b1cae3e6ca8f512982d69b757f39d6dc07b46f74c84e549cb22354a2f55d1265cba7b7013 +CompilerSupportLibraries.v1.1.0+0.i686-linux-musl-libgfortran4.tar.gz/md5/545bee22cb35d1c4c1381009e72eebca +CompilerSupportLibraries.v1.1.0+0.i686-linux-musl-libgfortran4.tar.gz/sha512/78a65b9e7cda79cd648a1ae09daea970eba9d04fd5ea41bc1e37b065cf5c53974f759590292876f57c7f65139be66a6c381aa6756cdda7b36845cfed1bb7fddc +CompilerSupportLibraries.v1.1.0+0.i686-linux-musl-libgfortran5.tar.gz/md5/3f1a08601a6a7bbd4ecfa36c8f6abbd9 +CompilerSupportLibraries.v1.1.0+0.i686-linux-musl-libgfortran5.tar.gz/sha512/0e225e0a7b651f6b3fbccf760d08d66f2d8af1e329d14ef67fd3968a46905e062edcf75f60d7540f0cd7dabcd3ac9130fa0f63e198869bdc6a9aabd391652805 +CompilerSupportLibraries.v1.1.0+0.i686-w64-mingw32-libgfortran3.tar.gz/md5/9cfea65fa6c1b587d9b4b84ee64af166 +CompilerSupportLibraries.v1.1.0+0.i686-w64-mingw32-libgfortran3.tar.gz/sha512/b30e24982d4140c312759b8c26d4b72845fc1fa4d7fdf49ccfe9994f7bbf1815ed006a228f6a2185c5b8f9d596d0b04debd1d8392e705c530e5177a22c7c081d +CompilerSupportLibraries.v1.1.0+0.i686-w64-mingw32-libgfortran4.tar.gz/md5/af99905c4f054fe13842559f7201b3ad +CompilerSupportLibraries.v1.1.0+0.i686-w64-mingw32-libgfortran4.tar.gz/sha512/96513ff22dc16cc259ad392862f1765218474bff24e561f14c1e0d349a6bc433952d9b7b73236b56722fd971e0b864b178d8a9f8d9499de4595bc9857ef17a95 +CompilerSupportLibraries.v1.1.0+0.i686-w64-mingw32-libgfortran5.tar.gz/md5/1be078cd374d3b501b20d9ce679009ee +CompilerSupportLibraries.v1.1.0+0.i686-w64-mingw32-libgfortran5.tar.gz/sha512/63097283c987dc439f02d72a6f70423acd962e4da25acc04185e654c7f16a617e34ad7efabd624fd2e70119e79e4d4806f76286d36d56c353f9e53814e75d3e4 +CompilerSupportLibraries.v1.1.0+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/156ae44ab4172903ad40932ca78a57ed +CompilerSupportLibraries.v1.1.0+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/e800c20342dd9886c4c3f57e92278d6d41c544adba202ef3f5a6a4f8211fbbd8fab65f169adf7320b7be8a2ea02c0aa1afedbaf0b3f9afbfb691759aaaaccc4c +CompilerSupportLibraries.v1.1.0+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/cb01c02fdcbd319784034744172e1eb9 +CompilerSupportLibraries.v1.1.0+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/0ba635d39958672a0a55069521e20ca6c0f9c81a9f55c360f6043acb415709edb72bfe8d0e83c25cdf9ace8a9e9ba10e39457e234e3905c988eb95e0e0ecff3d +CompilerSupportLibraries.v1.1.0+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/f9592263c6e72228c492ed2ed216f29e +CompilerSupportLibraries.v1.1.0+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/cbe29742959906e3fe9a356991ca1f09d4d8cc2a02a9af8624b3e02b4ab59e33bc05082826f7c67c73c6b91cc8e1e5c4a0c275c21c5f8eab8b58ed942cdcb55c +CompilerSupportLibraries.v1.1.0+0.x86_64-apple-darwin-libgfortran3.tar.gz/md5/8f0db2ff4688c3f9e1337a28976d833a +CompilerSupportLibraries.v1.1.0+0.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/98502e07499ad9e22147a977b1fe55320e75b6229c3993f1cd1b71e47a09ae6bf78e2341ce978ea72d33b111d09b813a332bfe8f4f6dfb669509c300fcec2561 +CompilerSupportLibraries.v1.1.0+0.x86_64-apple-darwin-libgfortran4.tar.gz/md5/980a1b8e6262c4a7b8f86b84f7234043 +CompilerSupportLibraries.v1.1.0+0.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/c0755d4fbb1b6fd7755d7508d7df929feabe7e5778661397ef0205e21aa3be565b39ccc2a08ed0d958e812c0c759be68ef52de09fe92ebab6da342b309a0810d +CompilerSupportLibraries.v1.1.0+0.x86_64-apple-darwin-libgfortran5.tar.gz/md5/4b3cdb65e6114c77fd1e51da69e41afa +CompilerSupportLibraries.v1.1.0+0.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/803cb771875d94eda554bade8197b31aab988ab0c957a2f8853d82d01418be9fee7d9d4b7ef6f5b7fc8d1825ab22083a71d467eb976d5076fc5d73a9a7a30440 +CompilerSupportLibraries.v1.1.0+0.x86_64-linux-gnu-libgfortran3.tar.gz/md5/36638a444b185954bf12169edace1914 +CompilerSupportLibraries.v1.1.0+0.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/33f657775258d0da1a57fc03c5e8ed203946944581ebf70af7b0205f9bff7fcd4f2bde5b6fa3b01659c51f106d0e6df5c7533ab8d3372c4895675854688e01dc +CompilerSupportLibraries.v1.1.0+0.x86_64-linux-gnu-libgfortran4.tar.gz/md5/36ac52a361fd0f4be5c66572345af7a4 +CompilerSupportLibraries.v1.1.0+0.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/802bd8089bb2a3b5959a47dbade2199b46c247d0a793cbf6fcbc97b9a1dccd6d8585ac7694ae4bef1dc3ba21796ae5b53f995c8793ccd7316e8fde68ac121f83 +CompilerSupportLibraries.v1.1.0+0.x86_64-linux-gnu-libgfortran5.tar.gz/md5/5911da90a0fc86d665aa86cba12e9d61 +CompilerSupportLibraries.v1.1.0+0.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/c966936dfd272d9706aa51ed44abcb8cded899b0caa8b12ee787a0fb1569fa90a1cba89c9a9b83e05c0993facc615feb851399f4799c06956ae3064d172c964d +CompilerSupportLibraries.v1.1.0+0.x86_64-linux-musl-libgfortran3.tar.gz/md5/5f42a52e72f0e79530d71733a93811bf +CompilerSupportLibraries.v1.1.0+0.x86_64-linux-musl-libgfortran3.tar.gz/sha512/51078ef0e447bb181003a50b899b39a9d1ee8ecc92fc293f5a358d836ddf21d03dc44433ae28aa21fdf756c2912b2d3f1e374a5ba108c8c34552fcf32f93fd0b +CompilerSupportLibraries.v1.1.0+0.x86_64-linux-musl-libgfortran4.tar.gz/md5/f3bbee1114cb85c266a45f64632c6911 +CompilerSupportLibraries.v1.1.0+0.x86_64-linux-musl-libgfortran4.tar.gz/sha512/102e638f49ff0f62644f15a931c71a16b96f02f4c90d1b8bd378e0d7c54f4e8a150cdb5ffdbc3dcbafb83131bef84f9071cb77e8debdd98d8929c7b65401fc54 +CompilerSupportLibraries.v1.1.0+0.x86_64-linux-musl-libgfortran5.tar.gz/md5/ff2b0ebdc7ef83cf8b48bd2ae76c6430 +CompilerSupportLibraries.v1.1.0+0.x86_64-linux-musl-libgfortran5.tar.gz/sha512/0730ecf1b9476612cadc3f3e7c1b227a1967edc091c88cd0cc19477079d1739fd5e7b1022ff686c0c6a2404edaebfb02c810dcfc1aa4187e7ecddb54998ad96c +CompilerSupportLibraries.v1.1.0+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/35642304a9a2f435cf5214b2715198fe +CompilerSupportLibraries.v1.1.0+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/a67f41ba31c99a064f504f508711537f9e90089ca5352bfc2698c3fcd3e499ca716f07ffeac4fb1b88c2c934f7f380f262af8c863d3b16ac7e805d5c805ab358 +CompilerSupportLibraries.v1.1.0+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/01df0fbb265e5ff1a480a7a5e23b0835 +CompilerSupportLibraries.v1.1.0+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/57a79f2b8e846c1514dcb18420f26ae2889962040f410b746836cab4395749155fa9cd9d00d4c25954c0ffa72f9f3823b1b50688a20ddf675301f64e0d4b5c7e +CompilerSupportLibraries.v1.1.0+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/1f1f6380ce8815cc9cedcea0b40860e7 +CompilerSupportLibraries.v1.1.0+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/a88ea8af8c8df792861812bfdf7f1bcaae31582ab78ce78b47a0dc6fd57b93441c0471f529ce23877131ac9701c6eed72ce89241746e18271f3686fbd718138c +CompilerSupportLibraries.v1.1.0+0.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/5eab740e86bfa7656f6a08038fe2fa63 +CompilerSupportLibraries.v1.1.0+0.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/3dc6b7ec39ff7dcb71478376c86ce34a35a62f049f6203722c5414b7b635ff1b412e02d8d24c13c123d18b2e914780da4639538676694e342a1a6b507691ef25 +CompilerSupportLibraries.v1.1.0+0.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/9718c79244ed31c367e715f1f563b8cd +CompilerSupportLibraries.v1.1.0+0.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/eec2380c4e182f4e923142736a2c4aaf11a525a5f966fed7e4ec4b431ee28f3842a4e73495df116604f74b419e6d398576ee3dd21d3c0c53b92167dcfd0f6b84 +CompilerSupportLibraries.v1.1.0+0.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/58d7b0b79a22f3aade7e4f39eec898e7 +CompilerSupportLibraries.v1.1.0+0.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/efecc0ca09ec6b7b8898c2ffd333c7e0a6a44706d72ac0e5010409aba92ee70a88b6fd77434bedafe0e013561f8d0c74b5a274808a6c9499f6a3005a7691785f diff --git a/deps/csl.mk b/deps/csl.mk index 37956ba5c3505..aaebc8f50c053 100644 --- a/deps/csl.mk +++ b/deps/csl.mk @@ -104,4 +104,20 @@ distclean-csl: clean-csl else $(eval $(call bb-install,csl,CSL,true)) +ifeq ($(OS),WINNT) +install-csl: + mkdir -p $(build_private_libdir)/ + cp -a $(build_libdir)/gcc/$(BB_TRIPLET)/13/libgcc_s.a $(build_private_libdir)/ + cp -a $(build_libdir)/gcc/$(BB_TRIPLET)/13/libgcc.a $(build_private_libdir)/ + cp -a $(build_libdir)/gcc/$(BB_TRIPLET)/13/libmsvcrt.a $(build_private_libdir)/ + cp -a $(build_libdir)/gcc/$(BB_TRIPLET)/13/libssp.dll.a $(build_private_libdir)/ +endif +endif +ifeq ($(OS),WINNT) +uninstall-csl: uninstall-gcc-libraries +uninstall-gcc-libraries: + -rm -f $(build_private_libdir)/libgcc_s.a + -rm -f $(build_private_libdir)/libgcc.a + -rm -f $(build_private_libdir)/libmsvcrt.a + -rm -f $(build_private_libdir)/libssp.dll.a endif diff --git a/stdlib/CompilerSupportLibraries_jll/Project.toml b/stdlib/CompilerSupportLibraries_jll/Project.toml index 6256c69d9bc10..3e15ff6b87b71 100644 --- a/stdlib/CompilerSupportLibraries_jll/Project.toml +++ b/stdlib/CompilerSupportLibraries_jll/Project.toml @@ -2,9 +2,9 @@ name = "CompilerSupportLibraries_jll" uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" # NOTE: When updating this, also make sure to update the value -# `CSL_NEXT_GLIBCXX_VERSION` in `deps/csl.mk`, to properly disable +# `CSL_NEXT_GLIBCXX_VERSION` in `Make.inc`, to properly disable # automatic usage of BB-built CSLs on extremely up-to-date systems! -version = "1.0.5+1" +version = "1.1.0+0" [deps] Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"