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
a01dcd3 Shuhei Kadowaki 01 June 2023, 05:32:00 UTC wip 01 June 2023, 05:32:00 UTC
e0761b3 Shuhei Kadowaki 01 June 2023, 04:37:51 UTC inlining: some refactoring on the inlining code (#50016) - clean up the edge tracking: * removed `valid_worlds` tracking since it is never updated * removed `EdgeTracker` object and make `InliningEdgeTracker` update inlining edges always - clean up dead `OptimizationParams` arguments 01 June 2023, 04:37:51 UTC
304e9a0 Kiran 31 May 2023, 20:16:01 UTC Add GC metric `last_full_sweep` (#50018) Records the time that the last full sweep ran. 31 May 2023, 20:16:01 UTC
e4cf096 Kristoffer Carlsson 31 May 2023, 18:50:46 UTC Merge pull request #50010 from JuliaLang/kc/profiling_changes Minor tweaks to the runtime profiling 31 May 2023, 18:50:46 UTC
28630ee Elliot Saba 31 May 2023, 18:39:13 UTC Merge pull request #50002 from topolarity/clangsa-gcc-error Makefile: Use Clang CFLAGS when running `analyzegc` 31 May 2023, 18:39:13 UTC
dd44113 Shuhei Kadowaki 31 May 2023, 17:25:03 UTC add `@inline` annotation to `Core.Compiler.specialize_method` (#50015) Since the return type of `Core.Compiler.specialize_method` relies on the boolean keyword argument `preexisting`, it is profitable to constant propagate it to get better inferrability. 31 May 2023, 17:25:03 UTC
9b27a8f Shuhei Kadowaki 31 May 2023, 15:49:36 UTC errorshow: simplify printing of keyword argument types using a new macro format (#49959) In Julia, keyword arguments are represented as `Base.Pairs` objects. However, the object type often appears unnecessarily complex, especially when printed in a stack trace. This commit aims to simplify the printing of stack traces that involve keyword method calls, while still allowing us to reconstruct the actual method signature types from the printed signature types. The approach is similar to #49117: this commit introduces a new macro called `Base.@Kwargs`. It follows the same syntax as `@NamedTuple` and returns a `Base.Pairs` type that is used for keyword method calls. We use this syntax when printing keyword argument types. Here's an example of a stack trace: ```diff diff --git a/b.jl b/a.jl index 91dd6f0464..b804ae4be5 100644 --- a/b.jl +++ b/a.jl @@ -22,12 +22,11 @@ Stacktrace: @ Base ./reduce.jl:44 [inlined] [6] mapfoldl(f::typeof(identity), op::typeof(Base.add_sum), itr::String; init::Int64) @ Base ./reduce.jl:175 [inlined] - [7] mapreduce(f::typeof(identity), op::typeof(Base.add_sum), itr::String; kw::Base.Pairs{…}) + [7] mapreduce(f::typeof(identity), op::typeof(Base.add_sum), itr::String; kw::@Kwargs{init::Int64}) @ Base ./reduce.jl:307 [inlined] - [8] sum(f::typeof(identity), a::String; kw::Base.Pairs{Symbol, Int64, Tuple{Symbol}, @NamedTuple{init::Int64}}) + [8] sum(f::typeof(identity), a::String; kw::@Kwargs{init::Int64}) @ Base ./reduce.jl:535 [inlined] - [9] sum(a::String; kw::Base.Pairs{Symbol, Int64, Tuple{Symbol}, @NamedTuple{init::Int64}}) + [9] sum(a::String; kw::@Kwargs{init::Int64}) @ Base ./reduce.jl:564 [inlined] [10] top-level scope ``` --- * RFC: errorshow: simplify printing of keyword argument types using a new macro format * export and document `Base.@Kwargs` and further simplify the stack trace view * use the `@Kwargs` syntax only when printing kwmethod signature within stack trace view And add tests. * add news entry * more type stability * Apply suggestions from code review * enable the type-repr simplification unconditionally in the stack trace Since keyword pairs can appear within positional arguments, it can be confusing if we print the same type with different representations. * omit type annotation for splat keyword argument * add test for `@Kwargs` * clean up test/errorshow.jl 31 May 2023, 15:49:36 UTC
d3d09c1 Kristoffer Carlsson 31 May 2023, 14:04:41 UTC add a timing zone for `call_require` (#49723) 31 May 2023, 14:04:41 UTC
d5145de Lilith Orion Hafner 31 May 2023, 13:44:55 UTC fix and test sorting arrays with >1 dimension and custom `similar` (#49392) * fix and test sorting arrays with >1 dimension and custom `similar` * add PR number --------- Co-authored-by: Lilith Hafner <Lilith.Hafner@gmail.com> 31 May 2023, 13:44:55 UTC
faca5bd KristofferC 31 May 2023, 10:18:36 UTC disable `TYPE_CACHE_INSERT` profile zone by default This one tend to be very fast, produce many entries and it tends to be not very interesting in most cases 31 May 2023, 11:16:15 UTC
b050ca9 KristofferC 31 May 2023, 10:17:45 UTC only add an entry for `METHOD_MATCH` if it does some work 31 May 2023, 11:16:15 UTC
da98f54 KristofferC 31 May 2023, 10:17:23 UTC move `jl_timing_apply_env` to a later place where it uses initialized data Also, move it after `DISABLE_SUBSYSTEM` to avoid it clobbering the results. 31 May 2023, 11:15:40 UTC
ca3270b Jameson Nash 31 May 2023, 09:33:03 UTC lowering: apply let hygiene in let environment (#49999) Not just a regression, since this test also fails on old versions, but #49897 applied the wrong environment to make this hygiene correct which broke it worse. Fix #49984 31 May 2023, 09:33:03 UTC
7e25ebf DilumAluthgeBot 31 May 2023, 09:32:18 UTC 🤖 [master] Bump the Pkg stdlib from daf02a458 to 9c01707a2 (#50005) * 🤖 [master] Bump the Pkg stdlib from daf02a458 to 9c01707a2 * remove Pkg.LazilyInitializedFields from docs --------- Co-authored-by: Dilum Aluthge <dilum@aluthge.com> Co-authored-by: Ian <i.r.butterworth@gmail.com> 31 May 2023, 09:32:18 UTC
c3a08fe Cody Tapscott 30 May 2023, 20:13:57 UTC Makefile: For gcanalyze, use Clang's CFLAGS not GCC's It's supported to build the analysis plugin with GCC, but the flags we actually run it with need to match Clang. 31 May 2023, 02:47:09 UTC
84bf67c Lilith Orion Hafner 30 May 2023, 19:55:28 UTC Support sorting iterators (#46104) * widen sort's type signature * throw on AbstractString * Throw on infinite iterator * make sort(::NTuple) return a tuple (use vector internally for sorting for large tuples) 30 May 2023, 19:55:28 UTC
d912d85 Fons van der Plas 30 May 2023, 19:32:58 UTC doc: simple docstring for `read(filename::AbstractString)` (#49836) 30 May 2023, 19:32:58 UTC
318f0ea Fons van der Plas 30 May 2023, 19:29:25 UTC docs: first describe simple `read` and `write` without streaming (#49834) 30 May 2023, 19:29:25 UTC
c63feee Fabian Zickgraf 30 May 2023, 19:25:24 UTC show: fix printing of "function (x...) end" (#49874) Previously, the parentheses were missing. 30 May 2023, 19:25:24 UTC
bd5e6da Jameson Nash 30 May 2023, 19:11:00 UTC fix atomic intrinsics implementation issues (#49967) * jltypes: add missing GC root for cmpswap_type Tuple. This is called with a fieldtype, which might not even be a DataType. * support Ptr{Union{}} and Ptr{Cvoid} better 30 May 2023, 19:11:00 UTC
f6f637a Jameson Nash 30 May 2023, 19:09:40 UTC cleanup: some fixes from effort to break up monolithic sysimg build (#49953) From #38119 30 May 2023, 19:09:40 UTC
20752db Nathan Daly 30 May 2023, 16:23:39 UTC thread safety: lock around atexit_hooks global (#49868) Ensure the lock is precise, so that we are allowed to register new atexit hooks from inside an atexit hook. But then disable `atexit()` when shutting down after it finishes running. Add tests that cover all the cases: 1. registering a hook from inside a hook 2. registering a hook from another thread while hooks are running 3. attempting to register a hook after all hooks have finished (disallowed) Fixes #49841 Co-authored-by: Jameson Nash <vtjnash@gmail.com> 30 May 2023, 16:23:39 UTC
ed5bd4c Shuhei Kadowaki 30 May 2023, 06:09:08 UTC Revert "Use `top_set_bit` to optimize `hash(Real)` (#49986)" (#49993) This reverts commit 18d02c249a90a7c2d25ac5a99a14cf7a414a3295. 30 May 2023, 06:09:08 UTC
18d02c2 Lilith Orion Hafner 29 May 2023, 23:23:15 UTC Use `top_set_bit` to optimize `hash(Real)` (#49986) 29 May 2023, 23:23:15 UTC
957972e Gabriel Baraldi 29 May 2023, 19:21:26 UTC Expose the Julia JIT with a C API (#49858) 29 May 2023, 19:21:26 UTC
1cc10a6 Shuhei Kadowaki 29 May 2023, 09:20:39 UTC refactor `Base.StackTraces.show_spec_linfo` (#49951) This commit separates the `MethodInstance` handling of `Base.StackTraces.show_spec_linfo` into `Base.StackTraces.show_spec_sig`, which can be generally useful for external code inspection tools or debuggers (like JET.jl). 29 May 2023, 09:20:39 UTC
0d5bd2f Navid C. Constantinou 29 May 2023, 09:16:17 UTC Add missing code formatting (#49983) 29 May 2023, 09:16:17 UTC
248ceda Lilith Orion Hafner 27 May 2023, 13:39:33 UTC Abbreviate varinfo signature and re-order for consistency (#48860) 27 May 2023, 13:39:33 UTC
e727afb Lilith Orion Hafner 27 May 2023, 11:36:10 UTC Move reflection documentation from devdocs to base (#47800) 27 May 2023, 11:36:10 UTC
fb3df69 romaindegivry 26 May 2023, 22:56:56 UTC Improve error when indexing is interpreted as a typed comprehension (#49939) * Improve errors for typed_hcat by adding a special error for indexing that gets resolved as a typed comprehension. * Add a test for issue #49676 26 May 2023, 22:56:56 UTC
ba2aa30 Stephan Hilb 26 May 2023, 21:44:37 UTC Enum: fix stackoverflow in `hash` for custom enum subtypes introduced in #49777 (#49964) 26 May 2023, 21:44:37 UTC
f8dd16e Zachary P Christensen 26 May 2023, 18:53:31 UTC Add Libc methods for memmove/memcpy/memset/memcmp (#49550) These are used in many places (and are actually LLVM compiler intrinsics), so it probably makes more sense to define them one and export them to users. The Libc module contains some code that we might not care to have as part of bootstrapping. However, the C-memory methods are directly called throughout bootstrapping so these are now defined in a seperate "cmem.jl" file that is defined in Base then imported into `Libc` for the public interface. Co-authored-by: Jameson Nash <vtjnash@gmail.com> 26 May 2023, 18:53:31 UTC
ba1391a Jameson Nash 26 May 2023, 18:51:09 UTC some minor hygiene fixes (#49897) This code does a bad job handling `(escape symbol)` in a lot of places. This attempts to fix some of them by peeking through it more. 26 May 2023, 18:51:09 UTC
23e0b2d Tim Besard 26 May 2023, 17:09:12 UTC Hide safepoint prologue and CFI instructions from reflection. (#49948) 26 May 2023, 17:09:12 UTC
666d325 Thomas Graham 26 May 2023, 12:53:34 UTC Fix conversion of infinities to integers (#49624) Fixes #49422 26 May 2023, 12:53:34 UTC
4ef9fb1 Tim Besard 26 May 2023, 12:25:37 UTC When adopting a thread, spin until GC isn't running. (#49934) Co-authored-by: Valentin Churavy <vchuravy@users.noreply.github.com> 26 May 2023, 12:25:37 UTC
91cd521 Cody Tapscott 26 May 2023, 01:55:35 UTC Extend comparison lifting to `Core.ifelse` (#49882) This change extends our existing transformation for: φ(a,b) === Const(c) => φ(a === c, b === c) to perform the analogous transformation for `Core.ifelse`: Core.ifelse(cond, a, b) === Const(c) => Core.ifelse(cond, a === c, b === c) 26 May 2023, 01:55:35 UTC
229269b Gabriel Baraldi 25 May 2023, 17:37:20 UTC Don't permalloc the pkgimgs, but with an option (#49940) 25 May 2023, 17:37:20 UTC
01ddf80 Jameson Nash 25 May 2023, 13:52:51 UTC lowering: preserve line numbers over julia-expand-macroscope pass (#44995) This is to preserve the line number of the macro caller in the output, in case we don't have context from eval on where it occured. But we make slightly more changes than strictly necessary to prepare for future improvements in this area. 25 May 2023, 13:52:51 UTC
94bc2f3 pchintalapudi 25 May 2023, 00:11:36 UTC Merge pull request #49679 from JuliaLang/pc/timing-events 25 May 2023, 00:11:36 UTC
e370e4e Cody Tapscott 24 May 2023, 18:26:14 UTC Slightly re-factor timing counts back-end This should make it clearer what the responsibilities for each function are, and fix a bug where conditionally-triggered events could end up with an invalid total time. 24 May 2023, 18:42:19 UTC
aea56a9 Kiran 24 May 2023, 15:01:20 UTC Ensure Distributed workers inherit threads spec properly (#49942) 24 May 2023, 15:01:20 UTC
310f590 Daniel Karrasch 24 May 2023, 12:30:14 UTC Include `HermOrSym` in character-based `mul!` dispatch (#49865) 24 May 2023, 12:30:14 UTC
bee2c30 Vasily Ilin 24 May 2023, 07:01:37 UTC doc: add rand! and randn! to docstrings of rand and randn (#49808) 24 May 2023, 07:01:37 UTC
c470dc3 Kiran 23 May 2023, 13:26:41 UTC Lock finalizers lists at exit (#49931) 23 May 2023, 13:26:41 UTC
1143b8f Oscar Smith 23 May 2023, 13:04:40 UTC improve error message when calling argextype on invalid ir (#49923) 23 May 2023, 13:04:40 UTC
22551a2 Stephan Hilb 23 May 2023, 11:15:31 UTC allow specializing `Base.hash` for enum types without overwriting method (#49777) Previously `@enum` defined `Base.hash(::MyEnumType, ::UInt)` on the user-defined enum type `MyEnumType`. When the user wants to specialize the hash function for his own enum type he will define exactly that method signature again which overwrites it and leads to the warning WARNING: Method definition hash(TestPackage.MyEnumType, UInt64) in module TestPackage at Enums.jl:210 overwritten at [...] ** incremental compilation may be fatally broken for this module ** This commit changes `@enum` so that an internal method is used instead which is called through a fallback `Base.hash(::Enum, ::UInt)`. 23 May 2023, 11:15:31 UTC
f44be79 Shuhei Kadowaki 23 May 2023, 06:16:47 UTC Merge pull request #41931 from JuliaLang/avi/noinfer * introduce `@nospecializeinfer` macro to tell the compiler to avoid excess inference This commit introduces a new compiler annotation called `@nospecializeinfer`, which allows us to request the compiler to avoid excessive inference. \## `@nospecialize` mechanism T discuss `@nospecializeinfer`, let's first understand the behavior of `@nospecialize`. Its docstring says that > This is only a hint for the compiler to avoid excess code generation. , and it works by suppressing dispatches with complex runtime occurrences of the annotated arguments. This could be understood with the example below: ```julia julia> function call_func_itr(func, itr) local r = 0 r += func(itr[1]) r += func(itr[2]) r += func(itr[3]) r end; julia> _isa = isa; # just for the sake of explanation, global variable to prevent inlining julia> func_specialize(a) = _isa(a, Function); julia> func_nospecialize(@nospecialize a) = _isa(a, Function); julia> dispatchonly = Any[sin, muladd, nothing]; # untyped container can cause excessive runtime dispatch julia> @code_typed call_func_itr(func_specialize, dispatchonly) CodeInfo( 1 ─ %1 = π (0, Int64) │ %2 = Base.arrayref(true, itr, 1)::Any │ %3 = (func)(%2)::Any │ %4 = (%1 + %3)::Any │ %5 = Base.arrayref(true, itr, 2)::Any │ %6 = (func)(%5)::Any │ %7 = (%4 + %6)::Any │ %8 = Base.arrayref(true, itr, 3)::Any │ %9 = (func)(%8)::Any │ %10 = (%7 + %9)::Any └── return %10 ) => Any julia> @code_typed call_func_itr(func_nospecialize, dispatchonly) CodeInfo( 1 ─ %1 = π (0, Int64) │ %2 = Base.arrayref(true, itr, 1)::Any │ %3 = invoke func(%2::Any)::Any │ %4 = (%1 + %3)::Any │ %5 = Base.arrayref(true, itr, 2)::Any │ %6 = invoke func(%5::Any)::Any │ %7 = (%4 + %6)::Any │ %8 = Base.arrayref(true, itr, 3)::Any │ %9 = invoke func(%8::Any)::Any │ %10 = (%7 + %9)::Any └── return %10 ) => Any ``` The calls of `func_specialize` remain to be `:call` expression (so that they are dispatched and compiled at runtime) while the calls of `func_nospecialize` are resolved as `:invoke` expressions. This is because `@nospecialize` requests the compiler to give up compiling `func_nospecialize` with runtime argument types but with the declared argument types, allowing `call_func_itr(func_nospecialize, dispatchonly)` to avoid runtime dispatches and accompanying JIT compilations (i.e. "excess code generation"). The difference is evident when checking `specializations`: ```julia julia> call_func_itr(func_specialize, dispatchonly) 2 julia> length(Base.specializations(only(methods(func_specialize)))) 3 # w/ runtime dispatch, multiple specializations julia> call_func_itr(func_nospecialize, dispatchonly) 2 julia> length(Base.specializations(only(methods(func_nospecialize)))) 1 # w/o runtime dispatch, the single specialization ``` The problem here is that it influences dispatch only, and does not intervene into inference in anyway. So there is still a possibility of "excess inference" when the compiler sees a considerable complexity of argument types during inference: ```julia julia> func_specialize(a) = _isa(a, Function); # redefine func to clear the specializations julia> @assert length(Base.specializations(only(methods(func_specialize)))) == 0; julia> func_nospecialize(@nospecialize a) = _isa(a, Function); # redefine func to clear the specializations julia> @assert length(Base.specializations(only(methods(func_nospecialize)))) == 0; julia> withinfernce = tuple(sin, muladd, "foo"); # typed container can cause excessive inference julia> @time @code_typed call_func_itr(func_specialize, withinfernce); 0.000812 seconds (3.77 k allocations: 217.938 KiB, 94.34% compilation time) julia> length(Base.specializations(only(methods(func_specialize)))) 4 # multiple method instances inferred julia> @time @code_typed call_func_itr(func_nospecialize, withinfernce); 0.000753 seconds (3.77 k allocations: 218.047 KiB, 92.42% compilation time) julia> length(Base.specializations(only(methods(func_nospecialize)))) 4 # multiple method instances inferred ``` The purpose of this PR is to implement a mechanism that allows us to avoid excessive inference to reduce the compilation latency when inference sees a considerable complexity of argument types. \## Design Here are some ideas to implement the functionality: 1. make `@nospecialize` block inference 2. add nospecializeinfer effect when `@nospecialize`d method is annotated as `@noinline` 3. implement as `@pure`-like boolean annotation to request nospecializeinfer effect on top of `@nospecialize` 4. implement as annotation that is orthogonal to `@nospecialize` After trying 1 ~ 3., I decided to submit 3. \### 1. make `@nospecialize` block inference This is almost same as what Jameson has done at <https://github.com/vtjnash/julia/commit/8ab7b6b94079b842b5db9f3fe29eb9d2708f5d1e>. It turned out that this approach performs very badly because some of `@nospecialize`'d arguments still need inference to perform reasonably. For example, it's obvious that the following definition of `getindex(@nospecialize(t::Tuple), i::Int)` would perform very badly if `@nospecialize` blocks inference, because of a lack of useful type information for succeeding optimizations: <https://github.com/JuliaLang/julia/blob/12d364e8249a07097a233ce7ea2886002459cc50/base/tuple.jl#L29-L30> \### 2. add nospecializeinfer effect when `@nospecialize`d method is annotated as `@noinline` The important observation is that we often use `@nospecialize` even when we expect inference to forward type and constant information. Adversely, we may be able to exploit the fact that we usually don't expect inference to forward information to a callee when we annotate it with `@noinline` (i.e. when adding `@noinline`, we're usually fine with disabling inter-procedural optimizations other than resolving dispatch). So the idea is to enable the inference suppression when `@nospecialize`'d method is annotated as `@noinline` too. It's a reasonable choice and can be efficiently implemented with #41922. But it sounds a bit weird to me to associate no infer effect with `@noinline`, and I also think there may be some cases we want to inline a method while partly avoiding inference, e.g.: ```julia \# the compiler will always infer with `f::Any` @noinline function twof(@nospecialize(f), n) # this method body is very simple and should be eligible for inlining if occursin('+', string(typeof(f).name.name::Symbol)) 2 + n elseif occursin('*', string(typeof(f).name.name::Symbol)) 2n else zero(n) end end ``` \### 3. implement as `@pure`-like boolean annotation to request nospecializeinfer effect on top of `@nospecialize` This is what this commit implements. It basically replaces the previous `@noinline` flag with a newly-introduced annotation named `@nospecializeinfer`. It is still associated with `@nospecialize` and it only has effect when used together with `@nospecialize`, but now it is not associated to `@noinline`, and it would help us reason about the behavior of `@nospecializeinfer` and experiment its effect more safely: ```julia \# the compiler will always infer with `f::Any` Base.@nospecializeinfer function twof(@nospecialize(f), n) # the compiler may or not inline this method if occursin('+', string(typeof(f).name.name::Symbol)) 2 + n elseif occursin('*', string(typeof(f).name.name::Symbol)) 2n else zero(n) end end ``` \### 4. implement as annotation that is orthogonal to `@nospecialize` Actually, we can have `@nospecialize` and `@nospecializeinfer` separately, and it would allow us to configure compilation strategies in a more fine-grained way. ```julia function noinfspec(Base.@nospecializeinfer(f), @nospecialize(g)) ... end ``` I'm fine with this approach but at the same time I'm afraid to have too many annotations that are related to some sort (I expect we will annotate both `@nospecializeinfer` and `@nospecialize` in this scheme). --- experiment `@nospecializeinfer` on `Core.Compiler` This commit adds `@nospecializeinfer` macro on various `Core.Compiler` functions and achieves the following sysimage size reduction: | | this commit | master | % | | --------------------------------- | ----------- | ----------- | ------- | | `Core.Compiler` compilation (sec) | `66.4551` | `71.0846` | `0.935` | | `corecompiler.jl` (KB) | `17638080` | `18407248` | `0.958` | | `sys.jl` (KB) | `88736432` | `89361280` | `0.993` | | `sys-o.a` (KB) | `189484400` | `189907096` | `0.998` | --------- Co-authored-by: Mosè Giordano <giordano@users.noreply.github.com> Co-authored-by: Tim Holy <tim.holy@gmail.com> 23 May 2023, 06:16:47 UTC
944b28c Diogo Netto 22 May 2023, 19:29:39 UTC show mark-queue on GC critical error (#49902) Re-adds the capability of showing the mark-queue on a GC critical error. 22 May 2023, 19:29:39 UTC
e02d3ba Jameson Nash 22 May 2023, 15:21:03 UTC jltypes: always run parameter normalization (#49845) This simplifies the types, which may help subtyping other other similar lookup code any time this is later used as a parameter, so it is probably worthwhile to do. This is a followup to #49820, where we reorganized the code to make this more straightforward. 22 May 2023, 15:21:03 UTC
1c21cbb Elliot Saba 22 May 2023, 14:32:54 UTC Merge pull request #48793 from stahta01/libgit_find_libssh2_fix [WINDOWS][BUILD] Fix for Cygwin using USE_BINARYBUILDER_LIBGIT2=0 22 May 2023, 14:32:54 UTC
672f609 Katharine Hyatt 22 May 2023, 11:06:39 UTC Two simple examples for Threads (#49704) 22 May 2023, 11:06:39 UTC
3b84b08 Katharine Hyatt 22 May 2023, 10:50:56 UTC xref and doctest for regexmatch and occursin (#49911) 22 May 2023, 10:50:56 UTC
e4a563a Tim Stahlhut 25 February 2023, 16:34:49 UTC deps/libgit2: Add LIBSSH2 paths 21 May 2023, 17:41:00 UTC
a6ad9ea Cody Tapscott 21 May 2023, 08:01:27 UTC Fix jl_timing_show_method_instance for top-level thunks (#49862) This was causing invalid pointer dereferences when the method instance had no backing method. 21 May 2023, 08:01:27 UTC
0495278 Jameson Nash 21 May 2023, 08:00:10 UTC lowering: avoid copying the entire module back to flisp just to get its name (#49898) 21 May 2023, 08:00:10 UTC
9cbee21 Alexander Plavin 21 May 2023, 07:58:19 UTC parentindices and parent of substring (#49511) * parentindices and parent of substring * upd docs * Update base/abstractarray.jl Co-authored-by: Jakob Nybo Nissen <jakobnybonissen@gmail.com> * Update test/strings/basic.jl Co-authored-by: Jakob Nybo Nissen <jakobnybonissen@gmail.com> --------- Co-authored-by: Jakob Nybo Nissen <jakobnybonissen@gmail.com> 21 May 2023, 07:58:19 UTC
046f610 Prem Chintalapudi 21 May 2023, 01:00:18 UTC t0 is in counts_ctx 21 May 2023, 01:00:18 UTC
8e03be1 Zachary P Christensen 20 May 2023, 20:52:22 UTC Improve `isassigned` implementation (#49827) Unless `isassigned` is called on `Array` with `Int`s, it uses a try catch, which is notoriously slow. This PR provides changes the default implementation of `isassigned` to coerce the indices provided to `Int`s and converts to linear or cartesian indices, depending on the arrays `IndexStyle`. This also overloads `isassigned` for many of the array types defined in Base. Fixes: https://github.com/JuliaLang/julia/issues/44720 20 May 2023, 20:52:22 UTC
d2f5bbd Shuhei Kadowaki 20 May 2023, 10:45:15 UTC REPLCompletions: use a fixed world age for `REPLInterpreter` inference (#49880) This commit uses a fixed world age for `REPLInterpreter` inference, making `REPLInterpreter` robust against potential invalidations of `Core.Compiler` methods. It also generates code cache for `REPLinterpreter` at the fixed world age so that the first-time to completion stays the (almost) same. 20 May 2023, 10:45:15 UTC
4d3000b Shuhei Kadowaki 20 May 2023, 07:08:45 UTC follow up #49889, pass `sv::AbsIntState` to `concrete_eval_call` (#49904) `sv` is not used by `NativeInterpreter`, but is used by external `AbstractInterpreter` like JET.jl. 20 May 2023, 07:08:45 UTC
1ef9f37 Shuhei Kadowaki 20 May 2023, 04:49:20 UTC [NFC] cosmetic refactor of `abstract_call_method_with_const_args` (#49889) This commit is a collection of minor NFC (No Functional Change) modifications. Essentially, it is a cosmetic refactor, so there should be no changes in terms of compiler functionality. The specific changes include: - Making `concrete_eval_eligible` always return a value of `Symbol`, either of `:concrete_eval`, `:semi_concrete_eval` and `:none`, clarifying its return value's meaning - Splitting `abstract_call_method_with_const_args` into more granular subroutines - Rearranged the subroutines in `abstract_call_method_with_const_args` to ensure that the processing flow of the code can be followed when read from top to bottom 20 May 2023, 04:49:20 UTC
5dafc84 N5N3 20 May 2023, 01:14:15 UTC subtype: add a fast-path for Union parameters (#49878) For #49857 performance The union explosion is caused by the following MWE: `Type{Vector{Union{....}} <: Type{Array{T}} where {T}` 280f9993608956f76eac30fc85e1c6ebbca4f5e6 only fixes for `Union{......}` without free `Typevar`. This fast-path makes sure the remaining get fixed. 20 May 2023, 01:14:15 UTC
6d70d2a Nathan Daly 19 May 2023, 21:49:47 UTC Attempting to add debug logs for ENQUEUING an invalid object (#49741) * Attempting to add debug logs for ENQUEUING an invalid object Check for the object's validity _before enqueuing_ so that we can hopefully give a more useful error message (which object's pointer was corrupted). --------- Co-authored-by: Diogo Netto <diogonetto.dcn@gmail.com> 19 May 2023, 21:49:47 UTC
6b2ba1d pchintalapudi 19 May 2023, 21:49:18 UTC Update src/timing.h Co-authored-by: Cody Tapscott <84105208+topolarity@users.noreply.github.com> 19 May 2023, 21:49:18 UTC
3500ba4 Prem Chintalapudi 19 May 2023, 21:30:43 UTC Move t0 init to jl_timing_block_start 19 May 2023, 21:30:43 UTC
a43ca05 Jeff Bezanson 19 May 2023, 20:14:26 UTC limit printing depth of argument types in stack traces (#49795) Co-authored-by: Tim Holy <tim.holy@gmail.com> 19 May 2023, 20:14:26 UTC
1acec74 Martin Holters 19 May 2023, 10:04:55 UTC Make `apply_type_nothrow` robust against `TypeVar`s in upper bounds (#49863) For types like `Foo{S, T<:S}`, `apply_type_nothrow` could in some situations check whether the argument is a subtype of the upper bound of `T`, i.e. `S`, but subtyping agaist a plain `TypeVar` would fail. Instead return `false` in this case. Fixes #49785. 19 May 2023, 10:04:55 UTC
863e131 Prem Chintalapudi 19 May 2023, 01:27:01 UTC Time events instead of subsystems 19 May 2023, 01:27:01 UTC
c99d839 Elliot Saba 18 May 2023, 19:18:32 UTC Merge pull request #49861 from JuliaLang/sf/null_terminate_path [cli] Ensure that probed `libstdc++` path is NULL-terminated 18 May 2023, 19:18:32 UTC
7111597 Elliot Saba 17 May 2023, 17:25:10 UTC [cli] Ensure that probed `libstdc++` path is NULL-terminated It appears that we were assuming our path was initialized with zeros, but that is not a safe assumption. 18 May 2023, 17:26:52 UTC
ce3909c Shuhei Kadowaki 18 May 2023, 02:54:39 UTC inference: prioritize `SlotNumber`-constraint over `MustAlias`-constraint (#49856) Currently external `AbstractInterpreter` that uses `MustAliasesLattice` can fail to propagate type constraint on `SlotNumber` in the call-site refinement, e.g. fail to infer the return type of `firstitem(::ItrList)` in the following code: ```julia struct ItrList list::Union{Tuple{},Vector{Int}} end hasitems(list) = length(list) >= 1 function firstitem(ilist::ItrList) list = ilist.list if hasitems(list) return list end error("list is empty") end ``` (xref: <https://github.com/aviatesk/JET.jl/issues/509#issuecomment-1546658476>) This commit fixes it up as well as fixes the implementation of `from_interprocedural!` so that it uses the correct lattice. 18 May 2023, 02:54:39 UTC
a612388 Shuhei Kadowaki 18 May 2023, 01:27:57 UTC reflection: declare keyword arguments types for reflection methods (#49783) 18 May 2023, 01:27:57 UTC
cb7d141 Prem Chintalapudi 17 May 2023, 19:54:18 UTC Overwrite random value in root timing slot 17 May 2023, 19:54:18 UTC
5a503b0 Prem Chintalapudi 17 May 2023, 19:48:24 UTC Print total time and self timing with timing counts 17 May 2023, 19:48:24 UTC
5774029 Prem Chintalapudi 17 May 2023, 19:30:37 UTC Sort timing names 17 May 2023, 19:30:37 UTC
8b4bb89 Prem Chintalapudi 17 May 2023, 19:15:15 UTC Allow number of subsystems to exceed 64 17 May 2023, 19:15:15 UTC
8e3a756 Prem Chintalapudi 17 May 2023, 19:04:17 UTC jl_timing_enable_mask -> jl_timing_disable_mask 17 May 2023, 19:04:17 UTC
98b64b2 Elliot Saba 17 May 2023, 19:00:26 UTC Merge pull request #49842 from JuliaLang/sf/dont_eagerly_load_libgomp Don't depend on `CompilerSupportLibraries_jll` from `OpenBLAS_jll` 17 May 2023, 19:00:26 UTC
4dc683b Prem Chintalapudi 17 May 2023, 18:55:40 UTC Make jl_timing_enable_mask atomic 17 May 2023, 18:55:40 UTC
84d4b92 Prem Chintalapudi 17 May 2023, 18:49:17 UTC Print timing outputs as CSV 17 May 2023, 18:49:17 UTC
d50e25e Prem Chintalapudi 17 May 2023, 18:31:19 UTC Make jl_timing_counts atomic 17 May 2023, 18:31:19 UTC
3583fae Tim Besard 17 May 2023, 18:14:39 UTC Tracy: add source-code information to lowering and macro zones. (#49802) 17 May 2023, 18:14:39 UTC
869c70e Shuhei Kadowaki 17 May 2023, 17:47:43 UTC follow up #49812, fix the wrong type declaration (#49854) JuliaLang/julia#49812 introduced a bug and broke the CI. This commit fixes it up. 17 May 2023, 17:47:43 UTC
34a2436 Elliot Saba 17 May 2023, 16:12:36 UTC Remove CSL from the test suite 17 May 2023, 16:12:36 UTC
becaa78 pchintalapudi 17 May 2023, 15:31:14 UTC Add optnone to invoke wrappers (#44590) 17 May 2023, 15:31:14 UTC
0b599ce pchintalapudi 17 May 2023, 13:16:35 UTC Fix --image-codegen (#49631) 17 May 2023, 13:16:35 UTC
10dc33e Kristoffer Carlsson 17 May 2023, 09:59:10 UTC Revert "Dark and light images for README.md" (#49819) 17 May 2023, 09:59:10 UTC
ff012aa Shuhei Kadowaki 17 May 2023, 08:52:36 UTC improve inferrability of loading.jl (#49812) 17 May 2023, 08:52:36 UTC
c245179 Jameson Nash 16 May 2023, 20:14:58 UTC fix missing gc root on store to iparams (#49820) Try to optimize the order of this code a bit more, given that these checks are somewhat infrequently to be needed. Fix #49762 16 May 2023, 20:14:58 UTC
45748b8 Jameson Nash 16 May 2023, 20:14:14 UTC [Profile] fix overhead counts in format=:flat (#49824) Regression caused by #41742, which inverted the loop without inverting the logic. And fix a number of related formatting mistakes. Fix #49732 16 May 2023, 20:14:14 UTC
ee0199f Viral B. Shah 16 May 2023, 19:44:55 UTC Various improvements to peakflops() (#49833) * Various improvements to peakflops Use 4096 as the default matrix size Add kwarg to pick the type of elements in the matrix Add kwarg for number of trials and pick best time 16 May 2023, 19:44:55 UTC
520b639 Cody Tapscott 16 May 2023, 19:19:12 UTC Merge pull request #49647 from topolarity/timing-refactor Make `jl_timer_block_t` allocation separate from timer-start (JL_TIMING) 16 May 2023, 19:19:12 UTC
4d0f35d Elliot Saba 16 May 2023, 18:35:37 UTC Don't depend on `CompilerSupportLibraries_jll` from `OpenBLAS_jll` This is important because CSL_jll loads in many other libraries that we may or may not care that much about, such as `libstdc++` and `libgomp`. We load `libstdc++` eagerly on Linux, so that will already be loaded in all cases that we care about, however on macOS we don't generally want that loaded, and this suppresses that. `libgomp` is needed by BB-provided software that uses OpenMP during compilation, however it can conflict with software compiled by the Intel compilers, such as `MKL`. It's best to allow MKL to load its OpenMP libraries first, so delaying loading `libgomp` until someone actually calls `using CompilerSupportLibraries_jll` is the right thing to do. In the future, we want to rework JLLs such that libraries aren't eagerly loaded at JLL `__init__()` time, but rather they should be JIT loaded upon first usage of the library handle itself. This would allow BB to emit much more fine-grained dependency structures, so that the distribution of a set of libraries can happen together, but the loading of said libraries would be independent. 16 May 2023, 18:35:37 UTC
c55000a Jameson Nash 16 May 2023, 18:09:57 UTC add a hash value to Typeofwrapper objects (#49725) We probably should not do this in full correctness, but the performance gain is too great to ignore. 16 May 2023, 18:09:57 UTC
78fbf1b Navid C. Constantinou 16 May 2023, 06:11:38 UTC docs: fix code formatting and add some spaces (#49814) 16 May 2023, 06:11:38 UTC
dfbcc45 Shuhei Kadowaki 16 May 2023, 02:10:13 UTC ensure all `isequal` methods to be inferred to return `Bool` (#49800) This would help inference on `Core.Compiler.return_type(isequal, tt)` when `tt` is not well inferred (e.g. `tt` is inferred to `Tuple{Any,Any}`). (although JuliaLang/julia#46810 may disable this `Core.Compiler.return_type` improvement for good reasons). Anyway, it is explicitly stated in the documentation that the `isequal` method should always return a value of `Bool`. So, not only does this annotation assist inference, it also serves to ensure the correctness of our code base, and therefore should be beneficial. We may need to take similar measures for `isless` and `isgreater` (in separate PRs). 16 May 2023, 02:10:13 UTC
909c57f pchintalapudi 15 May 2023, 21:46:22 UTC Merge pull request #49535 from JuliaLang/pc/ittapi-invalidations Count invalidations, JIT memory, and image memory in profiling reports 15 May 2023, 21:46:22 UTC
b9806d6 Keno Fischer 15 May 2023, 20:47:14 UTC irinterp: Don't try to rekill fall-through terminators (#49815) If a fall-through terminator was already Bottom, we should not attempt to rekill the successor edge, because it was already deleted. Yet another fix in the #49692, #49750, #49797 series, which is turning out to be quite a rabit hole. Also fix a typo in the verifer tweak where we were looking at the BB idx rather than the terminator idx. 15 May 2023, 20:47:14 UTC
d489203 pchintalapudi 15 May 2023, 20:33:58 UTC Merge pull request #49822 from JuliaLang/jn/jit-dylib-order jitlayers: move the local dylibs ahead of the global one 15 May 2023, 20:33:58 UTC
back to top