Fixed Cycle detection algorithm from recursive to iterative

Author: Pranav-Agarwal0612

drgn_tools/deadlock.py

@@ -5,6 +5,7 @@
 from typing import List
 from typing import Optional
 from typing import Set
+from typing import Tuple
 from typing import Union
 
 from drgn import Object
@@ -23,14 +24,16 @@ def from_object(cls, object: Object):
             if type_.kind == TypeKind.POINTER:
                 object = object[0]
                 type_ = object.type_
-
             if type_.kind != TypeKind.STRUCT or object.address_ is None:
                 raise ValueError(
                     "A reference object of type struct is expected"
                 )
 
-            object_node = cls(name=type_.typename(), address=object.address_)
-            object_node.object = object
+            object_node = cls.get_node(
+                name=type_.typename(), address=object.address_
+            )
+            if not object_node.object:
+                object_node.object = object
             return object_node
 
         def __init__(
@@ -50,50 +53,63 @@ def __hash__(self):
             # Will be useful in case of Objects which don't exist in memory (example : CPU) - can set address=0 and name='CPU10'
             return hash((self.name, self.address))
 
+        @classmethod
+        def get_node(cls, name: str, address: int):
+            hash_value = hash((name, address))
+            if hash_value in DependencyGraph.node_map:
+                return DependencyGraph.node_map[hash_value]
+            return cls(name, address)
+
+    node_map: Dict[int, Node] = dict()
+
     def __init__(self):
-        self.node_map: Dict[int, self.Node] = dict()
+        pass
 
     def add_edge(self, src: Node, dst: Node) -> None:
         if hash(src) not in self.node_map:
             self.node_map[hash(src)] = src
         else:
             src = self.node_map[hash(src)]
-
         if hash(dst) not in self.node_map:
             self.node_map[hash(dst)] = dst
         else:
             dst = self.node_map[hash(dst)]
 
         if dst not in src.blocked_nodes:
             src.blocked_nodes.append(dst)
-
         if src not in dst.depends_on:
             dst.depends_on.append(src)
 
     def detect_cycle(self) -> Optional[List[List[Node]]]:
         visited: Set[DependencyGraph.Node] = set()
-        path: List[DependencyGraph.Node] = []
         cycles: List[List[DependencyGraph.Node]] = []
-
-        def dfs(node: DependencyGraph.Node) -> None:
-            # If the node is currently being visited (part of the current DFS path), we've found a cycle
-            if node in path:
-                cycle_start = path.index(node)
-                cycles.append(path[cycle_start:] + [node])
-                return
-
-            # If it's fully visited, no need to process this node again
-            if node in visited:
-                return
-
-            visited.add(node)
-            path.append(node)
-
-            # Recursively visit all neighboring nodes
-            for neighbor in node.depends_on:
-                dfs(neighbor)
-
-            path.pop()
+        parent: Dict[int, Optional[DependencyGraph.Node]] = dict()
+
+        def dfs(start_node: DependencyGraph.Node) -> None:
+            stack: List[
+                Tuple[DependencyGraph.Node, Optional[DependencyGraph.Node]]
+            ] = [(start_node, None)]
+            while stack:
+                node, parent_node = stack.pop()
+                if node in visited:
+                    continue
+                visited.add(node)
+                parent[hash(node)] = parent_node
+
+                for neighbour in node.depends_on:
+                    if neighbour not in visited:
+                        stack.append((neighbour, node))
+                    else:
+                        cycle: List[DependencyGraph.Node] = []
+                        cycle.append(neighbour)
+                        temp: Optional[DependencyGraph.Node] = node
+                        while temp and temp != neighbour:
+                            cycle.append(temp)
+                            temp = parent[hash(temp)]
+                        cycle.append(neighbour)
+                        cycle.reverse()
+                        cycles.append(cycle)
+                        return
 
         # Run DFS for all nodes in the graph
         for node in self.node_map.values():
@@ -112,12 +128,9 @@ def add_args(self, parser: argparse.ArgumentParser) -> None:
     def run(self, prog: Program, args: argparse.Namespace) -> None:
         graph: DependencyGraph = DependencyGraph()
         get_mutex_lock_info(prog, stack=False, graph=graph)
-
         cycles = graph.detect_cycle()
-
         if not cycles:
             print("No cycle found")
             return
-
         for cycle in cycles:
             print(cycle)