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
Outline• Introduction
– Fracturing problem– Previous work
• Integer Linear Programming Formulation• Fast Heuristics• Experimental Results • Conclusions• Future Work
Mask Data Process Flow
Layout ExtractionRET
Circuit Design
Tape OutJob Decomposition
Mask Data Preparation
Mask Making
Writing
Inspection
Metrology
Normal or reverse tone
PEC Fracturing
Job Finishing
Fracturing
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 trapezoidsSuch that the number of trapezoids and number of slivers are minimized
Given:
Normal fracturing Reverse tone fracturing
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
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
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
Outline• Introduction• Integer Linear Programming Formulation• Fast Heuristics• Experimental Results • Conclusions• Future Work
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
Grid Graph
• For each concave point, draw two rays to the opposite side • Vertices are all intersection points
1
234
5
1 2 3 4 5 6
v4,4
eh4,2
Vi,j = intersection of ith vertical line and jth horizontal lineeh
i,j = horizontal line from Vi,j to Vi+1,j
Integer Linear Programming Formulation• Introduce a Boolean variable xd(i,j) for each edge xd(i,j)=1 ed
i,j belongs to the fracturing• Introduce a Boolean variable y(i,j) for each vertex y(i,j)=1 Vi,j is not isolated
1
234
5
1 2 3 4 5 6
v4,4
eh4,2
y(4,4) =1y(4,3) =0xh(4,2)=1
v4,3
Convexity Constraints
Concave points
360 degree
270 degree
Convex points
180 degree
180 degree
90 degree
0 degree
Convexity Constraints
vi,j
ehi,j
ehi-1,j
evi,j-1
evi,j
xh(i-1,j)+ xv(i-1,j)≤ 2xh(i,j)+ 2xv(i,j)
vi,j
ehi-1,j
evi,j-1
vi,j
evi,j-1
vi,j
ehi-1,j
Avoid
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)
Slant Constraints
xh(i,j)+ xv(i’,j’) ≥1
ehi,j
evi’,j’
One of them must be used
Counting Trapezoids• Eulerian formula # faces = # edges - # vertices +1 # trapezoid = ∑xd(i,j) - ∑y(i,j) +1
1
234
5
1 2 3 4 5 6
∑xd(i,j) =7∑y(i,j) =4# trapezoid=7-4+1= 4
Counting Slivers
• Introduce a Boolean variable sl(i,i’) for each pair of parallel edges whose distance <
< eh
i,j
ehi’,j
xh(i,j)+ xh(i’,j)-1≤ sl(i,i’)
< eh
i,j
xh(i,j)= sl(i,i’)
Integer Linear Programming Formulation
( , )dx i j
( , 1) ( 1, ) ( , ) ( , ) ( , )v h v hx i j x i j x i j x i j y i j
' ', , , | | | |
1 ( , ) ( , ) ( , ') ( , ')i ji j
d
d i j i j X X Y Y
x i j y i j sl i i sl j j
Minimizing:
Subject to:( 1, ) ( , 1) 2 ( , ) 2 ( , )
( , ) ( , 1) 2 ( 1, ) 2 ( , )
( , ) ( , ) 2 ( 1, ) 2 ( , 1)
( 1, ) ( , ) 2 ( , ) 2 ( , 1)
h v h v
h v h v
h v h v
h v h v
x i j x i j x i j x i j
x i j x i j x i j x i j
x i j x i j x i j x i j
x i j x i j x i j x i j
( , 1) ( , ) 1v hx i j x i j
: d=v,h; i=1,…,# horizontal rays and j=1,…,# vertical rays
Convexity constraints
Slant constraints
Shots counting
( , ') ( , ) ( ', ) 1v hsl i i x i j x i j Slivers counting
Fracturing Results of a Polygon
# sliver=0
Outline• Introduction• Integer Linear Programming Formulation• Fast Heuristics• Experimental Results • Conclusions• Future Work
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
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 34 5
6
78910
11 h1
h2
h1 h2
v1
(c)
12 3
4 5
6
78910
11 h1
h2
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”
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
010 1
0 <
<
0
Gain distribution
1-11 -1
0
Gain-Based Ray Selection Algorithm (GRS)
• Initially, Active set = {All ray segments whose starting point is a concave point} 0
1-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
-11
0
• Repeat until Active Set is empty
-11
1
# sliver=0
Outline• Introduction• Integer Linear Programming Formulation• Fast Heuristics• Experimental Results • Conclusions• Future Work
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
Experimental Results
Method
Design A Design B Design C
shot sliver CPU shot sliver CPU shot sliver CPU
Tool A 10754 6111 0 17335 11572 0 589 318 0
Tool B 10455 4451 0 17130 10797 0 566 147 0
Tool C 9755 786 2 17195 6502 3 592 66 0
GRS 9766 537 1.5 17182 4615 3.4 548 79 0
ILP 9750 417 134 17684 2750 222 518 83 8
Outline• Introduction• Integer Linear Programming Formulation• Fast Heuristics• Experimental Results • Conclusions• Future Work
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
Outline• Introduction• Integer Linear Programming Formulation• Fast Heuristics• Experimental Results • Conclusions• Future Work
Future Work• Fast heuristic to speed up ILP approach
with good solution quality• Non-rectilinear layouts• Reverse-tone fracturing