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
5d1ca6a Rafael Fourquet 11 July 2023, 16:00:54 UTC speed-up `randperm` by using our current `rand(1:n)` And similarly for `randcycle` and `shuffle`. We had a custom version of range generation for `randperm`, which was based on the ideas of our previous default range sampler `SamplerRangeFast` (generate `k`-bits integers using masking and reject out-of-range ones) and took advantage of the fact that `randperm` needs to generate `rand(1:i)` for `i = 2:n`. But our current range sampler ("Nearly Division Less") is usually better than this hack, and makes these functions more readable. Typically, for array lengths `< 2^20`, the new version is faster, but gets slightly slower beyond 2^22. 11 July 2023, 16:15:57 UTC
2d4d096 Tarn Yeong Ching 11 July 2023, 07:22:55 UTC unify `shuffle` and `randperm` (#50318) 11 July 2023, 07:22:55 UTC
680e3b3 Shuhei Kadowaki 11 July 2023, 04:57:30 UTC REPLCompletions: unswitch `Union` of same `UnionAll` results (#50483) With this commit the inference-base REPL completion algorithm converts `Union` result of same `UnionAll` instances to `UnionAll` of `Union`s so that it can use the field information of the `UnionAll`. This allows us to get completions for cases like: ```julia julia> union_somes() = rand() < 0.5 ? Some(1) : Some(2.); julia> union_somes().| # completes to `value` ``` 11 July 2023, 04:57:30 UTC
25eeba4 DilumAluthgeBot 11 July 2023, 03:51:26 UTC 🤖 [master] Bump the Pkg stdlib from e8197dd0e to 80e64bcd3 (#50501) 11 July 2023, 03:51:26 UTC
3a36e1a Keno Fischer 11 July 2023, 02:59:50 UTC sroa: Don't use unwrapped type for type constraint (#50499) In SROA, when we lift getfields over branches (ifelse or phi), we try to exclude branches that we know to not contribute by their types. However, we were incorrectly using the `unwrap_unionall`'ed version of the type. Type intersection has a bunch of fallbacks for free typevars, but the results are not necessarily correct (e.g. in the test case where `hasintersect(Wrap1{Wrap{Int}}, Wrap1{Wrap{T}})` gives false). We should ideally get around to just making type-quries for things with free typevars an error, but for now, just fix the particular issue in sroa, by using the non-unwrapped type. 11 July 2023, 02:59:50 UTC
b26f3b2 Viral B. Shah 11 July 2023, 01:01:40 UTC Update SparseArrays.jl stdlib for SuiteSparse 7 (#48977) * Use SparseArrays.jl updated to work with SuiteSparse 7, and with Int32 indices * SuiteSparse_jll Update to v7.2.0 (Using @Wimmerer's SuiteSparse fork for 32-bit QR) --------- Co-authored-by: Francois-Xavier Coudert <fxcoudert@gmail.com> Co-authored-by: Will Kimmerer <kimmerer@mit.edu> 11 July 2023, 01:01:40 UTC
a134076 Lilith Orion Hafner 10 July 2023, 22:30:48 UTC Revise sort.md and docstrings in sort.jl (#48363) Co-authored-by: Jeremie Knuesel <knuesel@gmail.com> 10 July 2023, 22:30:48 UTC
8dd58a4 Steven G. Johnson 10 July 2023, 16:45:27 UTC whitespace fix in randcycle (#50493) 10 July 2023, 16:45:27 UTC
e2e34f6 Andrés Riedemann 10 July 2023, 14:21:37 UTC correction in `Base.isassigned` with `Tridiagonal` boundscheck error (#50488) See https://github.com/JuliaLang/julia/pull/49827#discussion_r1252566082 10 July 2023, 14:21:37 UTC
db6193c Navid C. Constantinou 10 July 2023, 12:22:02 UTC doc: add spaces after commas in some function calls (#50478) 10 July 2023, 12:22:02 UTC
7530a63 Lilith Orion Hafner 10 July 2023, 11:46:54 UTC Clarify compat note in randcycle (#50482) 10 July 2023, 11:46:54 UTC
4051769 Steven G. Johnson 10 July 2023, 10:17:48 UTC clarify documentation for r"..."x mode (#50462) 10 July 2023, 10:17:48 UTC
206e59a Lionel Zoubritzky 10 July 2023, 10:16:28 UTC Fix compat annotation for italic printstyled (#50490) 10 July 2023, 10:16:28 UTC
7b435d0 Max Horn 10 July 2023, 10:15:23 UTC Fix minor typos in comments / docs (#50489) 10 July 2023, 10:15:23 UTC
8e877cb Diogo Netto 10 July 2023, 00:40:14 UTC relax assertion involving pg->nold to reflect that it may be a bit inaccurate with parallel marking (#50466) 10 July 2023, 00:40:14 UTC
84ef74f Shuhei Kadowaki 10 July 2023, 00:39:01 UTC minor cleanup on `Core.Compiler.type_annotate!` (#50484) 10 July 2023, 00:39:01 UTC
7c80589 Nathan Zimmerberg 09 July 2023, 19:17:01 UTC maximum is for array reduction, not max. (#50481) 09 July 2023, 19:17:01 UTC
fe2eead pchintalapudi 09 July 2023, 14:12:08 UTC Document llvm passes in more depth (#50319) 09 July 2023, 14:12:08 UTC
236c23b Kevin Song 08 July 2023, 19:54:20 UTC docs: Fix a `!!! note` which was miscapitalized (#50474) 08 July 2023, 19:54:20 UTC
2e0e3d5 Ian Butterworth 08 July 2023, 17:32:07 UTC report if task has started in show method (#50464) 08 July 2023, 17:32:07 UTC
d60f9b3 Keno Fischer 08 July 2023, 06:52:22 UTC Refactor and pass correct interpreter to typeinf finish loop (#50469) When we have an inference loop with different interpreters, the current code was trying to cache everything with the top level interpreter of the loop, yielding some unexpected behavior. I don't think that it's necessarily super well defined what should happen here, as it depends on the interpreters, in question, but I think it's better to try to cache each frame with the interpreter that created it, since they may have different lattices, etc. Doing this fixes an error I saw downstream that had just such a situation. --------- Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com> 08 July 2023, 06:52:22 UTC
e20274f Tim Besard 08 July 2023, 02:34:18 UTC Remove FATAL_TYPE_BOUND_ERROR (#50465) 08 July 2023, 02:34:18 UTC
085c3d1 Lilith Orion Hafner 07 July 2023, 22:16:25 UTC Make `(1:3:4)[6148914691236517207]` throw (#50118) 07 July 2023, 22:16:25 UTC
a660798 Jeremie Knuesel 07 July 2023, 22:14:40 UTC Improve documentation of sort-related functions (#48387) * document the `order` keyword in `sort!` * list explicitly the required properties of `lt` in `sort!` * clarify the sequence of "by" transformations if both `by` and `order` are given * show default values in the signatures for `searchsorted` and related functions * note that `by` is also applied to searched value in `searchsorted` and related * add `isunordered` to the manual (it's already exported) --------- Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com> 07 July 2023, 22:14:40 UTC
b99f251 Nicholas Bauer 07 July 2023, 19:11:29 UTC Merge new `reinterpret` with essentials.jl `reinterpret` (#50367) 07 July 2023, 19:11:29 UTC
930838b Guillaume Dalle 07 July 2023, 17:59:39 UTC Add exports to `Example` module for the test workflow in the docs (#50459) The tests are not supposed to work if the toy module `Example` does not export its functions See https://discourse.julialang.org/t/workflow-for-testing-packages/101305 07 July 2023, 17:59:39 UTC
21bb0c7 Keno Fischer 07 July 2023, 15:43:52 UTC Remove union penalties for inlining cost (#50429) I added this code back in #27057, when I first made Union-full signatures inlineable. The justification was to try to encourage the union splitting to happen on the outside. However (and I believe this changed since this code was introduced), these days inference is in complete control of union splitting and we do not take inlineability or non-inlineability of the non-unionsplit function into account when deciding how to inline. As a result, the only effect of the union split penalties was to prevent inlining of functions that are not union-split eligible (e.g. `+(::Vararg{Union{Int, Missing}, 3})`), but are nevertheless cheap by our inlining metric. There is really no reason not to try to inline such functions, so delete this logic. 07 July 2023, 15:43:52 UTC
0718995 Gabriel Baraldi 07 July 2023, 14:55:56 UTC Optimize getfield lowering to avoid boxing in some cases (#50444) 07 July 2023, 14:55:56 UTC
4cce2a2 pchintalapudi 07 July 2023, 13:34:55 UTC Add some documentation about ahead of time compilation mechanics (#50376) 07 July 2023, 13:34:55 UTC
d9ad6d2 Morten Piibeleht 06 July 2023, 22:23:35 UTC docs: fix link in `AbstractString` docstring (#50436) 06 July 2023, 22:23:35 UTC
2a406b2 Keno Fischer 06 July 2023, 21:20:40 UTC Add pattern matching for `typeof` into field type tparam (#50422) * Add pattern matching for `typeof` into field type tparam This PR allows full elimination of the following, even in ill-typed code. ``` struct TParamTypeofTest{T} x::T @eval TParamTypeofTest(x) = $(Expr(:new, :(TParamTypeofTest{typeof(x)}), :x)) end function tparam_typeof_test_elim(x) TParamTypeofTest(x).x end ``` Before this PR, we would get: ``` julia> code_typed(tparam_typeof_test_elim, Tuple{Any}) 1-element Vector{Any}: CodeInfo( 1 ─ %1 = Main.typeof(x)::DataType │ %2 = Core.apply_type(Main.TParamTypeofTest, %1)::Type{TParamTypeofTest{_A}} where _A │ %new(%2, x)::TParamTypeofTest └── return x ``` Where the `new` is non-eliminable, because the compiler did not know that `x::_A`. Fix this by pattern matching this particular pattern (where the condition is guaranteed, because we computed `_A` by `typeof`). This is not particularly general, but this pattern comes up a lot, so it's surprisingly effective. * add test case for optimizing multiple abstract fields * improve robustness --------- Co-authored-by: Shuhei Kadowaki <aviatesk@gmail.com> 06 July 2023, 21:20:40 UTC
46477cc Keno Fischer 06 July 2023, 21:18:59 UTC Delete `trust_inference` option (#50432) * Flip trust_inference option I think the time has come to flip this. This was added when the type system was much less reliable at producing intersections. It is true that we still have the occasional type sytem bug, but we're already trusting inference in a bunch of other places. At the same time, the cost of this has grown in terms of bloated IR needing to be visited in places like irinterp, so let's flip the bit and we'll deal with type system bugs the way we usually due. * refactor to remove trust_inference entirely --------- Co-authored-by: oscarddssmith <oscar.smith@juliacomputing.com> 06 July 2023, 21:18:59 UTC
c09efd9 Lilith Orion Hafner 06 July 2023, 20:42:14 UTC More consistent findall output type (take 2) (#48976) Fixup for #45538 Helps with #45495 06 July 2023, 20:42:14 UTC
6d44707 adienes 06 July 2023, 20:36:37 UTC retrieve `splice!` item via `only` rather than `getindex` (#50430) Because `only` uses iteration, similar to the other branches here, rather than assuming it supports one-based-indexing. 06 July 2023, 20:36:37 UTC
b6bfe98 Andrés Riedemann 06 July 2023, 20:05:43 UTC Define `Base.isstored` for Diagonals and Triangular matrices (#50391) X-ref #50377 06 July 2023, 20:05:43 UTC
c14d4bb Steven G. Johnson 06 July 2023, 19:50:32 UTC copyuntil(out::IO, in::IO, delim) (#48273) Note that this defines the lock order as `out` then `in` for streams which may try to take both locks. This is now a mandatory API convention for all future streams. Co-authored-by: Rafael Fourquet <fourquet.rafael@gmail.com> 06 July 2023, 19:50:32 UTC
64ab537 Malte Sandstede 06 July 2023, 18:45:02 UTC Add GC metric `last_incremental_sweep` (#50190) * Add GC metric `last_incremental_sweep` * Update gc.c * Update gc.c 06 July 2023, 18:45:02 UTC
feb2988 Simon Byrne 06 July 2023, 08:41:15 UTC remove type parameter from AbstractTriangular (#26307) Co-authored-by: Daniel Karrasch <daniel.karrasch@posteo.de> 06 July 2023, 08:41:15 UTC
77ce343 Jishnu Bhattacharya 06 July 2023, 08:31:12 UTC Fix some inference checks in reduce tests (#50437) 06 July 2023, 08:31:12 UTC
5579566 Guillaume Dalle 06 July 2023, 08:01:18 UTC Add paragraph on abstract `Function` fields to performance tips (#50421) Co-authored-by: Steven G. Johnson <stevenj@mit.edu> 06 July 2023, 08:01:18 UTC
0b54ded Steven G. Johnson 06 July 2023, 07:58:09 UTC avoid potential type-instability in _replace_(str, ...) (#50424) 06 July 2023, 07:58:09 UTC
2360140 Elliot Saba 06 July 2023, 00:08:45 UTC Merge pull request #50428 from JuliaLang/kf/divinlinecost Lower inlining cost of floating point div 06 July 2023, 00:08:45 UTC
c09a199 Diogo Netto 05 July 2023, 20:33:43 UTC update halfpages pointer after actually sweeping pages (#50387) 05 July 2023, 20:33:43 UTC
8d62b40 Keno Fischer 05 July 2023, 20:21:40 UTC Lower inlining cost of floating point div Our inlining cost model is extremely primitive, though surprisingly functional given its limitations. The basic idea for it was just that we'd give every intrinsic the approximate cost in cycles, such that for sufficiently large functions (>100 cycles), the cost of the extra call would be dwarfed by the cost of the function. However, there's a few problems with this. For one, the real issue is usually not the extra overhead of the call (which is small and well-predicated), but rather the inhibition of optimizations that inlining might have allowed. Additionally, the relevant cost comparison is not generally latency, but rather the size of the resulting binary. Lastly, the latency metric is misleading on modern superscalar architectures, because the core will perform other tasks while the operation is executing. In fact, somewhat counter-intuitively, this means that it is *more* important to inline high-latency instructions to allow the compiler to perform better latency hiding by spreading out the high-latency instructions. We probably need a full-on rethink of the inlining model at some point, but for the time being, this fixes a problem that I ran into in real code by reducing the inlining cost for floating point division to be the same as that of floating point multiplication. The particular case where I saw this was the batched forward AD rule for division, which had 6 calls to div_float. Inlining these provided substantially better performance. 05 July 2023, 20:28:32 UTC
23c0418 woclass 05 July 2023, 13:30:42 UTC gc: fix time unit in jl_print_gc_stats (#50417) 05 July 2023, 13:30:42 UTC
435c1c1 William Moses 05 July 2023, 11:32:13 UTC Add CPU feature helper function (#50402) 05 July 2023, 11:32:13 UTC
fcb3110 Santtu Söderholm 05 July 2023, 11:03:10 UTC REPL/latex_symbols: define commands for « and » (#50399) The new commands are \guillemotleft and \guillemotright, respectively. These commands are in line with the corresponding commands defined in the LaTeΧ package csquotes. Co-authored-by: Steven G. Johnson <stevenj@mit.edu> 05 July 2023, 11:03:10 UTC
fb2ceea Ben Baumgold 05 July 2023, 10:54:03 UTC enhance Timer call taking callback to accept any `timeout` arg and kwargs (#50027) 05 July 2023, 10:54:03 UTC
929a845 James Foster 05 July 2023, 10:22:33 UTC Docs: Windows build devdocs clean up (#49760) 05 July 2023, 10:22:33 UTC
877b368 Adnan Alhomssi 05 July 2023, 10:16:01 UTC Use tempdir() to store heap snapshot files instead of abspatch ~= rootdir (#50026) 05 July 2023, 10:16:01 UTC
7e3c706 Loong 05 July 2023, 10:12:43 UTC Check input expresion in numbered prompt (#50064) 05 July 2023, 10:12:43 UTC
e025877 Valentin Churavy 05 July 2023, 10:11:13 UTC Remove dynamic dispatch from _wait/wait2 (#50202) Co-authored-by: Gabriel Baraldi <baraldigabriel@gmail.com> 05 July 2023, 10:11:13 UTC
1279de6 Ujjwal Sarswat 05 July 2023, 10:10:08 UTC fix conversion of empty `Dates.CompoundPeriod()` to zero units (#50259) * fix(stdlib/Dates/periods.jl): conversion of empty CompoundPeriod to zero units * add(stdlib/Dates/test/periods.jl): add test for empty CompoundPeriod 05 July 2023, 10:10:08 UTC
63fefe0 Steve Kelly 05 July 2023, 10:09:10 UTC Add devdocs/jit.md to the menu (#50310) Added in https://github.com/JuliaLang/julia/pull/50168 05 July 2023, 10:09:10 UTC
d70ee20 Guillaume Dalle 05 July 2023, 10:06:41 UTC Fix weird dispatch of * with zero arguments (#50411) 05 July 2023, 10:06:41 UTC
7fc8646 Keno Fischer 04 July 2023, 15:10:54 UTC Extend ifelse lifting to regular SROA (#50403) * Extend ifelse lifting to regular SROA * Fix oracle violation This is a pre-existing bug, but was exposed by my improvements to SROA. 04 July 2023, 15:10:54 UTC
02272f0 Shuhei Kadowaki 04 July 2023, 04:59:29 UTC allow `show_tuple_as_call` to be used for abstract call signature (#50398) 04 July 2023, 04:59:29 UTC
ce1b420 Steven G. Johnson 03 July 2023, 18:27:12 UTC add replace(io, str, patterns...) (#48625) 03 July 2023, 18:27:12 UTC
8a4ab11 Dilum Aluthge 03 July 2023, 11:48:00 UTC Set `VERSION` to `1.11.0-DEV` (#50314) * Set `VERSION` to `1.11.0-DEV` * move NEWS to HISTORY Co-authored-by: KristofferC <kristoffer.carlsson@juliacomputing.com> 03 July 2023, 11:48:00 UTC
0ba6ec2 Waldir Pimenta 03 July 2023, 09:20:58 UTC Restore link to list of packages in Base docs (#50353) This link used to exist in the docs up to v0.2, but it was removed in e91294f47516787ac8648f59e6c6f1abb9e47557 as it was pointing to a doc page that was removed in ef0c44d0fa865a38aefc26b138367ba6c0b4cda5. This change restores the link in the original place, pointing to the up-to-date location. 03 July 2023, 09:20:58 UTC
43bf2c8 Diogo Netto 02 July 2023, 22:27:41 UTC ensure GC_FINAL_STATS is consistent with new page metadata layout (#50374) * ensure GC_FINAL_STATS is consistent with new page metadata layout 02 July 2023, 22:27:41 UTC
ecca2c5 pchintalapudi 02 July 2023, 13:10:38 UTC Expose PassBuilder callback registration via C api (#50390) 02 July 2023, 13:10:38 UTC
6336f68 DilumAluthgeBot 02 July 2023, 11:00:42 UTC 🤖 [master] Bump the Pkg stdlib from 4de1826bc to e8197dd0e (#50388) 02 July 2023, 11:00:42 UTC
36e188f pchintalapudi 01 July 2023, 22:40:56 UTC Parse pass options in opt/PassBuilder (#50383) 01 July 2023, 22:40:56 UTC
27e21c8 Nicholas Bauer 01 July 2023, 12:01:49 UTC `hvncat`: Added inbounds annotations that improve performance (#41200) * Added judicious inbounds/inline decorations * add inline to other one * bump * grammar Co-authored-by: Jeff Bezanson <jeff.bezanson@gmail.com> * Remove `@inline` * bump CI * bump CI 2 * Merge fix * Ensure `hvncat_fill!` can't execute when N < 2 * Bounds check in three-arg `hvncat_fill!` * Narrow inbounds * Moved bounds check up --------- Co-authored-by: Jeff Bezanson <jeff.bezanson@gmail.com> 01 July 2023, 12:01:49 UTC
36a39b0 Ian Butterworth 01 July 2023, 10:08:38 UTC add note to CONTRIBUTING.md about making issues and PR names self explanatory (#50370) 01 July 2023, 10:08:38 UTC
a40dec1 Keno Fischer 30 June 2023, 21:37:06 UTC sroa: Mark dead setfields as EFFECT_FREE (#50373) sroa tries to delete any `setfield!` call for allocations that it knows it can remove. However, if it does not know that the type is correct for the allocation, it may not be able to remove the setfield!. If the type later gets improved (e.g. by irinterp), the statement becomes eligible for removal, but it currently requires another sroa pass to actually remove it. Improve that situation my marking such a statement that is known-dead as IR_FLAG_EFFECT_FREE, so if we later also prove it nothrow, it (and the corresponding allocation) immediately become DCE-eligible. 30 June 2023, 21:37:06 UTC
196a5b4 Diogo Netto 30 June 2023, 18:45:09 UTC use a single uv_cond_t to coordinate wakeup of GC threads (#50339) * Should avoid going to the kernel multiple times to wake GC threads up. 30 June 2023, 18:45:09 UTC
92437c2 Gabriel Baraldi 30 June 2023, 18:42:26 UTC Move ccall tests to node 1 (#50350) The ccall tests seems to be a very common failure point so move it to node 1 because it usually has less maxrss. 30 June 2023, 18:42:26 UTC
8fc641c Daniel Karrasch 30 June 2023, 17:58:15 UTC Fix typos in symmetric eigendecomposition code (#50366) 30 June 2023, 17:58:15 UTC
530113f Diogo Netto 30 June 2023, 17:28:25 UTC ensure objects beyond bump allocated region are inserted into the object pool freelist * addresses follow-up comments from #50137, particularly https://github.com/JuliaLang/julia/pull/50137#discussion_r1246964490 30 June 2023, 17:28:25 UTC
934cab6 pchintalapudi 30 June 2023, 16:04:35 UTC Add escape hatch to avoid demoting float16 operations for unknown architectures (#50343) 30 June 2023, 16:04:35 UTC
734cafa pchintalapudi 30 June 2023, 13:38:59 UTC Remove `new BitCastInst` unless it's in a typed pointer context (#50338) * Add debug_level module flag * Make ptls use IRBuilder * Only use 'new BitCastInst' when we know we are not in opaque pointer mode 30 June 2023, 13:38:59 UTC
b303d0e Gabriel Baraldi 30 June 2023, 13:23:15 UTC Also set the nthreads for the threadpools during bootstrap (#50358) 30 June 2023, 13:23:15 UTC
eeb0b69 Daniel Karrasch 30 June 2023, 12:03:38 UTC Fix typos in 2x2 matmatmul (#50362) 30 June 2023, 12:03:38 UTC
0e8af1c Shuhei Kadowaki 30 June 2023, 04:06:06 UTC AbstractInterpreter: Refactor `abstract_call` to be more overload-friendly (#50355) The existing signature of `abstract_call` can lead to ambiguous method errors when it is overloaded for an external `AbstractInterpreter`. This commit mitigates this issue by narrowing the argument type of `max_methods` from `::Union{Int,Nothing}` to `::Int`. Additionally, it introduces `abstract_call_unknown`, providing a hook for static code analyzers like JET.jl to report unknown calls. 30 June 2023, 04:06:06 UTC
02f80c6 Ian Butterworth 30 June 2023, 00:12:42 UTC Add docs on task-specific buffering using multithreading (#48542) Co-authored-by: Mason Protter <mason.protter@icloud.com> 30 June 2023, 00:12:42 UTC
3d7aa6e Lilith Orion Hafner 29 June 2023, 19:06:00 UTC Remove broken conversion of `@fastmath x[i] += 1` (#50347) Fixes #47241 29 June 2023, 19:06:00 UTC
3ddceee Keno Fischer 29 June 2023, 18:50:53 UTC Fall bad generated functions back to interpreter (#50348) This fixes #49715. The fix itself is pretty simple - just remove the generator expansion that was added in #48766, but the bigger question here is what the correct behavior should be in the first place. # Dynamic Semantics, generally The primary question here are of the semantics of generated functions. Note that this is quite different to how they are implemented. In general, the way we think about compiling Julia is that there is a well defined set of *dynamic semantics* that specify what a particular piece of Julia code means. Julia's dynamic semantics are generally quite simple (at every point, call the most specific applicable method). What happens under the hood may be quite different (e.g. lots of inference, compiling constant folding, etc), but the compilation process should mostly preserve the semantics (with a few well defined exceptions around floating point arithmetic, effect assumptions, semantically unobservable side effects, etc.). # The dnymaic semantics of generated functions With that diatribe out of the way, let's think about the dynamic semantics of generated functions. We haven't always been particularly clear about this, but I propose it's basically the following: For a generated function: ``` @generated function f(args...) # = generator body =# end ``` this is semantically equivalent to the function to basically the following: ``` const lno = LineNumberNode(@__FILE__, @__LINE__); function f(args...) generator = @opaque @assume_effects :foldable :generator (args...)->#= generator body =# body = generator(Base.get_world_counter(), lno, Core.Typeof.(args)) execute(body, f, args...) end ``` A couple of notes on this: 1. `@opaque` used here for the world-age capture semantics of the generator itself 2. There's an effects-assumption `:generator` that doesn't exist but is supposed to capture the special allowance for calling generators. This is discussed more below. ## Implementing `execute` For a long time, we didn't really have a first-class implementation of `execute`. It's almost (some liberties around the way that the arguments work, but you get the idea) ``` execute_eval(body, f, args...) = eval((args...)->$body)(f, args....) ``` but that doesn't have the correct world age semantics (would error as written and even if you used invokelatest, the body would run in the wrong world). However, with OpaqueClosure we do actually have a mechanism now and we could write: ``` execute(body, f, args...) = OpaqueClosure(body, f)(args...) ``` Again, I'm not proposing this as an implementation, just to give us an idea of what the dynamic semantics of generated functions are. # The particular bug (#49715) The issue in #49715 is that the following happens: 1. A generated function gets called and inference is attempted. 2. Inference attempts to infer the generated function and call the generator. 3. The generator throws an error. 4. Inference fails. 5. The compiler enters a generic inference-failure fallback path 6. The compiler asks for a generator expansion in the generic world (-1) 7. This gives a different error, confusing the user. There is the additional problem that this error gets thrown at compilation time, which is not technically legal (and there was an existing TODO to fix that). In addition to that, I think there is a separate question of whether it should be semantically legal to throw an error for a different world age than the currently running one. Given the semantics proposed above, I would suggest that the answer should be no. This does depend on the exact semantics of :generator, but in general, our existing effects-related notions do not allow particularly strong assumptions on the particular error being thrown (requiring them to be re-evaluated at runtime), and I see no reason to depart from this practice here. Thus, I would suggest that the current behavior should be disallowed and the expected behavior is that the generic fallback implementation of generated functions invoke the generator in the runtime world and expose the appropriate error. # Should we keep the generic world? That does leave the question what to do about the generic world (-1). I'm not 100% convinced that this is necessarily a useful concept to have. It is true that most generated functions do not depend on the world age, but they can already indicate this by returning a value with bounded world range and no backedges (equivalently returning a plain expression). On the other hand, keeping the generic world does risk creating the inverse of the situation that prompted this issue, in that there is no semantically reachable path to calling the generator with the generic world, making it hard to debug. As a result, I am very strongly leaning towards removing this concept, but I am open to being convinced otherwise. # This PR This PR, which is considerably shorter than this commit message is very simple: The attempt to invoke the generator with the generic world -1 is removed. Instead, we fall back to the interpreter, which already has the precise semantics that I want here - invoking the generator in the dynamic world and interpreting the result. # The semantics of :generator That leaves one issue to be resolved which is the semantics of `:generator`. I don't think it's necessary to be as precise here as we are about the other effects we expose, but I propose it be something like the following: For functions with the :generator effects assumption, :consistent-cy is relaxed as follows: 1. The requistive notion of equality is relaxed to a "same code and metadata" equality of code instances. I don't think we have any predicate for this (and it's not necessarily computable), but the idea should be that the CodeInstance is always computed in the exact same way, but may be mutable and such. Note that this is explicitly not functional extensionality, because we do analyze the structure of the returned code and codegen based on it. 2. The world-age semantics of :consistent sharpened to require our relaxed notion of consistency for any overlapping min_world:max_world range returned from the generator. Co-authored-by: Oscar Smith <oscardssmith@gmail.com> 29 June 2023, 18:50:53 UTC
f6f3553 Ian Butterworth 29 June 2023, 17:15:16 UTC add `Base.isprecompiled(pkg::PkgId)` (#50218) 29 June 2023, 17:15:16 UTC
5db930e Cody Tapscott 29 June 2023, 16:26:51 UTC optimize: Handle path-excluded `Core.ifelse` arguments (#50312) It's possible for PiNodes to effectively imply statically the condition of a Core.ifelse. For example: ```julia 23 ─ %60 = Core.ifelse(%47, false, true)::Bool │ %61 = Core.ifelse(%47, %58, false)::Union{Missing, Bool} 25 ─ goto #27 if not %60 26 ─ %65 = π (%61, Bool) └─── ... ``` In basic block #26, the PiNode gives us enough information to conclude that `%47 === false` if control flow reaches that point. The previous code incorrectly assumed that this kind of pruning would only be done for PhiNodes. Resolves #50276 29 June 2023, 16:26:51 UTC
6d400e4 Cody Tapscott 29 June 2023, 16:23:36 UTC Makefile: Add support for symbol versioning (ON by default) (#49012) This enables symbol versioning by default, with the version string `JL_LIBJULIA_1.10` (the version suffix is the SOMAJOR in general). This will configure the linker to assign the specified version string to all Julia-exported symbols. As part of this change, the SOMAJOR has also been changed to be MAJOR.MINOR instead of just MAJOR. This is required to allow multiple minor releases of libjulia to live side-by-side in the same process. `SYMBOL_VERSION_SUFFIX` is provided to allow appending an additional unique "salt" to SOMAJOR, which can be helpful for creating template binaries that will be "version-stamped" after distribution. Correctly compute `LLVM_SHLIB_SYMBOL_VERSION` using `llvm-config`, so USE_SYSTEM_LLVM should continue to work. 29 June 2023, 16:23:36 UTC
6174056 Olivier Benz 29 June 2023, 15:52:38 UTC macOS <=10.14: move build flags to OSLIBS (#50017) Replace file src/mach_dyld_atfork.tbd with command line flags Fixes #49976 29 June 2023, 15:52:38 UTC
e4600c5 Keno Fischer 29 June 2023, 13:06:27 UTC Relax constraints on the PHI block (#50308) In #50158, I tought the verifier to reject code that has invalid statements in the original PHI block. In #50235, this required irinterp to stop folding PhiNodes to the respective constants. I said at the time that a subsequent compact would fix it, but it turns out that we don't actually have the logic for that. I might still add that logic, but on the other hand it just seems kinda silly that PhiNodes need to be a special case here. This PR relaxes the semantics of the PHI block, to allow any value-position constant to appear in the PHI block and undoes the irinterp change from #50235. Only the interpreter really cares about the semantics of the phi block, so the primary change is there. Of note, SSAValue forwards are not allowed in the phi block. This is because of the following: ``` loop: %1 = %(...) %2 = %1 %3 = %(top => %1) ``` The two phi values %1 and %2 have different semantics: %1 gets the *current* iteration of the loop, while %3 gets the *previous* value. As a result, any pass that wants to move SSAValues out of PhiNode uses would have to be aware of these semantics anyway, and there's no simplicitly benefits to allowing SSAValues in the middle of a phi block. 29 June 2023, 13:06:27 UTC
7eb358e Steven G. Johnson 29 June 2023, 06:46:21 UTC doc fix for @invokelatest (#50342) 29 June 2023, 06:46:21 UTC
cb6d0f2 Steven G. Johnson 29 June 2023, 06:45:08 UTC invokelatest docs should say not exported before 1.9 (#50341) 29 June 2023, 06:45:08 UTC
cf34aa2 Nicholas Bauer 29 June 2023, 02:57:40 UTC Round-trip reinterpret of all isbits types (#47116) Hiding padding bytes in the process, to avoid undefined behavior if those are observed. Co-authored-by: Andy Ferris <andy.ferris@roames.com.au> Co-authored-by: Jameson Nash <vtjnash@gmail.com> Co-authored-by: Sukera <11753998+Seelengrab@users.noreply.github.com> 29 June 2023, 02:57:40 UTC
663c58d Valentin Churavy 28 June 2023, 22:12:17 UTC Change SIMD Loop from Fast to only reassoc/contract (#49405) Addresses #49387 Co-authored-by: Mosè Giordano <mose@gnu.org> 28 June 2023, 22:12:17 UTC
4e0da0d Shuhei Kadowaki 28 June 2023, 22:09:56 UTC fix `compatible_vatuple` (#50331) Seemingly `vab` has been computed wrongly. 28 June 2023, 22:09:56 UTC
d67b899 Diogo Netto 28 June 2023, 20:25:27 UTC initialize jl_n_markthreads and jl_n_sweepthreads to be consistent with no parallel GC on bootstrap (#50332) 28 June 2023, 20:25:27 UTC
00191c0 Kristoffer Carlsson 28 June 2023, 20:22:00 UTC Revert "Add mutating `stat!` function for non-allocating filesystem `stat`" (#50323) 28 June 2023, 20:22:00 UTC
e6d67a7 Elliot Saba 28 June 2023, 18:31:54 UTC Merge pull request #50146 from JuliaLang/mg/llvm-ccache [deps] Deal with `USECCACHE=1` in common CMake options 28 June 2023, 18:31:54 UTC
850dd87 Lilith Orion Hafner 28 June 2023, 16:18:31 UTC Reword "how does Julia define its public API" [NFC] (#50324) 28 June 2023, 16:18:31 UTC
196956d Lilith Orion Hafner 28 June 2023, 11:08:24 UTC Replace `julia` with Julia in faq when referring to the language. (#50103) 28 June 2023, 11:08:24 UTC
1177b54 Valentin Churavy 28 June 2023, 09:46:52 UTC Merge pull request #50315 from JuliaLang/pc/fix-mssa-preserve Fix MemorySSA preservation in julia-licm 28 June 2023, 09:46:52 UTC
5c070f4 Aravindh Krishnamoorthy 28 June 2023, 05:29:00 UTC Rework symmetric generalized `eigen`/`eigvals` (#49673) 28 June 2023, 05:29:00 UTC
014f8de Keno Fischer 28 June 2023, 03:44:50 UTC Align meaning for effects and IR flags (#50313) This fixes a longstanding todo where the IR_FLAG_EFFECT_FREE flag actually required both :effect_free and :nothrow. After this PR, it is equivalent to :effect_free only. The mismatch in meaning here caused #50311. `Symbol(::String)` is :effect_free, but not :nothrow. As a result, setting IR_FLAG_EFFECT_FREE on it was not legal. Later, irinterp did discover that it was nothrow and set IR_FLAG_NOTHROW, but did not have sufficient information to know that it was also :effect_free, so it could not set that flag. With this PR, IR_FLAG_EFFECT_FREE is set early in inference, so once irinterp discovers IR_FLAG_NOTHROW, the call becomes DCE-eligible as desired. Fixes #50311. 28 June 2023, 03:44:50 UTC
9dc2991 Diogo Netto 28 June 2023, 01:25:51 UTC implement concurrent sweeping (#48969) Implements concurrent sweeping of fully empty pages. Concurrent sweeping is disabled by default and may be enabled through the --gcthreads flag. Co-authored-by: Valentin Churavy <v.churavy@gmail.com> 28 June 2023, 01:25:51 UTC
f5faa08 Prem Chintalapudi 27 June 2023, 23:16:29 UTC Fix small bug in memorydef for memset 27 June 2023, 23:16:29 UTC
5ea7f0b Prem Chintalapudi 27 June 2023, 22:49:58 UTC Add some memoryssa preservation tests 27 June 2023, 22:49:58 UTC
back to top