ICCAD-2018 CAD Contest in Smart EC: Program-Building for Name Mapping Suite Chi-An (Rocky) Wu, Cadence Design Systems, Inc. ICCAD 2018/ CAD Contest Session

Agenda Problem Description Benchmark Suites Contest Results

Introduction When implementation tools synthesize or modify designs, they will change the instances’ names by certain consistent rules. There are many situations that may happen name changes: Ungrouping modules, multibit grouping on registers, adding wrapper interface, inserting design for testing, two-dimension registers to one- dimension, appending library cell’s content, etc. For the industrial applications of equivalence checking (EC) and engine change order (ECO), it is important to perform name mapping to get the instance corresponding between the original netlist and the modified netlist. How to achieve the better name mapping is a complex issue.

The Challenge of this Problem Every implementation tools have different kinds of name changing depended on their name setup and modifying way. Besides, the final tape-out netlist is through many implementation tools. The problem is to find the compact rules or relations to mapping two sets of names. For application tools, it is better to use minimal statements to describe the rules and relations. For example, there is name changing for two-dimension to one- dimension: “name[0][0] -> [0]”, “name[1][0] -> [2]”, “name[1][1] -> [3]” The rule: “c = 2*a + b for [a][b] -> c” is better than telling the mapping of “[0][0]->0”,”[1][0]->2”, ”[1][1]->3”.

Problem Description Given the mapping relation of two sets of names, the problem goal is to generate a Python script with the smallest size. This Python script needs to output the original mapping relation when it’s inputs are the two sets of names without relations. For example, Given mapping relation { “a[dog]” : “a0”, “b[dog]” : b0”}, the contester’s program needs to generate a Python script. Then, giving two name sets [“a[dog]”,”b[dog]”] and [“a0”,”b0”], this Python script needs to output the original relation.

Problem Evaluation In each case, if a team output wrong mapping or it’s run out of time limit, the team get 0 score on this case. In each case, the rank of each case is decided by the size of Python. Smallest size gets the top-rank. If two teams have the same size, then the rank is decided by their runtime. The 1~6 rank can get {10, 7, 5, 4, 3, 2} score on this case. Others can get 1 score. The final rank of team is decided by the sum of scores on all cases.

Participation Statistics We have 20 teams attending this problem in the final evaluation. It is good to see students are interesting in this issue. Generating a good Python script is not easy to develop. Phase The Number of Teams Alpha 22 Beta 18 Final 20

Benchmark Suites Benchmarks comes from industrial cases with changing all name words. Their names go through some implementation tools from front-end synthesizer to back-end layout tools. There are 9 open cases for contestants to developing their algorithms and 15 hidden cases to test robustness.

Benchmark Data of Open Cases The size of contestants’ python scripts, which describing mapping relations, are much smaller than case size. Some cases has same smallest size. It may imply the same rules of changing names. Case Number of Names Average Name length Maximal Name length Smallest Python Size Set 1 Set 2 Case0 105376 57 72 150 94 Case1 11316 130 39 287 69 220 Case2 10871 134 Case3 62726 90 213 166 Case4 33731 21 23 107 157 Case5 55522 48 73 183 269 Case6 23933 35 43 105 115 180 Case7 22034 42 Case8 55980 52 92 101 614

Benchmark Data of Hidden Cases Number of Names Average Name length Maximal Name length Smallest Python Size Set 1 Set 2 Case9 58497 30 44 101 162 2109 Case10 70577 31 45 67 93 2929 Case11 72830 41 69 115 218 2928 Case12 80061 255 40 1608 189 33629 Case13 84918 52 77 266 159 2039 Case14 75899 74 103 166 Case15 79882 35 36 137 147 2042 Case16 54502 32 38 68 94 1103 Case17 243969 125 133 263 55498 Case18 189730 81 152 Case19 54209 33 51 108 112 2141 Case20 50563 46 2226 Case21 62853 34 144 207 1987 Case22 64628 110 12191 Case23 55608 15 88 92 3196

Case Study In open cases, high-ranked teams can find algorithms to generate python script with similar sizes 600~700. However, in hidden cases with unknown features, the smallest size can be in thousands (3196), but others are in ten thousands (19628) and more. It shows that the top-ranked team has more robust algorithms.

Total Score of Top 10 Teams Top-rank team is more robust.

Conclusion It is a special problem not like previous years. Contestants did good job on this problem. Open results have good performance by their algorithms. Besides, some teams have good hidden results, which is surprising.