RFC: Experimental API for may-happen in parallel parallelism

base/boot.jl

@@ -155,6 +155,21 @@
 #    name::Symbol
 #end
 
+#struct DetachNode
+#    syncregion
+#    label::Int
+#    reattach::Int
+#end
+
+#struct ReattachNode
+#    syncregion
+#    label::Int
+#end
+
+#struct SyncNode
+#    syncregion
+#end
+
 #mutable struct Task
 #    parent::Task
 #    storage::Any
@@ -415,6 +430,11 @@ eval(Core, :(PiNode(val, typ) = $(Expr(:new, :PiNode, :val, :typ))))
 eval(Core, :(PhiCNode(values::Array{Any, 1}) = $(Expr(:new, :PhiCNode, :values))))
 eval(Core, :(UpsilonNode(val) = $(Expr(:new, :UpsilonNode, :val))))
 eval(Core, :(UpsilonNode() = $(Expr(:new, :UpsilonNode))))
+eval(Core, :(LineInfoNode(@nospecialize(method), file::Symbol, line::Int, inlined_at::Int) =
+             $(Expr(:new, :LineInfoNode, :method, :file, :line, :inlined_at))))
+eval(Core, :(SyncNode(token) = $(Expr(:new, :SyncNode, :token))))
+eval(Core, :(DetachNode(token, bb::Int, reattach::Int) = $(Expr(:new, :DetachNode, :token, :bb, :reattach))))
+eval(Core, :(ReattachNode(token, bb::Int) = $(Expr(:new, :ReattachNode, :token, :bb))))
 eval(Core, :(LineInfoNode(mod::Module, @nospecialize(method), file::Symbol, line::Int, inlined_at::Int) =
              $(Expr(:new, :LineInfoNode, :mod, :method, :file, :line, :inlined_at))))
 eval(Core, :(CodeInstance(mi::MethodInstance, @nospecialize(rettype), @nospecialize(inferred_const),
@@ -497,11 +517,13 @@ module IR
 export CodeInfo, MethodInstance, CodeInstance, GotoNode, GotoIfNot, ReturnNode,
     NewvarNode, SSAValue, Slot, SlotNumber, TypedSlot, Argument,
     PiNode, PhiNode, PhiCNode, UpsilonNode, LineInfoNode,
+    DetachNode, ReattachNode, SyncNode,
     Const, PartialStruct
 
 import Core: CodeInfo, MethodInstance, CodeInstance, GotoNode, GotoIfNot, ReturnNode,
     NewvarNode, SSAValue, Slot, SlotNumber, TypedSlot, Argument,
     PiNode, PhiNode, PhiCNode, UpsilonNode, LineInfoNode,
+    DetachNode, ReattachNode, SyncNode,
     Const, PartialStruct
 
 end

base/compiler/abstractinterpretation.jl

@@ -1432,6 +1432,21 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
                 changes[sn] = VarState(Bottom, true)
             elseif isa(stmt, GotoNode)
                 pc´ = (stmt::GotoNode).label
+            elseif isa(stmt, DetachNode)
+                # A detach node has two edges we need to add
+                # the reattach edge to the work queue
+                l = (stmt::DetachNode).reattach
+                newstate_reattach = stupdate!(s[l], changes)
+                if newstate_reattach !== nothing
+                    if l < frame.pc´´
+                        frame.pc´´ = l
+                    end
+                    push!(W, l)
+                    s[l] = newstate_reattach
+                end
+                pc´ = (stmt::DetachNode).label
+            elseif isa(stmt, ReattachNode)
+                pc´ = (stmt::ReattachNode).label
             elseif isa(stmt, GotoIfNot)
                 condt = abstract_eval_value(interp, stmt.cond, changes, frame)
                 if condt === Bottom
@@ -1536,7 +1551,8 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
                     if isa(fname, Slot)
                         changes = StateUpdate(fname, VarState(Any, false), changes)
                     end
-                elseif hd === :inbounds || hd === :meta || hd === :loopinfo || hd === :code_coverage_effect
+                elseif hd === :inbounds || hd === :meta || hd === :loopinfo || hd === :code_coverage_effect ||
+                       (stmt isa SyncNode)
                     # these do not generate code
                 else
                     t = abstract_eval_statement(interp, stmt, changes, frame)

base/compiler/compiler.jl

@@ -86,6 +86,22 @@ ntuple(f, ::Val{3}) = (@_inline_meta; (f(1), f(2), f(3)))
 ntuple(f, ::Val{n}) where {n} = ntuple(f, n::Int)
 ntuple(f, n) = (Any[f(i) for i = 1:n]...,)
 
+all(xs) = all(identity, xs)
+function all(f, xs)
+    for x in xs
+        f(x) || return false
+    end
+    return true
+end
+
+any(xs) = any(identity, xs)
+function any(f, xs)
+    for x in xs
+        f(x) && return true
+    end
+    return false
+end
+
 # core docsystem
 include("docs/core.jl")
 
@@ -121,6 +137,7 @@ include("compiler/stmtinfo.jl")
 include("compiler/abstractinterpretation.jl")
 include("compiler/typeinfer.jl")
 include("compiler/optimize.jl") # TODO: break this up further + extract utilities
+include("compiler/tapirpasses.jl")
 
 include("compiler/bootstrap.jl")
 ccall(:jl_set_typeinf_func, Cvoid, (Any,), typeinf_ext_toplevel)

base/compiler/optimize.jl

@@ -161,7 +161,8 @@ end
 # if there is no usage within the function), but don't affect the purity
 # of the function as a whole.
 function stmt_affects_purity(@nospecialize(stmt), ir)
-    if isa(stmt, GotoNode) || isa(stmt, ReturnNode)
+    if isa(stmt, GotoNode) || isa(stmt, ReturnNode) ||
+        isa(stmt, DetachNode) || isa(stmt, ReattachNode) || isa(stmt, SyncNode)
         return false
     end
     if isa(stmt, GotoIfNot)
@@ -469,6 +470,27 @@ function renumber_ir_elements!(body::Vector{Any}, ssachangemap::Vector{Int}, lab
             if isdefined(el, :val) && isa(el.val, SSAValue)
                 body[i] = ReturnNode(SSAValue(el.val.id + ssachangemap[el.val.id]))
             end
+        elseif isa(el, DetachNode)
+            syncregion = el.syncregion
+            if isa(syncregion, SSAValue)
+                    syncregion = SSAValue(syncregion.id + ssachangemap[syncregion.id])
+            end
+            label = el.label + labelchangemap[el.label]
+            reattach = el.reattach + labelchangemap[el.reattach]
+            body[i] = DetachNode(syncregion, label, reattach)
+        elseif isa(el, ReattachNode)
+            syncregion = el.syncregion
+            if isa(syncregion, SSAValue)
+                    syncregion = SSAValue(syncregion.id + ssachangemap[syncregion.id])
+            end
+            label = el.label + labelchangemap[el.label]
+            body[i] = ReattachNode(syncregion, label)
+        elseif isa(el, SyncNode)
+            syncregion = el.syncregion
+            if isa(syncregion, SSAValue)
+                    syncregion = SSAValue(syncregion.id + ssachangemap[syncregion.id])
+            end
+            body[i] = SyncNode(syncregion)
         elseif isa(el, SSAValue)
             body[i] = SSAValue(el.id + ssachangemap[el.id])
         elseif isa(el, Expr)

base/compiler/ssair/driver.jl

@@ -125,6 +125,7 @@ function run_passes(ci::CodeInfo, nargs::Int, sv::OptimizationState)
     ir = slot2reg(ir, ci, nargs, sv)
     #@Base.show ("after_construct", ir)
     # TODO: Domsorting can produce an updated domtree - no need to recompute here
+    @timeit "Early tapir" ir = early_tapir_pass!(ir)
     @timeit "compact 1" ir = compact!(ir)
     @timeit "Inlining" ir = ssa_inlining_pass!(ir, ir.linetable, sv.inlining, ci.propagate_inbounds)
     #@timeit "verify 2" verify_ir(ir)
@@ -138,6 +139,7 @@ function run_passes(ci::CodeInfo, nargs::Int, sv::OptimizationState)
     @timeit "type lift" ir = type_lift_pass!(ir)
     @timeit "compact 3" ir = compact!(ir)
     #@Base.show ir
+    @timeit "tapir" ir = lower_tapir!(ir)
     if JLOptions().debug_level == 2
         @timeit "verify 3" (verify_ir(ir); verify_linetable(ir.linetable))
     end

base/compiler/ssair/inlining.jl

@@ -386,6 +386,10 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
                 end
             elseif isa(stmt′, GotoNode)
                 stmt′ = GotoNode(stmt′.label + bb_offset)
+            elseif isa(stmt′, DetachNode)
+                stmt′ = DetachNode(stmt′.syncregion, stmt′.label + bb_offset, stmt′.reattach + bb_offset)
+            elseif isa(stmt′, ReattachNode)
+                stmt′ = ReattachNode(stmt′.syncregion, stmt′.label + bb_offset)
             elseif isa(stmt′, Expr) && stmt′.head === :enter
                 stmt′ = Expr(:enter, stmt′.args[1] + bb_offset)
             elseif isa(stmt′, GotoIfNot)
@@ -559,6 +563,10 @@ function batch_inline!(todo::Vector{Pair{Int, Any}}, ir::IRCode, linetable::Vect
                 end
             elseif isa(stmt, GotoNode)
                 compact[idx] = GotoNode(state.bb_rename[stmt.label])
+            elseif isa(stmt, DetachNode)
+                compact[idx] = DetachNode(stmt.syncregion, state.bb_rename[stmt.label], state.bb_rename[stmt.reattach])
+            elseif isa(stmt, ReattachNode)
+                compact[idx] = ReattachNode(stmt.syncregion, state.bb_rename[stmt.label])
             elseif isa(stmt, Expr) && stmt.head === :enter
                 compact[idx] = Expr(:enter, state.bb_rename[stmt.args[1]])
             elseif isa(stmt, GotoIfNot)

base/compiler/ssair/ir.jl

@@ -3,6 +3,7 @@
 @inline isexpr(@nospecialize(stmt), head::Symbol) = isa(stmt, Expr) && stmt.head === head
 Core.PhiNode() = Core.PhiNode(Int32[], Any[])
 
+# TODO: add detach/reattach?
 isterminator(@nospecialize(stmt)) = isa(stmt, GotoNode) || isa(stmt, GotoIfNot) || isa(stmt, ReturnNode)
 
 struct CFG
@@ -50,6 +51,13 @@ function basic_blocks_starts(stmts::Vector{Any})
             # This is a fake dest to force the next stmt to start a bb
             idx < length(stmts) && push!(jump_dests, idx+1)
             push!(jump_dests, stmt.label)
+        elseif isa(stmt, DetachNode)
+            push!(jump_dests, stmt.label)
+            push!(jump_dests, stmt.reattach)
+        elseif isa(stmt, ReattachNode)
+            push!(jump_dests, stmt.label)
+        elseif isa(stmt, SyncNode)
+            push!(jump_dests, idx+1)
         elseif isa(stmt, Expr)
             if stmt.head === :leave
                 # :leave terminates a BB
@@ -100,12 +108,22 @@ function compute_basic_blocks(stmts::Vector{Any})
             # return never has any successors
             continue
         end
-        if isa(terminator, GotoNode)
+        if isa(terminator, GotoNode) || isa(terminator, ReattachNode)
             block′ = block_for_inst(basic_block_index, terminator.label)
             push!(blocks[block′].preds, num)
             push!(b.succs, block′)
             continue
         end
+        if isa(terminator, DetachNode)
+            block′ = block_for_inst(basic_block_index, terminator.label)
+            push!(blocks[block′].preds, num)
+            push!(b.succs, block′)
+
+            block′ = block_for_inst(basic_block_index, terminator.reattach)
+            push!(blocks[block′].preds, num)
+            push!(b.succs, block′)
+            continue
+        end
         # Conditional Branch
         if isa(terminator, GotoIfNot)
             block′ = block_for_inst(basic_block_index, terminator.dest)
@@ -290,6 +308,9 @@ function setindex!(x::IRCode, @nospecialize(repl), s::SSAValue)
     return x
 end
 
+first_insert_for_bb(ir::IRCode, block::Int) =
+    first_insert_for_bb(ir.stmts.inst, ir.cfg, block)
+
 # SSA values that need renaming
 struct OldSSAValue
     id::Int
@@ -347,6 +368,9 @@ function getindex(x::UseRef)
     elseif isa(stmt, GotoIfNot)
         x.op == 1 || return OOBToken()
         return stmt.cond
+    elseif isa(stmt, DetachNode) || isa(stmt, ReattachNode) || isa(stmt, SyncNode)
+        x.op == 1 || return OOBToken()
+        return stmt.syncregion
     elseif isa(stmt, ReturnNode)
         isdefined(stmt, :val) || return OOBToken()
         x.op == 1 || return OOBToken()
@@ -378,6 +402,7 @@ function is_relevant_expr(e::Expr)
                       :foreigncall, :isdefined, :copyast,
                       :undefcheck, :throw_undef_if_not,
                       :cfunction, :method, :pop_exception,
+                      :syncregion,
                       :new_opaque_closure)
 end
 
@@ -400,6 +425,15 @@ function setindex!(x::UseRef, @nospecialize(v))
     elseif isa(stmt, GotoIfNot)
         x.op == 1 || throw(BoundsError())
         x.stmt = GotoIfNot(v, stmt.dest)
+    elseif isa(stmt, DetachNode)
+        x.op == 1 || throw(BoundsError())
+        x.stmt = DetachNode(v, stmt.label, stmt.reattach)
+    elseif isa(stmt, ReattachNode)
+        x.op == 1 || throw(BoundsError())
+        x.stmt = ReattachNode(v, stmt.label)
+    elseif isa(stmt, SyncNode)
+        x.op == 1 || throw(BoundsError())
+        x.stmt = SyncNode(v)
     elseif isa(stmt, ReturnNode)
         x.op == 1 || throw(BoundsError())
         x.stmt = typeof(stmt)(v)
@@ -426,7 +460,8 @@ end
 function userefs(@nospecialize(x))
     relevant = (isa(x, Expr) && is_relevant_expr(x)) ||
         isa(x, GotoIfNot) || isa(x, ReturnNode) ||
-        isa(x, PiNode) || isa(x, PhiNode) || isa(x, PhiCNode) || isa(x, UpsilonNode)
+        isa(x, PiNode) || isa(x, PhiNode) || isa(x, PhiCNode) || isa(x, UpsilonNode) ||
+        isa(x, DetachNode) || isa(x, ReattachNode) || isa(x, SyncNode)
     return UseRefIterator(x, relevant)
 end
 
@@ -489,6 +524,14 @@ function foreachssa(f, @nospecialize(stmt))
     end
 end
 
+"""
+    insert_node!(ir::IRCode, postion::Int, type, statement, [attach_after=false])
+
+Insert a `statement` that results in a value of given `type` before/after
+`postion` if `attach_after` is `false`/ `true`. If called with the same
+`position` multiple times with `attach_after=false`, the order of the calls
+is reflected to the order of the statements that appear in the resulting IR.
+"""
 function insert_node!(ir::IRCode, pos::Int, @nospecialize(typ), @nospecialize(val), attach_after::Bool=false)
     line = ir.stmts[pos][:line]
     node = add!(ir.new_nodes, pos, attach_after)
@@ -956,6 +999,21 @@ function process_node!(compact::IncrementalCompact, result_idx::Int, inst::Instr
     elseif isa(stmt, GlobalRef) || isa(stmt, GotoNode)
         result[result_idx][:inst] = stmt
         result_idx += 1
+    elseif isa(stmt, DetachNode) || isa(stmt, ReattachNode) || isa(stmt, SyncNode)
+        stmt = renumber_ssa2!(stmt, ssa_rename, used_ssas, late_fixup, result_idx, do_rename_ssa)
+        if compact.cfg_transforms_enabled
+            if isa(stmt, DetachNode)
+                stmt = DetachNode(
+                    stmt.syncregion,
+                    compact.bb_rename_succ[stmt.label],
+                    compact.bb_rename_succ[stmt.reattach],
+                )
+            elseif isa(stmt, ReattachNode)
+                stmt = ReattachNode(stmt.syncregion, compact.bb_rename_succ[stmt.label])
+            end
+        end
+        result[result_idx][:inst] = stmt
+        result_idx += 1
     elseif isa(stmt, GotoIfNot) && compact.cfg_transforms_enabled
         stmt = renumber_ssa2!(stmt, ssa_rename, used_ssas, late_fixup, result_idx, do_rename_ssa)::GotoIfNot
         result[result_idx][:inst] = stmt

base/compiler/ssair/legacy.jl

@@ -18,6 +18,11 @@ function inflate_ir(ci::CodeInfo, sptypes::Vector{Any}, argtypes::Vector{Any})
         # Translate statement edges to bb_edges
         if isa(stmt, GotoNode)
             code[i] = GotoNode(block_for_inst(cfg, stmt.label))
+        elseif isa(stmt, DetachNode)
+            code[i] = DetachNode(stmt.syncregion, block_for_inst(cfg, stmt.label),
+                                                  block_for_inst(cfg, stmt.reattach))
+        elseif isa(stmt, ReattachNode)
+            code[i] = ReattachNode(stmt.syncregion, block_for_inst(cfg, stmt.label))
         elseif isa(stmt, GotoIfNot)
             code[i] = GotoIfNot(stmt.cond, block_for_inst(cfg, stmt.dest))
         elseif isa(stmt, PhiNode)
@@ -56,6 +61,11 @@ function replace_code_newstyle!(ci::CodeInfo, ir::IRCode, nargs::Int)
         stmt = ci.code[i]
         if isa(stmt, GotoNode)
             stmt = GotoNode(first(ir.cfg.blocks[stmt.label].stmts))
+        elseif isa(stmt, DetachNode)
+            stmt = DetachNode(stmt.syncregion, first(ir.cfg.blocks[stmt.label].stmts),
+                              first(ir.cfg.blocks[stmt.reattach].stmts))
+        elseif isa(stmt, ReattachNode)
+            stmt = ReattachNode(stmt.syncregion, first(ir.cfg.blocks[stmt.label].stmts))
         elseif isa(stmt, GotoIfNot)
             stmt = GotoIfNot(stmt.cond, first(ir.cfg.blocks[stmt.dest].stmts))
         elseif isa(stmt, PhiNode)

base/compiler/ssair/passes.jl

@@ -1146,12 +1146,12 @@ function cfg_simplify!(ir::IRCode)
         # Compute (renamed) successors and predecessors given (renamed) block
         function compute_succs(i)
             orig_bb = follow_merged_succ(result_bbs[i])
-            return map(i -> bb_rename_succ[i], bbs[orig_bb].succs)
+            return Int[bb_rename_succ[i] for i in bbs[orig_bb].succs]
         end
         function compute_preds(i)
             orig_bb = result_bbs[i]
             preds = bbs[orig_bb].preds
-            return map(pred -> bb_rename_pred[pred], preds)
+            return Int[bb_rename_pred[pred] for pred in preds]
         end
 
         BasicBlock[

base/compiler/ssair/queries.jl

@@ -9,6 +9,9 @@ function stmt_effect_free(@nospecialize(stmt), @nospecialize(rt), src, sptypes::
     isa(stmt, ReturnNode) && return false
     isa(stmt, GotoNode) && return false
     isa(stmt, GotoIfNot) && return false
+    isa(stmt, DetachNode) && return false
+    isa(stmt, ReattachNode) && return false
+    isa(stmt, SyncNode) && 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)