Skip to content

M
macroplacement
Commit 06d79d2d by ZhiangWang033
Options

fix gridding

parent db0819cc
Showing with 81 additions and 47 deletions
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,
chip_width, chip_height,
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):
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])
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment