inference: backward constraint propagation from call signatures #40880

aviatesk · 2021-05-19T16:48:56Z

This PR implements another (limited) backward analysis pass in abstract
interpretation; it exploits signatures of matching methods and refines
types of slots.

Here are couple of examples where these changes will improve the accuracy:

generic function example

addint(a::Int, b::Int) = a + b
@test Base.infer_return_type((Any,Any,)) do a, b
    c = addint(a, b)
    return a, b, c # now the compiler understands `a::Int`, `b::Int`
end == Tuple{Int,Int,Int}

typeassert example

@test Base.infer_return_type((Any,)) do a
    a::Int
    return a # now the compiler understands `a::Int`
end == Int

Unlike Conditional constrained type propagation, this type refinement
information isn't encoded within any lattice element, but rather they
are propagated within the newly added field frame.curr_stmt_change of
frame::InferenceState.
For now this commit exploits refinement information available from call
signatures of generic functions and typeassert.

base/compiler/abstractinterpretation.jl

KristofferC · 2021-05-19T18:15:20Z

Fixes #37866?

aviatesk · 2021-05-19T18:22:18Z

Oh, I didn't know there is already an issue on this.

And yeah, this PR will fix that:

julia> function find_first_above_5(v::Vector{Union{Nothing, Float64}})
           for x in v
               if x > 5.0
                   return x # x > 5.0 is MethodError for Nothing so can assume ::Float64
               end
           end
           return 0.0
       end
find_first_above_5 (generic function with 1 method)

julia> x = Union{Nothing, Float64}[1.0, 2.0, 3.0, 6.0, 4.0]
5-element Vector{Union{Nothing, Float64}}:
 1.0
 2.0
 3.0
 6.0
 4.0

julia> find_first_above_5(x)
6.0

julia> Core.Compiler.return_types(find_first_above_5, Tuple{Vector{Union{Nothing, Float64}}})
1-element Vector{Any}:
 Float64

julia> code_warntype(find_first_above_5, Tuple{Vector{Union{Nothing, Float64}}})
MethodInstance for find_first_above_5(::Vector{Union{Nothing, Float64}})
  from find_first_above_5(v::Vector{Union{Nothing, Float64}}) in Main at REPL[1]:1
Arguments
  #self#::Core.Const(find_first_above_5)
  v::Vector{Union{Nothing, Float64}}
Locals
  @_3::Union{Nothing, Tuple{Union{Nothing, Float64}, Int64}}
  x::Union{Nothing, Float64}
Body::Float64
1 ─ %1  = v::Vector{Union{Nothing, Float64}}
│         (@_3 = Base.iterate(%1))
│   %3  = (@_3 === nothing)::Bool
│   %4  = Base.not_int(%3)::Bool
└──       goto #6 if not %4
2 ┄ %6  = @_3::Tuple{Union{Nothing, Float64}, Int64}
│         (x = Core.getfield(%6, 1))
│   %8  = Core.getfield(%6, 2)::Int64
│   %9  = (x > 5.0)::Bool
└──       goto #4 if not %9
3 ─       return x::Float64
4 ─       (@_3 = Base.iterate(%1, %8))
│   %13 = (@_3 === nothing)::Bool
│   %14 = Base.not_int(%13)::Bool
└──       goto #6 if not %14
5 ─       goto #2
6 ┄       return 0.0

aviatesk · 2021-05-21T16:55:13Z

@nanosoldier runbenchmarks(ALL, vs=":master")

nanosoldier · 2021-05-22T11:44:05Z

Your benchmark job has completed - possible performance regressions were detected. A full report can be found here. cc @christopher-dG

aviatesk · 2021-05-23T09:23:20Z

@nanosoldier runbenchmarks(ALL, vs=":master")

nanosoldier · 2021-05-23T15:42:05Z

Your benchmark job has completed - possible performance regressions were detected. A full report can be found here. cc @christopher-dG

aviatesk · 2021-05-24T12:38:54Z

@vtjnash can I ask your review on this ?

StefanKarpinski · 2021-06-25T09:00:55Z

Bump!

aviatesk · 2021-09-23T06:16:46Z

@nanosoldier runbenchmarks(ALL, vs=":master")

nanosoldier · 2021-09-23T12:30:50Z

Something went wrong when running your job:

NanosoldierError: error when preparing/pushing to report repo: failed process: Process(setenv(`git push`; dir="/run/media/system/data/nanosoldier/workdir/NanosoldierReports"), ProcessExited(1)) [1]

Unfortunately, the logs could not be uploaded.
cc @christopher-dG

KristofferC · 2021-09-23T13:40:19Z

I think @vtjnash has to manually upload the result.

aviatesk · 2021-09-23T13:43:34Z

hm, does that mean a part of the system is kinda broken now ?

