fix gridding

CodeElements/Gridding/src/gridding.py

@@ -2,7 +2,6 @@
 ### Input:  a list of macros (each macro has a width and a height)
 ### Output: best choice of n_rows and n_cols
 
-
 import os
 from math import floor
 from math import ceil
@@ -22,6 +21,7 @@ class Grid:
         self.y_       = y
         self.placed_  = False  # if there is macro placed on the center of this grid
         self.macros_id_ = [] # the id of macros intersecting with this grid
+        self.macro_area = 0.0
 
 # Check if there is an overlap with other placed macros
 def CheckOverlap(lx, ly, ux, uy, macro_box):
@@ -33,19 +33,30 @@ def CheckOverlap(lx, ly, ux, uy, macro_box):
             pass
         else:
             return True  # there is an overlap
-
     return False
 
 
+# Get overlap area
+def GetOverlapArea(box_a, box_b):
+    box_a_lx, box_a_ly, box_a_ux, box_a_uy = box_a
+    box_b_lx, box_b_ly, box_b_ux, box_b_uy = box_b
+    if (box_a_lx >= box_b_ux or box_a_ly >= box_b_uy or box_a_ux <= box_b_lx or box_a_uy <= box_b_ly):
+        return 0.0
+    else:
+        width = min(box_a_ux, box_b_ux) - max(box_a_lx, box_b_lx)
+        height = min(box_a_uy, box_b_uy) - max(box_a_ly, box_b_ly)
+        return width * height
 
 # Place macros one by one
 # n = num_cols
 def PlaceMacros(macro_map, grid_list, chip_width, chip_height, n):
     ### All the macro must be placed on the center of one grid
-
     #Initialize the position of macros
+    ver_sum = 0.0
+    ver_span_sum = 0.0
+    hor_sum = 0.0
+    hor_span_sum = 0.0
     macro_bbox = []
-
     # Place macro one by one
     for key, value in macro_map.items():
         width = value[0]
@@ -55,7 +66,6 @@ def PlaceMacros(macro_map, grid_list, chip_width, chip_height, n):
         for grid in grid_list:
             if (grid.placed_ == True):
                 continue # this grid has been occupied
-
             # if the macro is placed on this
             x = grid.x_
             y = grid.y_
@@ -67,12 +77,10 @@ def PlaceMacros(macro_map, grid_list, chip_width, chip_height, n):
             # check if the macro is within the outline
             if (ux > chip_width or uy > chip_height):
                 continue
-
             # check if there is an overlap with other macros
             if (CheckOverlap(lx, ly, ux, uy, macro_bbox) == True):
                 continue
 
-
             # place current macro on this grid
             grid.placed_ = True
             placed_flag  = True
@@ -91,22 +99,43 @@ def PlaceMacros(macro_map, grid_list, chip_width, chip_height, n):
                 for j in range(min_col_id, max_col_id + 1):
                     grid_id = i * n + j # n is the num_cols
                     grid_list[grid_id].macros_id_.append(macro_id)
+                    grid_box = [i * grid_width, j * grid_height, (i + 1) * grid_width, (j + 1) * grid_height]
+                    overlap_area = GetOverlapArea(grid_box, [lx, ly, ux, uy])
+                    grid_list[grid_id].macro_area += overlap_area
+
+            ver_sum += height
+            ver_span_sum += (max_row_id + 1 - min_row_id) * grid_height
+            hor_sum += width
+            hor_span_sum += (max_col_id + 1 - min_col_id) * grid_width
             break # stop search remaining candidates
 
         # cannot find a valid position for the macro
         if (placed_flag == False):
-            return False
+            return False, [0.0, 0.0, 0.0, 0.0]
 
