GridTools
diff --git a/‎dace/sdfg/state.py‎
Lines changed: 1 addition & 1 deletion b/‎dace/sdfg/state.py‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎dace/sdfg/utils.py‎
Lines changed: 76 additions & 10 deletions b/‎dace/sdfg/utils.py‎
Lines changed: 76 additions & 10 deletions
diff --git a/‎dace/transformation/dataflow/wcr_conversion.py‎
Lines changed: 83 additions & 2 deletions b/‎dace/transformation/dataflow/wcr_conversion.py‎
Lines changed: 83 additions & 2 deletions
@@ -1086,7 +1086,7 @@ def data_nodes(self) -> List[nd.AccessNode]:
     def entry_node(self, node: nd.Node) -> Optional[nd.EntryNode]:
         for block in self.nodes():
             if node in block.nodes():
-                return block.exit_node(node)
+                return block.entry_node(node)
         return None
 
     def exit_node(self, entry_node: nd.EntryNode) -> Optional[nd.ExitNode]:
 
@@ -174,6 +174,64 @@ def dfs_topological_sort(G, sources=None, condition=None, reverse=False):
                 stack.pop()
 
 
+def _find_nodes_impl(
+    node_to_start: Node,
+    state: SDFGState,
+    forward: bool,
+    seen: Optional[Set[Node]],
+) -> Set[Node]:
+    to_scan: List[Node] = [node_to_start]
+    scanned_nodes: Set[Node] = set() if seen is None else seen
+    if forward:
+        get_edges = state.out_edges
+        get_node = lambda e: e.dst
+    else:
+        get_edges = state.in_edges
+        get_node = lambda e: e.src
+    while len(to_scan) != 0:
+        node_to_scan = to_scan.pop()
+        if node_to_scan in scanned_nodes:
+            continue
+        to_scan.extend(get_node(edge) for edge in get_edges(node_to_scan) if get_node(edge) not in scanned_nodes)
+        scanned_nodes.add(node_to_scan)
+    return scanned_nodes
+
+
+def find_downstream_nodes(node_to_start: Node, state: SDFGState, seen: Optional[Set[Node]] = None) -> Set[Node]:
+    """Find all downstream nodes of `node_to_start`.
+
+    The function will explore the state, similar to a BFS, just that the order in which the nodes of
+    the dataflow is explored is unspecific. It is possible to pass a `set` of nodes that should be
+    considered as already visited. It is important that the function will return the set of found
+    nodes. In case `seen` was passed that `set` will be updated in place and be returned.
+
+    :param node_to_start: Where to start the exploration of the state.
+    :param state: The state on which we operate on.
+    :param seen: The set of already seen nodes.
+
+    :note: See also `find_upstream_nodes()` in case the dataflow should be explored in the reverse direction.
+    """
+    return _find_nodes_impl(node_to_start=node_to_start, state=state, seen=seen, forward=True)
+
+
+def find_upstream_nodes(node_to_start: Node, state: SDFGState, seen: Optional[Set[Node]] = None) -> Set[Node]:
+    """Find all upstream nodes of `node_to_start`.
+
+    The function will explore the state, similar to a BFS, just that the order in which the nodes of
+    the dataflow is explored is unspecific. It is possible to pass a `set` of nodes that should be
+    considered as already visited. It is important that the function will return the set of found
+    nodes. In case `seen` was passed that `set` will be updated in place and be returned.
+
+    The main difference to `find_downstream_nodes()` is that the dataflow is traversed in reverse
+    order or "against the flow".
+
+    :param node_to_start: Where to start the exploration of the state.
+    :param state: The state on which we operate on.
+    :param seen: The set of already seen nodes.
+    """
+    return _find_nodes_impl(node_to_start=node_to_start, state=state, seen=seen, forward=False)
+
+
 class StopTraversal(Exception):
     """
     Special exception that stops DFS conditional traversal beyond the current node.
@@ -807,24 +865,32 @@ def get_all_view_edges(state: SDFGState, view: nd.AccessNode) -> List[gr.MultiCo
     if existent, else None
     """
     sdfg = state.parent
-    node = view
-    desc = sdfg.arrays[node.data]
+    previous_node = view
     result = []
+
+    desc = sdfg.arrays[previous_node.data]
+    forward = None
     while isinstance(desc, dt.View):
-        edge = get_view_edge(state, node)
+        edge = get_view_edge(state, previous_node)
         if edge is None:
             break
-        old_node = node
-        if edge.dst is view:
-            node = edge.src
+
+        if forward is None:
+            forward = edge.src is previous_node
+
+        if forward:
+            next_node = edge.dst
         else:
