Aa ey oom #69
Closed
Aa ey oom #69
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
I found some lattice issues when implementing `MustAlias` under the new extendable lattice system in another PR. (cherry picked from commit ee0f3fc)
We used to have this hack before JuliaLang#48246, but I removed it because I had hoped we don't need. Unfortunately, we weren't able to infer consistency of ``` @inbounds (1,2)[1] ``` With this hack, constprop is able to independently prove inbounded-ness, overriding the usual consistency taintaing that happens for inbounds. (cherry picked from commit 113c2f3)
(cherry picked from commit 2a0b9dd)
(cherry picked from commit 6bd658e)
(cherry picked from commit 4a75129)
Remove the high watermark logic, because it doesn't really make sense, and allow for use of 60% of system memory before aggressive GC kicks in. Should fix JuliaLang#48473 (cherry picked from commit 500f561)
Many of these test were hiding output or using semi-deprecated functions or failing to cleanup output or setting the wrong variables. (cherry picked from commit b48104d)
…ckage is loaded (JuliaLang#48703) (cherry picked from commit 200c962)
…aLang#46791) * effects: taint `:nothrow` effect on unknown `:static_parameter` (conservatively) With this commit, we taint `:nothrow` effect property correctly on access to unknown `:static_parameter`, e.g.: ```julia unknown_sparam_throw(::Union{Nothing, Type{T}}) where T = (T; nothing) @test Core.Compiler.is_nothrow(Base.infer_effects(unknown_sparam_throw, ((Type{Int},)))) @test !Core.Compiler.is_nothrow(Base.infer_effects(unknown_sparam_throw, ((Nothing,)))) ``` This commit implements a very conservative analysis, and thus there is a room for improvement still, e.g.: ```julia unknown_sparam_nothrow(x::Ref{T}) where {T} = (T; nothing) @test_broken Core.Compiler.is_nothrow(Base.infer_effects(unknown_sparam_nothrow, (Ref,))) ``` * inference: improve `:nothrow` modeling for `:static_parameter` (JuliaLang#46820) * Fix test with free type params * Test: Ignore ::Type{T} in detect_unbounded These are only technically unbounded because of the existence of ill-formed types. However, this function is supposed to be an API sanity check and ordinary users should never have ill-formed types, so for the purpose we want here, allow unboundedness in Type{T}. --------- Co-authored-by: Keno Fischer <keno@juliacomputing.com> Co-authored-by: Elliot Saba <staticfloat@gmail.com> (cherry picked from commit b5d17ea)
(cherry picked from commit c0d2c57)
* Run dsymutil on pkgimgs for apple platforms + LLD bump to get dsymutil from the jll (cherry picked from commit d8c2250)
(cherry picked from commit 56667bb)
…48689) * [OpenBLAS_jll] Upgrade to new build optimised for PowerPC This only difference compared to previous build is that this one enables use of dynamic architecture detection also for the PowerPC architecture. --------- Co-authored-by: Valentin Churavy <v.churavy@gmail.com> (cherry picked from commit aacfcf0)
On 64-bit, we have enough space to encode (1) the tag, (2) the `depmods` index, and (3) the offset all in a single 64-bit pointer field. This means we don't need the external `link_id` arrays, which reduces the size of many pkgimages by ~5%. On 32-bit, we don't have enough bits to implement this strategy. However, most linkages seem to be against the sysimage, and so by giving that a separate tag we can achieve similar compression because the `link_id` lists will be much shorter. Co-authored-by: Tim Holy <tim.holy@gmail.com> (cherry picked from commit 8e3e970)
(cherry picked from commit 0975906)
…#48583) Previously, the effects system would ignore certain cases where `GotoIfNot` nodes would be capable of throwing; this resulted in simple examples such as the following being marked as `nothrow`: ``` julia> foo(x) = x > 0 ? x : 0 Base.infer_effects(foo, (Missing,)) (+c,+e,+n,+t,+s,+m,+i) ``` With this change, we correctly notice when a `GotoIfNot` node is given a non-`Bool` condition, annotate the basic block as possibly throwing, and further end type inference if the condition is provably non-`Bool`.
I don't think there's any good reason to try to delete the statements here. The very next thing we do is to convert to IRCode which drops dead code anyway, so this just seems redundant. In addition, it complicates Cthulhu-like analysis, which now has to track an extra set of statement numbers.
…Lang#48826) Since we allow overloading of the `bail_out_xxx` hooks, we need to make sure that we widen both type and effects to the top when bailing on inference regardless of the condition presumed by a hook. This commit particularly fixes the correctness of `bail_out_apply` (fixes JuliaLang#48807). I wanted to make a simplified test case for this, but it turns out to be a bit tricky since it relies on the details of multiple match analysis and the bail out logic.
…y` (JuliaLang#48854) Previously the `:inaccessiblememonly` effect bit may be wrongly refined when analyzing va-method, e.g.: ```julia julia> callgetfield1(xs...) = getfield(getfield(xs, 1), 1) callgetfield1 (generic function with 1 method) julia> Base.infer_effects(callgetfield1, (Base.RefValue{Symbol},)) (+c,+e,!n,+t,+s,+m,+i) # inaccessiblememonly is wrongly refined here ``` This leads to wrong concrete evaluation of `callgetfield1` and thus may result in a problem like below: ```julia julia> const GLOBAL_XS = Ref(:julia); julia> global_getfield() = callgetfield1(GLOBAL_XS); julia> @test let Base.Experimental.@force_compile global_getfield() end === :julia Test Passed julia> GLOBAL_XS[] = :julia2; julia> @test let Base.Experimental.@force_compile global_getfield() end === :julia2 # this fails Test Failed at REPL[8]:1 Expression: let #= REPL[8]:2 =# Base.Experimental.@force_compile global_getfield() end === :julia2 Evaluated: julia === julia2 ``` This commit fixes it up.
(cherry picked from commit ba1e568)
(cherry picked from commit 219ef21)
(cherry picked from commit d6431a3)
…liaLang#48810) (cherry picked from commit 8570951)
We need to make sure that libjulia-internal is loaded and placed first in the DynamicLibrary search order so that calls to runtime intrinsics are resolved to the correct library when multiple libjulia-*'s have been loaded (e.g. when we `ccall` into a PackageCompiler.jl-created shared library). (cherry picked from commit fd45943)
* Update MbedTLS to 2.28.2 * Update deps/mbedtls.mk * Update mbedtls checksum (cherry picked from commit 127fb73)
(cherry picked from commit 48b4caa)
Prevent transparent huge pages (THP) overallocating pysical memory.
…poptask (JuliaLang#50802) Currently `poptask` is allocating every time it calls into `jl_task_get_next` due to `StickyWorkqueue` (`IntrusiveLinkedListSynchronized`) being immutable and requiring an allocation to be used as `Any` on the `ccall`. The allocations can be seen in the following snippet: ``` function work() done = 0.0 l = Threads.SpinLock() Threads.@sync for _ in 1:(Threads.nthreads() / 2) Threads.@Spawn begin v = 1.0 for i in 1:(1<<33) v *= 1.0001 if i % (1 << 13) == 0 yield() end end Base.@lock_nofail l done += v end end return done end julia> @time work() 15.758794 seconds (5.03 M allocations: 153.523 MiB, 0.35% gc time) ``` Which after the change becomes: ``` julia> @time work() 15.907513 seconds (67 allocations: 4.719 KiB) ```
Without this, the task created by a `Channel` will run in the threadpool of the creating task; in the REPL, this could be the interactive threadpool. With this, the `:default` threadpool is used instead, and that behavior can be overridden.
It was backported before it was changed, approved and merged upstream.
Along with the signal number.
Prepend threadid to stacktraces
Correctly prepend `[signal (X)] thread Y ` to each backtrace line that is displayed.
RAI: redo prepending to backtrace output
Backports PR JuliaLang#50337 for RAI julia v1.9.2 Original description: =================== Pass the types to the allocator functions. ------- Before this PR, we were missing the types for allocations in two cases: 1. allocations from codegen 2. allocations in `gc_managed_realloc_` The second one is easy: those are always used for buffers, right? For the first one: we extend the allocation functions called from codegen, to take the type as a parameter, and set the tag there. I kept the old interfaces around, since I think that they cannot be removed due to supporting legacy code? ------ An example of the generated code: ```julia %ptls_field6 = getelementptr inbounds {}**, {}*** %4, i64 2 %13 = bitcast {}*** %ptls_field6 to i8** %ptls_load78 = load i8*, i8** %13, align 8 %box = call noalias nonnull dereferenceable(32) {}* @ijl_gc_pool_alloc_typed(i8* %ptls_load78, i32 1184, i32 32, i64 4366152144) #7 ``` Fixes JuliaLang#43688. Fixes JuliaLang#45268. Co-authored-by: Valentin Churavy <vchuravy@users.noreply.github.com>
Bck v1.9.2+rai+madv free
Backport pool-live-bytes metric
Backport parallel marking
…ovements Backport allocation improvements
Restore the missing pool live bytes reset during sweeping
github-actions
bot
added
port-to-v1.10
nickrobinson251
removed
port-to-master
nickrobinson251
removed
the
port-to-v1.9
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
PR Description
What does this PR do?
Checklist
Requirements for merging:
port-to-*labels that don't apply.