-    return  True
+    return  True, [ver_sum, ver_span_sum, hor_sum, hor_span_sum]
 
 # Define the gridding function
 def Gridding(macro_width_list, macro_height_list,
-             chip_width, chip_height, tolerance = 0.1,
-             min_n_rows = 10, min_n_cols = 10,
-             max_n_rows = 100, max_n_cols = 100,
-             max_rows_times_cols = 3000,
-             min_rows_times_cols = 500,
-             max_aspect_ratio = 1.5):
+             chip_width, chip_height,
+             min_n_rows = 10,  min_n_cols = 10,
+             max_n_rows = 128, max_n_cols = 128,
+             min_num_grid_cells = 500,
+             max_num_grid_cells = 2500,
+             max_aspect_ratio = 1.5,
+             tolerance = 0.05):
+    """
+    Arguments:
+        macro_width_list, macro_height_list :  macro information
+        chip_width, chip_height : canvas size or core size of the chip
+        min_n_rows, min_n_cols : mininum number of rows/cols sweep
+        max_n_rows, max_n_rows : maximum number of rows/cols sweep
+        min_num_grid_cells, max_num_grid_cells :  mininum or maxinum grid cells
+        max_aspect_ratio : maximum aspect ratio of a grid cell (either w/h or h/w)
+        tolerance : tolerance to choose lower number of grids
+    Return:
+      the best number of rows and cols
+    """
     ### Sort all the macros in a non-decreasing order
     if (len(macro_width_list) != len(macro_height_list)):
       print("[Error] The macro information is wrong!!!")
