test #3
Open
test #3
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
... ... [bsd skip]
iblislin
pushed a commit
that referenced
this pull request
Apr 5, 2018
Make all `request` calls start at the first option
iblislin
pushed a commit
that referenced
this pull request
Aug 24, 2019
Consider the following function:
```
julia> function foo(a, b)
ntuple(i->(a+b; i), Val(4))
end
foo (generic function with 1 method)
```
(In particular note that the return type of the closure does not depend on the types
of `a` and b`). Unfortunately, prior to this change, inference was unable to determine
the return type in this situation:
```
julia> code_typed(foo, Tuple{Any, Any}, trace=true)
Refused to call generated function with non-concrete argument types ntuple(::getfield(Main, Symbol("#JuliaLang#15#16")){_A,_B} where _B where _A, ::Val{4}) [GeneratedNotConcrete]
1-element Array{Any,1}:
CodeInfo(
1 ─ %1 = Main.:(#JuliaLang#15#16)::Const(#JuliaLang#15#16, false)
│ %2 = Core.typeof(a)::DataType
│ %3 = Core.typeof(b)::DataType
│ %4 = Core.apply_type(%1, %2, %3)::Type{#JuliaLang#15#16{_A,_B}} where _B where _A
│ %5 = %new(%4, a, b)::#JuliaLang#15#16{_A,_B} where _B where _A
│ %6 = Main.ntuple(%5, $(QuoteNode(Val{4}())))::Any
└── return %6
) => Any
```
Looking at the definition of ntuple
https://github.com/JuliaLang/julia/blob/abb09f88804c4e74c752a66157e767c9b0f8945d/base/ntuple.jl#L45-L56
we see that it is a generated function an inference thus refuses to invoke it,
unless it can prove the concrete type of *all* arguments to the function. As
the above example illustrates, this restriction is more stringent than necessary.
It is true that we cannot invoke generated functions on arbitrary abstract
signatures (because we neither want to the user to have to be able to nor
do we trust that users are able to preverse monotonicity - i.e. that the return
type of the generated code will always be a subtype of the return type of a more
abstract signature).
However, if some piece of information is not used (the type of the passed function
in this case), there is no problem with calling the generated function (since
information that is unnused cannot possibly affect monotnicity).
This PR allows us to recognize pieces of information that are *syntactically* unused,
and call the generated functions, even if we do not have those pieces of information.
As a result, we are now able to infer the return type of the above function:
```
julia> code_typed(foo, Tuple{Any, Any})
1-element Array{Any,1}:
CodeInfo(
1 ─ %1 = Main.:(##3#4)::Const(##3#4, false)
│ %2 = Core.typeof(a)::DataType
│ %3 = Core.typeof(b)::DataType
│ %4 = Core.apply_type(%1, %2, %3)::Type{##3#4{_A,_B}} where _B where _A
│ %5 = %new(%4, a, b)::##3#4{_A,_B} where _B where _A
│ %6 = Main.ntuple(%5, $(QuoteNode(Val{4}())))::NTuple{4,Int64}
└── return %6
) => NTuple{4,Int64}
```
In particular, we use the new frontent `used` flags from the previous commit.
One additional complication is that we want to accesss these flags without
uncompressing the generator source, so we change the compression scheme to
place the flags at a known location.
Fixes JuliaLang#31004
iblislin
pushed a commit
that referenced
this pull request
Aug 24, 2019
…#32605) The bug here is a bit subtle, but perhaps best illustrated with the included test case: ``` function f32579(x::Int64, b::Bool) if b x = nothing end if isa(x, Int64) y = x else y = x end if isa(y, Nothing) z = y else z = y end return z === nothing end ``` The code just after SSA conversion looks like: ``` 2 1 ─ goto #3 if not _3 3 2 ─ %2 = Main.nothing::Core.Compiler.Const(nothing, false) 5 3 ┄ %3 = φ (#2 => %2, #1 => _2)::Union{Nothing, Int64} │ %4 = (%3 isa Main.Int64)::Bool └── goto JuliaLang#5 if not %4 6 4 ─ %6 = π (%3, Int64) └── goto JuliaLang#6 8 5 ─ %8 = π (%3, Nothing) 10 6 ┄ %9 = φ (#4 => %6, JuliaLang#5 => %8)::Union{Nothing, Int64} │ %10 = (%9 isa Main.Nothing)::Bool └── goto JuliaLang#8 if not %10 11 7 ─ %12 = π (%9, Nothing) └── goto JuliaLang#9 13 8 ─ %14 = π (%9, Int64) 15 9 ┄ %15 = φ (JuliaLang#7 => %12, JuliaLang#8 => %14)::Union{Nothing, Int64} │ %16 = (%15 === Main.nothing)::Bool └── return %16 ``` Now, we have special code in SROA (despite it not really being an SROA transform) that looks at `===` and replaces it by a nest of phis of booleans. The reasoning for this transform is that it eliminates a use of a value where we only care about the type and not the content, thus making it more likely that the value will subsequently be eligible for SROA. In addition, while it goes along resolving which values feed into any particular phi, it accumulates and type conditions it encounters along the way. Thus in the example above, something like the following happens: - We look at %14, which πs to %9 with an Int64 constraint, so we only consider the #4 predecessor for %9 (due to the constraint), until we get to %3, where we again only consider the #1 predecessor, where we find the argument (of type Int64) and conclude the result is always false - Now we pop the next item of the stack from our original phi, look at %12, which πs to %9 with a Nothing constraint. At this point we used to terminate the search because we already looked at %9. However, crucially, we looked at %9 only with an Int64 constraint, so we missed the fact that `nothing` was in fact a possible value for this phi. The result was a missing entry in the generated phi node: ``` 1 ─ goto #3 if not b 2 ─ %2 = Main.nothing::Core.Compiler.Const(nothing, false) 3 ┄ %3 = φ (#1 => false)::Bool │ %4 = φ (#2 => %2, #1 => _2)::Union{Nothing, Int64} │ %5 = (%4 isa Main.Int64)::Bool └── goto JuliaLang#5 if not %5 4 ─ %7 = π (%4, Int64) └── goto JuliaLang#6 5 ─ %9 = π (%4, Nothing) 6 ┄ %10 = φ (#4 => %3, JuliaLang#5 => %3)::Bool │ %11 = φ (#4 => %7, JuliaLang#5 => %9)::Union{Nothing, Int64} │ %12 = (%11 isa Main.Nothing)::Bool └── goto JuliaLang#8 if not %12 7 ─ goto JuliaLang#9 8 ─ nothing::Nothing 9 ┄ %16 = φ (JuliaLang#7 => %10, JuliaLang#8 => %10)::Bool └── return %16 ``` (note the missing #2 predecessor in phi node %3), which would result in an undefined value at runtime, though in this case LLVM would have taken advantage of that to just return 0: ``` define i8 @julia_f32579_16051(i64, i8) { top: ; @ REPL[1]:15 within `f32579' ret i8 0 } ``` Compare this now to the optimized IR with this patch: ``` 1 ─ goto #3 if not b 2 ─ %2 = Main.nothing::Core.Compiler.Const(nothing, false) 3 ┄ %3 = φ (#2 => true, #1 => false)::Bool │ %4 = φ (#2 => %2, #1 => _2)::Union{Nothing, Int64} │ %5 = (%4 isa Main.Int64)::Bool └── goto JuliaLang#5 if not %5 4 ─ %7 = π (%4, Int64) └── goto JuliaLang#6 5 ─ %9 = π (%4, Nothing) 6 ┄ %10 = φ (#4 => %3, JuliaLang#5 => %3)::Bool │ %11 = φ (#4 => %7, JuliaLang#5 => %9)::Union{Nothing, Int64} │ %12 = (%11 isa Main.Nothing)::Bool └── goto JuliaLang#8 if not %12 7 ─ goto JuliaLang#9 8 ─ nothing::Nothing 9 ┄ %16 = φ (JuliaLang#7 => %10, JuliaLang#8 => %10)::Bool └── return %16 ``` The %3 phi node has its missing entry and the generated LLVM code correctly returns `b`: ``` define i8 @julia_f32579_16112(i64, i8) { top: %2 = and i8 %1, 1 ; @ REPL[1]:15 within `f32579' ret i8 %2 } ```
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
No description provided.