Skip to main content

Browse the archive

https://github.com/JuliaLang/julia
19 April 2024, 06:28:37 UTC
sort by:
Revision Author Date Message Commit Date
6e7db14 Jameson Nash 01 February 2024, 18:19:57 UTC Update and load styledstrings in REPL (#51869) This has some value by itself, but mainly serves as a prerequisite for #51811, #51816, and #51829, along with two other PRs that have yet to be made. 01 February 2024, 18:19:57 UTC
f117a50 Jameson Nash 01 February 2024, 15:38:38 UTC Introduce AnnotatedIOBuffer (#51807) This allows for styled content to be constructed incrementally, without resorting to repeated concatenation. It operates very similarly to IOContext, just with a special `write` method and specifically wrapping an IOBuffer. 01 February 2024, 15:38:38 UTC
c16472b Jian Fang 01 February 2024, 14:59:17 UTC Change to streaming out the heap snapshot data (#52854) This PR is to continue the work on the following PR: Prevent OOMs during heap snapshot: Change to streaming out the snapshot data (https://github.com/JuliaLang/julia/pull/51518 ) Here are the commit history: ``` * Streaming the heap snapshot! This should prevent the engine from OOMing while recording the snapshot! Now we just need to sample the files, either online, before downloading, or offline after downloading :) If we're gonna do it offline, we'll want to gzip the files before downloading them. * Allow custom filename; use original API * Support legacy heap snapshot interface. Add reassembly function. * Add tests * Apply suggestions from code review * Update src/gc-heap-snapshot.cpp * Change to always save the parts in the same directory This way you can always recover from an OOM * Fix bug in reassembler: from_node and to_node were in the wrong order * Fix correctness mistake: The edges have to be reordered according to the node order. That's the whole reason this is tricky. But i'm not sure now whether the SoAs approach is actually an optimization.... It seems like we should probably prefer to inline the Edges right into the vector, rather than having to do another random lookup into the edges table? * Debugging messed up edge array idxs * Disable log message * Write the .nodes and .edges as binary data * Remove unnecessary logging * fix merge issues * attempt to add back the orphan node checking logic ``` --------- Co-authored-by: Nathan Daly <nathan.daly@relational.ai> Co-authored-by: Nathan Daly <NHDaly@gmail.com> 01 February 2024, 14:59:17 UTC
8b88e3b Neven Sajko 01 February 2024, 14:57:13 UTC delete unnecessary abstract type in `Base.Rounding` (#53093) 01 February 2024, 14:57:13 UTC
88218c6 Nicholas Bauer 01 February 2024, 14:39:45 UTC Clarify error when arrays are too big for the system bit width (#52545) On Slack, was helping someone who encountered an "Invalid Array size" error message on a 32-bit system. The cause wasn't clear, so I had to dig around and realized that it only triggers if an array is created that is too large for the bit width of the system. So I figured it would be better to clarify that in the error message. --------- Co-authored-by: Steven G. Johnson <stevenj@mit.edu> Co-authored-by: Ian Butterworth <i.r.butterworth@gmail.com> 01 February 2024, 14:39:45 UTC
453e9d0 Neven Sajko 01 February 2024, 14:35:22 UTC `typemin`, `typemax` for irrationals (#50894) Fixes #36978 01 February 2024, 14:35:22 UTC
30ccace TEC 25 October 2023, 15:51:33 UTC Load StyledStrings in REPL By loading the StyledStrings stdlib in REPL, we load the privateered print/show methods for the Annotated{String,Char} types defined there. This is nice to have, because it means that styled annotated strings can be constructed in Base and elsewhere without loading the StyledStrings stdlib, but they will be displayed as intended in the REPL. 01 February 2024, 12:54:33 UTC
1552116 TEC 25 October 2023, 15:59:05 UTC Update StyledStrings version This gets us two particular commits of interest: - Replace within-module eval with hygienic eval: which makes it possible to include StyledStrings in the sysimage without running into precompile errors. - Load the JULIA_*_COLOR env vars for compat: which mirrors the current behaviour to the relevant faces. 01 February 2024, 12:54:31 UTC
e7a1c7f DilumAluthgeBot 01 February 2024, 09:46:54 UTC 🤖 [master] Bump the Pkg stdlib from ba4955e2e to f3b81f1aa (#53138) Stdlib: Pkg URL: https://github.com/JuliaLang/Pkg.jl.git Stdlib branch: master Julia branch: master Old commit: ba4955e2e New commit: f3b81f1aa Julia version: 1.11.0-DEV Pkg version: 1.11.0 Bump invoked by: @KristofferC Powered by: [BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl) Diff: https://github.com/JuliaLang/Pkg.jl/compare/ba4955e2e0eb64e47861d0a7d96569c05d41f1f5...f3b81f1aac77acf08f5d847ead29ad0a228dec67 ``` $ git log --oneline ba4955e2e..f3b81f1aa f3b81f1aa disable `julia_version` tests (#3773) b13bd2ddf support the "path" key in Project.toml, (#3756) 731105126 why: show more when package is both a direct and indirect dep (#3771) a83783ecb Avoid deleting existing artifacts when ignoring hashes. (#3768) b43187590 ignore tree hashes on Windows w/o symlink capability (#3764) ``` Co-authored-by: Dilum Aluthge <dilum@aluthge.com> 01 February 2024, 09:46:54 UTC
f064e1b Jishnu Bhattacharya 01 February 2024, 06:12:14 UTC forward `repeat(A, cts..)` to `repeat(A; kw..)` (#49830) This would mean that custom array types that seek to extend `repeat` only need to add the method `repeat(A::CustomArray; kw...)` 01 February 2024, 06:12:14 UTC
6db867b Fengyang Wang 01 February 2024, 05:16:57 UTC Better libuv error message for ENOENT ~ (#22647) 01 February 2024, 05:16:57 UTC
353d7b7 Alexander Plavin 01 February 2024, 02:46:09 UTC Define valtype(::Tuple) and keytype(::Tuple) (#49179) Same as https://github.com/JuliaLang/julia/pull/46555, but for Tuples Co-authored-by: Oscar Smith <oscardssmith@gmail.com> 01 February 2024, 02:46:09 UTC
08e3c2e Jishnu Bhattacharya 31 January 2024, 20:38:30 UTC Access only stored inds in `copy` for strided `AbstractTriangular` (#52907) 31 January 2024, 20:38:30 UTC
444e14e James Wrigley 31 January 2024, 20:37:53 UTC Make FDWatcher check for file descriptors equal to -1 (#52902) 31 January 2024, 20:37:53 UTC
2b9839b TEC 31 January 2024, 08:22:45 UTC Use insert! not splice! for new annotations Co-authored-by: Jameson Nash <vtjnash@gmail.com> 31 January 2024, 17:54:29 UTC
39839ac TEC 28 December 2023, 10:35:15 UTC Update the mention of annotated features in NEWS 31 January 2024, 17:54:29 UTC
2e6ebb9 TEC 15 December 2023, 18:13:57 UTC Tests for AnnotatedIOBuffer 31 January 2024, 17:54:29 UTC
d49ba4f TEC 23 January 2024, 10:04:00 UTC Writing from one AnnotatedIOBuffer to another 31 January 2024, 17:54:29 UTC
f4c5e13 TEC 28 December 2023, 10:00:48 UTC Also read AnnotatedChars from an AnnotatedIOBuffer The `read(::AnnotatedIOBuffer, AnnotatedString)` method is intended as an approximate analogue to `read(::IOBuffer, String)`. In the same sense, it makes sense to define `read(::AnnotatedIOBuffer, AnnotatedChar)` as an analogue to `read(::IOBuffer, Char)`. 31 January 2024, 17:54:23 UTC
c2b441b TEC 28 December 2023, 10:00:36 UTC Make AnnotatedIOBuffer reading more generic While `String` is the only concrete type for which `read(::IOBuffer, ::Type{<:AbstractString})` is defined, is is entirely conceivable that some other custom string type could define a similar `read` method. Since making reading an `AnnotatedString` from an `AnnotatedIOBuffer` more generic is as easy as replacing the hardcoded `String` with a type parameter, we may as well do so. 31 January 2024, 17:53:42 UTC
886d7a4 Ian Butterworth 31 January 2024, 17:19:45 UTC get_bool_env: add method with a lazy default option. Add kwarg to throw (#52950) Based on need here https://github.com/JuliaLang/Pkg.jl/pull/3764#discussion_r1456534459 31 January 2024, 17:19:45 UTC
95ae27f Mason Protter 31 January 2024, 17:10:30 UTC Try to fix incorrect documentation of `nthreads` (#53117) Since https://github.com/JuliaLang/julia/pull/49094, the docstring of `nthreads` has been incorrect. It currently states that > The threads in default have id numbers `1:nthreads(:default)`. whereas that is no longer true: ```julia julia> filter(i -> Threads.threadpool(i) == :interactive, 1:Threads.maxthreadid()) 3-element Vector{Int64}: 1 2 3 julia> filter(i -> Threads.threadpool(i) == :default, 1:Threads.maxthreadid()) 6-element Vector{Int64}: 4 5 6 7 8 9 ``` 31 January 2024, 17:10:30 UTC
8304111 Nathan Daly 31 January 2024, 16:49:59 UTC Add `Base.checked_pow(x,y)` to `Base.Checked` library (#52849) Fixes #52262. Performs `^(x, y)` but throws OverflowError on overflow. Example: ```julia julia> 2^62 4611686018427387904 julia> 2^63 -9223372036854775808 julia> checked_pow(2, 63) ERROR: OverflowError: 2147483648 * 4294967296 overflowed for type Int64 ``` Co-authored-by: Jameson Nash <vtjnash@gmail.com> Co-authored-by: Shuhei Kadowaki <aviatesk@gmail.com> 31 January 2024, 16:49:59 UTC
81deb5e Ian Butterworth 31 January 2024, 16:01:30 UTC fix pkgimage.mk tree (#53133) Taken from https://github.com/JuliaLang/julia/pull/53111 31 January 2024, 16:01:30 UTC
cc74d24 Jishnu Bhattacharya 31 January 2024, 12:09:57 UTC Inplace transpose for unit Triangular may skip diagonal (#53101) Since the diagonal elements of a `UnitUpperTriangular` are given by `onelement`, these should be unchanged under `transpose/adjoint`, and we don't need to access these elements in the parent array when performing in-place operations. Fixes ```julia julia> using LinearAlgebra julia> M = Matrix{BigFloat}(undef, 2, 2); julia> M[1,2] = 3; julia> U = UnitUpperTriangular(M) 2×2 UnitUpperTriangular{BigFloat, Matrix{BigFloat}}: 1.0 3.0 ⋅ 1.0 julia> transpose!(U) ERROR: UndefRefError: access to undefined reference Stacktrace: [1] getindex @ ./essentials.jl:882 [inlined] [2] getindex @ ./array.jl:915 [inlined] [3] copytri! @ ~/packages/julias/julia-latest/share/julia/stdlib/v1.11/LinearAlgebra/src/matmul.jl:414 [inlined] [4] transpose!(A::UnitUpperTriangular{BigFloat, Matrix{BigFloat}}) @ LinearAlgebra ~/packages/julias/julia-latest/share/julia/stdlib/v1.11/LinearAlgebra/src/triangular.jl:470 [5] top-level scope @ REPL[5]:1 ``` After this PR: ```julia julia> transpose!(U) 2×2 UnitLowerTriangular{BigFloat, Matrix{BigFloat}}: 1.0 ⋅ 3.0 1.0 ``` 31 January 2024, 12:09:57 UTC
cb9b00d Shuhei Kadowaki 31 January 2024, 08:18:01 UTC follow up #53127, fix the broken test case (#53134) 31 January 2024, 08:18:01 UTC
311553e TEC 14 December 2023, 15:09:51 UTC Make AnnotatedIOBuffer behave more like IOBuffer A few extra methods help a lot. It also turns out that we don't actually need to implement lock/unlock, the fallback implementations are enough. 31 January 2024, 06:22:20 UTC
2730f29 TEC 21 October 2023, 11:48:18 UTC Introduce AnnotatedIOBuffer This allows for styled content to be constructed incrementally, without resorting to repeated concatenation. It operates very similarly to IOContext, just with a special `write` method and specifically wrapping an IOBuffer. 31 January 2024, 06:22:20 UTC
dc474d8 Jameson Nash 31 January 2024, 01:28:11 UTC inference: avoid adding duplicate edges as invoke targets (#53121) This was inefficient, though not wrong. Fixes #53020 31 January 2024, 01:28:11 UTC
1295379 Oscar Smith 31 January 2024, 01:24:10 UTC put a try catch around calls to `propertynames` in tab completion. (#53127) fixes https://github.com/JuliaLang/julia/issues/53126 31 January 2024, 01:24:10 UTC
9df7a67 DilumAluthgeBot 30 January 2024, 23:09:05 UTC 🤖 [master] Bump the ArgTools stdlib from 4eccde4 to 997089b (#53124) Stdlib: ArgTools URL: https://github.com/JuliaIO/ArgTools.jl.git Stdlib branch: master Julia branch: master Old commit: 4eccde4 New commit: 997089b Julia version: 1.11.0-DEV ArgTools version: 1.1.2(Does not match) Bump invoked by: @vtjnash Powered by: [BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl) Diff: https://github.com/JuliaIO/ArgTools.jl/compare/4eccde45ddc27e4f7fc9094b2861c684e062adb2...997089b9cd56404b40ff766759662e16dc1aab4b ``` $ git log --oneline 4eccde4..997089b 997089b fix tests for TEMP_CLEANUP, which might be a Lockable (#35) 4a5f003 build(deps): bump actions/cache from 3 to 4 (#36) 84ba9e8 Hardcode doc edit backlink (#34) 9238839 build(deps): bump actions/checkout from 3 to 4 (#33) ``` Co-authored-by: Dilum Aluthge <dilum@aluthge.com> 30 January 2024, 23:09:05 UTC
4b1bbeb Lorenzo Van Munoz 30 January 2024, 22:27:09 UTC make `Base.reduced_indices` more type-stable (#52905) This fixes #35199 by rewriting `Base.reduced_indices` to be type stable (and grounded). I was also able to remove a method since that case is covered by the general case. The changes are illustrated by the following quick benchmarks: ```julia julia> VERSION v"1.10.0" julia> using BenchmarkTools julia> M = [1 2; 3 4] 2×2 Matrix{Int64}: 1 2 3 4 julia> @btime sum($M, dims=$(2)) 194.816 ns (5 allocations: 160 bytes) 2×1 Matrix{Int64}: 3 7 julia> @btime sum($M, dims=$((2,))) 209.385 ns (5 allocations: 224 bytes) 2×1 Matrix{Int64}: 3 7 julia> function my_reduced_indices(inds::Base.Indices{N}, region) where N rinds = inds for i in region isa(i, Integer) || throw(ArgumentError("reduced dimension(s) must be integers")) d = Int(i) if d < 1 throw(ArgumentError("region dimension(s) must be ≥ 1, got $d")) elseif d <= N rinds = let rinds_=rinds ntuple(j -> j == d ? Base.reduced_index(rinds_[d]) : rinds_[j], Val(N)) end end end rinds end my_reduced_indices (generic function with 1 method) julia> Base.reduced_indices(inds::Base.Indices{N}, region::Int) where N = my_reduced_indices(inds, region) julia> Base.reduced_indices(inds::Base.Indices{N}, region) where N = my_reduced_indices(inds, region) julia> @btime sum($M, dims=$(2)) 43.582 ns (1 allocation: 80 bytes) 2×1 Matrix{Int64}: 3 7 julia> @btime sum($M, dims=$((2,))) 43.882 ns (1 allocation: 80 bytes) 2×1 Matrix{Int64}: 3 7 ``` I also rewrote `Base.reduced_indices0` in the same fashion. I wasn't sure how to add tests for this since the improvements are to type-groundedness. Since these changes affect all reductions I hope this solution is robust. 30 January 2024, 22:27:09 UTC
432d248 Max Horn 30 January 2024, 22:13:49 UTC Restrict some argument types for _truncate_at_width_or_chars (#53031) This resolved some invalidations for me in a package 30 January 2024, 22:13:49 UTC
9f643a0 Matt Bauman 30 January 2024, 21:06:19 UTC Fix invalid let syntax from LHS views (#53108) When the frontend lowers an expression like `lhs .+= rhs`, it needs to prevent evaluating the LHS more than once before re-writing to `lhs .= lhs .+ rhs`. If the LHS was a `let` block — commonly generated by `@views` and (since #53064) `@view` — the lowering pass had previously been emitting an invalid `let` temporary. This very directly addresses that case. Fixes #53107. Fixes #44356. 30 January 2024, 21:06:19 UTC
fdb342c Neven Sajko 30 January 2024, 20:40:35 UTC make `keytype` and `valtype` work for `UnionAll` `AbstractDict`s (#53116) Fixes #53115 30 January 2024, 20:40:35 UTC
ef69db6 Frames White 30 January 2024, 20:40:16 UTC Don't mention __precompile__(false) in error message (#53099) I am fairly sure nothing in my dep tree uses `__precompile__(false)` so this message is misleading. I know we changed another of them a while ago 30 January 2024, 20:40:16 UTC
3510f4e Jameson Nash 30 January 2024, 18:58:40 UTC Improve inferrability of large unions, as seen in `LinearAlgebra.wrap` (#53084) The `LinearAlgebra.wrap` makes a large (5 element) union with some almost-similar types. This was intended to be permitted currently in `tmerge`, but due to some unintended interactions in some heuristics, was not. Closes https://github.com/JuliaLang/julia/issues/53075 30 January 2024, 18:58:40 UTC
9f5f540 Jameson Nash 30 January 2024, 18:58:00 UTC remove length from Stateful (#51747) Stateful iterators do not have a consistent notion of length, as it is continuously changing as elements are removed. As the main purpose of Stateful is to take elements from multiple places, any notion of HaveShape is invalid for those cases, and thus not useful in general. Fix #47790 30 January 2024, 18:58:00 UTC
b7520d9 Florian 30 January 2024, 14:55:20 UTC `stale_cachefile`: account for path separator when checking @depot (#53058) 30 January 2024, 14:55:20 UTC
75c38e3 Mosè Giordano 30 January 2024, 08:30:00 UTC Make relocatedepot test more robust (#53110) As discussed in the `#ci-dev` call (see https://github.com/JuliaLang/julia/issues/53103#issuecomment-1915458694 and https://github.com/JuliaLang/julia/pull/53104#discussion_r1470021366) there were two problems: * the use of `Base.require` caused the package to be loaded * the name of the package was a generic placeholder, and clashed with other packages loaded during the tests called with the same generic name. The solution was to rename test module with a more specific name, and replace `Base.require` with `Base.compilecache`, the latter only compiles the package without loading it. Should fix #53103, close #53104. 30 January 2024, 08:30:00 UTC
9816a0b Lilith Orion Hafner 30 January 2024, 05:34:15 UTC Reland "Don't export Dates.adjust" (#53092) 30 January 2024, 05:34:15 UTC
8cb5854 Steven G. Johnson 30 January 2024, 02:42:51 UTC fix fd_in_limits test on Windows (#52779) Closes #52506 Note that this test dates back to #26341 30 January 2024, 02:42:51 UTC
2f845bb Jameson Nash 30 January 2024, 02:36:22 UTC some minor code cleanup of getHostCPUName handling (#53083) Try to minimize the places the code depends on this library function, since it is useful for generic code as long as LLVM is available, but we would also be happy with returning the text "native" here in most cases. Co-authored-by: Mosè Giordano <giordano@users.noreply.github.com> 30 January 2024, 02:36:22 UTC
8fdda09 Jameson Nash 27 January 2024, 18:09:46 UTC reorder the code in LinearAlgebra.wrap to be slightly more inferrable abstractly By adding a type-assert at the end, we can try to ensure that eltype and ndims info is preserved, even if inference decides not to preserve the giant Union in detail. This avoids complete loss of precision in the subsequent calls (generic_matmatmul! -> _generic_matmatmul!), which has a type-assert on each input of AbstractVecOrMat. Closes #53075 30 January 2024, 02:35:12 UTC
eeebb6e Jameson Nash 27 January 2024, 18:07:47 UTC inference: slightly relax union complexity limit Permits forming AbstractVecOrMat from tmerge(AbstractVector, AbstractMatrix}. With the standard limit of 3, this now permits a maximum of either: - 2 dispatch-leaf types + 1 other type - 2 non-dispatch-leaf types 30 January 2024, 02:33:23 UTC
aa10573 Jameson Nash 27 January 2024, 18:05:03 UTC inference: avoid having one over-widened type poison the whole union I observed `UnitLowerTriangular{T, AbstractMatrix{T}} where T` being widened to `UnitLowerTriangular{F64, <:Matrix}`, which then forced it to become `Any`. Avoid that by only widening at most to the wrapper as required by the earlier check in this function. 30 January 2024, 02:33:23 UTC
fbd14a2 Shuhei Kadowaki 30 January 2024, 00:57:05 UTC post-opt: fix minor logic errors (#53100) I've identified and am addressing some minor bugs and optimizations in the post-opt analysis code upon reviewing it. 30 January 2024, 00:57:05 UTC
3f468cd Pablo San-Jose 30 January 2024, 00:39:11 UTC Add a test to avoid #53054 regressions (#53079) Tests issue #53054. The same test is included in backport #53074. 30 January 2024, 00:39:11 UTC
9edf1dd Pablo San-Jose 30 January 2024, 00:25:02 UTC Ensure elision of `require_one_based_indexing` with high-dim array views (#53091) Closes #49332 --------- Co-authored-by: Denis Barucic <barucic.d@gmail.com> 30 January 2024, 00:25:02 UTC
a3357cd Denis Barucic 29 January 2024, 21:04:24 UTC Docs: cross-reference `username` and `homedir` (#52451) To improve discoverability (mainly) of `username`. 29 January 2024, 21:04:24 UTC
a26bd7f Shuhei Kadowaki 29 January 2024, 19:29:12 UTC optimize away `ifelse` when given values are egal (#53102) 29 January 2024, 19:29:12 UTC
b16c4d4 Neven Sajko 29 January 2024, 19:28:38 UTC extend `divrem(x, y)` for `BigInt` to `divrem(x, y, rm)` (#53106) Previously `divrem(x, y, rm)` was dispatched to a more generic code path that called `div`, causing unnecessary allocation. Xref #45159. Also replaced the `big` call with `BigInt`, which seems more correct to me. The issue is that a user may define some `<:Integer` type for which `big` doesn't convert to `BigInt`, which seems like it would lead to infinite recursion in this case. 29 January 2024, 19:28:38 UTC
67f7320 Jameson Nash 29 January 2024, 17:35:30 UTC builtin: allow equal types in set_global_type without error (#53086) Use the julia notion of equality (type-equal) instead of the strictly C notion (pointer-equal). Also add tests and docs for this function. 29 January 2024, 17:35:30 UTC
aec8823 Jameson Nash 29 January 2024, 17:35:06 UTC gf: small perf optimization to jl_method_table_add_backedge (#53085) If this table gets very large, doing a jl_types_equal against every element can be costly. Often they might all be the same signature also, just from different specializations. Try to short-circuit the comparisons to scan in a more optimal order. 29 January 2024, 17:35:06 UTC
08d229f Kristoffer Carlsson 29 January 2024, 11:51:55 UTC Extensions: make loading of extensions independent of what packages are in the sysimage (#52841) When triggers of extension are in the sysimage it is easy to end up with cycles in package loading. Say we have a package A with exts BExt and CExt and say that B and C is in the sysimage. - Upon loading A, we will immidiately start to precompile BExt (because the trigger B is "loaded" by virtue of being in the sysimage). - BExt will load A which will cause CExt to start precompiling (again because C is in the sysimage). - CExt will load A which will now cause BExt to start loading and we get a cycle. This is fixed in this PR by instead of looking at what modules are loaded, we look at what modules are actually `require`d and only use that to drive the loading of extensions. Fixes https://github.com/JuliaLang/julia/issues/52132. 29 January 2024, 11:51:55 UTC
9669eec Mosè Giordano 29 January 2024, 08:34:37 UTC Drop support for LLVM 14 (#53094) 29 January 2024, 08:34:37 UTC
741b5da Shuhei Kadowaki 29 January 2024, 06:28:39 UTC forward-port #53096 to nightly, fix the intermittent REPL test failure (#53097) While the original issue #52739 has been observed only in v1.10, the necessity to enhance the robustness of the corresponding test code is still applicable in the nightly. See #53096 for the details. 29 January 2024, 06:28:39 UTC
0588cd4 Shuhei Kadowaki 29 January 2024, 02:21:47 UTC remove unnecessary `true &&` part from `at-view` macro (#53064) The modification that expands `@view A[i]` to `true && view(A, i)` appears to go back as far as #20247. However, I'm not entirely sure why this is necessary. Considering that just expanding it to `view(A, i)` still seems to pass the base test suite, I wonder if it might be just better to get rid of that part. 29 January 2024, 02:21:47 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
back to top