X === nothing vs x isa Nothing

mkitti · July 14, 2021, 9:14pm

On Julia master branch (to be Julia 1.7) at the moment,

isnothing(x) = x === nothing

Previously (Julia 1.1 to 1.6, inclusive) it was

isnothing(::Any) = false
isnothing(::Nothing) = true

github.com/JuliaLang/julia

inference: inter-procedural conditional constraint back-propagation

JuliaLang:master ← aviatesk:backprop2

opened 11:41AM - 16 Dec 20 UTC

aviatesk

+384 -60

This PR propagates `Conditional`s inter-procedurally when a `Conditional` at re…turn site imposes a constraint on the call arguments. When inference exits local frame and the return type is annotated as `Conditional`, it will be converted into `InterConditional` object, which is implemented in `Core` and can be directly put into the global cache. Finally after going back to caller frame, `InterConditional` will be re-converted into `Conditional` in the context of the caller frame. ## improvements So now some simple "is-wrapper" functions will propagate its constraint as expected, e.g.: ```julia isaint(a) = isa(a, Int) @test Base.return_types((Any,)) do a isaint(a) && return a # a::Int return 0 end == Any[Int] isaint2(::Any) = false isaint2(::Int) = true @test Base.return_types((Any,)) do a isaint2(a) && return a # a::Int return 0 end == Any[Int] function isa_int_or_float64(a) isa(a, Int) && return true isa(a, Float64) && return true return false end @test Base.return_types((Any,)) do a isa_int_or_float64(a) && return a # a::Union{Float64,Int} 0 end == Any[Union{Float64,Int}] ``` (and now we don't need something like #38636) ## benchmarks A compile time comparison: > on the current master (82d79ce18f88923c14d322b70699da43a72e6b32) ``` Sysimage built. Summary: Total ─────── 55.295376 seconds Base: ─────── 23.359226 seconds 42.2444% Stdlibs: ──── 31.934773 seconds 57.7531% JULIA usr/lib/julia/sys-o.a Generating REPL precompile statements... 29/29 Executing precompile statements... 1283/1283 Precompilation complete. Summary: Total ─────── 91.129162 seconds Generation ── 68.800937 seconds 75.4983% Execution ─── 22.328225 seconds 24.5017% LINK usr/lib/julia/sys.dylib ``` > on this PR (37e279bce7136e48f159811641b68143412c3881) ``` Sysimage built. Summary: Total ─────── 51.694730 seconds Base: ─────── 21.943914 seconds 42.449% Stdlibs: ──── 29.748987 seconds 57.5474% JULIA usr/lib/julia/sys-o.a Generating REPL precompile statements... 29/29 Executing precompile statements... 1357/1357 Precompilation complete. Summary: Total ─────── 88.956226 seconds Generation ── 67.077710 seconds 75.4053% Execution ─── 21.878515 seconds 24.5947% LINK usr/lib/julia/sys.dylib ``` Here is a sample code that benefits from this PR: ```julia function summer(ary) r = 0 for a in ary if ispositive(a) r += a end end r end ispositive(a) = isa(a, Int) && a > 0 ary = Any[] for _ in 1:100_000 if rand(Bool) push!(ary, rand(-100:100)) elseif rand(Bool) push!(ary, rand('a':'z')) else push!(ary, nothing) end end using BenchmarkTools @btime summer($(ary)) ``` > on the current master (82d79ce18f88923c14d322b70699da43a72e6b32) ``` ❯ julia summer.jl 1.214 ms (24923 allocations: 389.42 KiB) ``` > on this PR (37e279bce7136e48f159811641b68143412c3881) ``` ❯ julia summer.jl 421.223 μs (0 allocations: 0 bytes) ``` ## caveats Within the `Conditional`/`InterConditional` framework, only a single constraint can be back-propagated inter-procedurally. This PR implements a naive heuristic to "pick up" a constraint to be propagated when a return type is a boolean. The heuristic may fail to select an "interesting" constraint in some cases. For example, we may expect `::Expr` constraint to be imposed on the first argument of `Meta.isexpr`, but the current heuristic ends up picking up a constraint on the second argument (i.e. `ex.head === head`). ```julia isexpr(@nospecialize(ex), head::Symbol) = isa(ex, Expr) && ex.head === head @test_broken Base.return_types((Any,)) do x Meta.isexpr(x, :call) && return x # x::Expr, ideally return nothing end == Any[Union{Nothing,Expr}] ``` I think We can get rid of this limitation by extending `Conditional` and `InterConditional` so that they can convey multiple constraints, but I'd like to leave this as a future work. EDIT: 3df027a implements the "pick up" logic within a caller (i.e. within `abstract_call_gf_by_type`), which allows us to choose a constraint more appropriately, and now the `Meta.isexpr` case is fixed. Still there is a limitation of multiple conditional constraint back-propagation; the following broken test case will explain the future work. ```julia is_int_and_int(a, b) = isa(a, Int) && isa(b, Int) @test_broken Base.return_types((Any,Any)) do a, b is_int_and_int(a, b) && return a, b # (a::Int, b::Int) ideally, but (a::Any, b::Int) 0, 0 end == Any[Tuple{Int,Int}] ``` --- - closes #38636 - closes #37342

github.com/JuliaLang/julia

tweaks for inter-procedural constraint back-prop'

committed 02:33AM - 24 Feb 21 UTC

aviatesk

+3 -5

note that the changes for `isnothing` and `ismissing` aren't necessary, but they… reduce the number of method definitions for good reason; the less the number of methods they have, the better we can back-propagate type constraints, because even after a package defines their own new methods for them we can keep to use our `InterConditional` logic as far as far as the number of methods is [≤3](https://github.com/JuliaLang/julia/blob/5c6e21edbfd8f0c7d16ea01c91d1c75c30d4eaa1/base/compiler/types.jl#L119)