1. 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

2. Agenda
Problem Description
Benchmark Suites
Contest Results

3. 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.

4. 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”.

5. 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.

6. 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.

7. 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

8. 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.

9. 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

10. 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

11. 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.

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

13. 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.