OptAnalyzer: ignore dynamic dispatches in "throw blocks"

Author: aviatesk

src/analyzers/optanalyzer.jl

@@ -113,6 +113,9 @@ that are specific to the optimization analysis.
       │└────────────────────
       ```
 
+---
+- `skip_throw_blocks = true`:\\
+
 ---
 - `function_filter = @nospecialize(f)->true`:\\
   A predicate which takes a function object and returns `false` to skip runtime dispatch
@@ -134,21 +137,24 @@ struct OptAnalyzer{RP<:ReportPass,FF} <: AbstractAnalyzer
     report_pass::RP
     function_filter::FF
     skip_noncompileable_calls::Bool
+    skip_throw_blocks::Bool
     __analyze_frame::BitVector # temporary stash to keep per-frame analysis-skip configuration
 
     function OptAnalyzer(state::AnalyzerState,
                          report_pass::RP,
                          function_filter::FF,
-                         skip_noncompileable_calls::Bool) where {RP<:ReportPass,FF}
+                         skip_noncompileable_calls::Bool,
+                         skip_throw_blocks::Bool) where {RP<:ReportPass,FF}
         cache_key = compute_hash(state.inf_params, state.opt_params, report_pass,
-                                 skip_noncompileable_calls)
+                                 skip_noncompileable_calls, skip_throw_blocks)
         cache_key = @invoke hash(function_filter::Any, cache_key::UInt) # HACK avoid dynamic dispatch
         analysis_cache = get!(AnalysisCache, OPT_ANALYZER_CACHE, cache_key)
         return new{RP,FF}(state,
                           analysis_cache,
                           report_pass,
                           function_filter,
                           skip_noncompileable_calls,
+                          skip_throw_blocks,
                           #=__analyze_frame=# BitVector())
     end
 end
@@ -160,7 +166,8 @@ function JETInterface.AbstractAnalyzer(analyzer::OptAnalyzer, state::AnalyzerSta
         state,
         analyzer.report_pass,
         analyzer.function_filter,
-        analyzer.skip_noncompileable_calls)
+        analyzer.skip_noncompileable_calls,
+        analyzer.skip_throw_blocks)
 end
 JETInterface.ReportPass(analyzer::OptAnalyzer) = analyzer.report_pass
 JETInterface.AnalysisCache(analyzer::OptAnalyzer) = analyzer.analysis_cache
@@ -313,24 +320,61 @@ end
 function (::OptAnalysisPass)(::Type{RuntimeDispatchReport}, analyzer::OptAnalyzer, caller::InferenceResult, opt::OptimizationState)
     (; src, sptypes, slottypes) = opt
 
-    # TODO better to work on `opt.ir::IRCode` (with some updates on `handle_sig!`)
+    # TODO better to work on `opt.ir::IRCode` (with some updates on `handle_sig!`),
+    #      without creating duplicated `CFG`s
+    cfg = CC.compute_basic_blocks(src.code)
+
+    unreachables = nothing
+    if analyzer.skip_throw_blocks
+        for i = 1:length(src.code)
+            x = src.code[i]
+            if x isa ReturnNode && !isdefined(x, :val)
+                if unreachables === nothing
+                    unreachables = Int[]
+                end
+                push!(unreachables, CC.block_for_inst(cfg, i))
+            end
+        end
+    end
+    is_in_throw_block = nothing
+    if unreachables !== nothing
+        postdomtree = CC.construct_postdomtree(cfg)
+        is_in_throw_block = function (pc::Int)
+            bb = CC.block_for_inst(cfg, pc)
+            for unreachable = unreachables
+                if CC.postdominates(postdomtree, unreachable, bb)
+                    return true
+                end
+            end
+            return false
+        end
+    end
+
     local reported = false
-    for (pc, x) in enumerate(src.code)
+    for i = 1:length(src.code)
+        x = src.code[i]
         if isexpr(x, :call)
             ft = argextype(first(x.args), src, sptypes, slottypes)
             f = singleton_type(ft)
             if f !== nothing
                 f isa Builtin && continue # ignore `:call`s of language intrinsics
                 analyzer.function_filter(f) || continue # ignore user-specified functions
             end
-            lins = get_lins((opt, pc))
+            lins = get_lins((opt, i))
             isempty(lins) && continue # dead statement, just ignore it
             if length(lins) > 1
                 # this statement has been inlined, so ignore it as any problems within
                 # that callee should already have been reported
                 continue
             end
-            add_new_report!(analyzer, caller, RuntimeDispatchReport((opt, pc)))
+            if is_in_throw_block !== nothing && is_in_throw_block(i)
+                # if this statement is in "throw block", ignore it
+                # unless this statement itself is causing the throw
+                if src.ssavaluetypes[i] !== Union{}
+                    continue
+                end
+            end
+            add_new_report!(analyzer, caller, RuntimeDispatchReport((opt, i)))
             reported |= true
         end
     end
@@ -345,17 +389,25 @@ function OptAnalyzer(world::UInt = Base.get_world_counter();
     report_pass::ReportPass = OptAnalysisPass(),
     function_filter = optanalyzer_function_filter,
     skip_noncompileable_calls::Bool = true,
+    skip_throw_blocks::Bool = true,
+    unoptimize_throw_blocks::Union{Nothing,Bool} = nothing,
     jetconfigs...)
+    if unoptimize_throw_blocks !== nothing
+        @warn "The `unoptimize_throw_blocks` configuration is deprecated, use `skip_throw_blocks` instead."
+        skip_throw_blocks = unoptimize_throw_blocks
+    end
     state = AnalyzerState(world; jetconfigs...)
     return OptAnalyzer(
         state,
         report_pass,
         function_filter,
-        skip_noncompileable_calls)
+        skip_noncompileable_calls,
+        skip_throw_blocks)
 end
 
 const OPT_ANALYZER_CONFIGURATIONS = Set{Symbol}((
-    :report_pass, :function_filter, :skip_noncompileable_calls))
+    :report_pass, :function_filter, :skip_noncompileable_calls, :skip_throw_blocks,
+    :unoptimize_throw_blocks))
 
 let valid_keys = GENERAL_CONFIGURATIONS ∪ OPT_ANALYZER_CONFIGURATIONS
     @eval JETInterface.valid_configurations(::OptAnalyzer) = $valid_keys

test/analyzers/test_optanalyzer.jl

@@ -325,13 +325,41 @@ const issue560μ = zeros(Issue560Vec3, 2, 3, 4, 5)
 issue560f(μ) = reinterpret(reshape, Float64, μ)
 @test_opt issue560f(issue560μ)
 
-f_issue643_1(x) = throw("$x <- dynamic dispatches from this interpolation should be ignored")
-@noinline _f_issue643_2(x) = "$x <- dynamic dispatches from this interpolation should be ignored"
+f_issue643_1(x) = throw("$x <- dynamic dispatches from this interpolation should be IGNORED")
+@noinline _f_issue643_2(x) = "$x <- dynamic dispatches from this interpolation should be IGNORED"
 f_issue643_2(x) = throw(_f_issue643_2(x))
-test_opt(f_issue643_1, (Any,); broken=true)
-test_opt(f_issue643_1, (Any,); broken=true) # check cached case
-test_opt(f_issue643_2, (Any,); broken=true)
-test_opt(f_issue643_2, (Any,); broken=true) # check cached case
+function f_issue643_3(x)
+    x isa Float64 ||
+        throw("$x <- dynamic dispatches from this interpolation should be IGNORED")
+    return sin(x)
+end
+function f_issue643_4(x, c)
+    if c
+        throw("$x <- dynamic dispatches from this interpolation should be IGNORED")
+    end
+    "$x <- dynamic dispatches from this interpolation should be REPORTED"
+end
+test_opt(f_issue643_1, (Any,))
+test_opt(f_issue643_1, (Any,)) # check cached case
+test_opt(f_issue643_2, (Any,))
+test_opt(f_issue643_2, (Any,)) # check cached case
+test_opt(f_issue643_3, (Any,))
+test_opt(f_issue643_3, (Any,)) # check cached case
+let res = report_opt(f_issue643_4, (Any,Bool))
+    @test count(@nospecialize(r)->r isa RuntimeDispatchReport, get_reports(res)) == 1
+end
+let res = report_opt(f_issue643_1, (Any,); skip_throw_blocks=false)
+    @test any(@nospecialize(r)->r isa RuntimeDispatchReport, get_reports(res))
+end
+let res = report_opt(f_issue643_2, (Any,); skip_throw_blocks=false)
+    @test any(@nospecialize(r)->r isa RuntimeDispatchReport, get_reports(res))
+end
+let res = report_opt(f_issue643_3, (Any,); skip_throw_blocks=false)
+    @test any(@nospecialize(r)->r isa RuntimeDispatchReport, get_reports(res))
+end
+let res = report_opt(f_issue643_4, (Any,Bool); skip_throw_blocks=false)
+    @test count(@nospecialize(r)->r isa RuntimeDispatchReport, get_reports(res)) == 2
+end
 # the dynamic dispatch should be reported if the method is analyzed standalone
 @test !isempty(get_reports(report_opt(_f_issue643_2, (Any,))))