Data Dependency Analysis for Control Flow Regions

dace/codegen/tools/type_inference.py

@@ -420,6 +420,8 @@ def _Attribute(t, symbols, inferred_symbols):
     if (isinstance(inferred_type, dtypes.pointer) and isinstance(inferred_type.base_type, dtypes.struct) and
             t.attr in inferred_type.base_type.fields):
         return inferred_type.base_type.fields[t.attr]
+    elif isinstance(inferred_type, dtypes.struct) and t.attr in inferred_type.fields:
+        return inferred_type.fields[t.attr]
     return inferred_type
 
 

dace/memlet.py

@@ -147,8 +147,20 @@ def __init__(self,
 
     @staticmethod
     def from_memlet(memlet: 'Memlet') -> 'Memlet':
-        sbs = subsets.Range(memlet.subset.ndrange()) if memlet.subset is not None else None
-        osbs = subsets.Range(memlet.other_subset.ndrange()) if memlet.other_subset is not None else None
+        if memlet.subset is not None:
+            if isinstance(memlet.subset, subsets.SubsetUnion):
+                sbs = subsets.SubsetUnion(memlet.subset.subset_list)
+            else:
+                sbs = subsets.Range(memlet.subset.ndrange())
+        else:
+            sbs = None
+        if memlet.other_subset is not None:
+            if isinstance(memlet.other_subset, subsets.SubsetUnion):
+                osbs = subsets.SubsetUnion(memlet.other_subset.subset_list)
+            else:
+                osbs = subsets.Range(memlet.other_subset.ndrange())
+        else:
+            osbs = None
         result = Memlet(data=memlet.data,
                         subset=sbs,
                         other_subset=osbs,

dace/sdfg/propagation.py

@@ -747,7 +747,7 @@ def propagate_states(sdfg: 'SDFG', concretize_dynamic_unbounded: bool = False) -
     if sdfg.using_explicit_control_flow:
         # Avoid cyclic imports
         from dace.transformation.pass_pipeline import Pipeline
-        from dace.transformation.passes.analysis import StatePropagation
+        from dace.transformation.passes.analysis.propagation import StatePropagation
 
         state_prop_pipeline = Pipeline([StatePropagation()])
         state_prop_pipeline.apply_pass(sdfg, {})
@@ -1456,24 +1456,48 @@ def propagate_subset(memlets: List[Memlet],
         else:
             subset = md.subset
 
-        for pclass in MemletPattern.extensions():
-            pattern = pclass()
-            if pattern.can_be_applied([subset], variable_context, rng, [md]):
-                tmp_subset = pattern.propagate(arr, [subset], rng)
-                break
+        if isinstance(subset, subsets.SubsetUnion):
+            tmp_subset_list = []
+            for sub in subset.subset_list:
+                for pclass in MemletPattern.extensions():
+                    pattern = pclass()
+                    if pattern.can_be_applied([sub], variable_context, rng, [md]):
+                        sub_tmp_subset = pattern.propagate(arr, [sub], rng)
+                        break
+                else:
+                    # No patterns found. Emit a warning and propagate the entire
+                    # array whenever symbols are used
+                    warnings.warn('Cannot find appropriate memlet pattern to '
+                                'propagate %s through %s' % (str(sub), str(rng)))
+                    entire_array = subsets.Range.from_array(arr)
+                    paramset = set(map(str, params))
+                    # Fill in the entire array only if one of the parameters appears in the
+                    # free symbols list of the subset dimension
+                    sub_tmp_subset = subsets.Range([
+                        ea if any(set(map(str, _freesyms(sd))) & paramset for sd in s) else s
+                        for s, ea in zip(sub, entire_array)
+                    ])
+                tmp_subset_list.append(sub_tmp_subset)
+            tmp_subset = subsets.SubsetUnion(tmp_subset_list)
         else:
-            # No patterns found. Emit a warning and propagate the entire
-            # array whenever symbols are used
-            warnings.warn('Cannot find appropriate memlet pattern to '
-                          'propagate %s through %s' % (str(subset), str(rng)))
-            entire_array = subsets.Range.from_array(arr)
-            paramset = set(map(str, params))
-            # Fill in the entire array only if one of the parameters appears in the
-            # free symbols list of the subset dimension
-            tmp_subset = subsets.Range([
-                ea if any(set(map(str, _freesyms(sd))) & paramset for sd in s) else s
-                for s, ea in zip(subset, entire_array)
-            ])
+            for pclass in MemletPattern.extensions():
+                pattern = pclass()
+                if pattern.can_be_applied([subset], variable_context, rng, [md]):
+                    tmp_subset = pattern.propagate(arr, [subset], rng)
+                    break
+            else:
+                # No patterns found. Emit a warning and propagate the entire
+                # array whenever symbols are used
+                warnings.warn('Cannot find appropriate memlet pattern to '
+                            'propagate %s through %s' % (str(subset), str(rng)))
+                entire_array = subsets.Range.from_array(arr)
+                paramset = set(map(str, params))
+                # Fill in the entire array only if one of the parameters appears in the
+                # free symbols list of the subset dimension
+                tmp_subset = subsets.Range([
+                    ea if any(set(map(str, _freesyms(sd))) & paramset for sd in s) else s
+                    for s, ea in zip(subset, entire_array)
+                ])
 
         # Union edges as necessary
         if new_subset is None:

dace/sdfg/state.py

@@ -1208,6 +1208,11 @@ class ControlFlowBlock(BlockGraphView, abc.ABC):
     _sdfg: Optional['SDFG'] = None
     _parent_graph: Optional['ControlFlowRegion'] = None
 
+    _certain_reads: Dict[str, mm.Memlet]
+    _possible_reads: Dict[str, mm.Memlet]
+    _certain_writes: Dict[str, mm.Memlet]
+    _possible_writes: Dict[str, mm.Memlet]
+
     def __init__(self, label: str = '', sdfg: Optional['SDFG'] = None, parent: Optional['ControlFlowRegion'] = None):
         super(ControlFlowBlock, self).__init__()
         self._label = label
@@ -1218,6 +1223,10 @@ def __init__(self, label: str = '', sdfg: Optional['SDFG'] = None, parent: Optio
         self.pre_conditions = {}
         self.post_conditions = {}
         self.invariant_conditions = {}
+        self._certain_reads = dict()
+        self._possible_reads = dict()
+        self._certain_writes = dict()
+        self._possible_writes = dict()
 
         self.guid = generate_element_id(self)
 

dace/sdfg/utils.py

@@ -867,16 +867,16 @@ def get_view_edge(state: SDFGState, view: nd.AccessNode) -> gr.MultiConnectorEdg
         return None
 
     in_edge = in_edges[0]
-    out_edge = out_edges[0]
+    out_edge = out_edges[0] if len(out_edges) > 0 else None
 
     # If there is one incoming and one outgoing edge, and one leads to a code
     # node, the one that leads to an access node is the viewed data.
     inmpath = state.memlet_path(in_edge)
-    outmpath = state.memlet_path(out_edge)
+    outmpath = state.memlet_path(out_edge) if out_edge else None
     src_is_data, dst_is_data = False, False
     if isinstance(inmpath[0].src, nd.AccessNode):
         src_is_data = True
-    if isinstance(outmpath[-1].dst, nd.AccessNode):
+    if outmpath and isinstance(outmpath[-1].dst, nd.AccessNode):
         dst_is_data = True
 
     if src_is_data and not dst_is_data: