Merge pull request #31338 from JuliaLang/jn/opt-faster

optimize (a little bit) faster

Author: vtjnash

base/compiler/optimize.jl

@@ -272,7 +272,7 @@ intrinsic_effect_free_if_nothrow(f) = f === Intrinsics.pointerref || is_pure_int
 plus_saturate(x::Int, y::Int) = max(x, y, x+y)
 
 # known return type
-isknowntype(@nospecialize T) = (T == Union{}) || isconcretetype(T)
+isknowntype(@nospecialize T) = (T === Union{}) || isconcretetype(T)
 
 function statement_cost(ex::Expr, line::Int, src::CodeInfo, sptypes::Vector{Any}, slottypes::Vector{Any}, params::Params)
     head = ex.head

base/compiler/ssair/inlining.jl

@@ -923,12 +923,13 @@ end
 # functions.
 function process_simple!(ir::IRCode, idx::Int, params::Params)
     stmt = ir.stmts[idx]
-    if isexpr(stmt, :splatnew)
+    stmt isa Expr || return nothing
+    if stmt.head === :splatnew
         inline_splatnew!(ir, idx)
         return nothing
     end
 
-    isexpr(stmt, :call) || return nothing
+    stmt.head === :call || return nothing
 
     sig = call_sig(ir, stmt)
     sig === nothing && return nothing

base/compiler/ssair/ir.jl

