Skip to main content

Browse the archive

https://github.com/JuliaLang/julia
23 September 2024, 22:14:07 UTC
sort by:
Revision Author Date Message Commit Date
2275dec Steven G. Johnson 13 August 2024, 23:36:22 UTC clarify that :compact prohibition on line breaks is for 2-arg show 13 August 2024, 23:36:22 UTC
b7aa5e3 Oscar Smith 13 August 2024, 15:46:04 UTC simplify complex atanh and remove singularity perturbation (#55268) fixes https://github.com/JuliaLang/julia/issues/55266, and use `inv(z)` rather than `1/z` and use `muladd` in a couple places. --------- Co-authored-by: Mosè Giordano <giordano@users.noreply.github.com> 13 August 2024, 15:46:04 UTC
881be64 matthias314 13 August 2024, 14:45:19 UTC fix hierarchy level of "API reference" in `Dates` documentation (#55483) Currently, "API reference" is at the same level as "Dates" although it is a subsection of it. This looks particularly weird in the PDF version of the manual: Section 67 is "Dates" and Section 68 is "API reference". Note that I didn't change the nesting level of the subsection "Constants" at the end of the file. As a result, it is now at the same level as "Dates and Time Types" and "Dates Functions". Before it was a subsection of the latter, which appears wrong to me. 13 August 2024, 14:45:19 UTC
5eda597 Kristoffer Carlsson 13 August 2024, 14:44:41 UTC make the previous active module in the REPL a non-global (#55418) The intent of the active module seems to have been for it to be REPL specific but this global kind of breaks that. Co-authored-by: KristofferC <kristoffer.carlsson@juliacomputing.com> 13 August 2024, 14:44:41 UTC
96fd25a DilumAluthgeBot 13 August 2024, 03:07:40 UTC 🤖 [master] Bump the JuliaSyntaxHighlighting stdlib from 04b2323 to b89dd99 (#55474) Stdlib: JuliaSyntaxHighlighting URL: https://github.com/julialang/JuliaSyntaxHighlighting.jl.git Stdlib branch: main Julia branch: master Old commit: 04b2323 New commit: b89dd99 Julia version: 1.12.0-DEV JuliaSyntaxHighlighting version: 1.12.0 Bump invoked by: @tecosaur Powered by: [BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl) Diff: https://github.com/julialang/JuliaSyntaxHighlighting.jl/compare/04b2323c41f6422464c838fe9045700e9ee75e95...b89dd99db56700c47434df6106b6c6afd1c9ed01 ``` $ git log --oneline 04b2323..b89dd99 b89dd99 Actually use the syntax_errors argument fee6aa5 Use a mutable type instead of ref fields ``` Co-authored-by: Dilum Aluthge <dilum@aluthge.com> 13 August 2024, 03:07:40 UTC
ac425a5 Viral B. Shah 12 August 2024, 19:01:03 UTC Bump SparseArrays for SuiteSparse 7.8.0 (#55472) 12 August 2024, 19:01:03 UTC
a23aee8 DilumAluthgeBot 12 August 2024, 16:20:03 UTC 🤖 [master] Bump the StyledStrings stdlib from d7496d2 to f6035eb (#55461) Stdlib: StyledStrings URL: https://github.com/JuliaLang/StyledStrings.jl.git Stdlib branch: main Julia branch: master Old commit: d7496d2 New commit: f6035eb Julia version: 1.12.0-DEV StyledStrings version: 1.11.0(Does not match) Bump invoked by: @LilithHafner Powered by: [BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl) Diff: https://github.com/JuliaLang/StyledStrings.jl/compare/d7496d24d3f05536bce6a7eb4cd8ca05a75c02aa...f6035eb97b516862b16e36cab2ecc6ea8adc3d7c ``` $ git log --oneline d7496d2..f6035eb f6035eb Replace accidental Int64s with Ints 4fcd8bb Use const fields in parser State instead of refs 35a3cdf Load user-customisations lazily 9802b6c Load ScopedValues symbols from their source 9b9cf71 Use branches when choosing how to merge face attrs eada2dc Avoid needlessly creating a new Face in get calls c647af9 Avoid boxing mergedface by making it toplevel a117008 Avoid creating strings for ansi_4bit_color_code 6863348 Improve type inference of face merging f588218 Quick fix for 4d04102adf0d (Optimised SimpleColor) 4d04102 Optimise creation of a SimpleColor from a UInt32 6d3f44d Actually overload Base's escape_string 58507e5 Fully qualify method overloads, avoid importing fc686f3 Explicitly test eachregion c417262 Refactor eachregion to be O(n log n) not O(n^2) f7af623 Use concrete refs in macro parser state struct 41b2446 Check for underline term capability flag 987f776 Treat printing as more than a nothing-return write 43fb018 Add types to some comprehensions d3aa7e1 Improve inference with a function over a closure 6901610 Mention the importance of semantic names in docs 0be209b Better hint at the package capabilities in readme 37b9e4b Load no faces.toml when the DEPOT_PATH is empty ``` Co-authored-by: Dilum Aluthge <dilum@aluthge.com> 12 August 2024, 16:20:03 UTC
cf4c30a Mark Kittisopikul 12 August 2024, 13:10:03 UTC Add push! implementation for AbstractArray depending only on resize! (#55470) Fix #55459 In Julia 1.10, `push!` and `append!` would be functional for `AbstractVector` implementations if `resize!` and `setindex!` were defined. As of #51903 by @vtjnash as in Julia 1.11.0-rc2, `append!` now depends on an implementation of `sizehint!` and `push!`. Since `push!` also depends on `append!`, a stack overflow situation can easily be created. To avoid this, this pull request defines the following * Add generic versions of `push!(a::AbstractVector, x)` which do not depend on `append!` * Add default implementation of `sizehint!` that is a no-op The implementation of `push!(a::AbstractVector, x)` is a generic version based on the implementation of `push!(a::Vector, x)` without depending on internals. # Example for SimpleArray Consider the `SimpleArray` example from test/abstractarray.jl: ```julia mutable struct SimpleArray{T} <: AbstractVector{T} els::Vector{T} end Base.size(sa::SimpleArray) = size(sa.els) Base.getindex(sa::SimpleArray, idx...) = getindex(sa.els, idx...) Base.setindex!(sa::SimpleArray, v, idx...) = setindex!(sa.els, v, idx...) Base.resize!(sa::SimpleArray, n) = resize!(sa.els, n) Base.copy(sa::SimpleArray) = SimpleArray(copy(sa.els)) ``` Note that `setindex!` and `resize!` are implemented for `SimpleArray`. ## Julia 1.10.4: push! is functional On Julia 1.10.4, `push!` has a functional implementation for `SimpleArray` ```julia-repl julia> push!(SimpleArray{Int}(zeros(Int,5)), 6) 6-element SimpleArray{Int64}: 0 0 0 0 0 6 ``` ## Julia 1.11.0-rc2 and nightly: push! requires sizehint! and is prone to stack overflow Before this pull request, on Julia 1.11.0-rc2 and nightly, `push!` fails for want of `sizehint!`. ```julia-repl julia> push!(SimpleArray{Int}(zeros(Int,5)), 6) ERROR: MethodError: no method matching sizehint!(::SimpleArray{Int64}, ::Int64) The function `sizehint!` exists, but no method is defined for this combination of argument types. ... ``` After implementing `sizehint!`, `push!` still fails with a stack overflow. ```julia-repl julia> Base.sizehint!(a::SimpleArray, x) = a julia> push!(SimpleArray{Int}(zeros(Int, 5)), 6) Warning: detected a stack overflow; program state may be corrupted, so further execution might be unreliable. ERROR: StackOverflowError: Stacktrace: [1] _append! @ ./array.jl:1344 [inlined] [2] append! @ ./array.jl:1335 [inlined] [3] push!(a::SimpleArray{Int64}, iter::Int64) @ Base ./array.jl:1336 --- the above 3 lines are repeated 79982 more times --- [239950] _append! @ ./array.jl:1344 [inlined] [239951] append! @ ./array.jl:1335 [inlined] ``` This is because the new implementation of `append!` depends on `push!`. ## After this pull request, push! is functional. After this pull request, there is a functional `push!` for `SimpleArray` again as in Julia 1.10.4: ```julia-repl julia> push!(SimpleArray{Int}(zeros(Int, 5), 6) 6-element SimpleArray{Int64}: 0 0 0 0 0 6 ``` 12 August 2024, 13:10:03 UTC
c907192 DilumAluthgeBot 12 August 2024, 10:51:19 UTC 🤖 [master] Bump the SparseArrays stdlib from e61663a to 55976a6 (#55469) Stdlib: SparseArrays URL: https://github.com/JuliaSparse/SparseArrays.jl.git Stdlib branch: main Julia branch: master Old commit: e61663a New commit: 55976a6 Julia version: 1.12.0-DEV SparseArrays version: 1.12.0 Bump invoked by: @ViralBShah Powered by: [BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl) Diff: https://github.com/JuliaSparse/SparseArrays.jl/compare/e61663ad0a79a48906b0b12d53506e731a614ab8...55976a6e4f883a32e3d3658af50c49879b98fce0 ``` $ git log --oneline e61663a..55976a6 55976a6 Keep sparse solvers docs as before (#552) 95fd7ff Missing space in error message (#554) b8a13ef implement in-place `ldiv!` for Cholesky factorization (#547) 1527014 Do not use nested dissection by default. (#550) ``` Co-authored-by: Dilum Aluthge <dilum@aluthge.com> 12 August 2024, 10:51:19 UTC
9d222b8 Mosè Giordano 12 August 2024, 01:13:05 UTC [OpenBLAS_jll] Upgrade to v0.3.28 (#55462) Memo to self: * update version number in `stdlib/OpenBLAS_jll/Project.toml` * update version number and sha in `deps/openblas.version` * refresh checksums with `make -f contrib/refresh_checksums.mk -j openblas` See the [release notes of v0.3.28](https://github.com/OpenMathLib/OpenBLAS/releases/tag/v0.3.28). 12 August 2024, 01:13:05 UTC
a3859ed DilumAluthgeBot 12 August 2024, 01:11:26 UTC 🤖 [master] Bump the JuliaSyntaxHighlighting stdlib from a463611 to 04b2323 (#55464) Stdlib: JuliaSyntaxHighlighting URL: https://github.com/julialang/JuliaSyntaxHighlighting.jl.git Stdlib branch: main Julia branch: master Old commit: a463611 New commit: 04b2323 Julia version: 1.12.0-DEV JuliaSyntaxHighlighting version: 1.12.0 Bump invoked by: @tecosaur Powered by: [BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl) Diff: https://github.com/julialang/JuliaSyntaxHighlighting.jl/compare/a463611e715c9ec546ac8463c38b6890d892e0c8...04b2323c41f6422464c838fe9045700e9ee75e95 ``` $ git log --oneline a463611..04b2323 04b2323 Support a syntax_errors keyword argument 3fba08b Use concrete refs in paren state struct ``` Co-authored-by: Dilum Aluthge <dilum@aluthge.com> 12 August 2024, 01:11:26 UTC
d302272 Ian Butterworth 11 August 2024, 14:13:56 UTC precompilepkgs: Handle when the terminal is very short (#55445) Fixes https://github.com/JuliaLang/Pkg.jl/issues/3935 1.10 counterpart https://github.com/JuliaLang/Pkg.jl/pull/3988 11 August 2024, 14:13:56 UTC
2e1235e Haakon Ludvig Langeland Ervik 10 August 2024, 22:35:20 UTC Update asyncmap docs to clarify order of outputs (#54974) 10 August 2024, 22:35:20 UTC
7e809b0 Jameson Nash 10 August 2024, 04:31:37 UTC compiler: apply more accurate effects to return_type_tfunc (#55338) In extreme cases, the compiler could mark this function for concrete-eval, even though that is illegal unless the compiler has first deleted this instruction. Otherwise the attempt to concrete-eval will re-run the function repeatedly until it hits a StackOverflow. Workaround to fix #55147 @aviatesk You might know how to solve this even better, using post-optimization effect refinements? Since we should actually only apply the refinement of terminates=false => terminates=true (and thus allowing concrete eval) if the optimization occurs, and not just in inference thinks the optimization would be legal. --------- Co-authored-by: Shuhei Kadowaki <aviatesk@gmail.com> 10 August 2024, 04:31:37 UTC
86231ce Jishnu Bhattacharya 09 August 2024, 19:20:42 UTC LinearAlgebra: round-trippable 2-argument show for `Tridiagonal`/`SymTridiagonal` (#55415) This makes the displayed form of a `Tridiaognal` and a `SymTridiagonal` valid constructors. ```julia julia> T = Tridiagonal(1:3, 1:4, 1:3) 4×4 Tridiagonal{Int64, UnitRange{Int64}}: 1 1 ⋅ ⋅ 1 2 2 ⋅ ⋅ 2 3 3 ⋅ ⋅ 3 4 julia> show(T) Tridiagonal(1:3, 1:4, 1:3) julia> S = SymTridiagonal(1:4, 1:3) 4×4 SymTridiagonal{Int64, UnitRange{Int64}}: 1 1 ⋅ ⋅ 1 2 2 ⋅ ⋅ 2 3 3 ⋅ ⋅ 3 4 julia> show(S) SymTridiagonal(1:4, 1:3) ``` Displaying the bands has several advantages: firstly, it's briefer than printing the full array, and secondly, it displays the special structure in the bands, if any. E.g.: ```julia julia> T = Tridiagonal(spzeros(3), spzeros(4), spzeros(3)); julia> show(T) Tridiagonal(sparsevec(Int64[], Float64[], 3), sparsevec(Int64[], Float64[], 4), sparsevec(Int64[], Float64[], 3)) ``` It's clear from the displayed form that `T` has sparse bands. A special handling for `SymTridiagonal` matrices is necessary, as the diagonal band is symmetrized. This means: ```julia julia> using StaticArrays julia> m = SMatrix{2,2}(1:4); julia> S = SymTridiagonal(fill(m,3), fill(m,2)) 3×3 SymTridiagonal{SMatrix{2, 2, Int64, 4}, Vector{SMatrix{2, 2, Int64, 4}}}: [1 3; 3 4] [1 3; 2 4] ⋅ [1 2; 3 4] [1 3; 3 4] [1 3; 2 4] ⋅ [1 2; 3 4] [1 3; 3 4] julia> show(S) SymTridiagonal(SMatrix{2, 2, Int64, 4}[[1 3; 3 4], [1 3; 3 4], [1 3; 3 4]], SMatrix{2, 2, Int64, 4}[[1 3; 2 4], [1 3; 2 4]]) ``` The displayed values correspond to the symmetrized band, and not the actual input arguments. I think displaying the symmetrized elements makes more sense here, as this matches the form in the 3-argument `show`. 09 August 2024, 19:20:42 UTC
7ec39e7 Ian Butterworth 09 August 2024, 17:50:58 UTC fix swallowing internal errors in precompilepkgs (#55432) Testing: - with a package error ``` (SimpleLooper) pkg> precompile Precompiling all packages... ✗ SimpleLooper 0 dependencies successfully precompiled in 2 seconds ERROR: The following 1 direct dependency failed to precompile: SimpleLooper Failed to precompile SimpleLooper [ff33fe5b-d8e3-4cbd-8bd9-3d2408ff8cab] to "/Users/ian/.julia/compiled/v1.12/SimpleLooper/jl_PQArnH". ERROR: LoadError: Stacktrace: [1] error() @ Base ./error.jl:53 ``` - with interrupt ``` (SimpleLooper) pkg> precompile Precompiling all packages... ^C Interrupted: Exiting precompilation... ◒ SimpleLooper 1 dependency had output during precompilation: ┌ SimpleLooper │ [57879] signal 2: Interrupt: 2 │ in expression starting at /Users/ian/Documents/GitHub/SimpleLooper.jl/src/SimpleLooper.jl:2 └ ``` - an internal error simulated in the same scope that https://github.com/JuliaLang/Pkg.jl/issues/3984 was failing to throw from ``` JULIA stdlib/release.image Unhandled Task ERROR: Stacktrace: [1] error() @ Base ./error.jl:53 [2] (::Base.Precompilation.var"#27#65"{Bool, Bool, Vector{Task}, Dict{Tuple{Base.PkgId, Pair{Cmd, Base.CacheFlags}}, String}, Dict{Tuple{Base.PkgId, Pair{Cmd, Base.CacheFlags}}, String}, Base.Event, Base.Event, ReentrantLock, Vector{Tuple{Base.PkgId, Pair{Cmd, Base.CacheFlags}}}, Dict{Tuple{Base.PkgId, Pair{Cmd, Base.CacheFlags}}, String}, Vector{Tuple{Base.PkgId, Pair{Cmd, Base.CacheFlags}}}, Int64, Vector{Base.PkgId}, Dict{Tuple{Base.PkgId, Pair{Cmd, Base.CacheFlags}}, Bool}, Dict{Tuple{Base.PkgId, Pair{Cmd, Base.CacheFlags}}, Base.Event}, Dict{Tuple{Base.PkgId, Pair{Cmd, Base.CacheFlags}}, Bool}, Vector{Base.PkgId}, Dict{Base.PkgId, String}, Dict{Tuple{Base.PkgId, UInt128, String, String}, Bool}, Base.Precompilation.var"#color_string#38"{Bool}, Bool, Base.Semaphore, Bool, String, Vector{String}, Vector{Base.PkgId}, Base.PkgId, Base.CacheFlags, Cmd, Pair{Cmd, Base.CacheFlags}, Tuple{Base.PkgId, Pair{Cmd, Base.CacheFlags}}})() @ Base.Precompilation ./precompilation.jl:819 ``` 09 August 2024, 17:50:58 UTC
18340a3 Ian Butterworth 09 August 2024, 17:47:20 UTC `stale_cachefile`: handle if the expected cache file is missing (#55419) Part of fixing https://github.com/JuliaLang/Pkg.jl/issues/3984 09 August 2024, 17:47:20 UTC
c3d0d67 Shuhei Kadowaki 09 August 2024, 15:33:43 UTC inference: follow up #49260, remove no longer necessary functions (#55430) 09 August 2024, 15:33:43 UTC
2727e36 Gabriel Baraldi 09 August 2024, 13:59:51 UTC Remove deprecated non string API for LLVM pass pipeline and parse all options (#55407) This technically removes the option for Oz in julia but it doesn't actually do what one wants. This removes an API currently used by Enzyme.jl and AllocCheck.jl but given that LLVM.jl doesn't support this API anymore that seems fine. @wsmoses @maleadt Do we want the replacement for this (a function that parses the PipelineConfig struct) to live in LLVM.jl or GPUCompiler.jl ? 09 August 2024, 13:59:51 UTC
3db1d19 Kristoffer Carlsson 09 August 2024, 11:08:23 UTC add missing clamp function for IOBuffer (#55424) The `clamp` function was defined in Base.Math, but required to be in Base now, so move it to intfuncs with other similar functions Fixes #55279 09 August 2024, 11:08:23 UTC
ac9558c Jameson Nash 09 August 2024, 11:07:31 UTC codegen: move undef freeze before promotion point (#55428) Fixes #55396 09 August 2024, 11:07:31 UTC
e7e8768 Alex Arslan 08 August 2024, 23:44:30 UTC Vendor the terminfo database for use with base/terminfo.jl (#55411) This adds the `terminfo` database to `deps/`, providing a better user experience on systems that don't have `terminfo` on the system by default. The database is built using BinaryBuilder but is not actually platform-specific (it's built for `AnyPlatform`) and as such, this fetches the artifact directly rather than adding a new JLL to stdlib, and it requires no compilation. A build flag, `WITH_TERMINFO`, is added here and assumed true by default, allowing users to set `WITH_TERMINFO=0` in Make.user to avoid bundling `terminfo` should they want to do so. The lookup policy for `terminfo` entries is still compliant with what's described in `terminfo(5)`; the bundled directory is taken to be the first "compiled in" location, i.e. prepended to `@TERMINFO_DIRS@`. This allows any user settings that exist locally, such as custom entries or locations, to take precedence. Fixes #55274 Co-authored-by: Mosè Giordano <giordano@users.noreply.github.com> 08 August 2024, 23:44:30 UTC
57aef91 Nathan Zimmerberg 08 August 2024, 22:56:56 UTC Make `mv` more atomic by trying rename before deleting `dst` (#55384) As noted in https://github.com/JuliaLang/julia/issues/41584 and https://discourse.julialang.org/t/safe-overwriting-of-files/117758/3 `mv` is usually expected to be "best effort atomic". Currently calling `mv` with `force=true` calls `checkfor_mv_cp_cptree(src, dst, "moving"; force=true)` before renaming. `checkfor_mv_cp_cptree` will delete `dst` if exists and isn't the same as `src`. If `dst` is an existing file and julia stops after deleting `dst` but before doing the rename, `dst` will be removed but will not be replaced with `src`. This PR changes `mv` with `force=true` to first try rename, and only delete `dst` if that fails. Assuming file system support and the first rename works, julia stopping will not lead to `dst` being removed without being replaced. This also replaces a stopgap solution from https://github.com/JuliaLang/julia/pull/36638#discussion_r453820564 08 August 2024, 22:56:56 UTC
1db5cf7 Jameson Nash 08 August 2024, 22:37:08 UTC ml-matches: ensure all methods are included (#55365) Some methods were filtered out based simply on visit order, which was not intentional, with the lim==-1 weak-edges mode. Fix #55231 08 August 2024, 22:37:08 UTC
7e1f0be Gabriel Baraldi 08 August 2024, 19:27:33 UTC codgen: make the Memory GEP an inbounds GEP (#55107) The Julia memory model is always inbounds for GEP. This makes the code in https://github.com/JuliaLang/julia/issues/55090 look almost the same as it did before the change. Locally I wasn't able to reproduce the regression, but given it's vectorized code I suspect it is backend sensitive. Fixes https://github.com/JuliaLang/julia/issues/55090 Co-authored-by: Zentrik <Zentrik@users.noreply.github.com> 08 August 2024, 19:27:33 UTC
32423a8 Jameson Nash 08 August 2024, 19:18:11 UTC handle unbound vars in NTuple fields (#55405) Comparing objects by `==` will happily answer nonsense for malformed type comparisons, such as `unwrap_unionall(A) == A`. Avoid forming that query. Additionally, need to recourse through Vararg when examining type structure to make decisions. Fix #55076 Fix #55189 08 August 2024, 19:18:11 UTC
f276757 Ian Butterworth 08 August 2024, 19:17:34 UTC REPL: disable flaky win32 stacktrace tests (#55408) Disables these tests on win32 that have been flaky on that platform since February at least https://github.com/JuliaLang/julia/issues/53340 08 August 2024, 19:17:34 UTC
be77f65 Jeff Bezanson 08 August 2024, 18:59:53 UTC improve docs for `collect` and square brackets (#55352) fixes #55350 --------- Co-authored-by: Neven Sajko <s@purelymail.com> 08 August 2024, 18:59:53 UTC
fc6047b Jameson Nash 08 August 2024, 18:42:45 UTC copyuntil: reduce over-allocation to start This fits into a 32-byte allocation pool, saving up to 64 bytes when repeatedly reading small chunks of data (e.g. tokenizing a CSV file). In some local `@btime` measurements, this seems to take <10% more time across a range of output lengths. 08 August 2024, 18:43:55 UTC
1d7b036 Jameson Nash 08 August 2024, 18:24:40 UTC move clamp from math to intfuncs This is a more apt description, since it is not floating point related, and used earlier (such as in IOBuffer). Fixes #55279 08 August 2024, 18:43:50 UTC
30d5a34 Shuhei Kadowaki 08 August 2024, 18:41:33 UTC inference: remove `throw` block deoptimization completely (#49260) Co-authored-by: Cody Tapscott <topolarity@tapscott.me> Co-authored-by: Oscar Smith <oscardssmith@gmail.com> 08 August 2024, 18:41:33 UTC
f0a2a7a Oscar Smith 08 August 2024, 14:51:48 UTC re-add `unsafe_convert` for Reinterpret and Reshaped array (#55226) Fxes https://github.com/JuliaLang/julia/issues/54725 08 August 2024, 14:51:48 UTC
e439836 Ian Butterworth 08 August 2024, 13:41:59 UTC add `rtruncate`, `ltruncate`, `ctruncate` for truncating strings in terms of `textwidth` (#55351) Co-authored-by: Timothy <git@tecosaur.net> Co-authored-by: Steven G. Johnson <2913679+stevengj@users.noreply.github.com> 08 August 2024, 13:41:59 UTC
07f563e Zentrik 08 August 2024, 12:07:38 UTC Fix unterminated strings in bolt makefiles (#55410) 08 August 2024, 12:07:38 UTC
c767032 Jishnu Bhattacharya 08 August 2024, 02:12:08 UTC Improve performance in `Bidiagonal` times `Diagonal` (#55175) This adds specialized methods to improve performance, and avoid allocations that were arising currently from the fallback tridiagonal implementations. ```julia julia> using LinearAlgebra, BenchmarkTools julia> n = 10000; B = Bidiagonal(rand(n), rand(n-1), :U); D = Diagonal(rand(size(B,1))); C = similar(B, size(B)); julia> @btime mul!($C, $B, $D); 25.552 ms (3 allocations: 78.19 KiB) # v"1.12.0-DEV.870" 25.559 ms (0 allocations: 0 bytes) # This PR julia> C = similar(B); julia> @btime mul!($C, $B, $D); 23.551 μs (3 allocations: 78.19 KiB) # v"1.12.0-DEV.870" 7.123 μs (0 allocations: 0 bytes) # This PR, specialized method ``` 08 August 2024, 02:12:08 UTC
2193895 Jameson Nash 07 August 2024, 19:48:45 UTC codegen: take gc roots (and alloca alignment) more seriously (#55336) Due to limitations in the LLVM implementation, we are forced to emit fairly bad code here. But we need to make sure it is still correct with respect to GC rooting. Fixes #54720 07 August 2024, 19:48:45 UTC
bd582f7 Jishnu Bhattacharya 07 August 2024, 16:42:30 UTC Accept axes in Base.checkdims_perm (#55403) Since `checkdims_perm` only checks the axes of the arrays that are passed to it, this PR adds a method that accepts the axes as arguments instead of the arrays. This will avoid having to specialize on array types. An example of an improvement: On master ```julia julia> using LinearAlgebra julia> D = Diagonal(zeros(1)); julia> Dv = Diagonal(view(zeros(1),:)); julia> @time @eval permutedims(D, (2,1)); 0.016841 seconds (13.68 k allocations: 680.672 KiB, 51.37% compilation time) julia> @time @eval permutedims(Dv, (2,1)); 0.009303 seconds (11.24 k allocations: 564.203 KiB, 97.79% compilation time) ``` This PR ```julia julia> @time @eval permutedims(D, (2,1)); 0.016837 seconds (13.42 k allocations: 667.438 KiB, 51.05% compilation time) julia> @time @eval permutedims(Dv, (2,1)); 0.009076 seconds (6.59 k allocations: 321.156 KiB, 97.46% compilation time) ``` The allocations are lower in the second call. I've retained the original method as well, as some packages seem to be using it. This now forwards the axes to the new method. 07 August 2024, 16:42:30 UTC
b43e247 Steven G. Johnson 07 August 2024, 11:48:13 UTC optimized textwidth(::Char) for ASCII (#55398) 07 August 2024, 11:48:13 UTC
b3a62b4 Mosè Giordano 07 August 2024, 01:16:44 UTC Restore cmdlineargs tests on non-Windows platforms (#55368) 07 August 2024, 01:16:44 UTC
016d035 DilumAluthgeBot 06 August 2024, 23:48:10 UTC 🤖 [master] Bump the Pkg stdlib from e4a6723bf to 7aef1f044 (#55399) 06 August 2024, 23:48:10 UTC
e4678ab Miles Cranmer 06 August 2024, 21:43:27 UTC Increase default stack size limit on 64-bit systems (#55185) This increases the default stack size limit on 64-bit systems from 4 MB to 8 MB, matching glibc and typical modern Linux and macOS machines, as well as the stack size limit of the root Julia process. 06 August 2024, 21:43:27 UTC
22f5580 Markus Hauru 06 August 2024, 21:28:51 UTC Deprecate conflicting @testset arguments (#55174) Currently `@testset` allows specifying multiple descriptions and testset types, and only the last one will take effect. The others will be silently ignored. This PR starts printing deprecation warnings whenever such conflicting arguments are provided. 06 August 2024, 21:28:51 UTC
fb4e4e5 Jishnu Bhattacharya 06 August 2024, 19:04:06 UTC Don't read destination indices when copying structured matrices (#55322) Fixes the following regression introduced in v1.11 ```julia julia> using LinearAlgebra julia> D = Diagonal(rand(4)); julia> T = Tridiagonal(Vector{BigFloat}(undef, 3), Vector{BigFloat}(undef, 4), Vector{BigFloat}(undef, 3)) 4×4 Tridiagonal{BigFloat, Vector{BigFloat}}: #undef #undef ⋅ ⋅ #undef #undef #undef ⋅ ⋅ #undef #undef #undef ⋅ ⋅ #undef #undef julia> copyto!(T, D) ERROR: UndefRefError: access to undefined reference Stacktrace: [1] getindex @ ./essentials.jl:907 [inlined] [2] _broadcast_getindex @ ./broadcast.jl:644 [inlined] [3] _getindex @ ./broadcast.jl:675 [inlined] [4] _broadcast_getindex @ ./broadcast.jl:650 [inlined] [5] getindex @ ./broadcast.jl:610 [inlined] [6] macro expansion @ ./broadcast.jl:973 [inlined] [7] macro expansion @ ./simdloop.jl:77 [inlined] [8] copyto! @ ./broadcast.jl:972 [inlined] [9] copyto! @ ./broadcast.jl:925 [inlined] [10] materialize! @ ./broadcast.jl:883 [inlined] [11] materialize! @ ./broadcast.jl:880 [inlined] [12] _copyto_banded!(T::Tridiagonal{BigFloat, Vector{BigFloat}}, D::Diagonal{Float64, Vector{Float64}}) @ LinearAlgebra ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.12/LinearAlgebra/src/special.jl:323 [13] copyto!(dest::Tridiagonal{BigFloat, Vector{BigFloat}}, src::Diagonal{Float64, Vector{Float64}}) @ LinearAlgebra ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.12/LinearAlgebra/src/special.jl:315 [14] top-level scope @ REPL[4]:1 ``` After this PR ```julia julia> copyto!(T, D) 4×4 Tridiagonal{BigFloat, Vector{BigFloat}}: 0.909968 0.0 ⋅ ⋅ 0.0 0.193341 0.0 ⋅ ⋅ 0.0 0.194794 0.0 ⋅ ⋅ 0.0 0.506905 ``` The current implementation used an optimization that may not be applicable for non-isbits types, and this PR ensures that we always read from the source and write to the destination. 06 August 2024, 19:04:06 UTC
09e5c40 Simeon David Schaub 06 August 2024, 17:03:54 UTC fix #55389: type-unstable `join` (#55395) 06 August 2024, 17:03:54 UTC
308cd7b Jishnu Bhattacharya 06 August 2024, 16:42:29 UTC LAPACK: return union of tuples in gees and trsen (#55353) This simplifies the return type from a `Tuple` with a `Union` field to a `Union` of `Tuple`s. 06 August 2024, 16:42:29 UTC
f94fe63 Viral B. Shah 06 August 2024, 15:14:58 UTC Disable printing of message about including GPL libs in libsuitesparse.mk (#55387) https://github.com/JuliaLang/julia/pull/54240/files#r1704655126 Co-authored-by: Viral B. Shah <viral@mayin.org> 06 August 2024, 15:14:58 UTC
7377760 Jishnu Bhattacharya 06 August 2024, 15:14:30 UTC Fuse complex conversion with function application for symmetric (#55391) This avoids allocating an intermediate array, which reduces allocation slightly. ```julia julia> S = Symmetric(diagm(0=>-rand(100))); julia> @btime $S^0.2; 479.196 μs (25 allocations: 560.20 KiB) # nightly v"1.12.0-DEV.994" 478.213 μs (23 allocations: 558.58 KiB) # This PR ``` 06 August 2024, 15:14:30 UTC
0717a94 Jameson Nash 06 August 2024, 10:53:10 UTC Revert "better type inference for several functions taking `NTuple` args" (#55375) Reverts JuliaLang/julia#55124 as this turns out to hurt performance quite a bit Closes #55374 06 August 2024, 10:53:10 UTC
1e1e710 William Moses 06 August 2024, 09:01:59 UTC AllocOpt: Fix stack lowering where alloca continas boxed and unboxed data (#55306) Co-authored-by: Valentin Churavy <vchuravy@users.noreply.github.com> Co-authored-by: Mosè Giordano <giordano@users.noreply.github.com> Co-authored-by: Gabriel Baraldi <baraldigabriel@gmail.com> 06 August 2024, 09:01:59 UTC
b0a8024 Mosè Giordano 06 August 2024, 08:46:41 UTC [build] Some improvements to the LLVM build system (#55354) ### Elaboration of the issue After #55180 we implicitly require an LLVM built with Zlib support, but compiling Julia with `make USE_BINARYBUILDER_LLVM=0` builds an LLVM without Zlib support, despite the fact we attempt to request it at https://github.com/JuliaLang/julia/blob/996351f5f6651d1508aef3c35c7d37eb22a0fb1e/deps/llvm.mk#L97 This was first identified in #55337. ### Explanation of how configuration of LLVM failed `ZLIB_LIBRARY` must be the path to the zlib library, but we currently set it to the libdir where the library is installed (introduced in #42622): https://github.com/JuliaLang/julia/blob/996351f5f6651d1508aef3c35c7d37eb22a0fb1e/deps/llvm.mk#L97 which is wrong. However, CMake is actually able to find Zlib correctly, but then the check at https://github.com/llvm/llvm-project/blob/46425b8d0fac3c529aa4a716d19abd7032e452f3/llvm/cmake/config-ix.cmake#L139-L141 uses the value of `ZLIB_LIBRARY` to list the Zlib to link for the test, but being `ZLIB_LIBRARY` a directory, CMake doesn't see any valid Zlib and thus tries to run the test without linking any Zlib, and the test silently fails (they're silent only when `LLVM_ENABLE_ZLIB=ON`), resulting in no usable Zlib available, even if found. ### Proposed solution `ZLIB_ROOT` is the only [hint recommended by the CMake module `FindZLIB`](https://cmake.org/cmake/help/latest/module/FindZLIB.html#hints). This PR replaces a broken `ZLIB_LIBRARY` with an appropriate `ZLIB_ROOT`. Also, we set `LLVM_ENABLE_ZLIB=FORCE_ON` which is the only way to make CMake fail loudly if no usable Zlib is available, and avoid going on with a non-usable build. ### Other comments I confirm this fixes #55337 for me, it should likely address https://github.com/JuliaCI/julia-buildkite/issues/373 as well. Also, options `COMPILER_RT_ENABLE_IOS`, `COMPILER_RT_ENABLE_WATCHOS`, `COMPILER_RT_ENABLE_TVOS`, and `HAVE_HISTEDIT_H` don't exist anymore, and they are removed. 06 August 2024, 08:46:41 UTC
1b32fa6 Michael Abbott 06 August 2024, 02:39:30 UTC Compact printing for `Adjoint` vectors, and `Diagonal` (#40722) This changes the compact printing to preserve more information -- an adjoint vector is not quite a matrix, and Diagonal wastes a lot of space: ```julia julia> (Diagonal(1:4), [5,6,7]', transpose(8:10)) # before ([1 0 0 0; 0 2 0 0; 0 0 3 0; 0 0 0 4], [5 6 7], [8 9 10]) julia> (Diagonal(1:4), [5,6,7]', transpose(8:10)) # after (Diagonal(1:4), adjoint([5, 6, 7]), transpose(8:10)) ``` Would have been better to do at the same time as 1.6's other printing changes, I guess. --------- Co-authored-by: Jishnu Bhattacharya <jishnub.github@gmail.com> 06 August 2024, 02:39:30 UTC
d1b1a5d Jameson Nash 05 August 2024, 20:46:54 UTC inference: fix missing LimitedAccuracy markers (#55362) If the LimitedAccuracy was supposed to resolve against the top-most frame (or hypothetically a non-InferenceState frame), it would not have a parentframe, preventing it from reaching the subsequent poison_callstack line that is required for reliable inference (avoiding caching bad results). This should restore the original intent of this code (pre #48913) 05 August 2024, 20:46:54 UTC
6ad6a8f Octogonapus 05 August 2024, 20:01:02 UTC Delete broken and unhelpful const mutation example from docs (#55182) 05 August 2024, 20:01:02 UTC
e38e4db GHTaarn 05 August 2024, 19:52:35 UTC Make REPL.TerminalMenus and some if its symbols public (#55307) 05 August 2024, 19:52:35 UTC
4200203 Satvik 05 August 2024, 19:44:48 UTC Replace `@async` mentions in manual with `Threads.@spawn` (#55315) 05 August 2024, 19:44:48 UTC
40ecf69 Jishnu Bhattacharya 05 August 2024, 12:54:45 UTC LinearAlgbera: pass sizes to muldiag_size_check (#55378) This will avoid having to specialize `_muldiag_size_check` on the matrix types, as we only need the sizes (and potentially `ndims`) for the error checks. 05 August 2024, 12:54:45 UTC
996351f Jishnu Bhattacharya 05 August 2024, 06:07:12 UTC Round-trippable show for `Bidiagonal` (#55347) This changes how a `Bidiagonal` is displayed using the 2-arg `show` to a form that may be parsed. After this, ```julia julia> B = Bidiagonal([1,2,3], [1,2], :U) 3×3 Bidiagonal{Int64, Vector{Int64}}: 1 1 ⋅ ⋅ 2 2 ⋅ ⋅ 3 julia> show(B) Bidiagonal([1, 2, 3], [1, 2], :U) ``` The displayed form is a valid constructor now. 05 August 2024, 06:07:12 UTC
a163483 Jishnu Bhattacharya 05 August 2024, 06:06:39 UTC Fix tr for block SymTridiagonal (#55371) This ensures that `tr` for a block `SymTridiagonal` symmetrizes the diagonal elements. 05 August 2024, 06:06:39 UTC
f4d1381 James Wrigley 04 August 2024, 21:14:40 UTC Document `Threads.threadid(::Task)` (#55369) This is quite handy to figure out which thread a task is running on, and I couldn't find another way to do it from outside the task. 04 August 2024, 21:14:40 UTC
065d456 Jishnu Bhattacharya 04 August 2024, 12:30:41 UTC Materialize complex Symmetric matrices in eigen (#55348) Currently, `eigen` for a complex Symmetric matrix fails, as there's no specialized LAPACK function to handle such matrices. We may instead materialize the matrix and use a generic solver. While a user may do it by themselves, I think returning an answer is better than throwing an error. 04 August 2024, 12:30:41 UTC
22e5362 Ian Butterworth 04 August 2024, 10:21:32 UTC REPL: enable import completion when in a macro (#55366) Fixes https://github.com/JuliaLang/julia/issues/55361 I think this regressed in https://github.com/JuliaLang/julia/pull/54719 given tests didn't include leading spaces/macros 04 August 2024, 10:21:32 UTC
2a56b78 Zentrik 04 August 2024, 09:05:44 UTC Bump LLVM to v18 (#54848) Co-authored-by: Gabriel Baraldi <baraldigabriel@gmail.com> 04 August 2024, 09:05:44 UTC
8bfef8f Jameson Nash 01 August 2024, 17:11:07 UTC codegen: take gc roots (and alloca alignment) more seriously Due to limitations in the LLVM implementation, we are forced to emit fairly bad code here. But we need to make sure it is still correct with respect to GC rooting. The PR 50833c84d454ef989797e035294ba27b3cca79b7 also changed the meaning of haspadding without changing all of the existing users to use the new equivalent flag (haspadding || !isbitsegal), incurring additional breakage here as well and needing more tests for that. Fixes #54720 03 August 2024, 15:43:53 UTC
e1e5a46 Jameson Nash 03 August 2024, 15:43:12 UTC codegen: update type of x after type-assert Later code likes to see that the type is consistent with the cgval and the unbox. 03 August 2024, 15:43:12 UTC
f38015f Jameson Nash 03 August 2024, 15:39:59 UTC codegen: NFC refactoring to use Align type 03 August 2024, 15:39:59 UTC
f2f188d Jishnu Bhattacharya 03 August 2024, 14:27:59 UTC Ensure bidiagonal setindex! does not read indices in error message (#55342) This fixes the error message if the matrix is uninitialized. This is because a `Bidiagonal` with `uplo == 'L'` may still be `istriu` if the subdiaognal is zero. We only care about the band index in the error message, and not the values. 03 August 2024, 14:27:59 UTC
3d99c24 Miles Cranmer 03 August 2024, 12:29:51 UTC Create `Base.Fix` as general `Fix1`/`Fix2` for partially-applied functions (#54653) This PR generalises `Base.Fix1` and `Base.Fix2` to `Base.Fix{N}`, to allow fixing a single positional argument of a function. With this change, the implementation of these is simply ```julia const Fix1{F,T} = Fix{1,F,T} const Fix2{F,T} = Fix{2,F,T} ``` Along with the PR I also add a larger suite of unittests for all three of these functions to complement the existing tests for `Fix1`/`Fix2`. ### Context There are multiple motivations for this generalization. **By creating a more general `Fix{N}` type, there is no preferential treatment of certain types of functions:** - (i) No limitation that you can only fix positions 1-2. You can now fix any position `n`. - (ii) No asymmetry between 2-argument and n-argument functions. You can now fix an argument for functions with any number of arguments. Think of this like if `Base` only had `Vector{T}` and `Matrix{T}`, and you wished to generalise it to `Array{T,N}`. It is an analogous situation here: `Fix1` and `Fix2` are now *aliases* of `Fix{N}`. - **Convenience**: - `Base.Fix1` and `Base.Fix2` are useful shorthands for creating simple anonymous functions without compiling new functions. - They are common throughout the Julia ecosystem as a shorthand for filling arguments: - `Fix1` https://github.com/search?q=Base.Fix1+language%3Ajulia&type=code - `Fix2` https://github.com/search?q=Base.Fix2+language%3Ajulia&type=code - **Less Compilation**: - Using `Fix*` reduces the need for compilation of repeatedly-used anonymous functions (which can often trigger compilation of new functions). - **Type Stability**: - `Fix`, like `Fix1` and `Fix2`, captures variables in a struct, encouraging users to use a functional paradigm for closures, preventing any potential type instabilities from boxed variables within an anonymous function. - **Easier Functional Programming**: - Allows for a stronger functional programming paradigm by supporting partial functions with _any number of arguments_. Note that this refactors `Fix1` and `Fix2` to be equal to `Fix{1}` and `Fix{2}` respectively, rather than separate structs. This is backwards compatible. Also note that this does not constrain future generalisations of `Fix{n}` for multiple arguments. `Fix{1,F,T}` is the clear generalisation of `Fix1{F,T}`, so this isn't major new syntax choices. But in a future PR you could have, e.g., `Fix{(n1,n2)}` for multiple arguments, and it would still be backwards-compatible with this. --------- Co-authored-by: Dilum Aluthge <dilum@aluthge.com> Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com> Co-authored-by: Alexander Plavin <alexander@plav.in> Co-authored-by: Neven Sajko <s@purelymail.com> 03 August 2024, 12:29:51 UTC
a1714ca Jishnu Bhattacharya 03 August 2024, 12:01:29 UTC Check only for Hermitian and not Symmetric in matrix exponentiation (#55349) For real matrices, a `Hermitian` eigenvalue problem would be equivalent to a `Symmetric` one, and for complex matrices, there is no special complex symmetric eigensolver (it errors at present, and complex symmetric matrices might not be diagonalizable). I think the `ishermitian` branch should suffice here. Removing the symmetric branch makes the return type simpler to infer. 03 August 2024, 12:01:29 UTC
124e0a7 Jishnu Bhattacharya 03 August 2024, 12:01:14 UTC Condense branches in Bidiagonal indexing (#55343) 03 August 2024, 12:01:14 UTC
05d0564 Cody Tapscott 03 August 2024, 02:29:39 UTC Profile: close files when assembling heap snapshot (#55356) 03 August 2024, 02:29:39 UTC
1dffd77 Matt Bauman 02 August 2024, 17:44:56 UTC mapreduce: don't inbounds unknown functions (#55329) More finely scope the `@inbounds` annotations to ensure neither `f` nor `op` are erroneously `@inbounds`ed. 02 August 2024, 17:44:56 UTC
b967cf0 Jishnu Bhattacharya 02 August 2024, 16:09:54 UTC LinearAlgebra: remove internal function _makevector (#55345) It seems a bit unnecessary to have a function to carry out a `convert`, instead of calling `convert` directly. 02 August 2024, 16:09:54 UTC
2ec9143 Keno Fischer 02 August 2024, 15:25:34 UTC Move `typename` and `<:` to Core and have inference check by value (#55289) As mentioned in #55271, the `istopfunction` binding-based comparisons are problematic. In #55272 and #55273, I attempted to remove the inference special cases for `>:` and `typename` (respectively) entirely, but for differing reasons (`>:` gets too many extra specializations, `typename` loses precision), those PRs are suboptimal. As discussed in #55273, this PR instead moves these functions to Core, so that both `Core.Compiler` and `Base` share the function object, allowing inference to detect them and apply the special handling by simple value-comparison. --- - closes #55273 02 August 2024, 15:25:34 UTC
2635dea Felix Wechsler 02 August 2024, 12:35:04 UTC Add insertdims method which is inverse to dropdims (#45793) Example: ```julia julia> a = [1 2; 3 4] 2×2 Matrix{Int64}: 1 2 3 4 julia> b = insertdims(a, dims=(1,4)) 1×2×2×1 Array{Int64, 4}: [:, :, 1, 1] = 1 3 [:, :, 2, 1] = 2 4 julia> b[1,1,1,1] = 5; a 2×2 Matrix{Int64}: 5 2 3 4 julia> b = insertdims(a, dims=(1,2)) 1×1×2×2 Array{Int64, 4}: [:, :, 1, 1] = 5 [:, :, 2, 1] = 3 [:, :, 1, 2] = 2 [:, :, 2, 2] = 4 julia> b = insertdims(a, dims=(1,3)) 1×2×1×2 Array{Int64, 4}: [:, :, 1, 1] = 5 3 [:, :, 1, 2] = 2 4 ``` --------- Co-authored-by: Neven Sajko <s@purelymail.com> Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com> Co-authored-by: Mark Kittisopikul <mkitti@users.noreply.github.com> 02 August 2024, 12:35:04 UTC
c6732a7 Ian Butterworth 02 August 2024, 08:51:21 UTC Avoid duplicate stat calls during startup/loading (#55331) Avoids immediately successive stat calls for the same path during startup & loading. According to MacOS Instruments this reduces `stat64` calls during `--start=no -e "using Pkg"` from 844 to 672. On MacOS I don't see a speed improvement, but on WSL2 @timholy reported the test from https://github.com/JuliaLang/julia/issues/55171 sees a modest improvement. This PR (10 iterations) ``` tim@diva:~/.julia/bin$ time for i in {1..10}; do ./cli --help &> /dev/null; done real 0m2.999s user 0m3.547s sys 0m6.552s ``` master ``` real 0m3.217s user 0m3.794s sys 0m6.700s ``` 1.11-rc2: ``` real 0m3.746s user 0m4.169s sys 0m6.755s ``` I left the `@debug`s in as they might be useful for similar investigations. 02 August 2024, 08:51:21 UTC
19165be Jeff Bezanson 01 August 2024, 21:01:37 UTC more small changes for trimming (#55255) A few more unobjectionable, NFC changes from #55047. 01 August 2024, 21:01:37 UTC
0ef8a91 Jishnu Bhattacharya 01 August 2024, 14:46:19 UTC Preserve structure in scaling triangular matrices by NaN (#55310) Addresses the `Matrix` cases from https://github.com/JuliaLang/julia/issues/55296. This restores the behavior to match that on v1.10, and preserves the structure of the matrix on scaling by `NaN`. This behavior is consistent with the strong-zero behavior for other structured matrix types, and the scaling may be seen to be occurring in the vector space corresponding to the filled elements. After this, ```julia julia> UpperTriangular(rand(2,2)) * NaN 2×2 UpperTriangular{Float64, Matrix{Float64}}: NaN NaN ⋅ NaN ``` cc. @mikmoore 01 August 2024, 14:46:19 UTC
7c6a1a2 Keno Fischer 01 August 2024, 13:47:19 UTC inference: Remove special casing for `!` (#55271) We have a handful of cases in inference where we look up functions by name (using `istopfunction`) and give them special behavior. I'd like to remove these. They're not only aesthetically ugly, but because they depend on binding lookups, rather than values, they have unclear semantics as those bindings change. They are also unsound should a user use the same name for something differnt in their own top modules (of course, it's unlikely that a user would do such a thing, but it's bad that they can't). This particular PR removes the special case for `!`, which was there to strengthen the inference result for `!` on Conditional. However, with a little bit of strengthening of the rest of the system, this can be equally well evaluated through the existing InterConditional mechanism. 01 August 2024, 13:47:19 UTC
df1976d Jakob Nybo Nissen 01 August 2024, 09:28:30 UTC Define parent(::GenericMemoryRef) (#55325) It would be nice to have function to extract the `GenericMemory` underlying the `GenericMemoryRef`, without accessing its undocumented field `.mem`. I'm not sure `parent` is the right function for this, but it's the best I could think of. 01 August 2024, 09:28:30 UTC
2179f14 Neven Sajko 01 August 2024, 08:16:43 UTC better type inference for several functions taking `NTuple` args (#55124) Improves the abstract return type inference for these functions, for homogeneous tuple arguments: * `tail` * `front` * `reverse` * `circshift` Example: ```julia f(g, t::Type{<:Tuple}) = println(Core.Compiler.return_type(g, t)) f(Base.tail, Tuple{NTuple}) f(Base.front, Tuple{NTuple}) f(reverse, Tuple{NTuple}) f(circshift, Tuple{NTuple,Int}) ``` Results before: ```julia Tuple Tuple Tuple Tuple ``` Results after: ```julia NTuple{N, T} where {N, T} NTuple{N, T} where {N, T} NTuple{N, T} where {N, T} NTuple{N, T} where {N, T} ``` Updates #54495 01 August 2024, 08:16:43 UTC
5092379 Neven Sajko 01 August 2024, 06:46:23 UTC document the return types of `fieldname` and `fieldnames` (#55259) 01 August 2024, 06:46:23 UTC
0f51a63 Steven G. Johnson 01 August 2024, 04:13:31 UTC ascii=true and fullhex=true flags for escape_string (#55099) 01 August 2024, 04:13:31 UTC
602b582 Elliot Saba 01 August 2024, 03:24:02 UTC [libblastrampoline] Bump to v5.11.0 (#55330) This includes support to properly forward MKL v2024's ILP64 CBLAS symbols, which fixes this [Enzyme issue](https://github.com/EnzymeAD/Enzyme.jl/issues/1683) 01 August 2024, 03:24:02 UTC
b759fe2 Ian Butterworth 01 August 2024, 00:48:42 UTC Profile: Fix stdlib paths (#55327) 01 August 2024, 00:48:42 UTC
761a8cf Diogo Netto 01 August 2024, 00:29:05 UTC WIP/NFC: create GC interface for third-party GCs (#55256) Prelude to the MMTk integration. Creates an interface header specifying the functions that a third-party GC must implement to plug into Julia, and also splits the stock Julia GC implementation into a separate file `gc-stock.c`. In the future, we'll include a few pre-processor guards to ensure some of these files are not compiled if MMTk is enabled. A WIP design document describing the rationale behind the interface and the plan for MMTk integration should be in this [design document](https://docs.google.com/document/d/1v0jtSrIpdEDNOxj5S9g1jPqSpuAkNWhr_T8ToFC9RLI/edit) (feedback is welcome at this stage!). ## TODO - [x] Ensure functions in `gc-interface.h` are only declared in this header. - [x] Add allocation fast-path & codegen write-barriers into the interface. 01 August 2024, 00:29:05 UTC
b0c2281 Jeff Bezanson 25 July 2024, 20:28:24 UTC make `Sysinfo.__init__` easier to compile 31 July 2024, 22:49:08 UTC
ecf08ce Jeff Bezanson 25 July 2024, 20:19:05 UTC improve task_done_hook code for trimming 31 July 2024, 22:49:08 UTC
920c936 Jeff Bezanson 05 July 2024, 18:01:43 UTC avoid unnecessary inexact check in `write(::IO, ::String)` 31 July 2024, 22:49:08 UTC
dcd8cad Jeff Bezanson 31 July 2024, 22:22:42 UTC add `delete` for NamedTuple (#55270) from #27725 Co-authored-by: Jeffrey Sarnoff <JeffreySarnoff@users.noreply.github.com> 31 July 2024, 22:22:42 UTC
5a904ac André Guedes 31 July 2024, 18:25:34 UTC Enable per thread register state cache on libunwind (#55049) Looking into a profile recently I realized that when recording backtraces the CPU utilization is mostly dominated by lookups/updates to libunwind's register state cache (`get_rs_cache`, `put_rs_cache`): ![Screenshot from 2024-07-05 19-29-45](https://github.com/JuliaLang/julia/assets/5301739/5e65f867-6dc8-4d55-8669-aaf1f756a2ac) It is also worth noting that those functions are taking a lock and using `sigprocmask` which does not scale, so by recording backtraces in parallel we get: ![Screenshot from 2024-07-05 19-30-21](https://github.com/JuliaLang/julia/assets/5301739/ed3124dd-f340-4b52-a7f9-c0a203f935b6) And this translates to these times on a recent laptop (Linux X86_64): ``` julia> @time for i in 1:1000000 Base.backtrace() end 8.286924 seconds (32.00 M allocations: 8.389 GiB, 1.46% gc time) julia> @time Threads.@sync for i in 1:16 Threads.@spawn for j in 1:1000000 Base.backtrace() end end 20.448630 seconds (160.01 M allocations: 123.740 GiB, 8.05% gc time, 0.43% compilation time: 18% of which was recompilation) ``` Good news is that libunwind already has the solution for this in the form of the `--enable-per-thread-cache` build option which uses a thread local cache for register state instead of the default global one ([1](https://libunwind-devel.nongnu.narkive.com/V3gtFUL9/question-about-performance-of-threaded-access-in-libunwind)). But this is not without some hiccups due to how we `dlopen` libunwind so we need a small patch ([2](https://libunwind-devel.nongnu.narkive.com/QG1K3Uke/tls-model-initial-exec-attribute-prevents-dynamic-loading-of-libunwind-via-dlopen)). By applying those changes we get: ``` julia> @time for i in 1:1000000 Base.backtrace() end 2.378070 seconds (32.00 M allocations: 8.389 GiB, 4.72% gc time) julia> @time Threads.@sync for i in 1:16 Threads.@spawn for j in 1:1000000 Base.backtrace() end end 3.657772 seconds (160.01 M allocations: 123.740 GiB, 52.05% gc time, 2.33% compilation time: 19% of which was recompilation) ``` Single-Threaded: ![Screenshot from 2024-07-05 20-25-49](https://github.com/JuliaLang/julia/assets/5301739/ebc87952-e51f-488c-92f4-72aed5abb93a) Multi-Threaded: ![Screenshot from 2024-07-05 20-26-32](https://github.com/JuliaLang/julia/assets/5301739/0ea2160a-60e8-49ea-af62-7d8ffc35c963) As a companion to this PR I have created another one for applying the same change to LibUnwind_jll [on Yggdrasil](https://github.com/JuliaPackaging/Yggdrasil/pull/9030). After that lands we can bump the version here. 31 July 2024, 18:25:34 UTC
fdecc59 jariji 31 July 2024, 17:59:55 UTC Restrict argument to `isleapyear(::Integer)` (#55317) In 1.10 we have ```jl julia> isleapyear(Year(1992)) false ``` which is semantically incorrect because `Year(1992)` is a duration (1992 years), not an instant. This PR restricts the currently unrestricted argument to integers. 31 July 2024, 17:59:55 UTC
d64ebd3 igrqb 31 July 2024, 12:45:18 UTC Update help info for qr.jl (#55320) 'Rather than' seems to be the correct intent of the help info. This would mean that Julia stores the result of QR in compact form instead of (=rather than) storing in dense form. 'Rather as' would mean that Julia stores Q and R in two separate dense matrices and not in compact form. 31 July 2024, 12:45:18 UTC
8d41d25 Kristoffer Carlsson 31 July 2024, 10:54:51 UTC Revert changing `wrap` on `Memory` to `view` and make `wrap` non-public. (#54927) Fixes https://github.com/JuliaLang/julia/issues/54768 31 July 2024, 10:54:51 UTC
f225f84 Matt Bauman 31 July 2024, 09:06:39 UTC avoid overflowing show for OffsetArrays around typemax (#55303) 31 July 2024, 09:06:39 UTC
c66513f Jakob Nybo Nissen 30 July 2024, 19:21:25 UTC Random: Mark unexported public symbols as public (#55148) The following symbols: `seed!, default_rng, Sampler, SamplerType, SamplerTrivial, SamplerSimple` Are documented in the Julia documentation and unexported, but not marked as public. Co-authored-by: Max Horn <max@quendi.de> 30 July 2024, 19:21:25 UTC
686804d Jishnu Bhattacharya 30 July 2024, 13:29:24 UTC LAPACK: Aggressive constprop to concretely infer syev!/syevd! (#55295) Currently, these are inferred as a 2-Tuple of possible return types depending on `jobz`, but since `jobz` is usually a constant, we may propagate it aggressively and have the return types inferred concretely. 30 July 2024, 13:29:24 UTC
125bac4 Shuhei Kadowaki 30 July 2024, 09:58:09 UTC inference: cleans up abstract interpretation code (#55308) - propagate the lattice that was not propagated - remove unused `condargs` allocation 30 July 2024, 09:58:09 UTC
6bc2c55 Neven Sajko 30 July 2024, 09:52:13 UTC expand the doc string of `Union{}` (#55291) Give some characterizations/relevant terms from type theory. Clarify the, previously unexplained, usage of "bottom" in names. Cross-reference the subtyping doc string. Add an entry to the doctest, clarifying the last sentence. 30 July 2024, 09:52:13 UTC
5d80593 Keno Fischer 30 July 2024, 09:34:18 UTC inference: Switch to typename-based override for constprop heuristics (#55288) As mentioned in #55271, I'd like to get rid of `istopfunction` for various reasons. Rather than hardcoding constprop overrides based on binding name, this annotates the relevant TypeNames (like the existing `max_methods` override), removing the binding lookups from inference. 30 July 2024, 09:34:18 UTC
5862301 Keno Fischer 30 July 2024, 09:33:35 UTC inference: Allow any non-nothing source in ci_has_source for extern owner (#55294) In updating DAECompiler to the new engine API, I was running some trouble, because the source it produces is not a `CodeInfo` or a `String` (which is fine because it has a non-nothing `owner`). Adjust the test to consider any non-nothing value in .inferred valid source (at least for non-nothing CI owners). 30 July 2024, 09:33:35 UTC
back to top