KristofferC · 2021-09-23T13:44:55Z

Yes, the files now get too big to upload to github. JuliaCI/Nanosoldier.jl#97

vtjnash · 2021-09-23T14:16:05Z

Yeah, I'm not sure why the files suddenly changed from 20MB to 100MB

https://github.com/JuliaCI/NanosoldierReports/blob/master/benchmark/by_hash/06b2bf2_vs_5e8d7ed/report.md

aviatesk · 2021-09-23T14:28:38Z

Okay, thanks for uploading it anyway.

nanosoldier · 2021-09-23T19:52:25Z

Something went wrong when running your job:

NanosoldierError: error when preparing/pushing to report repo: failed process: Process(setenv(`git push`; dir="/run/media/system/data/nanosoldier/workdir/NanosoldierReports"), ProcessExited(1)) [1]

Unfortunately, the logs could not be uploaded.
cc @christopher-dG

vtjnash · 2021-09-23T20:10:17Z

https://github.com/JuliaCI/NanosoldierReports/blob/master/benchmark/by_hash/49e5a54_vs_764159c/report.md

vchuravy · 2023-01-12T07:36:09Z

A rebase would be fantastic!

Should also fix #38274

JeffBezanson · 2024-07-18T16:39:00Z

Bump again!

base/compiler/abstractinterpretation.jl

test/compiler/inference.jl

@test

Separated from #40880. This subtle adjustment allows for more accurate type inference in the following kind of cases: ```julia function condition_object_update2(x) cond = x isa Int if cond # `cond` is known to be `Const(true)` within this branch return !cond ? nothing : x # ::Int else return cond ? nothing : 1 # ::Int end end @test Base.infer_return_type(condition_object_update2, (Any,)) == Int ```

@test

This PR implements another (limited) backward analysis pass in abstract interpretation; it exploits signatures of matching methods and refines types of slots. Here are couple of examples where these changes will improve the accuracy: > generic function example ```julia addint(a::Int, b::Int) = a + b @test Base.infer_return_type((Any,Any,)) do a, b c = addint(a, b) return a, b, c # now the compiler understands `a::Int`, `b::Int` end == Tuple{Int,Int,Int} ``` > `typeassert` example ```julia @test Base.infer_return_type((Any,)) do a a::Int return a # now the compiler understands `a::Int` end == Int ``` Unlike `Conditional` constrained type propagation, this type refinement information isn't encoded within any lattice element, but rather they are propagated within the newly added field `frame.curr_stmt_change` of `frame::InferenceState`. For now this commit exploits refinement information available from call signatures of generic functions and `typeassert`.

aviatesk · 2024-07-23T10:22:22Z

@nanosoldier runbenchmarks("inference", vs=":master")

nanosoldier · 2024-07-23T11:20:14Z

Your benchmark job has completed - possible performance regressions were detected. A full report can be found here.

@test

Separated from #40880. This subtle adjustment allows for more accurate type inference in the following kind of cases: ```julia function condition_object_update2(x) cond = x isa Int if cond # `cond` is known to be `Const(true)` within this branch return !cond ? nothing : x # ::Int else return cond ? nothing : 1 # ::Int end end @test Base.infer_return_type(condition_object_update2, (Any,)) == Int ``` Also cleans up typelattice.jl a bit.

nsajko · 2024-07-24T07:02:55Z

How come this is closed? Will there be a followup? I was hoping the linked issues will finally be fixed.

aviatesk · 2024-07-24T07:37:56Z

I'm not sure. It might be because the base branch of this PR was the one I just merged a little while ago. I don't know how to reopen it, so I'll prepare a new PR.

aviatesk · 2024-07-24T07:39:31Z

Now this PR is replaced by #55229.

@test

Separated from JuliaLang#40880. This subtle adjustment allows for more accurate type inference in the following kind of cases: ```julia function condition_object_update2(x) cond = x isa Int if cond # `cond` is known to be `Const(true)` within this branch return !cond ? nothing : x # ::Int else return cond ? nothing : 1 # ::Int end end @test Base.infer_return_type(condition_object_update2, (Any,)) == Int ``` Also cleans up typelattice.jl a bit.

aviatesk requested review from vtjnash, JeffBezanson and Keno May 19, 2021 16:49

aviatesk added the compiler:inference Type inference label May 19, 2021

aviatesk commented May 19, 2021

View reviewed changes

base/compiler/abstractinterpretation.jl Outdated Show resolved Hide resolved

aviatesk mentioned this pull request May 20, 2021

inference: form conditional constraint from non-Conditional object #40832

Merged

aviatesk force-pushed the multiupdates branch 3 times, most recently from e87ad2b to 34498f2 Compare May 21, 2021 16:38

aviatesk force-pushed the multiupdates branch from 85eedcb to 0ba0626 Compare May 23, 2021 09:22

