1. Yield- and Cost-Driven Fracturing for Variable Shaped-Beam Mask Writing Andrew B. Kahng CSE and ECE Departments, UCSD Xu Xu CSE Department, UCSD Alex Zelikovsky CS Department, Georgia State University Partially supported by MARCO GSRC and NSF CCF 0429735

2. Outline Introduction –Fracturing problem –Previous work Integer Linear Programming Formulation Fast Heuristics Experimental Results Conclusions Future Work

3. Mask Data Process Flow Layout Extraction RET Circuit Design Tape Out Job Decomposition Mask Data Preparation Mask Making Writing Inspection Metrology Normal or reverse tone PEC Fracturing Job Finishing Fracturing

4. Fracturing Problem A list of polygons P with axis parallel and slant edges Maximum shot size M Sliver size  Find a partition P into non-overlapping trapezoids Such that the number of trapezoids and number of slivers are minimized Given: Normal fracturing Reverse tone fracturing

5. Challenges in Fracturing Traditional objective = Minimize trapezoid number New objective = Minimize number of shots and Minimize sliver number New Constraint = No slant edge partition slant Wrong fracturing

6. Sliver Minimization A shot whose minimum width is <  is called a sliver According to Nakao et al. (2000), CD variation increases rapidly when dimension is below a threshold value . <  sliver New objective CD variation and error Yield

7. Previous Work Ohtzuki (1982) gave an exact O(n 5/2 ) algorithm to minimize the number of trapezoids Imai and Asano (1986) sped up this algorithm to O(n 3/2 logn) Nakao et al. (2000) developed a fast heuristic - considers the slivering, CD constraints - disregards slant edges - not optimal

8. Outline Introduction Integer Linear Programming Formulation Fast Heuristics Experimental Results Conclusions Future Work

9. Fracturing into Trapezoids Two rays to kill one concave point Any rectilinear polygon is a trapezoid iff it has no concave point Fracturing = “kill” all concave points Rays = axis-parallel lines from one concave points to the opposite side concave point

10. Grid Graph For each concave point, draw two rays to the opposite side Vertices are all intersection points 1 2 3 4 5 123456 v 4,4 e h 4,2 V i,j = intersection of i th vertical line and j th horizontal line e h i,j = horizontal line from V i,j to V i+1,j

11. Integer Linear Programming Formulation Introduce a Boolean variable x d (i,j) for each edge x d (i,j)=1  e d i,j belongs to the fracturing Introduce a Boolean variable y(i,j) for each vertex y(i,j)=1  V i,j is not isolated 1 2 3 4 5 123456 v 4,4 e h 4,2 y(4,4) =1 y(4,3) =0 x h (4,2)=1 v 4,3

12. Convexity Constraints Concave points 360 degree 270 degree Convex points 180 degree 90 degree 0 degree

13. Convexity Constraints v i,j e h i,j e h i-1,j e v i,j-1 e v i,j x h (i-1,j)+ x v (i-1,j)≤ 2x h (i,j)+ 2x v (i,j) v i,j e h i-1,j e v i,j-1 v i,j e v i,j-1 v i,j e h i-1,j Avoid x h (i,j)+ x v (i,j-1)≤ 2x h (i-1,j)+ 2x v (i,j) x h (i,j)+ x v (i,j)≤ 2x h (i-1,j)+ 2x v (i,j-1) x h (i-1,j)+ x v (i,j)≤ 2x h (i,j)+ 2x v (i,j-1)

14. Slant Constraints x h (i,j)+ x v (i ’,j ’ ) ≥1 e h i,j e v i ’,j ’ One of them must be used

15. Counting Trapezoids Eulerian formula # faces = # edges - # vertices +1  # trapezoid = ∑x d (i,j) - ∑y(i,j) +1 1 2 3 4 5 123456 ∑x d (i,j) =7 ∑y(i,j) =4 # trapezoid =7-4+1= 4

16. Counting Slivers Introduce a Boolean variable sl(i,i’) for each pair of parallel edges whose distance <  <  e h i,j e h i ’,j x h (i,j)+ x h (i ’,j)-1≤ sl(i,i ’ ) <  e h i,j x h (i,j)= sl(i,i ’ )

17. Integer Linear Programming Formulation Minimizing: Subject to: : d=v,h; i=1,…,# horizontal rays and j=1,…,# vertical rays Convexity constraints Slant constraints Shots counting Slivers counting

18. Fracturing Results of a Polygon # sliver=0

19. Outline Introduction Integer Linear Programming Formulation Fast Heuristics Experimental Results Conclusions Future Work

20. Matching Formulation Draw a ray from each concave point and stop at the first encountered ray or edges The trapezoid number increases by one for each ray # trapezoids = 1+ # concave points - # coincident rays Minimize # trapezoids = Maximize # coincident rays # trapezoids= 2 # trapezoids= 3

21. Matching Formulation Represent each coincident ray with a node Connect two nodes which represent two conflict rays Find maximal independent set Can be formulated as matching problem 1 v1 2 3 45 6 7 8 910 11 h1 h2 h1h2 v1 (c) 1 2 3 45 6 7 8 910 11 h1 h2

22. Formulate as Ray-Selection Problem Two candidates to kill one concave point For each concave point and grid point, choose one out of two candidate rays to minimize # slivers These are called a “conflict pair”

23. Gain Based Ray Selection For any conflict pair (i, j), the weight of i W(i)= # slivers between i and edges/chosen ray segments Gain of i: G(i) = W(j)-W(i) = # slivers saved by using i G(j)=-G(i) <  0 Weight distribution 01 01 0 <  0 Gain distribution 1 1 0

24. Gain-Based Ray Selection Algorithm (GRS) Initially, Active set = {All ray segments whose starting point is a concave point} 0 1 0 In each iteration –choose one ray segment i with the largest gain, delete i and its conflict pair –add the segment connected with i into Active Set –update the gains 1 0 Repeat until Active Set is empty 1 1 # sliver=0

25. Outline Introduction Integer Linear Programming Formulation Fast Heuristics Experimental Results Conclusions Future Work

26. Experiment Setup Three industry testcases Implement our algorithm in ANSI C Use CPLEX 8.100 to solve ILP Set slivering size as 100 nm Step ratio = 4 All tests are run on Xeon 2.4GHz CPU

27. Experimental Results Method Design ADesign BDesign C shotsliverCPUshotsliverCPUshotsliverCPU Tool A1075461110173351157205893180 Tool B1045544510171301079705661470 Tool C975578621719565023592660 GRS97665371.51718246153.4548790 ILP9750417134176842750222518838

28. Outline Introduction Integer Linear Programming Formulation Fast Heuristics Experimental Results Conclusions Future Work

29. Conclusions New ILP approach and fast heuristics Reduce # slivers by 82%, 79% and 28% compared with three commercial tools (options) Reduce # trapezoid by 5.5%, 0.6% and -2.5% Runtime can be reduced for hierarchical designs

30. Outline Introduction Integer Linear Programming Formulation Fast Heuristics Experimental Results Conclusions Future Work

31. Fast heuristic to speed up ILP approach with good solution quality Non-rectilinear layouts Reverse-tone fracturing