clean up debug statements prune cycle

src/graph_scheduler/condition.py

@@ -2623,39 +2623,38 @@ def _handle_remove_new_self_referential_edges(self, graph, base_graph):
     def _is_required_edge(self, sender, receiver):
         return False
 
-    def _prune_owner_edge(self, base_graph, graph, cycle, owner_idx):
+    def _prune_owner_edge(self, owner_idx, cycle, graph, base_graph):
         len_cycle = len(cycle)
         assert cycle[owner_idx % len_cycle] is self.owner
 
         owner_is_full_ancestor = True
         owner_is_full_descendant = True
+
+        # if any of self.nodes are in cycle, only check if owner is an
+        # ancestor/descendant of those nodes, otherwise check all
         nodes_in_cycle = [n for n in self.nodes if n in cycle]
         nodes_to_check = nodes_in_cycle if len(nodes_in_cycle) else self.nodes
+        ancestors = get_ancestors(base_graph)
+        descendants = get_descendants(base_graph)
         for n in nodes_to_check:
-            logger.debug(f'ancs of {n} {get_ancestors(base_graph)[n]}')
-            logger.debug(f'descs of {n} {get_descendants(base_graph)[n]}')
-
-            if self.owner not in get_ancestors(base_graph)[n]:
+            if self.owner not in ancestors[n]:
                 owner_is_full_ancestor = False
-                logger.debug(f'{self.owner} not ancestor of {n}')
-            if self.owner not in get_descendants(base_graph)[n]:
+            if self.owner not in descendants[n]:
                 owner_is_full_descendant = False
-                logger.debug(f'{self.owner} not descendant of {n}')
 
+        # if owner is an ancestor of all relevant nodes or they are
+        # unrelated/mixed, prune its outgoing edge. This favors
+        # displacing owner more than other nodes.
         if owner_is_full_ancestor or not owner_is_full_descendant:
-            logger.debug(f'f anc {owner_is_full_ancestor}  f d {owner_is_full_descendant}')
             sender = self.owner
             receiver = cycle[(owner_idx + 1) % len_cycle]
         else:
-            logger.debug(f'{self.owner} is desc of all')
             sender = cycle[(owner_idx - 1) % len_cycle]
             receiver = self.owner
 
-        logger.debug(f'sender {sender} receiver {receiver}')
-
         if sender in graph[receiver] and not self._is_required_edge(sender, receiver):
             graph[receiver].remove(sender)
-            logger.debug(f'Pruning cycle from {sender} to {receiver}')
+            logger.debug(f'Pruning edge {sender} to {receiver} in cycle {cycle}')
 
     def _handle_prune_cycles(self, graph, base_graph):
         if not self.prune_cycles:
@@ -2671,16 +2670,14 @@ def _handle_prune_cycles(self, graph, base_graph):
                     logger.debug(f'Cycle {c} already resolved')
                     continue
 
-                logger.debug(f'cycle {c}')
                 len_c = len(c)
                 for i in range(len_c):
                     sender = c[i]
                     receiver_idx = (i + 1) % len_c
                     receiver = c[receiver_idx]
-                    logger.debug(f'sender {sender} recevier {receiver}')
 
                     if receiver is self.owner:
-                        self._prune_owner_edge(base_graph, graph, c, receiver_idx)
+                        self._prune_owner_edge(receiver_idx, c, graph, base_graph)
                     elif (
                         receiver in base_graph[sender]
                         and sender is not self.owner
@@ -2689,12 +2686,15 @@ def _handle_prune_cycles(self, graph, base_graph):
                         # may have been removed in another cycle
                         if sender in graph[receiver]:
                             graph[receiver].remove(sender)
-                            logger.debug(f'Pruning non-owner simple cycle from {sender} to {receiver}')
+                            logger.debug(
+                                f'Pruning edge {sender} to {receiver} in simple'
+                                f'cycle not involving owner {c}'
+                            )
 
                 cycles = list(get_simple_cycles(graph))
 
             if prev_cycles == cycles:
-                logger.debug(f'Failed to prune all cycles stage 1, remaining: {cycles}')
+                logger.debug(f'Failed to prune all cycles, remaining: {cycles}')
                 break
 
             prev_cycles = cycles