aviatesk force-pushed the multiupdates branch from 0ba0626 to 7cb0913 Compare May 24, 2021 12:38

aviatesk force-pushed the multiupdates branch 4 times, most recently from 780e927 to ae85281 Compare June 3, 2021 03:54

aviatesk force-pushed the multiupdates branch from ae85281 to 83d28a2 Compare June 25, 2021 17:57

jakobnissen mentioned this pull request Jul 22, 2021

Improve inferability of download() JuliaLang/Downloads.jl#133

Merged

jakobnissen mentioned this pull request Aug 6, 2021

Improve inference JuliaIO/TranscodingStreams.jl#111

Merged

KristofferC mentioned this pull request Sep 7, 2021

improve minor inferrabilities #42141

Merged

aviatesk force-pushed the multiupdates branch from 83d28a2 to 34647a4 Compare September 23, 2021 06:08

aviatesk force-pushed the multiupdates branch from 34647a4 to f9575da Compare September 30, 2021 06:57

jakobnissen mentioned this pull request Feb 19, 2022

hash(::Vector{<abstract type>}, ::UInt) allocates quite a bit due to type instability: why can't hash(::Any) infer UInt return type? #44244

Open

aviatesk mentioned this pull request Jan 12, 2023

Lower typeassert a::Int as a=a::Int #48227

Closed

JeffBezanson mentioned this pull request Jul 18, 2024

doc: manual: performance tips: warn against suboptimal type asserts #55115

Closed

aviatesk force-pushed the multiupdates branch from f9575da to cc5a8c3 Compare July 22, 2024 18:01

nsajko reviewed Jul 22, 2024

View reviewed changes

base/compiler/abstractinterpretation.jl Outdated Show resolved Hide resolved

nsajko reviewed Jul 22, 2024

View reviewed changes

test/compiler/inference.jl Outdated Show resolved Hide resolved

aviatesk mentioned this pull request Jul 23, 2024

inference: refine branched Conditional types #55216

Merged

aviatesk force-pushed the multiupdates branch from cc5a8c3 to 6e94124 Compare July 23, 2024 10:00

aviatesk changed the base branch from master to avi/refine-condition-object July 23, 2024 10:00

aviatesk deleted the branch JuliaLang:avi/refine-condition-object July 24, 2024 06:36

aviatesk closed this Jul 24, 2024

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

inference: backward constraint propagation from call signatures #40880

inference: backward constraint propagation from call signatures #40880

aviatesk commented May 19, 2021 •

edited

Loading

KristofferC commented May 19, 2021

aviatesk commented May 19, 2021

aviatesk commented May 21, 2021

nanosoldier commented May 22, 2021

aviatesk commented May 23, 2021

nanosoldier commented May 23, 2021

aviatesk commented May 24, 2021

StefanKarpinski commented Jun 25, 2021

aviatesk commented Sep 23, 2021

nanosoldier commented Sep 23, 2021

KristofferC commented Sep 23, 2021

aviatesk commented Sep 23, 2021

KristofferC commented Sep 23, 2021

vtjnash commented Sep 23, 2021

aviatesk commented Sep 23, 2021

nanosoldier commented Sep 23, 2021

vtjnash commented Sep 23, 2021

vchuravy commented Jan 12, 2023

JeffBezanson commented Jul 18, 2024

aviatesk commented Jul 23, 2024

nanosoldier commented Jul 23, 2024

nsajko commented Jul 24, 2024

aviatesk commented Jul 24, 2024

aviatesk commented Jul 24, 2024

inference: backward constraint propagation from call signatures #40880

inference: backward constraint propagation from call signatures #40880

Conversation

aviatesk commented May 19, 2021 • edited Loading

KristofferC commented May 19, 2021

aviatesk commented May 19, 2021

aviatesk commented May 21, 2021

nanosoldier commented May 22, 2021

aviatesk commented May 23, 2021

nanosoldier commented May 23, 2021

aviatesk commented May 24, 2021

StefanKarpinski commented Jun 25, 2021

aviatesk commented Sep 23, 2021

nanosoldier commented Sep 23, 2021

KristofferC commented Sep 23, 2021

aviatesk commented Sep 23, 2021

KristofferC commented Sep 23, 2021

vtjnash commented Sep 23, 2021

aviatesk commented Sep 23, 2021

nanosoldier commented Sep 23, 2021

vtjnash commented Sep 23, 2021

vchuravy commented Jan 12, 2023

JeffBezanson commented Jul 18, 2024

aviatesk commented Jul 23, 2024

nanosoldier commented Jul 23, 2024

nsajko commented Jul 24, 2024

aviatesk commented Jul 24, 2024

aviatesk commented Jul 24, 2024

aviatesk commented May 19, 2021 •

edited

Loading