Complete Transition to Control Flow Regions

.github/workflows/pyFV3-ci.yml

@@ -1,12 +1,17 @@
 name: NASA/NOAA pyFV3 repository build test
 
+# Temporarily disabled for main, and instead applied to a specific DaCe v1 maintenance branch (v1/maintenance). Once
+# the FV3 bridge has been adapted to DaCe v1, this will need to be reverted back to apply to main.
 on:
   push:
-    branches: [ main, ci-fix ]
+    #branches: [ main, ci-fix ]
+    branches: [ v1/maintenance, ci-fix ]
   pull_request:
-    branches: [ main, ci-fix ]
+    #branches: [ main, ci-fix ]
+    branches: [ v1/maintenance, ci-fix ]
   merge_group:
-    branches: [ main, ci-fix ]
+    #branches: [ main, ci-fix ]
+    branches: [ v1/maintenance, ci-fix ]
 
 defaults:
     run:

dace/codegen/control_flow.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2021 ETH Zurich and the DaCe authors. All rights reserved.
+# Copyright 2019-2024 ETH Zurich and the DaCe authors. All rights reserved.
 """ 
 Various classes to facilitate the code generation of structured control 
 flow elements (e.g., ``for``, ``if``, ``while``) from state machines in SDFGs. 
@@ -200,7 +200,10 @@ class BreakCFBlock(ControlFlow):
     block: BreakBlock
 
     def as_cpp(self, codegen, symbols) -> str:
-        return 'break;\n'
+        cfg = self.block.parent_graph
+        expr = '__state_{}_{}:;\n'.format(cfg.cfg_id, self.block.label)
+        expr += 'break;\n'
+        return expr
 
     @property
     def first_block(self) -> BreakBlock:
@@ -214,7 +217,10 @@ class ContinueCFBlock(ControlFlow):
     block: ContinueBlock
 
     def as_cpp(self, codegen, symbols) -> str:
-        return 'continue;\n'
+        cfg = self.block.parent_graph
+        expr = '__state_{}_{}:;\n'.format(cfg.cfg_id, self.block.label)
+        expr += 'continue;\n'
+        return expr
 
     @property
     def first_block(self) -> ContinueBlock:
@@ -228,7 +234,10 @@ class ReturnCFBlock(ControlFlow):
     block: ReturnBlock
 
     def as_cpp(self, codegen, symbols) -> str:
-        return 'return;\n'
+        cfg = self.block.parent_graph
+        expr = '__state_{}_{}:;\n'.format(cfg.cfg_id, self.block.label)
+        expr += 'return;\n'
+        return expr
 
     @property
     def first_block(self) -> ReturnBlock:
@@ -316,7 +325,13 @@ def as_cpp(self, codegen, symbols) -> str:
                 # One unconditional edge
                 if (len(out_edges) == 1 and out_edges[0].data.is_unconditional()):
                     continue
-                expr += f'goto __state_exit_{sdfg.cfg_id};\n'
+                if self.region:
+                    expr += f'goto __state_exit_{self.region.cfg_id};\n'
+                else:
+                    expr += f'goto __state_exit_{sdfg.cfg_id};\n'
+
+        if self.region and not isinstance(self.region, SDFG):
+            expr += f'__state_exit_{self.region.cfg_id}:;\n'
 
         return expr
 
@@ -575,6 +590,8 @@ def as_cpp(self, codegen, symbols) -> str:
                 expr += _clean_loop_body(self.body.as_cpp(codegen, symbols))
                 expr += '\n}\n'
 
+        expr += f'__state_exit_{self.loop.cfg_id}:;\n'
+
         return expr
 
     @property
@@ -1022,21 +1039,16 @@ def _structured_control_flow_traversal_with_regions(cfg: ControlFlowRegion,
                                                     start: Optional[ControlFlowBlock] = None,
                                                     stop: Optional[ControlFlowBlock] = None,
                                                     generate_children_of: Optional[ControlFlowBlock] = None,
-                                                    branch_merges: Optional[Dict[ControlFlowBlock,
-                                                                                 ControlFlowBlock]] = None,
                                                     ptree: Optional[Dict[ControlFlowBlock, ControlFlowBlock]] = None,
                                                     visited: Optional[Set[ControlFlowBlock]] = None):
-    if branch_merges is None:
-        branch_merges = cfg_analysis.branch_merges(cfg)
-
     if ptree is None:
         ptree = cfg_analysis.block_parent_tree(cfg, with_loops=False)
 
     start = start if start is not None else cfg.start_block
 
-    def make_empty_block():
+    def make_empty_block(region):
         return GeneralBlock(dispatch_state, parent_block,
-                            last_block=False, region=None, elements=[], gotos_to_ignore=[],
+                            last_block=False, region=region, elements=[], gotos_to_ignore=[],
                             gotos_to_break=[], gotos_to_continue=[], assignments_to_ignore=[], sequential=True)
 
     # Traverse states in custom order
@@ -1063,18 +1075,18 @@ def make_empty_block():
             cfg_block = GeneralConditionalScope(dispatch_state, parent_block, False, node, [])
             for cond, branch in node.branches:
                 if branch is not None:
-                    body = make_empty_block()
+                    body = make_empty_block(branch)
                     body.parent = cfg_block
                     _structured_control_flow_traversal_with_regions(branch, dispatch_state, body)
                     cfg_block.branch_bodies.append((cond, body))
         elif isinstance(node, ControlFlowRegion):
             if isinstance(node, LoopRegion):
-                body = make_empty_block()
+                body = make_empty_block(node)
                 cfg_block = GeneralLoopScope(dispatch_state, parent_block, False, node, body)
                 body.parent = cfg_block
                 _structured_control_flow_traversal_with_regions(node, dispatch_state, body)
             else:
-                cfg_block = make_empty_block()
+                cfg_block = make_empty_block(node)
                 cfg_block.region = node
                 _structured_control_flow_traversal_with_regions(node, dispatch_state, cfg_block)
 
@@ -1132,7 +1144,7 @@ def structured_control_flow_tree(sdfg: SDFG, dispatch_state: Callable[[SDFGState
     :param sdfg: The SDFG to iterate over.
     :return: Control-flow block representing the entire SDFG.
     """