@@ -780,8 +780,10 @@ function renumber_ssa2(val::SSAValue, ssanums::Vector{Any}, used_ssa::Vector{Int
     if do_rename_ssa
         val = ssanums[id]
     end
-    if isa(val, SSAValue) && used_ssa !== nothing
-        used_ssa[val.id] += 1
+    if isa(val, SSAValue)
+        if used_ssa !== nothing
+            used_ssa[val.id] += 1
+        end
     end
     return val
 end
@@ -904,7 +906,7 @@ function process_node!(compact::IncrementalCompact, result::Vector{Any},
     elseif isa(stmt, Expr)
         stmt = renumber_ssa2!(stmt, ssa_rename, used_ssas, late_fixup, result_idx, do_rename_ssa)::Expr
         if compact.allow_cfg_transforms && isexpr(stmt, :enter)
-            stmt.args[1] = compact.bb_rename[stmt.args[1]]
+            stmt.args[1] = compact.bb_rename[stmt.args[1]::Int]
         end
         result[result_idx] = stmt
         result_idx += 1
@@ -913,15 +915,18 @@ function process_node!(compact::IncrementalCompact, result::Vector{Any},
         # type equality. We may want to consider using == in either a separate pass or if
         # performance turns out ok
         stmt = renumber_ssa2!(stmt, ssa_rename, used_ssas, late_fixup, result_idx, do_rename_ssa)::PiNode
-        if !isa(stmt.val, AnySSAValue) && !isa(stmt.val, GlobalRef)
-            valtyp = isa(stmt.val, QuoteNode) ? typeof(stmt.val.value) : typeof(stmt.val)
+        pi_val = stmt.val
+        if isa(pi_val, SSAValue)
+            if stmt.typ === compact.result_types[pi_val.id]
+                ssa_rename[idx] = pi_val
+                return result_idx
+            end
+        elseif !isa(pi_val, AnySSAValue) && !isa(pi_val, GlobalRef)
+            valtyp = isa(pi_val, QuoteNode) ? typeof(pi_val.value) : typeof(pi_val)
             if valtyp === stmt.typ
-                ssa_rename[idx] = stmt.val
+                ssa_rename[idx] = pi_val
                 return result_idx
             end
-        elseif isa(stmt.val, SSAValue) && stmt.typ === compact.result_types[stmt.val.id]
-            ssa_rename[idx] = stmt.val
-            return result_idx
         end
         result[result_idx] = stmt
         result_idx += 1

base/compiler/ssair/legacy.jl

@@ -11,7 +11,7 @@ function inflate_ir(ci::CodeInfo, linfo::MethodInstance)
 end
 
 function inflate_ir(ci::CodeInfo, sptypes::Vector{Any}, argtypes::Vector{Any})
-    code = copy_exprargs(ci.code)
+    code = copy_exprargs(ci.code) # TODO: this is a huge hot-spot
     for i = 1:length(code)
         if isa(code[i], Expr)
             code[i] = normalize_expr(code[i])

base/compiler/ssair/passes.jl

@@ -191,16 +191,16 @@ function walk_to_defs(compact::IncrementalCompact, @nospecialize(defssa), @nospe
         def = compact[defssa]
         if isa(def, PhiNode)
             push!(visited_phinodes, defssa)
-            possible_predecessors = let def=def, typeconstraint=typeconstraint
-                collect(Iterators.filter(1:length(def.edges)) do n
-                    isassigned(def.values, n) || return false
-                    val = def.values[n]
-                    if is_old(compact, defssa) && isa(val, SSAValue)
-                        val = OldSSAValue(val.id)
-                    end
-                    edge_typ = widenconst(compact_exprtype(compact, val))
-                    return typeintersect(edge_typ, typeconstraint) !== Union{}
-                end)
+            possible_predecessors = Int[]
+            for n in 1:length(def.edges)
+                isassigned(def.values, n) || continue
+                val = def.values[n]
+                if is_old(compact, defssa) && isa(val, SSAValue)
+                    val = OldSSAValue(val.id)
+                end
+                edge_typ = widenconst(compact_exprtype(compact, val))
+                typeintersect(edge_typ, typeconstraint) === Union{} && continue
+                push!(possible_predecessors, n)
             end
             for n in possible_predecessors
                 pred = def.edges[n]
@@ -829,15 +829,16 @@ function adce_erase!(phi_uses, extra_worklist, compact, idx)
     end
 end
 
-function count_uses(stmt, uses)
+function count_uses(@nospecialize(stmt), uses::Vector{Int})
     for ur in userefs(stmt)
-        if isa(ur[], SSAValue)
-            uses[ur[].id] += 1
+        use = ur[]
+        if isa(use, SSAValue)
+            uses[use.id] += 1
         end
     end
 end
 
-function mark_phi_cycles(compact, safe_phis, phi)
+function mark_phi_cycles(compact::IncrementalCompact, safe_phis::BitSet, phi::Int)
     worklist = Int[]
     push!(worklist, phi)
     while !isempty(worklist)
@@ -864,7 +865,7 @@ function adce_pass!(ir::IRCode)
     end
     non_dce_finish!(compact)
     for phi in all_phis
-        count_uses(compact.result[phi], phi_uses)
+        count_uses(compact.result[phi]::PhiNode, phi_uses)
     end
     # Perform simple DCE for unused values
     extra_worklist = Int[]
@@ -880,7 +881,7 @@ function adce_pass!(ir::IRCode)
     changed = true
     while changed
         changed = false
-        safe_phis = IdSet{Int}()
+        safe_phis = BitSet()
         for phi in all_phis
             # Save any phi cycles that have non-phi uses
             if compact.used_ssas[phi] - phi_uses[phi] != 0
@@ -898,7 +899,7 @@ function adce_pass!(ir::IRCode)
             end
         end
     end
-    complete(compact)
+    return complete(compact)
 end
 
 function type_lift_pass!(ir::IRCode)

base/compiler/ssair/queries.jl

@@ -4,10 +4,13 @@
 Determine whether a statement is side-effect-free, i.e. may be removed if it has no uses.
 """
 function stmt_effect_free(@nospecialize(stmt), @nospecialize(rt), src, sptypes::Vector{Any})
-    isa(stmt, Union{PiNode, PhiNode}) && return true
-    isa(stmt, Union{ReturnNode, GotoNode, GotoIfNot}) && return false
-    isa(stmt, GlobalRef) && return isdefined(stmt.mod, stmt.name)
+    isa(stmt, PiNode) && return true
+    isa(stmt, PhiNode) && return true
+    isa(stmt, ReturnNode) && return false
+    isa(stmt, GotoNode) && return false
+    isa(stmt, GotoIfNot) && return false
     isa(stmt, Slot) && return false # Slots shouldn't occur in the IR at this point, but let's be defensive here
+    isa(stmt, GlobalRef) && return isdefined(stmt.mod, stmt.name)
     if isa(stmt, Expr)
         e = stmt::Expr
         head = e.head

base/compiler/tfuncs.jl

@@ -410,7 +410,7 @@ add_tfunc(pointerref, 3, 3,
 add_tfunc(pointerset, 4, 4, (@nospecialize(a), @nospecialize(v), @nospecialize(i), @nospecialize(align)) -> a, 5)
 
 # more accurate typeof_tfunc for vararg tuples abstract only in length
-function typeof_concrete_vararg(@nospecialize(t))
+function typeof_concrete_vararg(t::DataType)
     np = length(t.parameters)
     for i = 1:np
         p = t.parameters[i]