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
b9d7ab8 Mosè Giordano 23 September 2024, 19:30:45 UTC Update stdlib/Test/src/Test.jl 23 September 2024, 19:30:45 UTC
bd44c2a Mosè Giordano 23 September 2024, 19:29:35 UTC Merge branch 'master' into sb/test-scope 23 September 2024, 19:29:35 UTC
0fade45 Ian Butterworth 23 September 2024, 15:39:00 UTC Replace regex package module checks with actual code checks (#55824) Fixes https://github.com/JuliaLang/julia/issues/55792 Replaces https://github.com/JuliaLang/julia/pull/55822 Improves what https://github.com/JuliaLang/julia/pull/51635 was trying to do i.e. ``` ERROR: LoadError: `using/import Printf` outside of a Module detected. Importing a package outside of a module is not allowed during package precompilation. ``` 23 September 2024, 15:39:00 UTC
f62a380 Jishnu Bhattacharya 23 September 2024, 13:02:04 UTC Specialize indexing triangular matrices with BandIndex (#55644) With this, certain indexing operations involving a `BandIndex` may be evaluated as constants. This isn't used directly presently, but might allow for more performant broadcasting in the future. With this, ```julia julia> n = 3; T = Tridiagonal(rand(n-1), rand(n), rand(n-1)); julia> @code_warntype ((T,j) -> UpperTriangular(T)[LinearAlgebra.BandIndex(2,j)])(T, 1) MethodInstance for (::var"#17#18")(::Tridiagonal{Float64, Vector{Float64}}, ::Int64) from (::var"#17#18")(T, j) @ Main REPL[12]:1 Arguments #self#::Core.Const(var"#17#18"()) T::Tridiagonal{Float64, Vector{Float64}} j::Int64 Body::Float64 1 ─ %1 = Main.UpperTriangular(T)::UpperTriangular{Float64, Tridiagonal{Float64, Vector{Float64}}} │ %2 = LinearAlgebra.BandIndex::Core.Const(LinearAlgebra.BandIndex) │ %3 = (%2)(2, j)::Core.PartialStruct(LinearAlgebra.BandIndex, Any[Core.Const(2), Int64]) │ %4 = Base.getindex(%1, %3)::Core.Const(0.0) └── return %4 ``` The indexing operation may be evaluated at compile-time, as the band index is constant-propagated. 23 September 2024, 13:02:04 UTC
9136bdd Jishnu Bhattacharya 22 September 2024, 16:40:08 UTC lmul!/rmul! for banded matrices (#55823) This adds fast methods for `lmul!` and `rmul!` between banded matrices and numbers. Performance impact: ```julia julia> T = Tridiagonal(rand(999), rand(1000), rand(999)); julia> @btime rmul!($T, 0.2); 4.686 ms (0 allocations: 0 bytes) # nightly v"1.12.0-DEV.1225" 669.355 ns (0 allocations: 0 bytes) # this PR ``` 22 September 2024, 16:40:08 UTC
4964c97 DilumAluthgeBot 22 September 2024, 14:59:09 UTC 🤖 [master] Bump the Pkg stdlib from 308f9d32f to ef9f76c17 (#55838) 22 September 2024, 14:59:09 UTC
d6fa66f Mosè Giordano 22 September 2024, 12:08:59 UTC [Dates] Make test more robust against non-UTC timezones (#55829) `%M` is the format specifier for the minutes, not the month (which should be `%m`), and it was used twice. Also, on macOS `Libc.strptime` internally calls `mktime` which depends on the local timezone. We now temporarily set `TZ=UTC` to avoid depending on the local timezone. Fix #55827. 22 September 2024, 12:08:59 UTC
d9555c6 Mateus Araújo 22 September 2024, 06:33:25 UTC allow kronecker product between recursive triangular matrices (#55527) Using the recently introduced recursive `zero` I can remove the specialization to `<:Number` as @dkarrasch wanted to do in #54413. --------- Co-authored-by: Jishnu Bhattacharya <jishnub.github@gmail.com> 22 September 2024, 06:33:25 UTC
911e025 Simeon David Schaub 21 September 2024, 07:58:15 UTC better error for esc outside of macro expansion (#55797) fixes #55788 --------- Co-authored-by: Jeff Bezanson <jeff.bezanson@gmail.com> 21 September 2024, 07:58:15 UTC
bce8f04 Denis Barucic 20 September 2024, 20:23:06 UTC Markdown: support `parse(::AbstractString)` (#55747) `Markdown.parse` is documented to accept `AbstractString` but it was implemented by calling `IOBuffer` on the string argument. `IOBuffer`, however, is documented only for `String` arguments. This commit changes the current `parse(::AbstractString)` to `parse(::String)` and implements `parse(::AbstractString)` by converting the argument to `String`. Now, even `LazyString`s can be parsed to Markdown representation. Fixes #55732 20 September 2024, 20:23:06 UTC
44bef0d Guillaume Dalle 20 September 2024, 15:59:39 UTC Improve printing of several arguments (#55754) Following a discussion on [Discourse](https://discourse.julialang.org/t/string-optimisation-in-julia/119301/10?u=gdalle), this PR tries to improve `print` (and variants) for more than one argument. The idea is that `for` is type-unstable over the tuple `args`, while `foreach` unrolls. --------- Co-authored-by: Steven G. Johnson <stevenj@mit.edu> 20 September 2024, 15:59:39 UTC
220742d Alexander Plavin 20 September 2024, 12:45:54 UTC Add errorhint for nonexisting fields and properties (#55165) I played a bit with error hints and crafted this: ```julia julia> (1+2im).real ERROR: FieldError: type Complex has no field real, available fields: `re`, `im` julia> nothing.xy ERROR: FieldError: type Nothing has no field xy; Nothing has no fields at all. julia> svd(rand(2,2)).VV ERROR: FieldError: type SVD has no field VV, available fields: `U`, `S`, `Vt` Available properties: `V` ``` --------- Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com> 20 September 2024, 12:45:54 UTC
7f7a472 Shuhei Kadowaki 20 September 2024, 09:31:32 UTC simplify the fields of `UnionSplitInfo` (#55815) xref: <https://github.com/JuliaLang/julia/pull/54972#discussion_r1766187771> 20 September 2024, 09:31:32 UTC
b30f80d Mosè Giordano 20 September 2024, 09:18:53 UTC [Random] Avoid conversion to `Float32` in `Float16` sampler (#55819) 20 September 2024, 09:18:53 UTC
550f321 Shuhei Kadowaki 20 September 2024, 04:59:38 UTC move the test case added in #50174 to test/core.jl (#55811) Also renames the name of the test function to avoid name collision. 20 September 2024, 04:59:38 UTC
a31a880 Jishnu Bhattacharya 19 September 2024, 18:04:17 UTC Reland " Avoid materializing arrays in bidiag matmul #55450" (#55777) This relands #55450 and adds tests for the failing case noted in https://github.com/JuliaLang/julia/issues/55727. The `addmul` tests that were failing earlier pass with this change. The issue in the earlier PR was that we were not exiting quickly for `iszero(alpha)` in `_bibimul!` for small matrices, and were computing the result as `C .= A * B * alpha + C * beta`. The problem with this is that if `A * B` contains `NaN`s, this propagates to `C` even if `alpha === 0.0`. This is fixed now, and the result is only computed if `!iszero(alpha)`. 19 September 2024, 18:04:17 UTC
b8093de Jishnu Bhattacharya 19 September 2024, 18:01:36 UTC Broadcast binary ops involving strided triangular (#55798) Currently, we evaluate expressions like `(A::UpperTriangular) + (B::UpperTriangular)` using broadcasting if both `A` and `B` have strided parents, and forward the summation to the parents otherwise. This PR changes this to use broadcasting if either of the two has a strided parent. This avoids accessing the parent corresponding to the structural zero elements, as the index might not be initialized. Fixes https://github.com/JuliaLang/julia/issues/55590 This isn't a general fix, as we still sum the parents if neither is strided. However, it will address common cases. This also improves performance, as we only need to loop over one half: ```julia julia> using LinearAlgebra julia> U = UpperTriangular(zeros(100,100)); julia> B = Bidiagonal(zeros(100), zeros(99), :U); julia> @btime $U + $B; 35.530 μs (4 allocations: 78.22 KiB) # nightly 13.441 μs (4 allocations: 78.22 KiB) # This PR ``` 19 September 2024, 18:01:36 UTC
a73ba3b Timothy 19 September 2024, 11:38:28 UTC Assume that docstring code with no lang is julia (#55465) 19 September 2024, 11:38:28 UTC
4045e7b Jeff Bezanson 19 September 2024, 11:37:10 UTC fix #52986, regression in `@doc` of macro without REPL loaded (#55795) fix #52986 19 September 2024, 11:37:10 UTC
58b239c Shuhei Kadowaki 19 September 2024, 03:08:34 UTC a minor improvement for EA-based `:effect_free`-ness refinement (#55796) 19 September 2024, 03:08:34 UTC
86c567f Cody Tapscott 19 September 2024, 00:04:04 UTC Improve codegen for `Core.throw_methoderror` and `Core.current_scope` (#55803) This slightly improves our (LLVM) codegen for `Core.throw_methoderror` and `Core.current_scope` ```julia julia> foo() = Core.current_scope() julia> bar() = Core.throw_methoderror(+, nothing) ``` Before: ```llvm ; Function Signature: foo() define nonnull ptr @julia_foo_2488() #0 { top: %0 = call ptr @jl_get_builtin_fptr(ptr nonnull @"+Core.#current_scope#2491.jit") %Builtin_ret = call nonnull ptr %0(ptr nonnull @"jl_global#2492.jit", ptr null, i32 0) ret ptr %Builtin_ret } ; Function Signature: bar() define void @julia_bar_589() #0 { top: %jlcallframe1 = alloca [2 x ptr], align 8 %0 = call ptr @jl_get_builtin_fptr(ptr nonnull @"+Core.#throw_methoderror#591.jit") %jl_nothing = load ptr, ptr @jl_nothing, align 8 store ptr @"jl_global#593.jit", ptr %jlcallframe1, align 8 %1 = getelementptr inbounds ptr, ptr %jlcallframe1, i64 1 store ptr %jl_nothing, ptr %1, align 8 %Builtin_ret = call nonnull ptr %0(ptr nonnull @"jl_global#592.jit", ptr nonnull %jlcallframe1, i32 2) call void @llvm.trap() unreachable } ``` After: ```llvm ; Function Signature: foo() define nonnull ptr @julia_foo_713() #0 { top: %thread_ptr = call ptr asm "movq %fs:0, $0", "=r"() #5 %tls_ppgcstack = getelementptr inbounds i8, ptr %thread_ptr, i64 -8 %tls_pgcstack = load ptr, ptr %tls_ppgcstack, align 8 %current_scope = getelementptr inbounds i8, ptr %tls_pgcstack, i64 -72 %0 = load ptr, ptr %current_scope, align 8 ret ptr %0 } ; Function Signature: bar() define void @julia_bar_1581() #0 { top: %jlcallframe1 = alloca [2 x ptr], align 8 %jl_nothing = load ptr, ptr @jl_nothing, align 8 store ptr @"jl_global#1583.jit", ptr %jlcallframe1, align 8 %0 = getelementptr inbounds ptr, ptr %jlcallframe1, i64 1 store ptr %jl_nothing, ptr %0, align 8 %jl_f_throw_methoderror_ret = call nonnull ptr @jl_f_throw_methoderror(ptr null, ptr nonnull %jlcallframe1, i32 2) call void @llvm.trap() unreachable } ``` 19 September 2024, 00:04:04 UTC
441bcd0 DilumAluthgeBot 18 September 2024, 23:23:39 UTC 🤖 [master] Bump the Pkg stdlib from 299a35610 to 308f9d32f (#55808) 18 September 2024, 23:23:39 UTC
e4c8d4f Ian Butterworth 18 September 2024, 21:49:15 UTC REPL: use atreplinit to change the active module during precompilation (#55805) 18 September 2024, 21:49:15 UTC
95a32db Diogo Netto 18 September 2024, 20:51:34 UTC use libuv to measure maxrss (#55806) Libuv has a wrapper around rusage on Unix (and its equivalent on Windows). We should probably use it. 18 September 2024, 20:51:34 UTC
0073917 Jameson Nash 17 September 2024, 23:47:48 UTC codegen: fix bits compare for UnionAll (#55770) Fixes #55768 in two parts: one is making the type computation in emit_bits_compare agree with the parent function and two is not using the optimized egal code for UnionAll kinds, which is different from how the egal code itself works for kinds. 17 September 2024, 23:47:48 UTC
48ddd2d norci 17 September 2024, 17:14:35 UTC Fix shell `cd` error when working dir has been deleted (#41244) root cause: if current dir has been deleted, then pwd() will throw an IOError: pwd(): no such file or directory (ENOENT) --------- Co-authored-by: Ian Butterworth <i.r.butterworth@gmail.com> 17 September 2024, 17:14:35 UTC
61c044c Gabriel Baraldi 17 September 2024, 16:18:44 UTC Inline statically known method errors. (#54972) This replaces the `Expr(:call, ...)` with a call of a new builtin `Core.throw_methoderror` This is useful because it makes very clear if something is a static method error or a plain dynamic dispatch that always errors. Tools such as AllocCheck or juliac can notice that this is not a genuine dynamic dispatch, and prevent it from becoming a false positive compile-time error. Dependent on https://github.com/JuliaLang/julia/pull/55705 --------- Co-authored-by: Cody Tapscott <topolarity@tapscott.me> 17 September 2024, 16:18:44 UTC
f808606 Shuhei Kadowaki 17 September 2024, 15:41:52 UTC use `inferencebarrier` instead of `invokelatest` for 1-arg `@assert` (#55783) This version would be better as per this comment: <https://github.com/JuliaLang/julia/pull/55739#pullrequestreview-2304360447> I confirmed this still allows us to avoid invalidations reported at JuliaLang/julia#55583. 17 September 2024, 15:41:52 UTC
02549d5 Ian Butterworth 17 September 2024, 08:05:24 UTC Use PrecompileTools mechanics to compile REPL (#55782) Fixes https://github.com/JuliaLang/julia/issues/55778 Based on discussion here https://github.com/JuliaLang/julia/issues/55778#issuecomment-2352428043 With this `?reinterpret` feels instant, with only these precompiles at the start. ![Screenshot 2024-09-16 at 9 49 39 AM](https://github.com/user-attachments/assets/20dc016d-c6f7-4870-acd7-0e795dcf541b) 17 September 2024, 08:05:24 UTC
5aad761 Ian Butterworth 16 September 2024, 19:08:57 UTC trace-compile: color recompilation yellow (#55763) Marks recompilation of a method that produced a `precompile` statement as yellow, or if color isn't supported adds a trailing comment: `# recompilation`. The coloring matches the `@time_imports` coloring. i.e. an excerpt of ``` % ./julia --start=no --trace-compile=stderr --trace-compile-timing -e "using InteractiveUtils; @time @time_imports using Plots" ``` ![Screenshot 2024-09-13 at 5 04 24 PM](https://github.com/user-attachments/assets/85bd99e0-586e-4070-994f-2d845be0d9e7) 16 September 2024, 19:08:57 UTC
753296e Gabriel Baraldi 16 September 2024, 18:58:40 UTC Fix hang in tmerge_types_slow (#55757) Fixes https://github.com/JuliaLang/julia/issues/55751 Co-authored-by: Jameson Nash <jameson@juliacomputing.com> 16 September 2024, 18:58:40 UTC
55c40ce Jeff Bezanson 16 September 2024, 17:25:20 UTC move null check in `unsafe_convert` of RefValue (#55766) LLVM can optimize out this check but our optimizer can't, so this leads to smaller IR in most cases. 16 September 2024, 17:25:20 UTC
a993cd8 Mosè Giordano 15 September 2024, 20:24:47 UTC Print results of `runtests` with `printstyled` (#55780) This ensures escape characters are used only if `stdout` can accept them. 15 September 2024, 20:24:47 UTC
4633607 Lilith Orion Hafner 15 September 2024, 12:11:22 UTC Try to put back previously flakey addmul tests (#55775) Partial revert of #50071, inspired by conversation in https://github.com/JuliaLang/julia/issues/49966#issuecomment-2350935477 Ran the tests 100 times to make sure we're not putting back something that's still flaky. Closes #49966 15 September 2024, 12:11:22 UTC
f4fb87b Ian Butterworth 15 September 2024, 11:12:12 UTC REPL: precompile in its own module because Main is closed. Add check for unexpected errors. (#55759) 15 September 2024, 11:12:12 UTC
346f38b Lilith Orion Hafner 14 September 2024, 19:40:10 UTC Add compat entry for `Base.donotdelete` (#55773) 14 September 2024, 19:40:10 UTC
243bded Ian Butterworth 14 September 2024, 16:22:31 UTC Add a docs section about loading/precomp/ttfx time tuning (#55569) 14 September 2024, 16:22:31 UTC
2ee6551 Mosè Giordano 13 September 2024, 22:47:28 UTC Revert "Avoid materializing arrays in bidiag matmul" (#55737) Reverts JuliaLang/julia#55450. @jishnub suggested reverting this PR to fix #55727. 13 September 2024, 22:47:28 UTC
2616634 Jeff Bezanson 13 September 2024, 19:57:19 UTC fix #45494, error in ssa conversion with complex type decl (#55744) We were missing a call to `renumber-assigned-ssavalues` in the case where the declared type is used to assert the type of a value taken from a closure box. 13 September 2024, 19:57:19 UTC
467ab85 Katharine Hyatt 13 September 2024, 12:18:03 UTC Reorganize search tests into testsets (#55658) Some of these tests are nearly 10 years old! Organized some of them into testsets just in case one breaks in the future, should make it easier to find the problem. --------- Co-authored-by: Simeon David Schaub <simeon@schaub.rocks> 13 September 2024, 12:18:03 UTC
94f8a3d Katharine Hyatt 13 September 2024, 12:17:21 UTC More testsets for SubString and a few missing tests (#55656) Co-authored-by: Simeon David Schaub <simeon@schaub.rocks> 13 September 2024, 12:17:21 UTC
e52a46c Neven Sajko 12 September 2024, 21:02:46 UTC define `numerator` and `denominator` for `Complex` (#55694) Fixes #55693 12 September 2024, 21:02:46 UTC
4079648 Gabriel Baraldi 12 September 2024, 19:52:47 UTC Don't pass lSystem to the linker since macos always links it (#55722) This stops it complaing about duplicated libs. For libunwind there isn't much we can do because it's part of lsystem and we also need out own. 12 September 2024, 19:52:47 UTC
7642856 Nick Robinson 12 September 2024, 19:17:17 UTC Don't leave trailing whitespace when printing do-block expr (#55738) Before, when printing a `do`-block, we'd print a white-space after `do` even if no arguments follow. Now we don't print that space. --------- Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com> 12 September 2024, 19:17:17 UTC
6af5838 Katharine Hyatt 12 September 2024, 18:52:59 UTC Few more missing AnnotatedStrings tests (#55655) 12 September 2024, 18:52:59 UTC
ac150b3 Katharine Hyatt 12 September 2024, 16:51:36 UTC Move lets to testsets and add codeunits tests (#55654) 12 September 2024, 16:51:36 UTC
8a9f384 Christian Guinard 12 September 2024, 15:59:20 UTC Don't show string concatenation error hint with zero arg `+` (#55749) Closes #55745 12 September 2024, 15:59:20 UTC
945517b Cody Tapscott 12 September 2024, 07:41:49 UTC Add `invokelatest` barrier to `string(...)` in `@assert` (#55739) This change protects `@assert` from invalidations to `Base.string(...)` by adding an `invokelatest` barrier. A common source of invalidations right now is `print(io, join(args...))`. The problem is: 1. Inference concludes that `join(::Any...)` returns `Union{String,AnnotatedString}` 2. The `print` call is union-split to `String` and `AnnotatedString` 3. This code is now invalidated when StyledStrings defines `print(io, ::AnnotatedString)` The invalidation chain for `@assert` is similar: ` @assert 1 == 1` calls into `string(::Expr)` which calls into `print(io, join(args::Any...))`. Unfortunately that leads to the invalidation of almost all `@assert`s without an explicit error message Similar to https://github.com/JuliaLang/julia/pull/55583#issuecomment-2308969806 12 September 2024, 07:41:49 UTC
22eded8 Gabriele Bozzola 12 September 2024, 04:14:37 UTC Update stable version number in readme to v1.10.5 (#55742) 12 September 2024, 04:14:37 UTC
bf6962c Ian Butterworth 11 September 2024, 23:25:01 UTC Add some loading / LazyArtifacts precompiles to the sysimage (#55740) Fixes https://github.com/JuliaLang/julia/issues/55725 These help LazyArtifacts mainly but seem beneficial for the sysimage. 11 September 2024, 23:25:01 UTC
1eabe90 Jameson Nash 11 September 2024, 18:04:10 UTC codegen: some cleanup of layout computations (#55730) Change Alloca to take an explicit alignment, rather than relying on LLVM to guess our intended alignment from the DataLayout. Eventually we should try to change this code to just get all layout data from julia queries (jl_field_offset, julia_alignment, etc.) instead of relying on creating an LLVM element type for memory and inspecting it (CountTrackedPointers, DataLayout, and so on). 11 September 2024, 18:04:10 UTC
255162c Ian Butterworth 11 September 2024, 15:50:05 UTC Precompile the `@time_imports` printing so it doesn't confuse reports (#55729) Makes functions for the report printing that can be precompiled into the sysimage. 11 September 2024, 15:50:05 UTC
bee75f7 Zentrik 11 September 2024, 10:52:14 UTC Fix `make binary-dist` when using `USE_BINARYBUILDER_LLVM=0` (#55731) `make binary-dist` expects lld to be in usr/tools but it ends up in usr/bin so I copied it into usr/tools. Should fix the scheduled source tests which currently fail at linking. I think this is also broken with `USE_BINARYBUILDER_LLVM=0` and `BUILD_LLD=0`, maybe https://github.com/JuliaLang/julia/commit/ceaeb7b71bc76afaca2f3b80998164a47e30ce33 is the fix? --------- Co-authored-by: Zentrik <Zentrik@users.noreply.github.com> 11 September 2024, 10:52:14 UTC
d7e417d Nathan Zimmerberg 11 September 2024, 03:35:40 UTC Fix "Various fixes to byte / bytearray search" (#55734) Fixes the conflict between #54593 and #54579 `_search` returns `nothing` instead of zero as a sentinal in #54579 11 September 2024, 03:35:40 UTC
c6c449c Jameson Nash 10 September 2024, 20:13:52 UTC codegen: deduplicate code for calling a specsig (#55728) I am tired of having 3 gratuitously different versions of this code to maintain. 10 September 2024, 20:13:52 UTC
56451d8 Jakob Nybo Nissen 10 September 2024, 18:45:38 UTC Various fixes to byte / bytearray search (#54579) This was originally intended as a targeted fix to #54578, but I ran into a bunch of smaller issues with this code that also needed to be solved and it turned out to be difficult to fix them with small, trivial PRs. I would also like to refactor this whole file, but I want these correctness fixes to be merged first, because a larger refactoring has higher risk of getting stuck without getting reviewed and merged. ## Larger things that needs decisions * The internal union `Base.ByteArray` has been deleted. Instead, the unions `DenseInt8` and `DenseUInt8` have been added. These more comprehensively cover the types that was meant, e.g. `Memory{UInt8}` was incorrectly not covered by the former. As stated in the TODO, the concept of a "memory backed dense byte array" is needed throughout Julia, so this ideally needs to be implemented as a single type and used throughout Base. The fix here is a decent temporary solution. See #53178 #54581 * The `findall` docstring between two arrays was incorrectly not attached to the method - now it is. **Note that this change _changes_ the documentation** since it includes a docstring that was previously missed. Hence, it's an API addition. * Added a new minimal `testhelpers/OffsetDenseArrays.jl` which provide a `DenseVector` with offset axes for testing purposes. ## Trivial fixes * `findfirst(==(Int8(-1)), [0xff])` and similar findlast, findnext and findprev is no longer buggy, see #54578 * `findfirst([0x0ff], Int8[-1])` is similarly no longer buggy, see #54578 * `findnext(==('\xa6'), "æ", 1)` and `findprev(==('\xa6'), "æa", 2)` no longer incorrectly throws an error * The byte-oriented find* functions now work correctly with offset arrays * Fixed incorrect use of `GC.@preserve`, where the pointer was taken before the preserve block. * More of the optimised string methods now also apply to `SubString{String}` Closes #54578 Co-authored-by: Martin Holters <martin.holters@hsu-hh.de> 10 September 2024, 18:45:38 UTC
a7c9235 Jameson Nash 10 September 2024, 18:43:33 UTC [REPL] prevent silent hang if precompile script async blocks fail (#55685) 10 September 2024, 18:43:33 UTC
bcf41ba Shuhei Kadowaki 10 September 2024, 17:04:35 UTC minor fixup for JuliaLang/julia#55705 (#55726) 10 September 2024, 17:04:35 UTC
3653b38 Jameson Nash 10 September 2024, 16:51:55 UTC drop typed GEP calls (#55708) Now that we use LLVM 18, and almost have LLVM 19 support, do cleanup to remove LLVM 15/16 type pointer support. LLVM now slightly prefers that we rewrite our complex GEP to use a simple emit_ptrgep call instead, which is also much simpler for julia to emit also. 10 September 2024, 16:51:55 UTC
d280792 Ian Butterworth 10 September 2024, 11:33:56 UTC Fix `@time_imports` extension recognition (#55718) 10 September 2024, 11:33:56 UTC
7a645dd Jishnu Bhattacharya 10 September 2024, 06:39:54 UTC Avoid materializing arrays in bidiag matmul (#55450) Currently, small `Bidiagonal`/`Tridiagonal` matrices are materialized in matrix multiplications, but this is wasteful and unnecessary. This PR changes this to use a naive matrix multiplication for small matrices, and fall back to the banded multiplication for larger ones. Multiplication by a `Bidiagonal` falls back to a banded matrix multiplication for all sizes in the current implementation, and iterates in a cache-friendly manner for the non-`Bidiagonal` matrix. In certain cases, the matrices were being materialized if the non-structured matrix was small, even if the structured matrix was large. This is changed as well in this PR. Some improvements in performance: ```julia julia> B = Bidiagonal(rand(3), rand(2), :U); A = rand(size(B)...); C = similar(A); julia> @btime mul!($C, $A, $B); 193.152 ns (6 allocations: 352 bytes) # nightly v"1.12.0-DEV.1034" 18.826 ns (0 allocations: 0 bytes) # This PR julia> T = Tridiagonal(rand(99), rand(100), rand(99)); A = rand(2, size(T,2)); C = similar(A); julia> @btime mul!($C, $A, $T); 9.398 μs (8 allocations: 79.94 KiB) # nightly 416.407 ns (0 allocations: 0 bytes) # This PR julia> B = Bidiagonal(rand(300), rand(299), :U); A = rand(20000, size(B,2)); C = similar(A); julia> @btime mul!($C, $A, $B); 33.395 ms (0 allocations: 0 bytes) # nightly 6.695 ms (0 allocations: 0 bytes) # This PR (cache-friendly) ``` Closes https://github.com/JuliaLang/julia/pull/55414 --------- Co-authored-by: Daniel Karrasch <daniel.karrasch@posteo.de> 10 September 2024, 06:39:54 UTC
99b8868 Ian Butterworth 10 September 2024, 01:01:08 UTC Fix `pkgdir` for extensions (#55720) Fixes https://github.com/JuliaLang/julia/issues/55719 --------- Co-authored-by: Max Horn <241512+fingolfin@users.noreply.github.com> 10 September 2024, 01:01:08 UTC
88c90ca Zentrik 09 September 2024, 20:19:30 UTC Fix various issues with PGO+LTO makefile (#55581) This fixes various issues with the PGO+LTO makefile - `USECCACHE` doesn't work throwing an error at https://github.com/JuliaLang/julia/blob/eb5587dac02d1f6edf486a71b95149139cc5d9f7/Make.inc#L734 This is because setting `CC` and `CCX` by passing them as arguments to `make` prevents `Make.inc` from prepending these variables with `ccache` as `Make.inc` doesn't use override. To workaround this I instead set `USECLANG` and add the toolchain to the `PATH`. - To deal with similar issues for the other make flags, I pass them as environment variables which can be edited in `Make.inc`. - I add a way to build in one go by creating the `all` target, now you can just run `make` and a PGO+LTO build that profiles Julia's build will be generated. - I workaround `PROFRAW_FILES` not being reevaluated after `stage1` builds, this caused the generation of `PROFILE_FILE` to run an outdated command if `stage1` was built and affected the profraw files. This is important when building in one go. - I add a way to run rules like `binary-dist` which are not defined in this makefile with the correct toolchain which for example prevents `make binary-dist` from unnecessarily rebuilding `sys.ji`. - Include `-Wl,--undefined-version` till https://github.com/JuliaLang/julia/issues/54533 gets fixed. These changes need to be copied to the PGO+LTO+BOLT makefile and some to the BOLT makefile in a later pr. --------- Co-authored-by: Zentrik <Zentrik@users.noreply.github.com> 09 September 2024, 20:19:30 UTC
68feddc Nathan Zimmerberg 09 September 2024, 18:23:38 UTC Fix invalidations for FileIO (#55593) Fixes https://github.com/JuliaIO/FileIO.jl/issues/396 09 September 2024, 18:23:38 UTC
1463c99 Páll Haraldsson 09 September 2024, 17:57:18 UTC Add precompile signatures to Markdown to reduce latency. (#55715) Fixes #55706 that is seemingly a 4472x regression, not just 16x (was my first guess, based on CondaPkg, also fixes or greatly mitigates https://github.com/JuliaPy/CondaPkg.jl/issues/145), and large part of 3x regression for PythonCall. --------- Co-authored-by: Kristoffer Carlsson <kcarlsson89@gmail.com> 09 September 2024, 17:57:18 UTC
169e9e8 Gabriel Baraldi 09 September 2024, 15:10:33 UTC Implement faster thread local rng for scheduler (#55501) Implement optimal uniform random number generator using the method proposed in https://github.com/swiftlang/swift/pull/39143 based on OpenSSL's implementation of it in https://github.com/openssl/openssl/blob/1d2cbd9b5a126189d5e9bc78a3bdb9709427d02b/crypto/rand/rand_uniform.c#L13-L99 This PR also fixes some bugs found while developing it. This is a replacement for https://github.com/JuliaLang/julia/pull/50203 and fixes the issues found by @IanButterworth with both rngs C rng <img width="1011" alt="image" src="https://github.com/user-attachments/assets/0dd9d5f2-17ef-4a70-b275-1d12692be060"> New scheduler rng <img width="985" alt="image" src="https://github.com/user-attachments/assets/4abd0a57-a1d9-46ec-99a5-535f366ecafa"> ~On my benchmarks the julia implementation seems to be almost 50% faster than the current implementation.~ With oscars suggestion of removing the debiasing this is now almost 5x faster than the original implementation. And almost fully branchless We might want to backport the two previous commits since they technically fix bugs. --------- Co-authored-by: Valentin Churavy <vchuravy@users.noreply.github.com> 09 September 2024, 15:10:33 UTC
5272dad Katharine Hyatt 09 September 2024, 14:01:16 UTC Small missing tests for Irrationals (#55657) Looks like a bunch of methods for `Irrational`s are tested but not picked up by coverage... 09 September 2024, 14:01:16 UTC
527fa1c Cody Tapscott 09 September 2024, 05:17:29 UTC builtins: add `Core.throw_methoderror` (#55705) This allows us to simulate/mark calls that are known-to-fail. Required for https://github.com/JuliaLang/julia/pull/54972/ 09 September 2024, 05:17:29 UTC
95c643a Jishnu Bhattacharya 08 September 2024, 12:42:38 UTC Avoid stack overflow in triangular eigvecs (#55497) This fixes a stack overflow in ```julia julia> using LinearAlgebra, StaticArrays julia> U = UpperTriangular(SMatrix{2,2}(1:4)) 2×2 UpperTriangular{Int64, SMatrix{2, 2, Int64, 4}} with indices SOneTo(2)×SOneTo(2): 1 3 ⋅ 4 julia> eigvecs(U) Warning: detected a stack overflow; program state may be corrupted, so further execution might be unreliable. ERROR: StackOverflowError: Stacktrace: [1] eigvecs(A::UpperTriangular{Float32, SMatrix{2, 2, Float32, 4}}) (repeats 79984 times) @ LinearAlgebra ~/.julia/juliaup/julia-nightly/share/julia/stdlib/v1.12/LinearAlgebra/src/triangular.jl:2749 ``` After this, ```julia julia> eigvecs(U) 2×2 Matrix{Float32}: 1.0 1.0 0.0 1.0 ``` 08 September 2024, 12:42:38 UTC
8173750 Neven Sajko 08 September 2024, 10:12:38 UTC delete flaky ranges/`TwicePrecision` test (#55712) Fixes #55710 08 September 2024, 10:12:38 UTC
4f0a333 Jameson Nash 07 September 2024, 22:16:22 UTC [Profile] fix threading issue (#55704) I forgot about the existence of threads, so had hard-coded this to only support one thread. Clearly that is not sufficient though, so use the semaphore here as it is intended to be used. Fixes #55703 --------- Co-authored-by: Ian Butterworth <i.r.butterworth@gmail.com> 07 September 2024, 22:16:22 UTC
8cae8d1 Jishnu Bhattacharya 07 September 2024, 18:39:16 UTC Remove redundant conversion in structured matrix broadcasting (#55695) The additional construction is unnecessary, as we are already constructing a `Matrix`. Performance: ```julia julia> using LinearAlgebra julia> U = UpperTriangular(rand(1000,1000)); julia> L = LowerTriangular(rand(1000,1000)); julia> @btime $U .+ $L; 1.956 ms (6 allocations: 15.26 MiB) # nightly 1.421 ms (3 allocations: 7.63 MiB) # This PR ``` 07 September 2024, 18:39:16 UTC
61be4de Cody Tapscott 07 September 2024, 14:46:30 UTC TOML: Improve type-stability (#55016) Dependent on https://github.com/JuliaLang/julia/pull/55017. This changes the output of the TOML parser to provide specialized `Vector{T}` less aggressively. Specifically, combinatorially expensive types like `Vector{Vector{Float64}}` or `Vector{Union{Float64,Int64}}` are instead returned as `Vector{Any}`, while vectors of homogeneous leaf types (e.g. `Vector{Float64}`) are still supported as before. This change makes the TOML parser fully type-stable. 07 September 2024, 14:46:30 UTC
e95eedd Cody Tapscott 07 September 2024, 13:43:58 UTC Artifacts: Improve type-stability (#55707) This improves Artifacts.jl to make `artifact"..."` fully type-stable, so that it can be used with `--trim`. This is a requirement for JLL support w/ trimmed executables. Dependent on https://github.com/JuliaLang/julia/pull/55016 --------- Co-authored-by: Gabriel Baraldi <baraldigabriel@gmail.com> 07 September 2024, 13:43:58 UTC
fa1c6b2 Mosè Giordano 07 September 2024, 12:04:14 UTC [LinearAlgebra] Initialise number of BLAS threads with `jl_effective_threads` (#55574) This is a safer estimate than `Sys.CPU_THREADS` to avoid oversubscribing the machine when running distributed applications, or when the Julia process is constrained by external controls (`taskset`, `cgroups`, etc.). Fix #55572 07 September 2024, 12:04:14 UTC
ac54799 Mosè Giordano 06 September 2024, 22:17:22 UTC Use `uv_available_parallelism` inside `jl_effective_threads` (#55592) 06 September 2024, 22:17:22 UTC
0c9c1e2 Diogo Netto 06 September 2024, 19:10:50 UTC Canonicalize names of nested functions by keeping a more fine grained counter -- per (module, method name) pair (#53719) As mentioned in https://github.com/JuliaLang/julia/pull/53716, we've been noticing that `precompile` statements lists from one version of our codebase often don't apply cleanly in a slightly different version. That's because a lot of nested and anonymous function names have a global numeric suffix which is incremented every time a new name is generated, and these numeric suffixes are not very stable across codebase changes. To solve this, this PR makes the numeric suffixes a bit more fine grained: every pair of (module, top-level/outermost function name) will have its own counter, which should make nested function names a bit more stable across different versions. This PR applies @JeffBezanson's idea of making the symbol name changes directly in `current-julia-module-counter`. Here is an example: ```Julia julia> function foo(x) function bar(y) return x + y end end foo (generic function with 1 method) julia> f = foo(42) (::var"#bar#foo##0"{Int64}) (generic function with 1 method) ``` 06 September 2024, 19:10:50 UTC
8547b02 Yi Lin 06 September 2024, 18:06:49 UTC Add `JL_DATA_TYPE` for `jl_line_info_node_t` and `jl_code_info_t` (#55698) 06 September 2024, 18:06:49 UTC
6f04ee0 Gabriel Baraldi 06 September 2024, 00:54:11 UTC [LLVMLibUnwindJLL] Update llvmlibunwind to 14.0.6 (#48140) 06 September 2024, 00:54:11 UTC
bada969 Ian Butterworth 04 September 2024, 22:35:33 UTC Profile.print: Shorten C paths too (#55683) 04 September 2024, 22:35:33 UTC
4aac5ae Cody Tapscott 04 September 2024, 21:29:16 UTC contrib: include private libdir in `ldflags` on macOS (#55687) The private libdir is used on macOS, so it needs to be included in our `ldflags` 04 September 2024, 21:29:16 UTC
e217f93 Nathan Zimmerberg 04 September 2024, 14:18:02 UTC Make `rename` public (#55652) Fixes #41584. Follow up of #55503 I think `rename` is a very useful low-level file system operation. Many other programming languages have this function, so it is useful when porting IO code to Julia. One use case is to improve the Zarr.jl package to be more compatible with zarr-python. https://github.com/zarr-developers/zarr-python/blob/0b5483a7958e2ae5512a14eb424a84b2a75dd727/src/zarr/v2/storage.py#L994 uses the `os.replace` function. It would be nice to be able to directly use `Base.rename` as a replacement for `os.replace` to ensure compatibility. Another use case is writing a safe zip file extractor in pure Julia. https://github.com/madler/sunzip/blob/34107fa9e2a2e36e7e72725dc4c58c9ad6179898/sunzip.c#L365 uses the `rename` function to do this in C. Lastly in https://github.com/medyan-dev/MEDYANSimRunner.jl/blob/67d5b42cc599670486d5d640260a95e951091f7a/src/file-saving.jl#L83 I am using `ccall(:jl_fs_rename` to save files, because I have large numbers of Julia processes creating and reading these files at the same time on a distributed file system on a cluster, so I don't want data to become corrupted if one of the nodes crashes (which happens fairly regularly). However `jl_fs_rename` is not public, and might break in a future release. This PR also adds a note to `mv` comparing it to the `mv` command, similar to the note on the `cp` function. 04 September 2024, 14:18:02 UTC
68d04ba Gabriel Baraldi 04 September 2024, 14:16:00 UTC codegen: make boundscheck GEP not be inbounds while the load GEP is inbounds (#55681) Avoids undefined behavior on the boundschecking arithmetic, which is correct only assuming overflow follows unsigned arithmetic wrap around rules. Also add names to the Memory related LLVM instructions to aid debugging Closes: https://github.com/JuliaLang/julia/pull/55674 04 September 2024, 14:16:00 UTC
351727f Gabriel Baraldi 04 September 2024, 14:13:05 UTC Make GEP when loading the PTLS an inbounds one. (#55682) Non inbounds GEPs should only be used when doing pointer arithmethic i.e Ptr or MemoryRef boundscheck. Found when auditing non inbounds GEPs for https://github.com/JuliaLang/julia/pull/55681 04 September 2024, 14:13:05 UTC
e818863 Eduardo Souza 04 September 2024, 14:05:49 UTC Adding `JL_DATA_TYPE` annotation to `_jl_globalref_t` (#55684) `_jl_globalref_t` seems to be allocated in the heap, and there is an object `jl_globalref_type` which indicates that it is in fact, a data type, thus it should be annotated with `JL_DATA_TYPE`?? 04 September 2024, 14:05:49 UTC
53d3ca9 N5N3 04 September 2024, 13:08:14 UTC subtype: minor clean up for fast path for lhs union and rhs typevar (#55645) Follow up #55413. The error pattern mentioned in https://github.com/JuliaLang/julia/pull/55413#issuecomment-2288384468 care's `∃y`'s ub in env rather than its original ub. So it seems more robust to check the bounds in env directly. The equivalent typevar propagation is lifted from `subtype_var` for the same reason. 04 September 2024, 13:08:14 UTC
62084b7 Shuhei Kadowaki 04 September 2024, 11:32:36 UTC inference: fixes and improvements for exct modeling of `invoke`/OC calls (#55678) - fix exct for mismatched opaque closure call: bfeaa277e3c9ed28c642f1fa209e2038367a1811 (following up #55672 ) - improve exct modeling for opaque closure calls: 7a65218b0b1796b2bd722204f5f03ed661267607 - fix `nothrow` modeling for `invoke` calls: 6916bc1bf3e3aa049484e7f3af7c38e2458527e9 - improve `exct` modeling for `invoke` calls: 7b2d5d966fb9f3081e0ca6b2259c086bf84bfab4 04 September 2024, 11:32:36 UTC
2f0607f Ian Butterworth 04 September 2024, 11:26:41 UTC show a bit more detail when finished precompiling (#55660) 04 September 2024, 11:26:41 UTC
9482961 Shuhei Kadowaki 03 September 2024, 08:06:21 UTC improve `exct` modeling for `invoke` calls 04 September 2024, 06:03:55 UTC
f87d164 Shuhei Kadowaki 03 September 2024, 08:00:21 UTC fix `nothrow` modeling for `invoke` calls 04 September 2024, 06:03:55 UTC
8f6a3ef Shuhei Kadowaki 03 September 2024, 07:32:25 UTC improve `exct` modeling for opaque closure calls 04 September 2024, 06:03:55 UTC
7ce90a3 Shuhei Kadowaki 03 September 2024, 07:25:33 UTC fix `exct` for mismatched opaque closure call 04 September 2024, 06:03:55 UTC
b1b968e Jameson Nash 04 September 2024, 02:14:41 UTC better signal handling (#55623) Instead of relying on creating a fake stack frame, and having no signals delivered, kernel bugs, accidentally gc_collect, or other issues occur during the delivery and execution of these calls, use the ability we added recently to emulate a longjmp into a unw_context to eliminate any time where there would exist any invalid states. Secondly, when calling jl_exit_thread0_cb, we used to end up completely smashing the unwind info (with CFI_NOUNWIND), but this makes core files from SIGQUIT much less helpful, so we now have a `fake_stack_pop` function with contains the necessary CFI directives such that a minimal unwind from the debugger will likely still succeed up into the frames that were removed. We cannot do this perfectly on AArch64 since that platform's DWARF spec lacks the ability to do so. On other platforms, this should be possible to implement exactly (subject to libunwind implementation quality). This is currently thus only fully implemented for x86_64 on Darwin Apple. 04 September 2024, 02:14:41 UTC
48b40ac Ian Butterworth 04 September 2024, 00:16:24 UTC Profile.print: color Base/Core & packages. Make paths clickable (#55335) Updated ## This PR ![Screenshot 2024-09-02 at 1 47 23 PM](https://github.com/user-attachments/assets/1264e623-70b2-462a-a595-1db2985caf64) ## master ![Screenshot 2024-09-02 at 1 49 42 PM](https://github.com/user-attachments/assets/14d62fe1-c317-4df5-86e9-7c555f9ab6f1) Todo: - [ ] ~Maybe drop the `@` prefix when coloring it, given it's obviously special when colored~ If someone copy-pasted the profile into an issue this would make it confusing. - [ ] Figure out why `Profile.print(format=:flat)` is truncating before the terminal width is used up - [x] Make filepaths terminal links (even if they're truncated) 04 September 2024, 00:16:24 UTC
e474e0b Gabriel Baraldi 03 September 2024, 19:32:48 UTC Check if ct is not null before doing is_addr_on_stack in the macos signal handler. (#55603) Before the check we used to segfault while segfaulting and hang --------- Co-authored-by: Jameson Nash <vtjnash@gmail.com> 03 September 2024, 19:32:48 UTC
eebc1e4 Jameson Nash 03 September 2024, 16:24:01 UTC win: move stack_overflow_warning to the backtrace fiber (#55640) There is not enough stack space remaining after a stack overflow on Windows to allocate the 4k page used by `write` to call the WriteFile syscall. This causes it to hard-crash. But we can simply run this on the altstack implementation, where there is plenty of space. 03 September 2024, 16:24:01 UTC
34b81fb Jishnu Bhattacharya 03 September 2024, 08:25:10 UTC Forward istriu/istril for triangular to parent (#55663) 03 September 2024, 08:25:10 UTC
04d6d5f Shuhei Kadowaki 03 September 2024, 04:31:38 UTC inference: check argtype compatibility in `abstract_call_opaque_closure` (#55672) 03 September 2024, 04:31:38 UTC
39f2ad1 Jishnu Bhattacharya 02 September 2024, 14:42:39 UTC Reroute Symmetric/Hermitian + Diagonal through triangular (#55605) This should fix the `Diagonal`-related issue from https://github.com/JuliaLang/julia/issues/55590, although the `SymTridiagonal` one still remains. ```julia julia> using LinearAlgebra julia> a = Matrix{BigFloat}(undef, 2,2) 2×2 Matrix{BigFloat}: #undef #undef #undef #undef julia> a[1] = 1; a[3] = 1; a[4] = 1 1 julia> a = Hermitian(a) 2×2 Hermitian{BigFloat, Matrix{BigFloat}}: 1.0 1.0 1.0 1.0 julia> b = Symmetric(a) 2×2 Symmetric{BigFloat, Matrix{BigFloat}}: 1.0 1.0 1.0 1.0 julia> c = Diagonal([1,1]) 2×2 Diagonal{Int64, Vector{Int64}}: 1 ⋅ ⋅ 1 julia> a+c 2×2 Hermitian{BigFloat, Matrix{BigFloat}}: 2.0 1.0 1.0 2.0 julia> b+c 2×2 Symmetric{BigFloat, Matrix{BigFloat}}: 2.0 1.0 1.0 2.0 ``` 02 September 2024, 14:42:39 UTC
5c706af Lionel Zoubritzky 02 September 2024, 14:32:52 UTC Allow exact redefinition for types with recursive supertype reference (#55380) This PR allows redefining a type when the new type is exactly identical to the previous one (like #17618, #20592 and #21024), even if the type has a reference to itself in its supertype. That particular case used to error (issue #54757), whereas with this PR: ```julia julia> struct Rec <: AbstractVector{Rec} end julia> struct Rec <: AbstractVector{Rec} end # this used to error julia> ``` Fix #54757 by implementing the solution proposed there. Hence, this should also fix downstream Revise bug https://github.com/timholy/Revise.jl/issues/813. --------- Co-authored-by: N5N3 <2642243996@qq.com> 02 September 2024, 14:32:52 UTC
back to top