-    if sdfg.root_sdfg.using_experimental_blocks:
+    if sdfg.root_sdfg.using_explicit_control_flow:
         return structured_control_flow_tree_with_regions(sdfg, dispatch_state)
 
     # Avoid import loops

dace/codegen/targets/framecode.py

@@ -485,7 +485,7 @@ def dispatch_state(state: SDFGState) -> str:
             states_generated.add(state)  # For sanity check
             return stream.getvalue()
 
-        if sdfg.root_sdfg.recheck_using_experimental_blocks():
+        if sdfg.root_sdfg.recheck_using_explicit_control_flow():
             # Use control flow blocks embedded in the SDFG to generate control flow.
             cft = cflow.structured_control_flow_tree_with_regions(sdfg, dispatch_state)
         elif config.Config.get_bool('optimizer', 'detect_control_flow'):
@@ -697,19 +697,7 @@ def determine_allocation_lifetime(self, top_sdfg: SDFG):
                     if name in self.free_symbols(isedge.data):
                         multistate = True
                 for cfg in sdfg.all_control_flow_regions():
-                    block_syms = set()
-                    if isinstance(cfg, LoopRegion):
-                        block_syms |= symbolic.free_symbols_and_functions(cfg.loop_condition.as_string)
-                        update_stmt = loop_analysis.get_update_assignment(cfg)
-                        init_stmt = loop_analysis.get_init_assignment(cfg)
-                        if update_stmt:
-                            block_syms |= symbolic.free_symbols_and_functions(update_stmt)
-                        if init_stmt:
-                            block_syms |= symbolic.free_symbols_and_functions(init_stmt)
-                    elif isinstance(cfg, ConditionalBlock):
-                        for cond, _ in cfg.branches:
-                            if cond is not None:
-                                block_syms |= symbolic.free_symbols_and_functions(cond.as_string)
+                    block_syms = cfg.used_symbols(all_symbols=True, with_contents=False)
                     if name in block_syms:
                         multistate = True
 

dace/frontend/fortran/fortran_parser.py

@@ -29,7 +29,7 @@ class AST_translator:
     """  
     This class is responsible for translating the internal AST into a SDFG.
     """
-    def __init__(self, ast: ast_components.InternalFortranAst, source: str, use_experimental_cfg_blocks: bool = False):
+    def __init__(self, ast: ast_components.InternalFortranAst, source: str, use_explicit_cf: bool = False):
         """
         :ast: The internal fortran AST to be used for translation
         :source: The source file name from which the AST was generated
@@ -69,7 +69,7 @@ def __init__(self, ast: ast_components.InternalFortranAst, source: str, use_expe
             ast_internal_classes.Allocate_Stmt_Node: self.allocate2sdfg,
             ast_internal_classes.Break_Node: self.break2sdfg,
         }
-        self.use_experimental_cfg_blocks = use_experimental_cfg_blocks
+        self.use_explicit_cf = use_explicit_cf
 
     def get_dace_type(self, type):
         """  