-            node = edge.dst
-        if node is old_node:
+            next_node = edge.src
+
+        if previous_node is next_node:
             break
-        if not isinstance(node, nd.AccessNode):
+        if not isinstance(next_node, nd.AccessNode):
             break
-        desc = sdfg.arrays[node.data]
+        desc = sdfg.arrays[next_node.data]
         result.append(edge)
+        previous_node = next_node
+
     return result
 
 
 
@@ -4,7 +4,7 @@
 import copy
 import re
 import copy
-from dace import nodes, dtypes, Memlet
+from dace import nodes, dtypes, Memlet, data
 from dace.frontend.python import astutils
 from dace.transformation import transformation
 from dace.sdfg import utils as sdutil
@@ -151,7 +151,7 @@ def apply(self, state: SDFGState, sdfg: SDFG):
 
         # If state fission is necessary to keep semantics, do it first
         if state.in_degree(input) > 0:
-            new_state = helpers.state_fission_after(state, tasklet)
+            new_state = self.isolate_tasklet(state)
         else:
             new_state = state
 
@@ -270,6 +270,87 @@ def apply(self, state: SDFGState, sdfg: SDFG):
             # At this point we are leading to an access node again and can
             # traverse further up
 
+    def isolate_tasklet(
+        self,
+        state: SDFGState,
+    ) -> SDFGState:
+        tlet: nodes.Tasklet = self.tasklet
+        newstate = state.parent_graph.add_state_after(state)
+
+        # Bookkeeping
+        nodes_to_move = set([tlet])
+        boundary_nodes = set()
+        orig_edges = set()
+
+        for edge in state.in_edges(tlet):
+            for e in state.memlet_path(edge):
+                nodes_to_move.add(e.src)
+                orig_edges.add(e)
+            if isinstance(e.src, nodes.AccessNode) and isinstance(e.src.desc(sdfg), data.View):
+                assert state.in_degree(e.src) > 0
+                view_edges = sdutil.get_all_view_edges(state, e.src)
+                for edge in view_edges:
+                    nodes_to_move.add(edge.src)
+                    orig_edges.add(edge)
+
+        # Find all consumer nodes of `tlet`.
+        for edge in state.edge_bfs(tlet):
+            nodes_to_move.add(edge.dst)
+            orig_edges.add(edge)
+
+            # If a consumer is not an AccessNode we also have to relocate its dependencies.
+            if not isinstance(edge.dst, nodes.AccessNode):
+                for iedge in state.in_edges(edge.dst):
+                    if iedge == edge:
+                        continue
+                    for e in state.memlet_path(iedge):
+                        nodes_to_move.add(e.src)
+                        orig_edges.add(e)
+
+        # Define boundary nodes
+        for node in nodes_to_move:
+            if isinstance(node, nodes.AccessNode):
+                for iedge in state.in_edges(node):
+                    if iedge.src not in nodes_to_move:
+                        boundary_nodes.add(node)
+                        break
+                if node in boundary_nodes:
+                    continue
+                for oedge in state.out_edges(node):
+                    if oedge.dst not in nodes_to_move:
+                        boundary_nodes.add(node)
+                        break
+
+        # Duplicate boundary nodes
+        new_nodes = {}
+        for node in boundary_nodes:
+            node_ = copy.deepcopy(node)
+            state.add_node(node_)
+            new_nodes[node] = node_
+
+        for edge in state.edges():
+            if edge.src in boundary_nodes and edge.dst in boundary_nodes:
+                state.add_edge(new_nodes[edge.src], edge.src_conn, new_nodes[edge.dst], edge.dst_conn,
+                               copy.deepcopy(edge.data))
+            elif edge.src in boundary_nodes:
+                state.add_edge(new_nodes[edge.src], edge.src_conn, edge.dst, edge.dst_conn, copy.deepcopy(edge.data))
+            elif edge.dst in boundary_nodes:
+                state.add_edge(edge.src, edge.src_conn, new_nodes[edge.dst], edge.dst_conn, copy.deepcopy(edge.data))
+
+        state.remove_nodes_from(nodes_to_move)
+
+        # Set the new parent state
+        # TODO: Note sure if `add_node()` does it on its own?
+        for node in nodes_to_move:
+            if isinstance(node, nodes.NestedSDFG):
+                node.sdfg.parent = newstate
+
+        newstate.add_nodes_from(nodes_to_move)
+        for e in orig_edges:
+            newstate.add_edge(e.src, e.src_conn, e.dst, e.dst_conn, e.data)
+
+        return newstate
+
 
 class WCRToAugAssign(transformation.SingleStateTransformation):
     """