inference: form `PartialStruct` for extra type information propagation #42831

aviatesk · 2021-10-28T07:27:05Z

This commit forms PartialStruct whenever there is any type-level
refinement available about a field, even if it's not "constant" information.

In Julia "definitions" are allowed to be abstract whereas "usages"
(i.e. callsites) are often concrete. The basic idea is to allow inference
to make more use of such precise callsite type information by encoding it
as PartialStruct.

This may increase optimization possibilities of "unidiomatic" Julia code,
which may contain poorly-typed definitions, like this very contrived example:

struct Problem
    n; s; c; t
end

function main(args...)
    prob = Problem(args...)
    s = 0
    for i in 1:prob.n
        m = mod(i, 3)
        s += m == 0 ? sin(prob.s) : m == 1 ? cos(prob.c) : tan(prob.t)
    end
    return prob, s
end

# master: 1ms, this commit: 100μs
main(10000, 1, 2, 3)

One of the obvious limitation is that this extra type information can be
propagated inter-procedurally only as a const-propagation.
I'm not sure this kind of "just a type-level" refinement can often make
constant-prop' successful (i.e. shape-up a method body and allow it to
be inlined, encoding the extra type information into the generated code),
thus I didn't not modify any part of const-prop' heuristics.

So the improvements from this change is almost for local analysis,
and for very simple inter-procedural calls.

vtjnash · 2021-10-28T17:07:25Z

base/compiler/abstractinterpretation.jl

+            local anyconst = anyrefine = false
+            local allconst = true


What is the purpose of adding local in this PR? There is no scope block except the function itself here

Why is the purpose of computing anyconst? It seems to be redundant with computing anyrefine

What is the purpose of adding local in this PR? There is no scope block except the function itself here

I tend to use such local v = rhs declaration just before a loop in order to indicate v may be wrote within the loop (as we need the local v decl if we don't initialize it with rhs). Does it sound weird ? Then I'm welcome to craft a PR to remove these unnecessary local v = rhs decls I recently added.

Why is the purpose of computing anyconst? It seems to be redundant with computing anyrefine

yeah, I unified them into anyrefine.

It is unusual to worry that the scope rules won't work, though not really an issue. I find it can unduly imbalance the code if there are later parallel assignments, but there is nothing either for or against it in the style guide generally

vtjnash

This looks like a good find and good improvement!

base/compiler/typelattice.jl

DilumAluthge · 2021-10-29T21:00:24Z

@aviatesk @vtjnash CI is green, but I saw you are still having a discussion, so I held off on merging, in case you decide to make additional changes.

DilumAluthge · 2021-11-01T03:09:43Z

I'm removing the merge me label for now, since it seems like you might still be working on this PR.

aviatesk · 2021-11-01T03:11:20Z

No, this PR is solid atm, and I'm going to merge this once CI runs green.

DilumAluthge · 2021-11-01T03:12:25Z

Back it goes :)

This commit forms `PartialStruct` whenever there is any type-level refinement available about a field, even if it's not "constant" information. In Julia "definitions" are allowed to be abstract whereas "usages" (i.e. callsites) are often concrete. The basic idea is to allow inference to make more use of such precise callsite type information by encoding it as `PartialStruct`. This may increase optimization possibilities of "unidiomatic" Julia code, which may contain poorly-typed definitions, like this very contrived example: ```julia struct Problem n; s; c; t end function main(args...) prob = Problem(args...) s = 0 for i in 1:prob.n m = mod(i, 3) s += m == 0 ? sin(prob.s) : m == 1 ? cos(prob.c) : tan(prob.t) end return prob, s end main(10000, 1, 2, 3) ``` One of the obvious limitation is that this extra type information can be propagated inter-procedurally only as a const-propagation. I'm not sure this kind of "just a type-level" refinement can often make constant-prop' successful (i.e. shape-up a method body and allow it to be inlined, encoding the extra type information into the generated code), thus I didn't not modify any part of const-prop' heuristics. So the improvements from this change is almost for local analysis, and for very simple inter-procedural calls.