@@ -271,7 +271,7 @@ def forstmt2sdfg(self, node: ast_internal_classes.For_Stmt_Node, sdfg: SDFG, cfg
         :param sdfg: The SDFG to which the node should be translated
         """
 
-        if not self.use_experimental_cfg_blocks:
+        if not self.use_explicit_cf:
             declloop = False
             name = "FOR_l_" + str(node.line_number[0]) + "_c_" + str(node.line_number[1])
             begin_state = ast_utils.add_simple_state_to_sdfg(self, cfg, "Begin" + name)
@@ -1103,7 +1103,7 @@ def create_sdfg_from_string(
     source_string: str,
     sdfg_name: str,
     normalize_offsets: bool = False,
-    use_experimental_cfg_blocks: bool = False
+    use_explicit_cf: bool = False
 ):
     """
     Creates an SDFG from a fortran file in a string
@@ -1133,7 +1133,7 @@ def create_sdfg_from_string(
 
     program = ast_transforms.ForDeclarer().visit(program)
     program = ast_transforms.IndexExtractor(program, normalize_offsets).visit(program)
-    ast2sdfg = AST_translator(own_ast, __file__, use_experimental_cfg_blocks)
+    ast2sdfg = AST_translator(own_ast, __file__, use_explicit_cf)
     sdfg = SDFG(sdfg_name)
     ast2sdfg.top_level = program
     ast2sdfg.globalsdfg = sdfg
@@ -1148,11 +1148,11 @@ def create_sdfg_from_string(
     sdfg.parent_sdfg = None
     sdfg.parent_nsdfg_node = None
     sdfg.reset_cfg_list()
-    sdfg.using_experimental_blocks = use_experimental_cfg_blocks
+    sdfg.using_explicit_control_flow = use_explicit_cf
     return sdfg
 
 
-def create_sdfg_from_fortran_file(source_string: str, use_experimental_cfg_blocks: bool = False):
+def create_sdfg_from_fortran_file(source_string: str, use_explicit_cf: bool = False):
     """
     Creates an SDFG from a fortran file
     :param source_string: The fortran file name
@@ -1180,11 +1180,11 @@ def create_sdfg_from_fortran_file(source_string: str, use_experimental_cfg_block
 
     program = ast_transforms.ForDeclarer().visit(program)
     program = ast_transforms.IndexExtractor(program).visit(program)
-    ast2sdfg = AST_translator(own_ast, __file__, use_experimental_cfg_blocks)
+    ast2sdfg = AST_translator(own_ast, __file__, use_explicit_cf)
     sdfg = SDFG(source_string)
     ast2sdfg.top_level = program
     ast2sdfg.globalsdfg = sdfg
     ast2sdfg.translate(program, sdfg)
 
-    sdfg.using_experimental_blocks = use_experimental_cfg_blocks
+    sdfg.using_explicit_control_flow = use_explicit_cf
     return sdfg

dace/frontend/python/interface.py

@@ -44,7 +44,7 @@ def program(f: F,
             recompile: bool = True,
             distributed_compilation: bool = False,
             constant_functions=False,
-            use_experimental_cfg_blocks=True,
+            use_explicit_cf=True,
             **kwargs) -> Callable[..., parser.DaceProgram]:
     """
     Entry point to a data-centric program. For methods and ``classmethod``s, use
@@ -69,8 +69,7 @@ def program(f: F,
                                not depend on internal variables are constant.
                                This will hardcode their return values into the
                                resulting program.
-    :param use_experimental_cfg_blocks: If True, makes use of experimental CFG blocks susch as loop and conditional
-                                        regions.
+    :param use_explicit_cfl: If True, makes use of explicit control flow constructs.
     :note: If arguments are defined with type hints, the program can be compiled
            ahead-of-time with ``.compile()``.
     """
@@ -87,7 +86,7 @@ def program(f: F,
                               regenerate_code=regenerate_code,
                               recompile=recompile,
                               distributed_compilation=distributed_compilation,
-                              use_experimental_cfg_blocks=use_experimental_cfg_blocks)
+                              use_explicit_cf=use_explicit_cf)
 
 
 function = program

dace/frontend/python/parser.py

@@ -156,7 +156,7 @@ def __init__(self,
                  recompile: bool = True,
                  distributed_compilation: bool = False,
                  method: bool = False,
-                 use_experimental_cfg_blocks: bool = True):
+                 use_explicit_cf: bool = True):
         from dace.codegen import compiled_sdfg  # Avoid import loops
 
         self.f = f
@@ -176,7 +176,7 @@ def __init__(self,
         self.recreate_sdfg = recreate_sdfg
         self.regenerate_code = regenerate_code
         self.recompile = recompile
-        self.use_experimental_cfg_blocks = use_experimental_cfg_blocks
+        self.use_explicit_cf = use_explicit_cf
         self.distributed_compilation = distributed_compilation
 
         self.global_vars = _get_locals_and_globals(f)
@@ -494,10 +494,10 @@ def _parse(self, args, kwargs, simplify=None, save=False, validate=False) -> SDF
         # Obtain DaCe program as SDFG
         sdfg, cached = self._generate_pdp(args, kwargs, simplify=simplify)
 
-        if not self.use_experimental_cfg_blocks:
+        if not self.use_explicit_cf:
             for nsdfg in sdfg.all_sdfgs_recursive():
                 sdutils.inline_control_flow_regions(nsdfg)
-        sdfg.using_experimental_blocks = self.use_experimental_cfg_blocks
+        sdfg.using_explicit_control_flow = self.use_explicit_cf
 
         sdfg.reset_cfg_list()
 

dace/sdfg/analysis/schedule_tree/sdfg_to_tree.py

@@ -652,7 +652,7 @@ def as_schedule_tree(sdfg: SDFG, in_place: bool = False, toplevel: bool = True)
     #############################
 
     # Create initial tree from CFG
-    if sdfg.using_experimental_blocks:
+    if sdfg.using_explicit_control_flow:
         cfg: cf.ControlFlow = cf.structured_control_flow_tree_with_regions(sdfg, lambda _: '')
     else:
         cfg: cf.ControlFlow = cf.structured_control_flow_tree(sdfg, lambda _: '')

dace/sdfg/analysis/writeset_underapproximation.py

@@ -685,7 +685,7 @@ class UnderapproximateWritesDict:
                 Tuple[SDFGState, SDFGState, List[SDFGState], str, subsets.Range]] = field(default_factory=dict)
 
 
-@transformation.experimental_cfg_block_compatible
+@transformation.explicit_cf_compatible
 class UnderapproximateWrites(ppl.Pass):
 
     # Dictionary mapping each edge to a copy of the memlet of that edge with its write set underapproximated.

dace/sdfg/infer_types.py

@@ -1,7 +1,6 @@
 # Copyright 2019-2021 ETH Zurich and the DaCe authors. All rights reserved.
 from collections import defaultdict
 from dace import data, dtypes
-from dace.codegen.tools import type_inference
 from dace.memlet import Memlet
 from dace.sdfg import SDFG, SDFGState, nodes, validation
 from dace.sdfg import nodes

dace/sdfg/propagation.py

@@ -744,7 +744,7 @@ def propagate_states(sdfg: 'SDFG', concretize_dynamic_unbounded: bool = False) -
     :note: This operates on the SDFG in-place.
     """
 
-    if sdfg.using_experimental_blocks:
+    if sdfg.using_explicit_control_flow:
         # Avoid cyclic imports
         from dace.transformation.pass_pipeline import Pipeline
         from dace.transformation.passes.analysis import StatePropagation

dace/sdfg/replace.py

@@ -11,7 +11,6 @@
 from dace import dtypes, properties, symbolic
 from dace.codegen import cppunparse
 from dace.frontend.python.astutils import ASTFindReplace
-from dace.sdfg.state import ConditionalBlock, LoopRegion
 
 if TYPE_CHECKING:
     from dace.sdfg.state import StateSubgraphView
@@ -203,13 +202,4 @@ def replace_datadesc_names(sdfg: 'dace.SDFG', repl: Dict[str, str]):
                         edge.data.data = repl[edge.data.data]
 
         # Replace in loop or branch conditions:
-        if isinstance(cf, LoopRegion):
-            replace_in_codeblock(cf.loop_condition, repl)
-            if cf.update_statement:
-                replace_in_codeblock(cf.update_statement, repl)
-            if cf.init_statement:
-                replace_in_codeblock(cf.init_statement, repl)
-        elif isinstance(cf, ConditionalBlock):
-            for c, _ in cf.branches:
-                if c is not None:
-                    replace_in_codeblock(c, repl)
+        cf.replace_meta_accesses(repl)