EDAthon2020-P4 Floorplanning问题 BSG + Simulated Annealing解决方案
文章目录
- 1. 概念介绍
- 2.问题描述
- 3.解决方案
- 3.1 BSG 架构
- 3.2 模拟退火
- 3.3 具体改进
- 4. 代码参考
- 5.总结
1. 概念介绍
EDAthon是一个围绕硬件相关的一个比赛，涉及的面居多，每个题都是基于某个领域的经典问题，今年的题目涉及具体IP核实现，PCB布线算法，IP核布局算法，指令调度相关，神经网络的量化等
Floorplanning问题大概如下：给你若干个矩形（模块），让你不重叠的放置在平面中使得最终的包围矩形最小，当然可以加些约束，比如指定某些模块靠的近一些，或者某些模块是软的（只要保证面积不变，长宽比可以任意），或者指定模块四周要留某个单位的空余，等等
如下图所示，10个模块的最小包围矩形面积为100*100
2.问题描述
题目给你n个矩形，边长为浮点数，和m对约束，约束为两个矩形尽可能的离得近，不能旋转矩形。最终输出每个矩形最终状态的左下角坐标。
PS:题目未说明n的大小，但上限不会太大，可以按照200作为上限。
输入样例如下：
8
400.0 300.0
400.0 140.0
330.0 240.0
280.0 220.0
150.0 240.0
380.0 130.0
530.0 210.0
230.0 220.0
1
1 2
输出样例如下：
0.0 0.0
400.0 0.0
0.0 300.0
400.0 140.0
680.0 140.0
330.0 380.0
0.0 540.0
530.0 510.0
此样例最终状态如下图所示：
评判标准：
F c o s t = ( A f + D ) / A c Fcost = ( Af+ D ) / Ac Fcost=(Af+D)/Ac
其中 F c o s t Fcost Fcost为最终代价，使其最小化， A f Af Af是最终的包围矩形面积， D D D是m对矩形间曼哈顿距离的平方和的和， A c Ac Ac是所有矩形的面积和
时空约束：
R u n t i m e : 5 m i n Runtime:5 ~min Runtime:5 min
M e m o r y : 1 G B Memory:1~GB Memory:1 GB
3.解决方案
主要参考了这篇论文,可能需要梯子，也可以参考下面自行下载
BSG(Bounded slicing grid)- structure：Nakatake S, Fujiyoshi K, Murata H, et al. Module placement on BSG-structure and IC layout applications[C]//Proceedings of International Conference on Computer Aided Design. IEEE, 1996: 484-491
该论文主要提出了BSG结构，可以很巧妙的构建出模块的分布，进而可以计算每个分布的包围矩形，再结合模拟退火随机算法，最终得到的解还挺理想。
简单介绍下论文提出的架构。
3.1 BSG 架构
如上右图1B是一个4*3的BSG图，首先观察该图线段很有规律，比如横向观察，第一层线段长度为2,1第二层为1,2，再往上就循环如此，纵向类似。当然这个图是可以无限放大的。每个交错的横纵线段中有很多ROOM，如图1A所示，这里的ROOM可以放一个矩形（模块）
在上述的BGS图中，横向和纵向分别建图，如上图2所示，可以很巧妙的发现每个图的节点位置都是线段长度为2的中心点。我们有可以很巧妙的发现在Gh和Gv中每个room都会有一条边覆盖，进而利于我们在可以在任意的room中放置矩形（模块）。每个图都要设置超级源点和超级汇点。
现在进入实战环节，假如有4个矩形 a , b , c , d a,b,c,d a,b,c,d，长宽如上图A所示，假如我们的BSG图为4*4，恰好每个模块所在的位置如上图B所示，那么我们就可以得到上图CD的Gh，Gv，如果在BSG图某个room有模块时，那么在Gh图对应边的权值应为对应模块的宽，同理Gv对应的权值应为模块的高，如果BSG图某个room没有模块，对应的Gh，Gv边权都为0。
通过Gh,Gv我们就可以得到每个模块在最终布局的具体坐标
比如 a a a模块，首先根据Gh图对应 r o o m room room源点 V 1 V1 V1（边权为8的左下角的点），从超级源点 S v Sv Sv到 V 1 V1 V1的最长路径为0，即表示 a a a模块最终位置的 x x x坐标为0。同理可以得到 y y y坐标为9，进而得到 a a a模块的左下角坐标，其他模块类似。
重点是我们可以直接通过Gh，Gv求得最终包围矩形的宽和长
只需要分别在Gh，Gv图中跑一边最长路径即可。利用记忆化搜索可以把时间降低到O(N)，N为节点的个数。
该样例最终的布置如下：
基于论文中所述的BSG结构，可以轻松的建图，8*8的图，Gh，Gv原始图如下，可能会更详细点。代码就是基于此图构建的
3.2 模拟退火
首先模拟退火算法的原理具体不多介绍。
主要利用 Simulated Annealing 来确定每个模块在BSG的具体位置，以及再退火的过程中如何变化每个模块的位置。
首先是初始化，直接暴力“塞进去”，按照编号一个个进入ROOM编号。
退火过程就是随机挑选两个位置，如果两个位置都为空，再重新挑选，直到找到至少有一个位置不为空为止，然后就是交换两个ROOM的值，更新图和相关的变量，然后就是退火的老一套，如果当前Cost是上次的Cost小，则直接交换，否则随机一波值，让它有一定概率Cost变大。然后就让它随机下去，直到温度小于阈值。
3.3 具体改进
- 由于题目所提供的矩形边长为浮点，考虑到浮点数运算会更耗时，虽然可能得到的结果更优，但最终还是选择把题目提供的边长向上取整为整数边长来求解。
- 题目要求不能旋转矩形，所以降低了复杂度（因为题目准备的是可以旋转，临时删了）
- 由于题目提供了代价函数，所以在退火时计算代价直接用题目提供的即可
- 退火降温系数可以随机选取
- 在寻找最长路径时采用了记忆化搜索
4. 代码参考
代码很水，有手就能敲，仅供参考，可能有的函数懒得加注释了，反正C++都能看懂
#include Judge代码参考
import argparse
import matplotlib.pyplot as plt
def parse_argument():
parser = argparse.ArgumentParser(description='JUDGER of the problem - '
'"floorplanning with optimum area utilization under constraints"')
parser.add_argument('input_path', help='the input file path')
parser.add_argument('output_path', help='the output file path')
args = parser.parse_args()
return args
def read_input_file(input_path):
with open(input_path) as input_file:
n = int(input_file.readline().strip())
cells = []
for _ in range(n):
w, h = (float(_) for _ in input_file.readline().strip().split(' '))
cells.append((w, h))
m = int(input_file.readline().strip())
nears = []
for _ in range(m):
a, b = (int(_) for _ in input_file.readline().strip().split(' '))
nears.append((a, b))
return n, cells, m, nears
def read_output_file(output_path):
coors = []
with open(output_path) as output_file:
for line in output_file:
x, y = (float(_) for _ in line.strip().split(' '))
coors.append((x, y))
return coors
def segment_distance(a0, b0, a1, b1):
return max(a0 - b1, a1 - b0)
def display_placement(n, x0_lst, x1_lst, y0_lst, y1_lst, nears):
fig, ax = plt.subplots()
for i in range(n):
x0, x1, y0, y1 = x0_lst[i], x1_lst[i], y0_lst[i], y1_lst[i]
rect = plt.Rectangle((x0, y0), x1-x0, y1-y0, lw=1.0, ls='-', fc='blue', ec='black')
ax.add_patch(rect)
ax.annotate(str(i), ((x0 + x1) / 2.0, (y0 + y1) / 2.0),
color='w', weight='bold', fontsize=6, ha='center', va='center')
for (i, j) in nears:
x0a, x1a, y0a, y1a = x0_lst[i], x1_lst[i], y0_lst[i], y1_lst[i]
x0b, x1b, y0b, y1b = x0_lst[j], x1_lst[j], y0_lst[j], y1_lst[j]
plt.plot([(x0a + x1a) / 2.0, (x0b + x1b) / 2.0 ],
[(y0a + y1a) / 2.0, (y0b + y1b) / 2.0])
min_x, max_x = min(x0_lst), max(x1_lst)
min_y, max_y = min(y0_lst), max(y1_lst)
aix_range = max(max_x - min_x, max_y - min_y) * 1.1
center_x = (min_x + max_x) / 2.0
center_y = (min_y + max_y) / 2.0
ax.set_xlim([center_x - aix_range / 2.0, center_x + aix_range / 2.0])
ax.set_ylim([center_y - aix_range / 2.0, center_y + aix_range / 2.0])
plt.show()
def main():
# get input and output file path
args = parse_argument()
# read input and output files
n, cells, m, nears = read_input_file(args.input_path)
coors = read_output_file(args.output_path)
x0_lst = [coor[0] for coor in coors]
x1_lst = [coor[0] + cell[0] for (coor, cell) in zip(coors, cells)]
y0_lst = [coor[1] for coor in coors]
y1_lst = [coor[1] + cell[1] for (coor, cell) in zip(coors, cells)]
# displace placement
display_placement(n, x0_lst, x1_lst, y0_lst, y1_lst, nears)
# check if cells overlap
for i in range(n-1):
for j in range(i+1, n):
dx = segment_distance(x0_lst[i], x1_lst[i], x0_lst[j], x1_lst[j])
dy = segment_distance(y0_lst[i], y1_lst[i], y0_lst[j], y1_lst[j])
if dx < 0 and dy < 0:
raise Exception(f"The cell[{i}] and cell[{j}] overlapped.")
# calculate the bounding rect area
min_x, max_x = min(x0_lst), max(x1_lst)
min_y, max_y = min(y0_lst), max(y1_lst)
area = (max_x - min_x) * (max_y - min_y)
# calculate the dist scores
dist = 0
for (i, j) in nears:
dx = segment_distance(x0_lst[i], x1_lst[i], x0_lst[j], x1_lst[j])
dy = segment_distance(y0_lst[i], y1_lst[i], y0_lst[j], y1_lst[j])
ds = (dx if dx > 0 else 0) + (dy if dy > 0 else 0)
dist += ds * ds
norm = sum((x1 - x0) * (y1 - y0) for x0, x1, y0, y1 in zip(x0_lst, x1_lst, y0_lst, y1_lst))
score = (area + dist) / norm
print("%.3f" % score)
if __name__ == "__main__":
main()
5.总结
首先是比赛关于此题的总结，总体来说还算比较充分，基本赛前准备和赛题较吻合，当然由于自己的debug能力，导致这道题拖到了4h后才交，好在最后这道题的成绩也是满分，也可能是样例比较水吧，同时也侧面反映出了自己的编码、找错能力下滑了很多。
然后是这道题的拓展，总的来看题目给的约束很松，很多约束没有涉及到，比如说提前预制某个模块在某个位置，有一些模块时软模块，等等。说实话，在赛前一直和队友讨论如何解决模块预制问题，一直没有好的解决方案，因为最终的布置图是未知的，所以没办法提前在某个区域预制模块，但是论文中提到了这一点，并且给出了相应布置图，但是具体的解决方案没有详细说，如果哪位大佬看到这里并且有好的解决方案，麻烦告知下，谢谢。
在code上我觉得还有很多地方可以优化，比如可以进入多线程进行自动调参，毕竟是个随机算法嘛，说不定某个参数就可以找个更优的结果，想进一步讨论也可以私信我。
另外真的好久不写blog了，不知道该如何描述算法或者解决方案，可能会引起极度不适，东一头西一头的，见谅啦。加油陌生人~