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
1d8379e Shuhei Kadowaki 29 January 2024, 02:18:25 UTC concrete-eval sortable `Union` only 29 January 2024, 03:55:34 UTC
b77fa2b Shuhei Kadowaki 10 January 2023, 04:49:17 UTC allow concrete-eval for `Union`-type arguments By allowing `hasuniquerep` to analyze `Union`-types. Motivated by <https://github.com/aviatesk/JET.jl/issues/444>. 29 January 2024, 02:18:27 UTC
5b64a0d Shuhei Kadowaki 29 January 2024, 02:15:18 UTC forward-port the test cases added in #53076 (#53077) The fix for #53062 was included in #50805, but it lacked explicit test cases added. This commit cherry-picks the test cases from #53076 to prevent future regression. 29 January 2024, 02:15:18 UTC
746fad0 Max Horn 29 January 2024, 01:43:22 UTC doc: replace harr HTML entity by unicode (#53066) Documenter does not support HTML entities. See discussion in PR #52078 for further background. Co-authored-by: Dilum Aluthge <dilum@aluthge.com> 29 January 2024, 01:43:22 UTC
dcb196e Dilum Aluthge 28 January 2024, 21:53:31 UTC Revert "Don't export Dates.adjust" (#53089) Reverts JuliaLang/julia#53027 #53027 broke the `doctest` job in CI. 28 January 2024, 21:53:31 UTC
0ce62fe James Wrigley 28 January 2024, 21:38:20 UTC Document the generic functions nextind() and prevind() (#52658) Co-authored-by: inky <git@wo-class.cn> Co-authored-by: Denis Barucic <barucic.d@gmail.com> Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com> 28 January 2024, 21:38:20 UTC
d298c44 James Wrigley 28 January 2024, 16:27:37 UTC Document that findnext(f,x,i) and findprev(f,x,i) work for strings. (#52625) 28 January 2024, 16:27:37 UTC
35a5711 jam-khan 28 January 2024, 15:43:26 UTC Added reference to UnionAll manual for UnionAll docstrings. (#52838) 28 January 2024, 15:43:26 UTC
6ce6d31 Jameson Nash 27 January 2024, 17:45:03 UTC methods: add a lock around method table changes (#52997) Ensures that only one update can occur simultaneously by adding a lock around it, and that the acquire-release on the world-age will be sequenced after all of the invalidations to the caches, by updating it last. It should now be safe to add methods in parallel, concurrently with running code. However, there are still no locks here to ensure that only one module is deserialized at a time, which means that parallel require calls are still unsafe. (and also because the loading.jl code is currently a thread-safety disaster zone) As future work, all of the method inserting and (separately) the validation/insertion work could run in parallel after loading an image, since there is a fine-grained lock on each individual part of that, as well as the big lock so that only one module at a time can load methods. The min/max fields are always written behind a lock, but they are not usually read from behind a lock, so add relaxed atomic markers to all uses of that field to make any data-race analysis tools happy. These are never used in a comparison with a value greater than `jl_atomic_load_acquire(&jl_world_counter)`, and therefore the results achieved are consistent. 27 January 2024, 17:45:03 UTC
ecc14ca jariji 27 January 2024, 15:45:57 UTC Don't export Dates.adjust (#53027) `Dates.adjust` has been exported for a while, but has no docstring and is not in the manual in 1.10. Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com> 27 January 2024, 15:45:57 UTC
20085f4 jam-khan 27 January 2024, 15:45:12 UTC Add docstring for Dates.adjust (#52914) Co-authored-by: Steven G. Johnson <stevenj@mit.edu> Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com> 27 January 2024, 15:45:12 UTC
26e54d3 N5N3 27 January 2024, 14:47:04 UTC Subtype: fix mis-usage of `simple_subtype(2)` (#53078) 27 January 2024, 14:47:04 UTC
c32aeb5 Hendrik Ranocha 27 January 2024, 01:38:42 UTC Clarify documentation of do-block syntax (#52807) The previous version > The `do x` syntax creates an anonymous function with argument `x` and passes *it* as the first argument could be misunderstood since one may think that *it* refers to the argument `x`, not the anonymous function. --------- Co-authored-by: inky <git@wo-class.cn> 27 January 2024, 01:38:42 UTC
77dc56b Neven Sajko 27 January 2024, 01:35:44 UTC Fix some missing xrefs in collections.md (#53047) 27 January 2024, 01:35:44 UTC
c42df60 Sukera 26 January 2024, 16:41:20 UTC Improve type inference for `@something` (#52381) `@something` eagerly unwraps any `Some` given to it, while keeping the variable between its arguments the same. This can be an issue if a previously unpacked value is used as input to `@something`, leading to a type instability on more than two arguments (e.g. because of a fallback to `Some(nothing)`). By using different variables for each argument, type inference has an easier time handling these cases that are isolated to single branches anyway. This also adds some comments to the macro, since it's non-obvious what it does. Benchmarking the specific case I encountered this in led to a ~2x performance improvement on multiple machines. 1.10-beta3/master: ``` [sukera@tower 01]$ jl1100 -q --project=. -L 01.jl -e 'bench()' v"1.10.0-beta3" BenchmarkTools.Trial: 10000 samples with 1 evaluation. Range (min … max): 38.670 μs … 70.350 μs ┊ GC (min … max): 0.00% … 0.00% Time (median): 43.340 μs ┊ GC (median): 0.00% Time (mean ± σ): 43.395 μs ± 1.518 μs ┊ GC (mean ± σ): 0.00% ± 0.00% ▆█▂ ▁▁ ▂▂▂▂▂▂▂▂▂▁▂▂▂▃▃▃▂▂▃▃▃▂▂▂▂▂▄▇███▆██▄▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂ ▃ 38.7 μs Histogram: frequency by time 48 μs < Memory estimate: 0 bytes, allocs estimate: 0. ``` This PR: ``` [sukera@tower 01]$ julia -q --project=. -L 01.jl -e 'bench()' v"1.11.0-DEV.970" BenchmarkTools.Trial: 10000 samples with 1 evaluation. Range (min … max): 22.820 μs … 44.980 μs ┊ GC (min … max): 0.00% … 0.00% Time (median): 24.300 μs ┊ GC (median): 0.00% Time (mean ± σ): 24.370 μs ± 832.239 ns ┊ GC (mean ± σ): 0.00% ± 0.00% ▂▅▇██▇▆▅▁ ▂▂▂▂▂▂▂▂▃▃▄▅▇███████████▅▄▃▃▂▂▂▂▂▂▂▂▂▂▁▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▁▁▂▂ ▃ 22.8 μs Histogram: frequency by time 27.7 μs < Memory estimate: 0 bytes, allocs estimate: 0. ``` <details> <summary>Benchmarking code (spoilers for Advent Of Code 2023 Day 01, Part 01). Running this requires the input of that Advent Of Code day.</summary> ```julia using BenchmarkTools using InteractiveUtils isdigit(d::UInt8) = UInt8('0') <= d <= UInt8('9') someDigit(c::UInt8) = isdigit(c) ? Some(c - UInt8('0')) : nothing function part1(data) total = 0 may_a = nothing may_b = nothing for c in data digitRes = someDigit(c) may_a = @something may_a digitRes Some(nothing) may_b = @something digitRes may_b Some(nothing) if c == UInt8('\n') digit_a = may_a::UInt8 digit_b = may_b::UInt8 total += digit_a*0xa + digit_b may_a = nothing may_b = nothing end end return total end function bench() data = read("input.txt") display(VERSION) println() display(@benchmark part1($data)) nothing end ``` </details> <details> <summary>`@code_warntype` before</summary> ```julia julia> @code_warntype part1(data) MethodInstance for part1(::Vector{UInt8}) from part1(data) @ Main ~/Documents/projects/AOC/2023/01/01.jl:7 Arguments #self#::Core.Const(part1) data::Vector{UInt8} Locals @_3::Union{Nothing, Tuple{UInt8, Int64}} may_b::Union{Nothing, UInt8} may_a::Union{Nothing, UInt8} total::Int64 c::UInt8 digit_b::UInt8 digit_a::UInt8 val@_10::Any val@_11::Any digitRes::Union{Nothing, Some{UInt8}} @_13::Union{Some{Nothing}, Some{UInt8}, UInt8} @_14::Union{Some{Nothing}, Some{UInt8}} @_15::Some{Nothing} @_16::Union{Some{Nothing}, Some{UInt8}, UInt8} @_17::Union{Some{Nothing}, UInt8} @_18::Some{Nothing} Body::Int64 1 ── (total = 0) │ (may_a = Main.nothing) │ (may_b = Main.nothing) │ %4 = data::Vector{UInt8} │ (@_3 = Base.iterate(%4)) │ %6 = (@_3 === nothing)::Bool │ %7 = Base.not_int(%6)::Bool └─── goto #24 if not %7 2 ┄─ Core.NewvarNode(:(digit_b)) │ Core.NewvarNode(:(digit_a)) │ Core.NewvarNode(:(val@_10)) │ %12 = @_3::Tuple{UInt8, Int64} │ (c = Core.getfield(%12, 1)) │ %14 = Core.getfield(%12, 2)::Int64 │ (digitRes = Main.someDigit(c)) │ (val@_11 = may_a) │ %17 = (val@_11::Union{Nothing, UInt8} !== Base.nothing)::Bool └─── goto #4 if not %17 3 ── (@_13 = val@_11::UInt8) └─── goto #11 4 ── (val@_11 = digitRes) │ %22 = (val@_11::Union{Nothing, Some{UInt8}} !== Base.nothing)::Bool └─── goto #6 if not %22 5 ── (@_14 = val@_11::Some{UInt8}) └─── goto #10 6 ── (val@_11 = Main.Some(Main.nothing)) │ %27 = (val@_11::Core.Const(Some(nothing)) !== Base.nothing)::Core.Const(true) └─── goto #8 if not %27 7 ── (@_15 = val@_11::Core.Const(Some(nothing))) └─── goto #9 8 ── Core.Const(:(@_15 = Base.nothing)) 9 ┄─ (@_14 = @_15) 10 ┄ (@_13 = @_14) 11 ┄ %34 = @_13::Union{Some{Nothing}, Some{UInt8}, UInt8} │ (may_a = Base.something(%34)) │ (val@_10 = digitRes) │ %37 = (val@_10::Union{Nothing, Some{UInt8}} !== Base.nothing)::Bool └─── goto #13 if not %37 12 ─ (@_16 = val@_10::Some{UInt8}) └─── goto #20 13 ─ (val@_10 = may_b) │ %42 = (val@_10::Union{Nothing, UInt8} !== Base.nothing)::Bool └─── goto #15 if not %42 14 ─ (@_17 = val@_10::UInt8) └─── goto #19 15 ─ (val@_10 = Main.Some(Main.nothing)) │ %47 = (val@_10::Core.Const(Some(nothing)) !== Base.nothing)::Core.Const(true) └─── goto #17 if not %47 16 ─ (@_18 = val@_10::Core.Const(Some(nothing))) └─── goto #18 17 ─ Core.Const(:(@_18 = Base.nothing)) 18 ┄ (@_17 = @_18) 19 ┄ (@_16 = @_17) 20 ┄ %54 = @_16::Union{Some{Nothing}, Some{UInt8}, UInt8} │ (may_b = Base.something(%54)) │ %56 = c::UInt8 │ %57 = Main.UInt8('\n')::Core.Const(0x0a) │ %58 = (%56 == %57)::Bool └─── goto #22 if not %58 21 ─ (digit_a = Core.typeassert(may_a, Main.UInt8)) │ (digit_b = Core.typeassert(may_b, Main.UInt8)) │ %62 = total::Int64 │ %63 = (digit_a * 0x0a)::UInt8 │ %64 = (%63 + digit_b)::UInt8 │ (total = %62 + %64) │ (may_a = Main.nothing) └─── (may_b = Main.nothing) 22 ┄ (@_3 = Base.iterate(%4, %14)) │ %69 = (@_3 === nothing)::Bool │ %70 = Base.not_int(%69)::Bool └─── goto #24 if not %70 23 ─ goto #2 24 ┄ return total ``` </details> <details> <summary>`@code_native debuginfo=:none` Before </summary> ```julia julia> @code_native debuginfo=:none part1(data) .text .file "part1" .globl julia_part1_418 # -- Begin function julia_part1_418 .p2align 4, 0x90 .type julia_part1_418,@function julia_part1_418: # @julia_part1_418 # %bb.0: # %top push rbp mov rbp, rsp push r15 push r14 push r13 push r12 push rbx sub rsp, 40 mov rax, qword ptr [rdi + 8] test rax, rax je .LBB0_1 # %bb.2: # %L17 mov rcx, qword ptr [rdi] dec rax mov r10b, 1 xor r14d, r14d # implicit-def: $r12b # implicit-def: $r13b # implicit-def: $r9b # implicit-def: $sil mov qword ptr [rbp - 64], rax # 8-byte Spill mov al, 1 mov dword ptr [rbp - 48], eax # 4-byte Spill # implicit-def: $al # kill: killed $al xor eax, eax mov qword ptr [rbp - 56], rax # 8-byte Spill mov qword ptr [rbp - 72], rcx # 8-byte Spill # implicit-def: $cl jmp .LBB0_3 .p2align 4, 0x90 .LBB0_8: # in Loop: Header=BB0_3 Depth=1 mov dword ptr [rbp - 48], 0 # 4-byte Folded Spill .LBB0_24: # %post_union_move # in Loop: Header=BB0_3 Depth=1 movzx r13d, byte ptr [rbp - 41] # 1-byte Folded Reload mov r12d, r8d cmp qword ptr [rbp - 64], r14 # 8-byte Folded Reload je .LBB0_13 .LBB0_25: # %guard_exit113 # in Loop: Header=BB0_3 Depth=1 inc r14 mov r10d, ebx .LBB0_3: # %L19 # =>This Inner Loop Header: Depth=1 mov rax, qword ptr [rbp - 72] # 8-byte Reload xor ebx, ebx xor edi, edi movzx r15d, r9b movzx ecx, cl movzx esi, sil mov r11b, 1 # implicit-def: $r9b movzx edx, byte ptr [rax + r14] lea eax, [rdx - 58] lea r8d, [rdx - 48] cmp al, -10 setae bl setb dil test r10b, 1 cmovne r15d, edi mov edi, 0 cmovne ecx, ebx mov bl, 1 cmovne esi, edi test r15b, 1 jne .LBB0_7 # %bb.4: # %L76 # in Loop: Header=BB0_3 Depth=1 mov r11b, 2 test cl, 1 jne .LBB0_5 # %bb.6: # %L78 # in Loop: Header=BB0_3 Depth=1 mov ebx, r10d mov r9d, r15d mov byte ptr [rbp - 41], r13b # 1-byte Spill test sil, 1 je .LBB0_26 .LBB0_7: # %L82 # in Loop: Header=BB0_3 Depth=1 cmp al, -11 jbe .LBB0_9 jmp .LBB0_8 .p2align 4, 0x90 .LBB0_5: # in Loop: Header=BB0_3 Depth=1 mov ecx, r8d mov sil, 1 xor ebx, ebx mov byte ptr [rbp - 41], r8b # 1-byte Spill xor r9d, r9d xor ecx, ecx cmp al, -11 ja .LBB0_8 .LBB0_9: # %L90 # in Loop: Header=BB0_3 Depth=1 test byte ptr [rbp - 48], 1 # 1-byte Folded Reload jne .LBB0_23 # %bb.10: # %L115 # in Loop: Header=BB0_3 Depth=1 cmp dl, 10 jne .LBB0_11 # %bb.14: # %L122 # in Loop: Header=BB0_3 Depth=1 test r15b, 1 jne .LBB0_15 # %bb.12: # %L130.thread # in Loop: Header=BB0_3 Depth=1 movzx eax, byte ptr [rbp - 41] # 1-byte Folded Reload mov bl, 1 add eax, eax lea eax, [rax + 4*rax] add al, r12b movzx eax, al add qword ptr [rbp - 56], rax # 8-byte Folded Spill mov al, 1 mov dword ptr [rbp - 48], eax # 4-byte Spill cmp qword ptr [rbp - 64], r14 # 8-byte Folded Reload jne .LBB0_25 jmp .LBB0_13 .p2align 4, 0x90 .LBB0_23: # %L115.thread # in Loop: Header=BB0_3 Depth=1 mov al, 1 # implicit-def: $r8b mov dword ptr [rbp - 48], eax # 4-byte Spill cmp dl, 10 jne .LBB0_24 jmp .LBB0_21 .LBB0_11: # in Loop: Header=BB0_3 Depth=1 mov r8d, r12d jmp .LBB0_24 .LBB0_1: xor eax, eax mov qword ptr [rbp - 56], rax # 8-byte Spill .LBB0_13: # %L159 mov rax, qword ptr [rbp - 56] # 8-byte Reload add rsp, 40 pop rbx pop r12 pop r13 pop r14 pop r15 pop rbp ret .LBB0_21: # %L122.thread test r15b, 1 jne .LBB0_15 # %bb.22: # %post_box_union58 movabs rdi, offset .L_j_str1 movabs rax, offset ijl_type_error movabs rsi, 140008511215408 movabs rdx, 140008667209736 call rax .LBB0_15: # %fail cmp r11b, 1 je .LBB0_19 # %bb.16: # %fail movzx eax, r11b cmp eax, 2 jne .LBB0_17 # %bb.20: # %box_union54 movzx eax, byte ptr [rbp - 41] # 1-byte Folded Reload movabs rcx, offset jl_boxed_uint8_cache mov rdx, qword ptr [rcx + 8*rax] jmp .LBB0_18 .LBB0_26: # %L80 movabs rax, offset ijl_throw movabs rdi, 140008495049392 call rax .LBB0_19: # %box_union movabs rdx, 140008667209736 jmp .LBB0_18 .LBB0_17: xor edx, edx .LBB0_18: # %post_box_union movabs rdi, offset .L_j_str1 movabs rax, offset ijl_type_error movabs rsi, 140008511215408 call rax .Lfunc_end0: .size julia_part1_418, .Lfunc_end0-julia_part1_418 # -- End function .type .L_j_str1,@object # @_j_str1 .section .rodata.str1.1,"aMS",@progbits,1 .L_j_str1: .asciz "typeassert" .size .L_j_str1, 11 .section ".note.GNU-stack","",@progbits ``` </details> <details> <summary>`@code_warntype` After</summary> ```julia [sukera@tower 01]$ julia -q --project=. -L 01.jl julia> data = read("input.txt"); julia> @code_warntype part1(data) MethodInstance for part1(::Vector{UInt8}) from part1(data) @ Main ~/Documents/projects/AOC/2023/01/01.jl:7 Arguments #self#::Core.Const(part1) data::Vector{UInt8} Locals @_3::Union{Nothing, Tuple{UInt8, Int64}} may_b::Union{Nothing, UInt8} may_a::Union{Nothing, UInt8} total::Int64 val@_7::Union{} val@_8::Union{} c::UInt8 digit_b::UInt8 digit_a::UInt8 ##215::Some{Nothing} ##216::Union{Nothing, UInt8} ##217::Union{Nothing, Some{UInt8}} ##212::Some{Nothing} ##213::Union{Nothing, Some{UInt8}} ##214::Union{Nothing, UInt8} digitRes::Union{Nothing, Some{UInt8}} @_19::Union{Nothing, UInt8} @_20::Union{Nothing, UInt8} @_21::Nothing @_22::Union{Nothing, UInt8} @_23::Union{Nothing, UInt8} @_24::Nothing Body::Int64 1 ── (total = 0) │ (may_a = Main.nothing) │ (may_b = Main.nothing) │ %4 = data::Vector{UInt8} │ (@_3 = Base.iterate(%4)) │ %6 = @_3::Union{Nothing, Tuple{UInt8, Int64}} │ %7 = (%6 === nothing)::Bool │ %8 = Base.not_int(%7)::Bool └─── goto #24 if not %8 2 ┄─ Core.NewvarNode(:(val@_7)) │ Core.NewvarNode(:(val@_8)) │ Core.NewvarNode(:(digit_b)) │ Core.NewvarNode(:(digit_a)) │ Core.NewvarNode(:(##215)) │ Core.NewvarNode(:(##216)) │ Core.NewvarNode(:(##217)) │ Core.NewvarNode(:(##212)) │ Core.NewvarNode(:(##213)) │ %19 = @_3::Tuple{UInt8, Int64} │ (c = Core.getfield(%19, 1)) │ %21 = Core.getfield(%19, 2)::Int64 │ %22 = c::UInt8 │ (digitRes = Main.someDigit(%22)) │ %24 = may_a::Union{Nothing, UInt8} │ (##214 = %24) │ %26 = Base.:!::Core.Const(!) │ %27 = ##214::Union{Nothing, UInt8} │ %28 = Base.isnothing(%27)::Bool │ %29 = (%26)(%28)::Bool └─── goto #4 if not %29 3 ── %31 = ##214::UInt8 │ (@_19 = Base.something(%31)) └─── goto #11 4 ── %34 = digitRes::Union{Nothing, Some{UInt8}} │ (##213 = %34) │ %36 = Base.:!::Core.Const(!) │ %37 = ##213::Union{Nothing, Some{UInt8}} │ %38 = Base.isnothing(%37)::Bool │ %39 = (%36)(%38)::Bool └─── goto #6 if not %39 5 ── %41 = ##213::Some{UInt8} │ (@_20 = Base.something(%41)) └─── goto #10 6 ── %44 = Main.Some::Core.Const(Some) │ %45 = Main.nothing::Core.Const(nothing) │ (##212 = (%44)(%45)) │ %47 = Base.:!::Core.Const(!) │ %48 = ##212::Core.Const(Some(nothing)) │ %49 = Base.isnothing(%48)::Core.Const(false) │ %50 = (%47)(%49)::Core.Const(true) └─── goto #8 if not %50 7 ── %52 = ##212::Core.Const(Some(nothing)) │ (@_21 = Base.something(%52)) └─── goto #9 8 ── Core.Const(nothing) │ Core.Const(:(val@_8 = Base.something(Base.nothing))) │ Core.Const(nothing) │ Core.Const(:(val@_8)) └─── Core.Const(:(@_21 = %58)) 9 ┄─ %60 = @_21::Core.Const(nothing) └─── (@_20 = %60) 10 ┄ %62 = @_20::Union{Nothing, UInt8} └─── (@_19 = %62) 11 ┄ %64 = @_19::Union{Nothing, UInt8} │ (may_a = %64) │ %66 = digitRes::Union{Nothing, Some{UInt8}} │ (##217 = %66) │ %68 = Base.:!::Core.Const(!) │ %69 = ##217::Union{Nothing, Some{UInt8}} │ %70 = Base.isnothing(%69)::Bool │ %71 = (%68)(%70)::Bool └─── goto #13 if not %71 12 ─ %73 = ##217::Some{UInt8} │ (@_22 = Base.something(%73)) └─── goto #20 13 ─ %76 = may_b::Union{Nothing, UInt8} │ (##216 = %76) │ %78 = Base.:!::Core.Const(!) │ %79 = ##216::Union{Nothing, UInt8} │ %80 = Base.isnothing(%79)::Bool │ %81 = (%78)(%80)::Bool └─── goto #15 if not %81 14 ─ %83 = ##216::UInt8 │ (@_23 = Base.something(%83)) └─── goto #19 15 ─ %86 = Main.Some::Core.Const(Some) │ %87 = Main.nothing::Core.Const(nothing) │ (##215 = (%86)(%87)) │ %89 = Base.:!::Core.Const(!) │ %90 = ##215::Core.Const(Some(nothing)) │ %91 = Base.isnothing(%90)::Core.Const(false) │ %92 = (%89)(%91)::Core.Const(true) └─── goto #17 if not %92 16 ─ %94 = ##215::Core.Const(Some(nothing)) │ (@_24 = Base.something(%94)) └─── goto #18 17 ─ Core.Const(nothing) │ Core.Const(:(val@_7 = Base.something(Base.nothing))) │ Core.Const(nothing) │ Core.Const(:(val@_7)) └─── Core.Const(:(@_24 = %100)) 18 ┄ %102 = @_24::Core.Const(nothing) └─── (@_23 = %102) 19 ┄ %104 = @_23::Union{Nothing, UInt8} └─── (@_22 = %104) 20 ┄ %106 = @_22::Union{Nothing, UInt8} │ (may_b = %106) │ %108 = Main.:(==)::Core.Const(==) │ %109 = c::UInt8 │ %110 = Main.UInt8('\n')::Core.Const(0x0a) │ %111 = (%108)(%109, %110)::Bool └─── goto #22 if not %111 21 ─ %113 = may_a::Union{Nothing, UInt8} │ (digit_a = Core.typeassert(%113, Main.UInt8)) │ %115 = may_b::Union{Nothing, UInt8} │ (digit_b = Core.typeassert(%115, Main.UInt8)) │ %117 = Main.:+::Core.Const(+) │ %118 = total::Int64 │ %119 = Main.:+::Core.Const(+) │ %120 = Main.:*::Core.Const(*) │ %121 = digit_a::UInt8 │ %122 = (%120)(%121, 0x0a)::UInt8 │ %123 = digit_b::UInt8 │ %124 = (%119)(%122, %123)::UInt8 │ (total = (%117)(%118, %124)) │ (may_a = Main.nothing) └─── (may_b = Main.nothing) 22 ┄ (@_3 = Base.iterate(%4, %21)) │ %129 = @_3::Union{Nothing, Tuple{UInt8, Int64}} │ %130 = (%129 === nothing)::Bool │ %131 = Base.not_int(%130)::Bool └─── goto #24 if not %131 23 ─ goto #2 24 ┄ %134 = total::Int64 └─── return %134 ``` </details> <details> <summary>`@code_native debuginfo=:none` After </summary> ```julia julia> @code_native debuginfo=:none part1(data) .text .file "part1" .globl julia_part1_1203 # -- Begin function julia_part1_1203 .p2align 4, 0x90 .type julia_part1_1203,@function julia_part1_1203: # @julia_part1_1203 ; Function Signature: part1(Array{UInt8, 1}) # %bb.0: # %top #DEBUG_VALUE: part1:data <- [DW_OP_deref] $rdi push rbp mov rbp, rsp push r15 push r14 push r13 push r12 push rbx sub rsp, 40 vxorps xmm0, xmm0, xmm0 #APP mov rax, qword ptr fs:[0] #NO_APP lea rdx, [rbp - 64] vmovaps xmmword ptr [rbp - 64], xmm0 mov qword ptr [rbp - 48], 0 mov rcx, qword ptr [rax - 8] mov qword ptr [rbp - 64], 4 mov rax, qword ptr [rcx] mov qword ptr [rbp - 72], rcx # 8-byte Spill mov qword ptr [rbp - 56], rax mov qword ptr [rcx], rdx #DEBUG_VALUE: part1:data <- [DW_OP_deref] 0 mov r15, qword ptr [rdi + 16] test r15, r15 je .LBB0_1 # %bb.2: # %L34 mov r14, qword ptr [rdi] dec r15 mov r11b, 1 mov r13b, 1 # implicit-def: $r12b # implicit-def: $r10b xor eax, eax jmp .LBB0_3 .p2align 4, 0x90 .LBB0_4: # in Loop: Header=BB0_3 Depth=1 xor r11d, r11d mov ebx, edi mov r10d, r8d .LBB0_9: # %L114 # in Loop: Header=BB0_3 Depth=1 mov r12d, esi test r15, r15 je .LBB0_12 .LBB0_10: # %guard_exit126 # in Loop: Header=BB0_3 Depth=1 inc r14 dec r15 mov r13d, ebx .LBB0_3: # %L36 # =>This Inner Loop Header: Depth=1 movzx edx, byte ptr [r14] test r13b, 1 movzx edi, r13b mov ebx, 1 mov ecx, 0 cmove ebx, edi cmovne edi, ecx movzx ecx, r10b lea esi, [rdx - 48] lea r9d, [rdx - 58] movzx r8d, sil cmove r8d, ecx cmp r9b, -11 ja .LBB0_4 # %bb.5: # %L89 # in Loop: Header=BB0_3 Depth=1 test r11b, 1 jne .LBB0_8 # %bb.6: # %L102 # in Loop: Header=BB0_3 Depth=1 cmp dl, 10 jne .LBB0_7 # %bb.13: # %L106 # in Loop: Header=BB0_3 Depth=1 test r13b, 1 jne .LBB0_14 # %bb.11: # %L114.thread # in Loop: Header=BB0_3 Depth=1 add ecx, ecx mov bl, 1 mov r11b, 1 lea ecx, [rcx + 4*rcx] add cl, r12b movzx ecx, cl add rax, rcx test r15, r15 jne .LBB0_10 jmp .LBB0_12 .p2align 4, 0x90 .LBB0_8: # %L102.thread # in Loop: Header=BB0_3 Depth=1 mov r11b, 1 # implicit-def: $sil cmp dl, 10 jne .LBB0_9 jmp .LBB0_15 .LBB0_7: # in Loop: Header=BB0_3 Depth=1 mov esi, r12d jmp .LBB0_9 .LBB0_1: xor eax, eax .LBB0_12: # %L154 mov rcx, qword ptr [rbp - 56] mov rdx, qword ptr [rbp - 72] # 8-byte Reload mov qword ptr [rdx], rcx add rsp, 40 pop rbx pop r12 pop r13 pop r14 pop r15 pop rbp ret .LBB0_15: # %L106.thread test r13b, 1 jne .LBB0_14 # %bb.16: # %post_box_union47 movabs rax, offset jl_nothing movabs rcx, offset jl_small_typeof movabs rdi, offset ".L_j_str_typeassert#1" mov rdx, qword ptr [rax] mov rsi, qword ptr [rcx + 336] movabs rax, offset ijl_type_error mov qword ptr [rbp - 48], rsi call rax .LBB0_14: # %post_box_union movabs rax, offset jl_nothing movabs rcx, offset jl_small_typeof movabs rdi, offset ".L_j_str_typeassert#1" mov rdx, qword ptr [rax] mov rsi, qword ptr [rcx + 336] movabs rax, offset ijl_type_error mov qword ptr [rbp - 48], rsi call rax .Lfunc_end0: .size julia_part1_1203, .Lfunc_end0-julia_part1_1203 # -- End function .type ".L_j_str_typeassert#1",@object # @"_j_str_typeassert#1" .section .rodata.str1.1,"aMS",@progbits,1 ".L_j_str_typeassert#1": .asciz "typeassert" .size ".L_j_str_typeassert#1", 11 .section ".note.GNU-stack","",@progbits ``` </details> Co-authored-by: Sukera <Seelengrab@users.noreply.github.com> 26 January 2024, 16:41:20 UTC
5d4d6ab Mosè Giordano 26 January 2024, 10:17:58 UTC [OpenBLAS_jll] Update to new build with BFloat16 kernels (#53059) This also * drops a patch (`deps/patches/neoverse-generic-kernels.patch`) not needed anymore for an [old bug](https://github.com/OpenMathLib/OpenBLAS/issues/2998) fixed upstream in OpenBLAS. This results in ~5x speedup in the computation of `BLAS.nrm2` (and hence `LinearAlgebra.norm` for vectors longer than `LinearAlgebra.NRM2_CUTOFF` (== 32) elements) when the neoversen1 kernels are used, e.g. by default on all Apple Silicon CPUs * adds a regression test for the above bug * updates other patches when building openblas from source Corresponding PR in Yggdrasil: https://github.com/JuliaPackaging/Yggdrasil/pull/7202. 26 January 2024, 10:17:58 UTC
5cf1021 N5N3 26 January 2024, 02:37:39 UTC Subtype: Fix some diagonal rule related false alarm (#53034) close #33137 close #53021 --------- Co-authored-by: Jameson Nash <vtjnash@gmail.com> 26 January 2024, 02:37:39 UTC
1e45aba Jishnu Bhattacharya 26 January 2024, 01:46:45 UTC Fix indexing triangular matrices with `undef` elements in the parent (#52530) I'm not totally sure about specializing`getindex` for numeric arrays, but this lets us display a triangular matrix where the parent is not initialized. ```julia julia> M = Matrix{BigFloat}(undef, 4, 4) 4×4 Matrix{BigFloat}: #undef #undef #undef #undef #undef #undef #undef #undef #undef #undef #undef #undef #undef #undef #undef #undef julia> UpperTriangular(M) 4×4 UpperTriangular{BigFloat, Matrix{BigFloat}}: #undef #undef #undef #undef ⋅ #undef #undef #undef ⋅ ⋅ #undef #undef ⋅ ⋅ ⋅ #undef ``` 26 January 2024, 01:46:45 UTC
4919dd7 Ian Butterworth 25 January 2024, 19:50:47 UTC Profile: use full terminal cols to show function name (#53055) 25 January 2024, 19:50:47 UTC
55c13d2 Harmen Stoppels 25 January 2024, 17:06:21 UTC Symlink lld and dsymutil in correct build_depsbindir when `USE_SYSTEM_LLD=1` (#53050) Fixes #53049. Two things are addressed: 1. `dsymutil` wasn't linked 2. `lld` was put in `build_bindir`, but on install was looked for in `build_depsbindir` 25 January 2024, 17:06:21 UTC
936701e Jishnu Bhattacharya 25 January 2024, 15:16:47 UTC Avoid `StackOverflowError` in generic recursive `dot` (#53030) A quick check to throw an error early if `first(x) == x && first(y) == y`, in which case the recursive `dot` will lead to a stack overflow. Close https://github.com/JuliaLang/julia/issues/35654 25 January 2024, 15:16:47 UTC
14cf64f Jeremie Knuesel 25 January 2024, 11:18:30 UTC Remove wrong entries from NEWS.md (#53036) This removes the `hardlink` and `diskstat` entries in `NEWS.md` that I think were wrongly copied from the 1.8 release notes. (I took the opportunity to fix also a couple of unrelated typos) 25 January 2024, 11:18:30 UTC
0eec031 Diogo Netto 25 January 2024, 07:58:15 UTC fix cache line size of PPC7+ (#53044) Ref: https://reviews.llvm.org/D33656. --------- Co-authored-by: Keno Fischer <keno@juliacomputing.com> 25 January 2024, 07:58:15 UTC
b3ecd61 Jeff Bezanson 25 January 2024, 07:22:13 UTC make `isassigned(::ScopedValue)` more compatible with the generic meaning (#53022) 25 January 2024, 07:22:13 UTC
3da897b Jishnu Bhattacharya 25 January 2024, 03:06:15 UTC Don't access uninitialized indices in `tril!`/`triu!` for numeric arrays (#52528) This specializes the generic `triu!` and `tril!` methods for arrays of numbers, where a zero is known to exist. In such cases, we don't need to read the possibly uninitialized values of the elements at the indices that are to be assigned to. After this, the following would be possible: ```julia julia> M = Matrix{BigFloat}(undef, 3, 3) 3×3 Matrix{BigFloat}: #undef #undef #undef #undef #undef #undef #undef #undef #undef julia> triu!(M) 3×3 Matrix{BigFloat}: #undef #undef #undef 0.0 #undef #undef 0.0 0.0 #undef ``` 25 January 2024, 03:06:15 UTC
ca7b9c3 tecosaur 24 January 2024, 21:22:28 UTC Make concatenation of SubString{AnnotatedString} preserve annotations (#51806) `SubStrings` have been overlooked, and thanks to a few compiler quirks (relating to inlining and effect analysis), adding support for them is unfortunately a little more complicated than adding a `|| s isa SubString{<:AnnotatedString}` clause thanks to the new generated runtime-checks. To maintain the zero-overhead non-annotated code path, we need to implement a separate function `_isannotated`, which we also make use of to simplify the current join method. 24 January 2024, 21:22:28 UTC
e42ffa6 Max Horn 24 January 2024, 18:17:31 UTC Add GC.logging_enabled() (#51647) 24 January 2024, 18:17:31 UTC
919c390 Diogo Netto 24 January 2024, 17:08:42 UTC use proper cache-line size variable in work-stealing queue (#53035) 24 January 2024, 17:08:42 UTC
f5816f4 Ian Butterworth 24 January 2024, 15:59:44 UTC Int64 -> Int in fixed precompile statements (#53029) Fixes https://github.com/JuliaLang/julia/issues/53025 24 January 2024, 15:59:44 UTC
e74f9e4 tecosaur 24 January 2024, 15:25:13 UTC Introduce new syntax highlighting stdlib (#51810) Having this as a standard library allows for syntax highlighting to be used in the Markdown and REPL standard libraries. As a bonus, this provides an easy and canonical way of obtaining syntax highlighted code across the ecosystem. This is a pretty tiny library, at just ~200 lines, but a useful one. 24 January 2024, 15:25:13 UTC
81c4f8e Max Horn 24 January 2024, 13:20:49 UTC Replace `&hArr;` by `&harr;` in documentation (#52078) There is no HTML entity `&hArr;` and accordingly all the usual browsers (Chrome, Firefox, Safari) don't render it. My guess is that there is confusion because GitHub supports `&hArr;` and shows it as &hArr; (and `&harr;` as &harr;). But here is for example what Firefox shows: <img width="853" alt="Screen Shot 2023-11-08 at 14 02 01" src="https://github.com/JuliaLang/julia/assets/241512/af7d9e27-a5c3-46c3-94d9-82ed52653cb4"> This patch could be backported to 1.9 and 1.10. 24 January 2024, 13:20:49 UTC
91ec2bb Gabriel Baraldi 24 January 2024, 13:20:40 UTC Apple silicon has 128 byte alignment so fix our defines to match (#52996) https://github.com/JuliaLang/julia/blob/8a69745bdcb06409ab7e4fc84718f34d7d54a7f9/base/lock.jl#L33-L50 this probably also needs a fix, and maybe other places as well 24 January 2024, 13:20:40 UTC
35c0498 Max Horn 24 January 2024, 12:31:28 UTC Fix a list in GC devdocs (#53032) When splitting a Markdown list item into multiple lines, the following lines must be indented or else a new paragraph starts. 24 January 2024, 12:31:28 UTC
128e6e4 Mosè Giordano 24 January 2024, 01:33:37 UTC [nghttp2_jll] Update to v1.59.0 (#53010) 24 January 2024, 01:33:37 UTC
d741c24 Oscar Smith 23 January 2024, 14:57:41 UTC Make empty `Dict` only have space for 0 rather than 16 elements (and the minimum size for non-empty `Dict` down to 4). (#52912) This improves speed and reduces allocation for small Dicts. ``` #before julia> @btime Dict{Int,Int}() 46.815 ns (4 allocations: 448 bytes) #after julia> @btime Dict{Int, Int}() 9.429 ns (1 allocation: 80 bytes) ``` The initialization to 16 before made sense when `Dict` was `Vector` backed since `Vectors` were slow to instantiate, but Memory is much faster). 23 January 2024, 14:57:41 UTC
4dcd271 Neven Sajko 23 January 2024, 14:44:08 UTC Base: prevent `precision` infinite recursion (#52910) Make the single-argument method of `_precision` into its own function. Now `precision(Union{Float16,Float32})` results in a `MethodError` instead of in a `StackOverflowError`. Fixes #52909 23 January 2024, 14:44:08 UTC
32ad80b Jishnu Bhattacharya 23 January 2024, 14:40:41 UTC Add type assertion in iterate for logicalindex (#53015) The type-assertion helps convey the information that `iterate(tail(s)...)` would never return `nothing`, which makes JET happy. On master ```julia julia> L = Base.LogicalIndex([true]) 1-element Base.LogicalIndex{Int64, Vector{Bool}}: 1 julia> @report_call iterate(L) ═════ 2 possible errors found ═════ ┌ iterate(L::Base.LogicalIndex{Int64, Vector{Bool}}) @ Base ./multidimensional.jl:778 │┌ iterate(L::Base.LogicalIndex{Int64, Vector{Bool}}, s::Tuple{Int64, LinearIndices{1, Tuple{Base.OneTo{Int64}}}}) @ Base ./multidimensional.jl:789 ││┌ indexed_iterate(I::Nothing, i::Int64) @ Base ./tuple.jl:94 │││ no matching method found `iterate(::Nothing)`: x = iterate(I::Nothing) ││└──────────────────── ││┌ indexed_iterate(I::Nothing, i::Int64, state::Int64) @ Base ./tuple.jl:99 │││ no matching method found `iterate(::Nothing, ::Int64)`: x = iterate(I::Nothing, state::Int64) ``` This PR ```julia julia> @report_call iterate(L) No errors detected ``` Close https://github.com/JuliaArrays/StaticArrays.jl/issues/1225 23 January 2024, 14:40:41 UTC
e6bf976 DilumAluthgeBot 23 January 2024, 12:36:19 UTC 🤖 [master] Bump the StyledStrings stdlib from 61e7b10 to 302a0d0 (#53012) Stdlib: StyledStrings URL: https://github.com/JuliaLang/StyledStrings.jl.git Stdlib branch: main Julia branch: master Old commit: 61e7b10 New commit: 302a0d0 Julia version: 1.11.0-DEV StyledStrings version: 1.11.0 Bump invoked by: @vchuravy Powered by: [BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl) Diff: https://github.com/JuliaLang/StyledStrings.jl/compare/61e7b105b157b40807ed0b4840166a25b0948549...302a0d023a58d38cddf0a1b82c618621613c8d2a ``` $ git log --oneline 61e7b10..302a0d0 302a0d0 Directly import ScopedValue 3fab35e Fix showing AnnotatedChar with colour 44f5fd7 Restrict the Base docstrings included in the docs 4dee5d9 Add readme c49ae82 Add documentation task to CI 38ae1b3 Setting the terminal colour to :default is special 2709150 Adjust face merge tests after inheritance change 036631f Swap inheritance processing in face merge 9b35f08 Merge branch 'jn/Statefulempty' [#21] 508ab57 Refactor zip of eachindex to just use pairs 02b3f81 Remove use of length of Stateful 41c8218 Merge branch 'lh/ci-codecov' [#15] d581fda Disable codecov commenting in every PR a8a25ba Merge branch 'lh/ci-old-julia' [#13] b7fca5b Merge branch 'lh/newline' [#16] 984485e Adjust newline parsing to work with CLRF encoding 27b02d1 Test styled"" parsing of \-continued newlines a7981fe Merge pull request #17 from caleb-allen/add-beep-face c1ab675 Add repl_prompt_beep face 0d8f5df Merge pull request #18 from JuliaLang/whitespace-fixup 1ef0f90 Nicer whitespace alignment 91a24f8 Disable CI for older versions of Julia 63ff132 add tagbot 792fda7 add CI 506afe3 add .gitignore 74e7135 Load the JULIA_*_COLOR env vars for compat 87d1fb5 Replace within-module eval with hygienic eval 4777e60 Touchups to documented examples ``` Co-authored-by: Dilum Aluthge <dilum@aluthge.com> 23 January 2024, 12:36:19 UTC
9f36490 Diogo Netto 23 January 2024, 12:20:08 UTC place work-stealing queue indices on different cache lines to avoid false-sharing (#52994) For some reason this only shows up in the `many_refs.jl` benchmark, since it's the only one that hammers the work-stealing queue (we also didn't test this benchmark on a large number of GC threads in our [previous analysis](https://github.com/JuliaLang/julia/pull/48600#issuecomment-1518944785)). - master: ``` bench = "many_refs.jl" (gcthreads, threads) = (1, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 4268 │ 3243 │ 3048 │ 194 │ 1126 │ 15 │ 868 │ 76 │ │ median │ 4270 │ 3246 │ 3051 │ 195 │ 1128 │ 17 │ 868 │ 76 │ │ maximum │ 4278 │ 3247 │ 3052 │ 195 │ 1128 │ 18 │ 868 │ 76 │ │ stdev │ 5 │ 2 │ 2 │ 0 │ 1 │ 1 │ 0 │ 0 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ (gcthreads, threads) = (2, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 2728 │ 1692 │ 1551 │ 141 │ 598 │ 23 │ 868 │ 62 │ │ median │ 2732 │ 1709 │ 1567 │ 141 │ 603 │ 23 │ 868 │ 62 │ │ maximum │ 2744 │ 1712 │ 1571 │ 143 │ 607 │ 24 │ 868 │ 63 │ │ stdev │ 6 │ 9 │ 9 │ 1 │ 4 │ 0 │ 0 │ 0 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ (gcthreads, threads) = (4, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 2105 │ 1082 │ 987 │ 95 │ 405 │ 23 │ 875 │ 51 │ │ median │ 2115 │ 1089 │ 994 │ 95 │ 409 │ 23 │ 875 │ 52 │ │ maximum │ 2127 │ 1100 │ 1003 │ 97 │ 417 │ 25 │ 875 │ 52 │ │ stdev │ 8 │ 8 │ 7 │ 1 │ 5 │ 1 │ 0 │ 0 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ (gcthreads, threads) = (8, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 3861 │ 2755 │ 2676 │ 79 │ 1301 │ 22 │ 878 │ 68 │ │ median │ 3864 │ 2835 │ 2756 │ 80 │ 1342 │ 25 │ 879 │ 73 │ │ maximum │ 4032 │ 2877 │ 2797 │ 80 │ 1378 │ 26 │ 880 │ 74 │ │ stdev │ 73 │ 45 │ 45 │ 1 │ 28 │ 2 │ 1 │ 2 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ (gcthreads, threads) = (16, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 7455 │ 6425 │ 6344 │ 80 │ 3262 │ 24 │ 882 │ 86 │ │ median │ 7703 │ 6682 │ 6602 │ 81 │ 3313 │ 25 │ 884 │ 87 │ │ maximum │ 7826 │ 6806 │ 6725 │ 81 │ 3422 │ 27 │ 887 │ 87 │ │ stdev │ 152 │ 153 │ 153 │ 0 │ 68 │ 1 │ 2 │ 0 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ ``` - PR: ``` bench = "many_refs.jl" (gcthreads, threads) = (1, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 4264 │ 3240 │ 3048 │ 192 │ 1127 │ 15 │ 868 │ 76 │ │ median │ 4271 │ 3244 │ 3052 │ 192 │ 1129 │ 17 │ 868 │ 76 │ │ maximum │ 4514 │ 3481 │ 3289 │ 193 │ 1247 │ 18 │ 868 │ 77 │ │ stdev │ 109 │ 106 │ 106 │ 0 │ 53 │ 1 │ 0 │ 1 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ (gcthreads, threads) = (2, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 2712 │ 1680 │ 1541 │ 138 │ 591 │ 22 │ 868 │ 62 │ │ median │ 2713 │ 1691 │ 1552 │ 140 │ 594 │ 24 │ 868 │ 62 │ │ maximum │ 2732 │ 1710 │ 1569 │ 141 │ 606 │ 25 │ 868 │ 63 │ │ stdev │ 11 │ 12 │ 12 │ 1 │ 6 │ 1 │ 0 │ 0 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ (gcthreads, threads) = (4, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 2090 │ 1057 │ 962 │ 95 │ 398 │ 22 │ 874 │ 50 │ │ median │ 2103 │ 1070 │ 974 │ 95 │ 401 │ 24 │ 874 │ 51 │ │ maximum │ 2140 │ 1074 │ 978 │ 96 │ 402 │ 25 │ 875 │ 51 │ │ stdev │ 19 │ 6 │ 6 │ 0 │ 1 │ 1 │ 1 │ 1 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ (gcthreads, threads) = (8, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 2236 │ 1208 │ 1129 │ 79 │ 528 │ 23 │ 880 │ 54 │ │ median │ 2238 │ 1214 │ 1135 │ 79 │ 533 │ 23 │ 880 │ 54 │ │ maximum │ 2246 │ 1218 │ 1138 │ 80 │ 534 │ 35 │ 880 │ 54 │ │ stdev │ 4 │ 4 │ 4 │ 0 │ 3 │ 5 │ 0 │ 0 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ (gcthreads, threads) = (16, 1) ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 2326 │ 1297 │ 1216 │ 80 │ 595 │ 24 │ 884 │ 56 │ │ median │ 2348 │ 1325 │ 1245 │ 80 │ 620 │ 25 │ 885 │ 56 │ │ maximum │ 2370 │ 1341 │ 1262 │ 81 │ 631 │ 26 │ 887 │ 57 │ │ stdev │ 17 │ 19 │ 19 │ 0 │ 14 │ 1 │ 1 │ 0 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ ``` 23 January 2024, 12:20:08 UTC
5824c73 Cody Tapscott 23 January 2024, 04:43:22 UTC irinterp: add Tarjan SCC algorithm for reachability (#52966) This PR optimizes `kill_edge!` for IR interp. The basic algorithm flow is: ``` 1. Check whether `target` of dead edge is unreachable, which is true iff: - Reducible CFG node: there are no live incoming forward edges (predecessors) - Irreducible CFG node: Tarjan's SCC algorithm reports no live incoming forward edges to the SCC 2. If `target` is dead, repeat (1) for all of its outgoing edges ``` This maintains reachability information very efficiently, especially for reducible CFG's which are overwhelmingly common. As an added bonus, `CFGReachability` can also be consulted to check which BasicBlocks are part of an irreducible loop. 23 January 2024, 04:43:22 UTC
bc642cf Valentin Churavy 23 January 2024, 02:56:13 UTC NFC: Remove stale code from external objects handling (#53009) Thanks to @gbaraldi for pointing this out. 23 January 2024, 02:56:13 UTC
4d26be0 Christian Guinard 22 January 2024, 21:30:30 UTC Fix string output of `Base.format_bytes` when `binary=false` (#52932) Introduced in [50572](https://github.com/JuliaLang/julia/pull/50572) Before: ``` julia> Base.format_bytes(1, binary=false) "1 " julia> Base.format_bytes(11, binary=false) "11 s" ``` This PR: ``` julia> Base.format_bytes(1, binary=false) "1 byte" julia> Base.format_bytes(11, binary=false) "11 bytes" ``` Also add tests. 22 January 2024, 21:30:30 UTC
081f045 James Wrigley 22 January 2024, 20:20:21 UTC doc: Explicitly document how to add docstrings for inner constructors (#52995) xref https://github.com/JuliaLang/julia/issues/14962 22 January 2024, 20:20:21 UTC
68c0b2d Navid C. Constantinou 22 January 2024, 20:16:32 UTC doc: add a few missing spaces in `functions.md` (#53005) 22 January 2024, 20:16:32 UTC
59e505c Ian Butterworth 22 January 2024, 20:14:55 UTC NEWS: improve the hint for disabling on-the-fly tab completion (#53006) Followup to https://github.com/JuliaLang/julia/pull/51229 22 January 2024, 20:14:55 UTC
47d31ac Shuhei Kadowaki 22 January 2024, 09:46:23 UTC refactor the optimization flags set and utilities (#52998) 22 January 2024, 09:46:23 UTC
400ee71 Cody Tapscott 22 January 2024, 05:07:23 UTC Add `filter` parameter to `tarjan!` This still isn't an entirely generic version of the algorithm, but it's certainly a step in the right direction. 22 January 2024, 05:07:23 UTC
188cc93 Shuhei Kadowaki 22 January 2024, 02:02:13 UTC move `REPL.REPLCompletions.UndefVarError_hint` to `REPL` module (#52990) Since `UndefVarError_hint` is an interactive feature and isn't directly related to completion, it seems more appropriate to place it within `REPL` module rather than its `REPLCompletions` submodule. 22 January 2024, 02:02:13 UTC
9c78420 Diogo Netto 21 January 2024, 19:57:20 UTC reduce contention on page metadata lists during the sweeping phase (#52943) **EDIT**: fixes https://github.com/JuliaLang/julia/issues/52937 by decreasing the contention on the page lists and only waking GC threads up if we have a sufficiently large number of pages. Seems to address the regression from the MWE of https://github.com/JuliaLang/julia/issues/52937: - master: ``` ../julia-master/julia --project=. run_benchmarks.jl serial obj_arrays issue-52937 -n5 --gcthreads=1 bench = "issue-52937.jl" ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 24841 │ 818 │ 78 │ 740 │ 44 │ 10088 │ 96 │ 3 │ │ median │ 24881 │ 834 │ 83 │ 751 │ 45 │ 10738 │ 97 │ 3 │ │ maximum │ 25002 │ 891 │ 87 │ 803 │ 48 │ 11074 │ 112 │ 4 │ │ stdev │ 78 │ 29 │ 4 │ 26 │ 1 │ 393 │ 7 │ 0 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ ../julia-master/julia --project=. run_benchmarks.jl serial obj_arrays issue-52937 -n5 --gcthreads=8 bench = "issue-52937.jl" ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 29113 │ 5200 │ 68 │ 5130 │ 12 │ 9724 │ 95 │ 18 │ │ median │ 29354 │ 5274 │ 69 │ 5204 │ 12 │ 10456 │ 96 │ 18 │ │ maximum │ 29472 │ 5333 │ 70 │ 5264 │ 14 │ 11913 │ 97 │ 18 │ │ stdev │ 138 │ 54 │ 1 │ 55 │ 1 │ 937 │ 1 │ 0 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ ``` - PR: ``` ../julia-master/julia --project=. run_benchmarks.jl serial obj_arrays issue-52937 -n5 --gcthreads=1 bench = "issue-52937.jl" ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 24475 │ 761 │ 77 │ 681 │ 40 │ 9499 │ 94 │ 3 │ │ median │ 24845 │ 775 │ 80 │ 698 │ 43 │ 10793 │ 97 │ 3 │ │ maximum │ 25128 │ 811 │ 85 │ 726 │ 47 │ 12820 │ 113 │ 3 │ │ stdev │ 240 │ 22 │ 3 │ 21 │ 3 │ 1236 │ 8 │ 0 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ ../julia-master/julia --project=. run_benchmarks.jl serial obj_arrays issue-52937 -n5 --gcthreads=8 bench = "issue-52937.jl" ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 24709 │ 679 │ 70 │ 609 │ 11 │ 9981 │ 95 │ 3 │ │ median │ 24869 │ 702 │ 70 │ 631 │ 12 │ 10705 │ 96 │ 3 │ │ maximum │ 24911 │ 708 │ 72 │ 638 │ 13 │ 10820 │ 98 │ 3 │ │ stdev │ 79 │ 12 │ 1 │ 12 │ 1 │ 401 │ 1 │ 0 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ ``` Also, performance on `objarray.jl` (an example of benchmark in which sweeping parallelizes well with the current implementation) seems fine: - master: ``` ../julia-master/julia --project=. run_benchmarks.jl multithreaded bigarrays -n5 --gcthreads=1 bench = "objarray.jl" ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 19301 │ 10792 │ 7485 │ 3307 │ 1651 │ 196 │ 4519 │ 56 │ │ median │ 21415 │ 12646 │ 9094 │ 3551 │ 1985 │ 241 │ 6576 │ 59 │ │ maximum │ 21873 │ 13118 │ 9353 │ 3765 │ 2781 │ 330 │ 8793 │ 60 │ │ stdev │ 1009 │ 932 │ 757 │ 190 │ 449 │ 50 │ 1537 │ 2 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ ../julia-master/julia --project=. run_benchmarks.jl multithreaded bigarrays -n5 --gcthreads=8 bench = "objarray.jl" ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 13135 │ 4377 │ 3350 │ 1007 │ 491 │ 231 │ 6062 │ 33 │ │ median │ 13164 │ 4540 │ 3370 │ 1177 │ 669 │ 256 │ 6383 │ 35 │ │ maximum │ 13525 │ 4859 │ 3675 │ 1184 │ 748 │ 320 │ 7528 │ 36 │ │ stdev │ 183 │ 189 │ 146 │ 77 │ 129 │ 42 │ 584 │ 1 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ ``` - PR: ``` ../julia-master/julia --project=. run_benchmarks.jl multithreaded bigarrays -n5 --gcthreads=1 bench = "objarray.jl" ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 19642 │ 10931 │ 7566 │ 3365 │ 1653 │ 204 │ 5688 │ 56 │ │ median │ 21441 │ 12717 │ 8948 │ 3770 │ 1796 │ 217 │ 6972 │ 59 │ │ maximum │ 23494 │ 14643 │ 10576 │ 4067 │ 2513 │ 248 │ 8229 │ 62 │ │ stdev │ 1408 │ 1339 │ 1079 │ 267 │ 393 │ 19 │ 965 │ 2 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ ../julia-master/julia --project=. run_benchmarks.jl multithreaded bigarrays -n5 --gcthreads=8 bench = "objarray.jl" ┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐ │ │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │ │ │ ms │ ms │ ms │ ms │ ms │ us │ MB │ % │ ├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤ │ minimum │ 13365 │ 4544 │ 3389 │ 1104 │ 516 │ 255 │ 6349 │ 34 │ │ median │ 13445 │ 4624 │ 3404 │ 1233 │ 578 │ 275 │ 6385 │ 34 │ │ maximum │ 14413 │ 5278 │ 3837 │ 1441 │ 753 │ 300 │ 7547 │ 37 │ │ stdev │ 442 │ 303 │ 194 │ 121 │ 89 │ 18 │ 522 │ 1 │ └─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘ ``` 21 January 2024, 19:57:20 UTC
a9e2bd4 Bhuminjay Soni 21 January 2024, 11:16:12 UTC Add general fallback for rem2pi (#52955) **Overview:** - This PR fixes #44715 by adding a general fallback. **Testing:** - Tested the updated code. - Verified that other functionalities remain unaffected. **Dependencies:** - No dependencies on other pull requests. **CC:** - @N5N3 --------- Signed-off-by: 11happy <soni5happy@gmail.com> Co-authored-by: N5N3 <2642243996@qq.com> 21 January 2024, 11:16:12 UTC
1f111e1 Jameson Nash 20 January 2024, 19:02:52 UTC aotcompile: remove most offset code (#52865) Use absolute addresses for fvars, to avoid needing some of the copies and complexity around them, and the buggy-ness of LLVM linker features with doing this. This may replace https://github.com/JuliaLang/llvm-project/commit/a5ccdfbba7e54ea4792ff4bd61e163d209af36e1 20 January 2024, 19:02:52 UTC
8bb0109 Neven Sajko 20 January 2024, 18:18:28 UTC Add note to `names` docstring about not implying isdefined (#51593) 20 January 2024, 18:18:28 UTC
32534dd Eric Hanson 20 January 2024, 16:00:29 UTC implement `@time` and `@timev` in terms of `@timed` (#52889) closes https://github.com/JuliaLang/julia/issues/47056 I suspect there was some reason this wasn't done in the first place, but I figured opening a PR could be a way to discuss that. ~~Needs tests still for the new `@timed` fields.~~ --------- Co-authored-by: inky <git@wo-class.cn> 20 January 2024, 16:00:29 UTC
690a87e Diogo Netto 20 January 2024, 15:29:56 UTC check for ptls == NULL in a few places in the GC codebase (#52984) Also add a few `assert(ptls != NULL)` where necessary. 20 January 2024, 15:29:56 UTC
ce82696 Gabriel Baraldi 20 January 2024, 10:50:10 UTC Add detection for zen 4 cpus in processor_x86 (#52944) 20 January 2024, 10:50:10 UTC
6246074 Mosè Giordano 20 January 2024, 10:44:31 UTC Remove debug `@show`s in tests (#52983) Ref: https://github.com/JuliaLang/julia/pull/52750#discussion_r1457756113 20 January 2024, 10:44:31 UTC
63188d5 Keno Fischer 19 January 2024, 23:30:03 UTC Effects-tune PersitentDict (#52954) To in particular allow elimination of dead PersistentDict constructions. 19 January 2024, 23:30:03 UTC
fb2d946 Diogo Netto 19 January 2024, 15:22:51 UTC ensure a few GC verify functions conform with the new page metadata layout (#52975) Fix https://github.com/JuliaLang/julia/issues/52973. 19 January 2024, 15:22:51 UTC
d384a36 Gabriel Baraldi 19 January 2024, 13:39:33 UTC Add detection for apple m2 and m3 cpus, and cleanup code (#52396) This only makes a difference with LLVM 16 19 January 2024, 13:39:33 UTC
48ef5e9 Diogo Netto 19 January 2024, 13:10:50 UTC NFC: move memory pressure callback declaration to julia_gcext.h (#52962) It should probably be in `julia_gcext.h` together with the other callbacks for consistency. 19 January 2024, 13:10:50 UTC
d6adba1 Cody Tapscott 17 January 2024, 09:58:47 UTC irinterp: Add Tarjan SCC algorithm for reachability This optimizes `kill_edge!` for IR interp. The basic algorithm flow is: 1. Check whether `target` of dead edge is unreachable, i.e. iff: - Reducible CFG node: there is no live incoming forward edge - Irreducible CFG node: Tarjan's SCC algorithm reports no live incoming forward edges to the SCC 2. If `target` is dead, repeat (1) for all of its outgoing edges This maintains reachability information very efficiently, especially for reducible CFG's which are overwhelmingly common. As an added bonus CFGReachability can also be consulted to check which BasicBlocks are part of an irreducible loop. 19 January 2024, 05:54:58 UTC
eb26d63 inky 19 January 2024, 02:49:39 UTC add missing docstrings for Base.Sys (#52777) Part of #52725 19 January 2024, 02:49:39 UTC
a1be59a inky 19 January 2024, 02:46:55 UTC Sys.SC_CLK_TCK value on windows (#52936) I noticed in #52777 that `Sys.SC_CLK_TCK` is set to `0` on Windows, which is treated as an unknown clock-tick unit. This undocumented global variable is *only* used by `Sys` to display CPU load times from the `CPUInfo` data structure, which until #52777 was completely undocumented and only seems to be used by `versioninfo(verbose=true)`. On POSIX systems it is set to a `> 0` value, and is used to convert the CPU times into seconds. On Windows, it is set to `0`, which is treated as an unknown unit, so the CPU times are displayed without units. Since it is only used for CPU times, we can look at the [`uv_cpu_info` implementation](https://github.com/libuv/libuv/blob/3b6a1a14caeeeaf5510f2939a8e28ed9ba0ad968/src/win/util.c#L531-L653) to see how libuv computes these values on Windows. This function calls `pNtQuerySystemInformation`, which returns times in ["100ns intervals"](https://learn.microsoft.com/en-us/windows/win32/api/winternl/nf-winternl-ntquerysysteminformation#system_processor_performance_information), i.e. in units of 10⁻⁷ seconds. However, `uv_cpu_info` then divides these values by `10000`, which converts them to units of milliseconds. So, I believe that the correct value of `Sys.SC_CLK_TCK` on Windows is `1000`. Basically this just means that `versioninfo(verbose=true)` output on Windows will get units of seconds when printing CPU loads. As far as I can tell, no external package is using these (undocumented until now) timing values — the few packages that call `Sys.cpu_info()` only do so to get the `model` (string) field. 19 January 2024, 02:46:55 UTC
ca1e519 Richie Wilynnton 19 January 2024, 02:33:16 UTC Documentation for "Printf" Module (#52791) Part of https://github.com/JuliaLang/julia/issues/52725 --------- Co-authored-by: RichieWilynnton <richiewilynton@gmail.com> 19 January 2024, 02:33:16 UTC
ab9573f William Moses 19 January 2024, 01:47:11 UTC Add option to disable vector pipeline (#52544) This will allow tools like Enzyme to use the internal julia pass pipeline, rather than having their own version. 19 January 2024, 01:47:11 UTC
a0d55cd Shuhei Kadowaki 18 January 2024, 23:13:58 UTC [REPLCompletions] enable completions for `using Module.Inner|` (#52952) 18 January 2024, 23:13:58 UTC
3a63f25 Shuhei Kadowaki 18 January 2024, 23:10:57 UTC fixup! #52953, follow up the refactor on REPLCompletions.jl (#52959) 18 January 2024, 23:10:57 UTC
607b2b9 Viral B. Shah 18 January 2024, 19:51:44 UTC Bump SparseArrays to latest master at f37477 (#52968) @DilumAluthge BumpStdlibs did not work: https://github.com/JuliaLang/BumpStdlibs.jl/actions/runs/7574895316/job/20630289750 18 January 2024, 19:51:44 UTC
877c05e Viral B. Shah 18 January 2024, 19:10:52 UTC Bump to SuiteSparse 7.5.1 (#52960) 18 January 2024, 19:10:52 UTC
a28e553 Neven Sajko 18 January 2024, 15:49:40 UTC Remove single-argument methods for `map`, `foreach`, `Iterators.map` (#52631) In the case of `map` and `foreach`, this removes awkward functionality. `Iterators.map(::Any)`, on the other hand, already threw. 18 January 2024, 15:49:40 UTC
8c49e5e Frederik Banning 18 January 2024, 14:41:29 UTC Fix eachslice docstring typo (#52926) 18 January 2024, 14:41:29 UTC
8562af5 Shuhei Kadowaki 18 January 2024, 11:01:17 UTC minor refactors on REPLCompletions.jl (#52953) Those I found while working on #52952. 18 January 2024, 11:01:17 UTC
8f2f178 jariji 18 January 2024, 04:17:24 UTC Make `hasdoc` public (#52708) Making `Docs.hasdoc` `public` per @LilithHafner https://github.com/JuliaLang/julia/pull/52139#issuecomment-1874748877. --------- Co-authored-by: Steven G. Johnson <stevenj@mit.edu> Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com> 18 January 2024, 04:17:24 UTC
8274088 Shuhei Kadowaki 18 January 2024, 03:21:13 UTC irinterp: don't add backedges to top-level thunks (#52916) irinterp utilizes `store_backedges(::MethodInstance, edges)`, but it doesn't check to prevent adding backedges to top-level thunks. This is no issue in native compilation, however, it can become problematic when an external `AbstractInterpreter` that does irinterp on top-level thunks tries precompilation (this could, for instance, trigger [this assert](https://github.com/JuliaLang/julia/blob/b058146cafec8405aa07f9647642fd485ea3b5d7/src/staticdata_utils.c#L450)). This commit tries to resolve this issue by performing the top-level thunk check within `store_backedges(::MethodInstance, edges)` instead of `store_backedges(::InferenceResult, edges)` 18 January 2024, 03:21:13 UTC
94db364 Shuhei Kadowaki 18 January 2024, 03:18:17 UTC replace the `depwarn` special case with the recent compiler annotations (#52918) The special handling for `depwarn`, originating from JuliaLang/julia#27918 in 2018, is now set to be replaced by the more recent compiler annotations, esp. `@nospecializeinfer`. Assessing potential regressions from this change might be challenging, but I confirmed this only has a minimal impact on image sizes at least. 18 January 2024, 03:18:17 UTC
0b0e3bf Neven Sajko 18 January 2024, 03:17:17 UTC doc: fix typos, Markdown, language in the Manual section on `Main.main` (#52939) 18 January 2024, 03:17:17 UTC
3ed49fd Shuhei Kadowaki 17 January 2024, 06:57:37 UTC absint: merge `const_prop_enabled` into `bail_out_const_call` (#52921) Both of these interfaces have nearly identical roles. Considering the simplicity in the codebase and the possible overloads by external abstract interpreters, it seems more sensible to unify them into one interface. Also tweaks remarks a bit. 17 January 2024, 06:57:37 UTC
b4f7263 Mason Protter 17 January 2024, 02:21:10 UTC make `Base.remove_linenums!` public (#52911) 17 January 2024, 02:21:10 UTC
313cd79 Steven G. Johnson 17 January 2024, 01:51:49 UTC Update sys.c: whoops 17 January 2024, 01:51:49 UTC
45b1839 Steven G. Johnson 17 January 2024, 01:38:01 UTC Sys.SC_CLK_TCK value on windows 17 January 2024, 01:38:01 UTC
d4e3a3d Steven G. Johnson 17 January 2024, 01:26:47 UTC Update test/sysinfo.jl 17 January 2024, 01:26:47 UTC
b1c4fbf N5N3 17 January 2024, 01:25:25 UTC Fix `widen_diagonal` bug for nested `UnionAll` (#52924) Fix #52919. 17 January 2024, 01:25:25 UTC
6fa896d Mosè Giordano 16 January 2024, 23:23:57 UTC [OpenBLAS_jll] Use new build compiled with GCC 11 (#52928) This enables SVE kernels on aarch64, and sapphire rapids kernels on x86_64. For the record, corresponding PR in Yggdrasil: https://github.com/JuliaPackaging/Yggdrasil/pull/7952. 16 January 2024, 23:23:57 UTC
a327a95 Lilith Orion Hafner 16 January 2024, 23:09:30 UTC Insert hardcoded backlinks to stdlib doc pages (#51375) This is #48814 times 23. It solves most of but not all of #50035. 16 January 2024, 23:09:30 UTC
a391a4e 11happy 16 January 2024, 16:17:35 UTC Formatted the code Signed-off-by: 11happy <soni5happy@gmail.com> 16 January 2024, 16:17:35 UTC
adbf6b0 Bhuminjay Soni 16 January 2024, 16:08:09 UTC Update base/sysinfo.jl Co-authored-by: Steven G. Johnson <stevenj@mit.edu> 16 January 2024, 16:08:09 UTC
718740e Bhuminjay Soni 16 January 2024, 14:25:56 UTC Update base/sysinfo.jl Co-authored-by: Steven G. Johnson <stevenj@mit.edu> 16 January 2024, 14:25:56 UTC
6cf7d26 Bhuminjay Soni 16 January 2024, 14:25:35 UTC Update base/sysinfo.jl Co-authored-by: Steven G. Johnson <stevenj@mit.edu> 16 January 2024, 14:25:35 UTC
06f5a4c Bhuminjay Soni 16 January 2024, 14:25:18 UTC Update base/sysinfo.jl Co-authored-by: Steven G. Johnson <stevenj@mit.edu> 16 January 2024, 14:25:18 UTC
5e2cdbd Bhuminjay Soni 16 January 2024, 14:24:43 UTC Update test/sysinfo.jl Co-authored-by: Steven G. Johnson <stevenj@mit.edu> 16 January 2024, 14:24:43 UTC
3309d86 Bhuminjay Soni 16 January 2024, 14:24:13 UTC Update base/sysinfo.jl Co-authored-by: Steven G. Johnson <stevenj@mit.edu> 16 January 2024, 14:24:13 UTC
143169d 11happy 16 January 2024, 04:45:49 UTC resolved merge conflict Signed-off-by: 11happy <soni5happy@gmail.com> 16 January 2024, 04:45:49 UTC
b058146 Shuhei Kadowaki 16 January 2024, 01:18:01 UTC add `:import`/`:using`/`:export` heads to `VALID_EXPR_HEADS` (#52906) Typically, top-level thunks that include these exprs aren't compiled. However, in certain `AbstractInterpreter`s such as JET, there's a need to perform inference on arbitrary top-level thunks for analysis purposes. So this commit updates the IR validator so that it does not raise errors on these exprs. 16 January 2024, 01:18:01 UTC
d479660 Shuhei Kadowaki 16 January 2024, 01:15:22 UTC inference: always bail out const-prop' with non-const result limited (#52836) Investigating into #52763, I've found that `AbstractInterpreters` which enables the `aggressive_constprop` option, such as `REPLInterpreter`, might perform const-prop' even if the result of a non-const call is `LimitedAccuracy`. This can lead to an unintended infinite loop with a custom aggressive const-prop' implementation. This commit restricts const-prop' for such cases where the non-const call result is limited to avoid the issue. This fix is conservative, but given that accurate inference is mostly impossible when there are unresolvable cycles (which is indicated by limited result), aggressive const-prop' isn't necessary for such cases, and I don't anticipate this leading to any obvious regression. fix #52763 16 January 2024, 01:15:22 UTC
89710bf jam-khan 15 January 2024, 20:32:31 UTC Add docstring for TOML stdlib module (#52834) 15 January 2024, 20:32:31 UTC
8d92a49 11happy 15 January 2024, 18:03:30 UTC removed export of Sys.JIT,Sys.CPU_NAME,Sys.cpu_summary,Sys.cpu_info Signed-off-by: 11happy <soni5happy@gmail.com> 15 January 2024, 18:03:30 UTC
fc6295d DilumAluthgeBot 15 January 2024, 05:47:28 UTC 🤖 [master] Bump the Pkg stdlib from 3c86ba27e to ba4955e2e (#52903) 15 January 2024, 05:47:28 UTC
25c4166 Steven G. Johnson 14 January 2024, 23:00:41 UTC add tests for undocumented symbols (#52723) Following #52413 by @jariji and the discussion in #51174, this adds tests to ensure that there are no undocumented *(= lacking docstrings)* public symbols in any documented module. Many of the tests are broken — we have a lot of undocumented exports. In such cases I added both a `@test_broken` and a `@test` to ensure that there are no additional regressions added in the future. ~~(This PR may have to be updated when https://github.com/JuliaLang/julia/pull/52413#discussion_r1441068405 is fixed, i.e. when ~~#52727~~ #52743 is merged.)~~ Has been updated. --------- Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com> 14 January 2024, 23:00:41 UTC
681816c Jishnu Bhattacharya 14 January 2024, 15:03:44 UTC [WIP] Specialize `chklapackerror` to improve error messages (#51645) This is an attempt at resolving https://github.com/JuliaLang/julia/issues/46636. Since each LAPACK function generally has a specific meaning attached to a positive error code, this PR tries to specialize `chklapackerror` for the caller to throw a more informative error instead of a `LAPACKException`. For example: ```julia julia> U = UpperTriangular([1 2; 0 0]) 2×2 UpperTriangular{Int64, Matrix{Int64}}: 1 2 ⋅ 0 julia> inv(U) ERROR: SingularException(2) [...] ``` Currently, I've only specialized it for `trtrs!`, but if this seems reasonable, I'll add others. Functions to be implemented: - [ ] `gbtrf` - [ ] `gbtrs` - [ ] `gebal!` - [ ] `gebak!` - [ ] `gebrd!` - [ ] `gelqf!` - [ ] `geqlf!` - [ ] `geqp3!` - [ ] `geqrt!` - [ ] `geqrt3!` - [ ] `geqrf!` - [ ] `gerqf!` - [ ] `getrf!` - [ ] `tzrzf!` - [ ] `ormrz!` - [ ] `gels!` - [ ] `gesv!` - [ ] `getrs!` - [ ] `getri!` - [ ] `gesvx!` - [ ] `gelsd!` - [ ] `gelsy!` - [ ] `gglse!` - [ ] `geev!` - [ ] `gesdd!` - [ ] `gesvd!` - [ ] `ggsvd!` - [ ] `ggsvd3!` - [ ] `geevx!` - [ ] `ggev!` - [ ] `ggev3!` - [ ] `gtsv!` - [ ] `gttrf!` - [ ] `gttrs!` - [ ] `orglq!` - [ ] `orgqr!` - [ ] `orgql!` - [ ] `orgrq!` - [ ] `ormlq!` - [ ] `ormqr!` - [ ] `ormql!` - [ ] `ormrq!` - [ ] `gemqrt!` - [ ] `potrs!` - [ ] `ptsv!` - [ ] `pttrf!` - [ ] `pttrs!` - [ ] `trtri!` - [x] `trtrs!` - [ ] `trcon!` - [ ] `trevc!` - [ ] `trrfs!` - [ ] `stev!` - [ ] `stebz!` - [ ] `stegr!` - [ ] `stein!` - [ ] `syconv!` - [ ] `sytrs!` - [ ] `sytrs_rook!` - [ ] `syconvf_rook!` - [ ] `hesv!` - [ ] `hetri!` - [ ] `hetrs!` - [ ] `hesv_rook!` - [ ] `hetri_rook!` - [ ] `hetrs_rook!` - [ ] `sytri!` - [ ] `sytri_rook!` - [ ] `syconvf_rook!` - [ ] `syev!` - [ ] `syevr!` - [ ] `syevd!` - [ ] `bdsqr!` - [ ] `bdsdc!` - [ ] `gecon!` - [ ] `gehrd!` - [ ] `orghr!` - [ ] `ormhr!` - [ ] `hseqr!` - [ ] `hetrd!` - [ ] `ormtr!` - [ ] `gees!` - [ ] `gges!` - [ ] `gges3!` - [ ] `trexc!` - [ ] `trsen!` - [ ] `tgsen!` - [ ] `trsyl!` 14 January 2024, 15:03:44 UTC
eadec43 Ian Butterworth 14 January 2024, 13:50:36 UTC REPLCompletions: PATH caching tweaks (#52893) 14 January 2024, 13:50:36 UTC
back to top