@@ -116,30 +145,34 @@ def Gridding(macro_width_list, macro_height_list,
     macro_map = {  }
     for i in range(len(macro_width_list)):
         macro_map[i] = [macro_width_list[i], macro_height_list[i]]
-
     macro_map = dict(sorted(macro_map.items(), key=lambda item: item[1][0] * item[1][1], reverse = True))
-    macro_bbox = [] # (lx, ly, ux, uy) for each bounding box
 
+    ### Print information
     print("*"*80)
-    print("[INFO] Outline Information :  outline_width =", chip_width,  "  outline_height =", chip_height)
+    print("[INFO] Canvas Information :  canvas_width =", chip_width,  "canvas_height =", chip_height)
     print("\n")
     print("[INFO] Sorted Macro Information")
     for key, value in macro_map.items():
-        print("macro_" + str(key), "  macro_width =", round(value[0], 2), "  macro_height =", round(value[1], 2), "  macro_area =", round(value[0] * value[1], 2))
+        line = "macro_" + str(key) + " "
+        line += "macro_width = " + str(round(value[0], 2)) + " "
+        line += "macro_height = " + str(round(value[1], 2)) + " "
+        line += "macro_area = " + str(round(value[0] * value[1], 2))
+        print(line)
     print("\n")
 
+    ### Sweep the n_rows (m) and n_cols (n) in a row-based manner
+    macro_bbox = [] # (lx, ly, ux, uy) for each bounding box
     # we use m for max_n_rows and n for max_n_cols
     m_best = -1
     n_best = -1
-    best_cost = 2.0 # cost should be less than 2.0 based on definition
-    choice_map = {  }
-
-    for m in range(min_n_rows, max_n_rows + 1):
+    best_metric = -1.0
+    choice_map = {  }  # [m][n] : (ver_cost, hor_cost, empty_ratio)
+    for m in range(min_n_rows, max_n_rows):
         choice_map[m] = {  }
-        for n in range(min_n_cols, max_n_cols + 1):
-            if (m * n > max_rows_times_cols):
+        for n in range(min_n_cols, max_n_cols):
+            if (m * n > max_num_grid_cells):
                 break
-            if (m * n < min_rows_times_cols):
+            if (m * n < min_num_grid_cells):
                 continue
 
             ### Step1:  Divide the canvas into grids
@@ -148,10 +181,10 @@ def Gridding(macro_width_list, macro_height_list,
             grid_width  = chip_width / n
             if (grid_height / grid_width > max_aspect_ratio):
                 continue
-
             if (grid_width / grid_height > max_aspect_ratio):
                 continue
 
+            ### Step2:  Try to place macros on canvas
             grid_list = []
             for i in range(m):
                 for j in range(n):
@@ -160,24 +193,24 @@ def Gridding(macro_width_list, macro_height_list,
                     grid_id = len(grid_list)
                     grid_list.append(Grid(grid_id, grid_width, grid_height, x, y))
 
+            value = [0.0, 0.0, 0.0, 0.0]
             ### Place macros one by one
-            if (PlaceMacros(macro_map, grid_list, chip_width, chip_height, n) == False):
+            result_flag, value = PlaceMacros(macro_map, grid_list, chip_width, chip_height, n)
+            if (result_flag == False):
                 continue
             else:
-                ### Calculate the cost
-                total_grid_width = 0.0
-                total_grid_height = 0.0
+                ### compute the empty ratio
+                used_threshold = 1e-5
+                num_empty_grids = 0
                 for grid in grid_list:
-                    if (len(grid.macros_id_) > 0):
-                        total_grid_width += grid.width_
-                        total_grid_height += grid.height_
-
-                # calculate h_cost
-                cost = 1.0 - sum(macro_width_list) / total_grid_width
-                cost += 1.0 - sum(macro_height_list) / total_grid_height
-                choice_map[m][n] = cost
-                if (cost < best_cost):
-                    best_cost = cost
+                    if (grid.macro_area / (grid_width * grid_height) < used_threshold):
+                        num_empty_grids += 1
+                metric = 1.0 - value[0] / value[1]
+                metric += 1.0 - value[2] / value[3]
+                metric += num_empty_grids / len(grid_list)
+                choice_map[m][n] = metric
+                if (metric > best_metric):
+                    best_metric = metric
                     m_best = m
                     n_best = n
     m_opt = m_best
@@ -188,9 +221,9 @@ def Gridding(macro_width_list, macro_height_list,
     print("n_best = ", n_best)
     print("tolerance = ", tolerance)
     for [m, m_map] in choice_map.items():
-        for [n, cost] in m_map.items():
-            print("m = ", m , "  n = ", n, "  cost = ", cost)
-            if ((cost <= (1.0 + tolerance) * best_cost) and (m * n < num_grids_opt)):
+        for [n, metric] in m_map.items():
+            print("m = ", m , "  n = ", n, "  metric = ", metric)
+            if ((metric >= (1.0 - tolerance) * best_metric) and (m * n < num_grids_opt)):
                 m_opt = m
                 n_opt = n
                 num_grids_opt = m * n
@@ -201,7 +234,7 @@ def Gridding(macro_width_list, macro_height_list,
 
 class GriddingLefDefInterface:
     def __init__(self, src_dir, design, setup_file = "setup.tcl", tolerance = 0.05,
-                 halo_width = 5.0, min_n_rows = 10, min_n_cols = 10, max_n_rows = 128,
+                 halo_width = 0.0, min_n_rows = 10, min_n_cols = 10, max_n_rows = 128,
                  max_n_cols = 128, max_rows_times_cols = 2500,  min_rows_times_cols = 500,
                  max_aspect_ratio = 1.5):
         self.src_dir = src_dir
@@ -227,11 +260,11 @@ class GriddingLefDefInterface:
         self.GenerateHypergraph()
         self.ExtractInputs()
         self.m_opt, self.n_opt = Gridding(self.macro_width_list, self.macro_height_list,
-                                          self.chip_width, self.chip_height, self.tolerance,
+                                          self.chip_width, self.chip_height,
                                           self.min_n_rows, self.min_n_cols,
                                           self.max_n_rows, self.max_n_cols,
-                                          self.max_rows_times_cols, self.min_rows_times_cols,
-                                          self.max_aspect_ratio)
+                                          self.min_rows_times_cols, self.max_rows_times_cols,
+                                          self.max_aspect_ratio, self.tolerance)
 
     def GetNumRows(self):
         return self.m_opt
@@ -278,6 +311,7 @@ class GriddingLefDefInterface:
         f.close()
 
         items = content[0].split()
+        print(items)
         self.chip_width = float(items[2]) - float(items[0])
         self.chip_height = float(items[3]) - float(items[1])