JuliaLang#42831) * inference: form `PartialStruct` for extra type information propagation This commit forms `PartialStruct` whenever there is any type-level refinement available about a field, even if it's not "constant" information. In Julia "definitions" are allowed to be abstract whereas "usages" (i.e. callsites) are often concrete. The basic idea is to allow inference to make more use of such precise callsite type information by encoding it as `PartialStruct`. This may increase optimization possibilities of "unidiomatic" Julia code, which may contain poorly-typed definitions, like this very contrived example: ```julia struct Problem n; s; c; t end function main(args...) prob = Problem(args...) s = 0 for i in 1:prob.n m = mod(i, 3) s += m == 0 ? sin(prob.s) : m == 1 ? cos(prob.c) : tan(prob.t) end return prob, s end main(10000, 1, 2, 3) ``` One of the obvious limitation is that this extra type information can be propagated inter-procedurally only as a const-propagation. I'm not sure this kind of "just a type-level" refinement can often make constant-prop' successful (i.e. shape-up a method body and allow it to be inlined, encoding the extra type information into the generated code), thus I didn't not modify any part of const-prop' heuristics. So the improvements from this change might not be very useful for general inter-procedural analysis currently, but they should definitely improve the accuracy of local analysis and very simple inter-procedural analysis.

Be more aggressive about merging fields to greatly accelerate convergence, but also compute anyrefine more correctly as we do now elsewhere (since #42831, a121721) Move the tmeet algorithm, without changes, since it is a precise lattice operation, not a heuristic limit like tmerge. Close #43784

JuliaLang#42831) * inference: form `PartialStruct` for extra type information propagation This commit forms `PartialStruct` whenever there is any type-level refinement available about a field, even if it's not "constant" information. In Julia "definitions" are allowed to be abstract whereas "usages" (i.e. callsites) are often concrete. The basic idea is to allow inference to make more use of such precise callsite type information by encoding it as `PartialStruct`. This may increase optimization possibilities of "unidiomatic" Julia code, which may contain poorly-typed definitions, like this very contrived example: ```julia struct Problem n; s; c; t end function main(args...) prob = Problem(args...) s = 0 for i in 1:prob.n m = mod(i, 3) s += m == 0 ? sin(prob.s) : m == 1 ? cos(prob.c) : tan(prob.t) end return prob, s end main(10000, 1, 2, 3) ``` One of the obvious limitation is that this extra type information can be propagated inter-procedurally only as a const-propagation. I'm not sure this kind of "just a type-level" refinement can often make constant-prop' successful (i.e. shape-up a method body and allow it to be inlined, encoding the extra type information into the generated code), thus I didn't not modify any part of const-prop' heuristics. So the improvements from this change might not be very useful for general inter-procedural analysis currently, but they should definitely improve the accuracy of local analysis and very simple inter-procedural analysis.

Be more aggressive about merging fields to greatly accelerate convergence, but also compute anyrefine more correctly as we do now elsewhere (since #42831, a121721) Move the tmeet algorithm, without changes, since it is a precise lattice operation, not a heuristic limit like tmerge. Close #43784

* inference: fix tmerge lattice over issimpleenoughtype Previously we assumed only union type could have complexity that violated the tmerge lattice requirements, but other types can have that too. This lets us fix an issue with the PartialStruct comparison failing for undefined fields, mentioned in #43784. * inference: refine PartialStruct lattice tmerge Be more aggressive about merging fields to greatly accelerate convergence, but also compute anyrefine more correctly as we do now elsewhere (since #42831, a121721) Move the tmeet algorithm, without changes, since it is a precise lattice operation, not a heuristic limit like tmerge. Close #43784

* inference: fix tmerge lattice over issimpleenoughtype Previously we assumed only union type could have complexity that violated the tmerge lattice requirements, but other types can have that too. This lets us fix an issue with the PartialStruct comparison failing for undefined fields, mentioned in #43784. * inference: refine PartialStruct lattice tmerge Be more aggressive about merging fields to greatly accelerate convergence, but also compute anyrefine more correctly as we do now elsewhere (since #42831, a121721) Move the tmeet algorithm, without changes, since it is a precise lattice operation, not a heuristic limit like tmerge. Close #43784 (cherry picked from commit ff88fa4)

improve opaqueclosure inference #42831 started calling `tmeet` in abstractinterpretation of `:new` which meant that we now need to be able to infer it. Co-authored-by: Keno Fischer <[email protected]>

improve opaqueclosure inference JuliaLang#42831 started calling `tmeet` in abstractinterpretation of `:new` which meant that we now need to be able to infer it. Co-authored-by: Keno Fischer <[email protected]>

aviatesk requested a review from vtjnash October 28, 2021 07:27

aviatesk force-pushed the avi/partialtype branch from c713708 to 85371ed Compare October 28, 2021 07:29

aviatesk mentioned this pull request Oct 28, 2021

optimizer: enhance SROA, handle partially-initialized allocations #42834

Merged

aviatesk force-pushed the avi/partialtype branch 3 times, most recently from 2b0d9f7 to 4c3f77a Compare October 28, 2021 16:33

vtjnash reviewed Oct 28, 2021

View reviewed changes

vtjnash approved these changes Oct 28, 2021

View reviewed changes

aviatesk force-pushed the avi/partialtype branch from 4c3f77a to ab23760 Compare October 29, 2021 02:51

aviatesk added compiler:inference Type inference merge me PR is reviewed. Merge when all tests are passing labels Oct 29, 2021

vtjnash reviewed Oct 29, 2021

View reviewed changes

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

aviatesk force-pushed the avi/partialtype branch 2 times, most recently from 6bfb3a8 to 3606e59 Compare November 1, 2021 03:08

DilumAluthge removed the merge me PR is reviewed. Merge when all tests are passing label Nov 1, 2021

aviatesk force-pushed the avi/partialtype branch from 3606e59 to 16b1154 Compare November 1, 2021 03:11

DilumAluthge added the merge me PR is reviewed. Merge when all tests are passing label Nov 1, 2021

aviatesk added 3 commits November 1, 2021 15:25

more symbolism

411fa5c

simplify argument collection, delay constant argument array allocation

3c6dfeb

aviatesk force-pushed the avi/partialtype branch from 16b1154 to 3c6dfeb Compare November 1, 2021 06:25

aviatesk merged commit a121721 into master Nov 1, 2021

aviatesk deleted the avi/partialtype branch November 1, 2021 10:49

DilumAluthge removed the merge me PR is reviewed. Merge when all tests are passing label Nov 1, 2021

vtjnash mentioned this pull request Mar 2, 2022

inference: refine PartialStruct lattice tmerge #44404

Merged

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

inference: form `PartialStruct` for extra type information propagation #42831

inference: form `PartialStruct` for extra type information propagation #42831

aviatesk commented Oct 28, 2021 •

edited

Loading

vtjnash Oct 28, 2021

vtjnash Oct 28, 2021

aviatesk Oct 29, 2021

aviatesk Oct 29, 2021

vtjnash Oct 29, 2021

vtjnash left a comment

DilumAluthge commented Oct 29, 2021

DilumAluthge commented Nov 1, 2021

aviatesk commented Nov 1, 2021

DilumAluthge commented Nov 1, 2021

inference: form PartialStruct for extra type information propagation #42831

inference: form PartialStruct for extra type information propagation #42831

Conversation

aviatesk commented Oct 28, 2021 • edited Loading

vtjnash Oct 28, 2021

Choose a reason for hiding this comment

vtjnash Oct 28, 2021

Choose a reason for hiding this comment

aviatesk Oct 29, 2021

Choose a reason for hiding this comment

aviatesk Oct 29, 2021

Choose a reason for hiding this comment

vtjnash Oct 29, 2021

Choose a reason for hiding this comment

vtjnash left a comment

Choose a reason for hiding this comment

DilumAluthge commented Oct 29, 2021

DilumAluthge commented Nov 1, 2021

aviatesk commented Nov 1, 2021

DilumAluthge commented Nov 1, 2021

inference: form `PartialStruct` for extra type information propagation #42831

inference: form `PartialStruct` for extra type information propagation #42831

aviatesk commented Oct 28, 2021 •

edited

Loading