Added quality improvements to graph: improved naming, auto vdd/gnd removal

compiler/base/graph_util.py

@@ -9,28 +9,43 @@ import debug
 from vector import vector
 from pin_layout import pin_layout
 
-class graph():
+class timing_graph():
-    """Implements a directed graph"""
+    """Implements a directed graph
+       Nodes are currently just Strings.
+    """
     
     def __init__(self):
-        self.graph = defaultdict(list)
+        self.graph = defaultdict(set)
 
-    def add_edge(self, u, v):
+    def add_edge(self, src_node, dest_node):
         """Adds edge to graph. Nodes added as well if they do not exist."""
-        if v not in self.graph[u]:
+        src_node = src_node.lower()
-            self.graph[u].append(v)
+        dest_node = dest_node.lower()
+        self.graph[src_node].add(dest_node)
 
-    def add_node(self, u):
+    def add_node(self, node):
         """Add node to graph with no edges"""
-        if not u in self.graph:
+        node = node.lower()
-            self.graph[u] = []
+        if not node in self.graph:
+            self.graph[node] = set()
             
     def remove_edges(self, node):
         """Helper function to remove edges, useful for removing vdd/gnd"""
-        self.graph[node] = []    
+        node = node.lower()
+        self.graph[node] = set()    
             
-    def print_all_paths(self,s, d): 
+    def print_all_paths(self, src_node, dest_node, rmv_rail_nodes=True): 
-  
+        """Traverse all paths from source to destination"""
+        src_node = src_node.lower()
+        dest_node = dest_node.lower()
+        
+        #Remove vdd and gnd by default
+        #Will require edits if separate supplies are implemented.
+        if rmv_rail_nodes:
+            #Names are also assumed.
+            self.remove_edges('vdd')
+            self.remove_edges('gnd')
+        
         # Mark all the vertices as not visited 
         visited = set()
   
@@ -39,30 +54,30 @@ class graph():
         self.path_count = 0
   
         # Call the recursive helper function to print all paths 
-        self.print_all_paths_util(s, d,visited, path)     
+        self.print_all_paths_util(src_node, dest_node, visited, path)     
         debug.info(1, "Paths found={}".format(self.path_count))
             
-    def print_all_paths_util(self, u, d, visited, path): 
+    def print_all_paths_util(self, cur_node, dest_node, visited, path): 
-  
+        """Recursive function to find all paths in a Depth First Search manner"""
         # Mark the current node as visited and store in path 
-        visited.add(u)
+        visited.add(cur_node)
-        path.append(u) 
+        path.append(cur_node) 
   
         # If current vertex is same as destination, then print 
         # current path[] 
-        if u == d: 
+        if cur_node == dest_node: 
             debug.info(1,"{}".format(path)) 
             self.path_count+=1
         else: 
             # If current vertex is not destination 
             #Recur for all the vertices adjacent to this vertex 
-            for i in self.graph[u]: 
+            for node in self.graph[cur_node]: 
-                if i not in visited: 
+                if node not in visited: 
-                    self.print_all_paths_util(i, d, visited, path) 
+                    self.print_all_paths_util(node, dest_node, visited, path) 
                       
         # Remove current vertex from path[] and mark it as unvisited 
         path.pop() 
-        visited.remove(u)        
+        visited.remove(cur_node)        
             
     def __str__(self):
         """ override print function output """

compiler/tests/21_hspice_delay_test.py

@@ -44,13 +44,13 @@ class timing_sram_test(openram_test):
         
         debug.info(1,'pins={}'.format(s.s.pins))
         import graph_util
-        graph = graph_util.graph()
+        graph = graph_util.timing_graph()
         pins=['DIN0[0]', 'ADDR0[0]', 'ADDR0[1]', 'ADDR0[2]', 'ADDR0[3]', 'csb0', 'web0', 'clk0', 'DOUT0[0]', 'vdd', 'gnd']
         s.s.build_graph(graph,"Xsram",pins)
-        graph.remove_edges('vdd')
-        graph.remove_edges('gnd')
         #debug.info(1,"{}".format(graph))
         graph.print_all_paths('clk0', 'DOUT0[0]')
+        # import sys
+        # sys.exit(1)
 
         tempspice = OPTS.openram_temp + "temp.sp"
         s.sp_write(tempspice)