def build_route_utilization_map(self, params, placedb, data_collections):
"""
@brief routing congestion map based on current cell locations
@param params parameters
@param placedb placement database
@param data_collections a collection of all data and variables required for constructing the ops
"""
congestion_op = rudy.Rudy(
netpin_start=data_collections.flat_net2pin_start_map,
flat_netpin=data_collections.flat_net2pin_map,
net_weights=data_collections.net_weights,
xl=placedb.routing_grid_xl,
yl=placedb.routing_grid_yl,
xh=placedb.routing_grid_xh,
yh=placedb.routing_grid_yh,
num_bins_x=placedb.num_routing_grids_x,
num_bins_y=placedb.num_routing_grids_y,
unit_horizontal_capacity=placedb.unit_horizontal_capacity,
unit_vertical_capacity=placedb.unit_vertical_capacity,
initial_horizontal_utilization_map=data_collections.
initial_horizontal_utilization_map,
initial_vertical_utilization_map=data_collections.
initial_vertical_utilization_map,
num_threads=params.num_threads)
def route_utilization_map_op(pos):
pin_pos = self.op_collections.pin_pos_op(pos)
return congestion_op(pin_pos)
return route_utilization_map_op
def test_rudy(self):
# the data of net and pin are from unitest/ops/weighted_average_wirelength_unitest.py
dtype = torch.float32
pin_pos = torch.Tensor([[0.0, 0.0], [1.0, 2.0], [1.5, 0.2], [0.5, 3.1],
[0.6, 1.1]]).to(dtype)
net2pin_map = np.array([np.array([0, 4]), np.array([1, 2, 3])])
net_weights = torch.Tensor([1, 2]).to(dtype)
# construct flat_net2pin_map and flat_net2pin_start_map
# flat netpin map, length of #pins
flat_net2pin_map = np.zeros(len(pin_pos), dtype=np.int32)
# starting index in netpin map for each net, length of #nets+1, the last entry is #pins
flat_net2pin_start_map = np.zeros(len(net2pin_map) + 1, dtype=np.int32)
count = 0
for i in range(len(net2pin_map)):
flat_net2pin_map[count:count +
len(net2pin_map[i])] = net2pin_map[i]
flat_net2pin_start_map[i] = count
count += len(net2pin_map[i])
flat_net2pin_start_map[len(net2pin_map)] = len(pin_pos)
print("flat_net2pin_map = ", flat_net2pin_map)
print("flat_net2pin_start_map = ", flat_net2pin_start_map)
flat_net2pin_map = torch.from_numpy(flat_net2pin_map)
flat_net2pin_start_map = torch.from_numpy(flat_net2pin_start_map)
# parameters for this test
xl, xh = 0.0, 2.0
yl, yh = 0.0, 4.0
num_bins_x = 8
num_bins_y = 8
unit_horizontal_capacity = 0.1
unit_vertical_capacity = 0.2
# test cpu
rudy_op = rudy.Rudy(netpin_start=flat_net2pin_start_map,
flat_netpin=flat_net2pin_map,
net_weights=net_weights,
xl=xl,
xh=xh,
yl=yl,
yh=yh,
num_bins_x=num_bins_x,
num_bins_y=num_bins_y,
unit_horizontal_capacity=unit_horizontal_capacity,
unit_vertical_capacity=unit_vertical_capacity,
num_threads=8)
result_cpu = rudy_op.forward(pin_pos.t().contiguous().view(-1))
print("Test on CPU. rudy map = ", result_cpu)
if torch.cuda.device_count():
# test gpu
rudy_op_cuda = rudy.Rudy(
netpin_start=flat_net2pin_start_map.cuda(),
flat_netpin=flat_net2pin_map.cuda(),
net_weights=net_weights.cuda(),
xl=xl,
xh=xh,
yl=yl,
yh=yh,
num_bins_x=num_bins_x,
num_bins_y=num_bins_y,
unit_horizontal_capacity=unit_horizontal_capacity,
unit_vertical_capacity=unit_vertical_capacity)
result_cuda = rudy_op_cuda.forward(
pin_pos.t().contiguous().view(-1).cuda())
print("Test on GPU. rudy map = ", result_cuda)
np.testing.assert_allclose(result_cpu, result_cuda.cpu())