Yield- and Cost-Driven Fracturing for Variable Shaped-Beam Mask Writing

1 / 31

# Yield- and Cost-Driven Fracturing for Variable Shaped-Beam Mask Writing

## Yield- and Cost-Driven Fracturing for Variable Shaped-Beam Mask Writing

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
##### Presentation Transcript

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 Circuit Design Layout Extraction RET Tape Out Fracturing Job Decomposition Normal or reverse tone Mask Data Preparation PEC Fracturing Job Finishing Writing Mask Making Inspection Metrology

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

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 • New objective • CD variation and error • Yield • A shot whose minimum width is < e is called a sliver • According to Nakao et al. (2000), CD variation increases • rapidly when dimension is below a threshold value . <  sliver

7. Previous Work • Ohtzuki (1982) gave an exact O(n5/2) algorithm to minimize • the number of trapezoids • Imai and Asano (1986) sped up this algorithm to O(n3/2logn) • 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 • 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 Two rays to kill one concave point concave point

10. Grid Graph • For each concave point, draw two rays to the • opposite side • Vertices are all intersection points 5 v4,4 4 3 2 eh4,2 1 1 2 3 4 5 6 Vi,j = intersection of ith vertical line and jth horizontal line ehi,j = horizontal line from Vi,j to Vi+1,j

11. Integer Linear Programming Formulation • Introduce a Boolean variable xd(i,j) for each edge • xd(i,j)=1  edi,j belongs to the fracturing • Introduce a Boolean variable y(i,j) for each vertex • y(i,j)=1  Vi,j is not isolated 5 v4,4 4 y(4,4)=1 y(4,3) =0 xh(4,2)=1 3 v4,3 2 eh4,2 1 1 2 3 4 5 6

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

13. Convexity Constraints evi,j ehi-1,j ehi-1,j ehi,j vi,j vi,j evi,j-1 evi,j-1 Avoid xh(i-1,j)+ xv(i-1,j)≤ 2xh(i,j)+ 2xv(i,j) vi,j evi,j-1 ehi-1,j xh(i,j)+ xv(i,j-1)≤ 2xh(i-1,j)+ 2xv(i,j) xh(i,j)+ xv(i,j)≤ 2xh(i-1,j)+ 2xv(i,j-1) xh(i-1,j)+ xv(i,j)≤ 2xh(i,j)+ 2xv(i,j-1) vi,j

14. Slant Constraints evi’,j’ One of them must be used ehi,j xh(i,j)+ xv(i’,j’) ≥1

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

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

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

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 2 2 3 3 h1 h2 h1 h1 11 1 11 1 4 5 4 5 v1 h2 h2 6 6 10 9 10 9 v1 7 7 8 8 (c)

22. Formulate as Ray-Selection Problem • For each concave point and grid point, choose • one out of two candidate rays to minimize # slivers Two candidates to kill one concave point 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) <  <  1 -1 0 1 -1 1 1 0 0 <  0 <  0 0 Weight distribution Gain distribution

24. Gain-Based Ray Selection Algorithm (GRS) -1 1 • Initially, Active set = {All ray segments whose starting point is a concave point} 0 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 0 1 -1 1 -1 • Repeat until Active Set is empty 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

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. Future Work • Fast heuristic to speed up ILP approach with good solution quality • Non-rectilinear layouts • Reverse-tone fracturing