Yield and CostDriven Fracturing for Variable ShapedBeam Mask Writing

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
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 lt e is called a
  sliver
• According to Nakao et al. (2000), CD variation
  increases
• rapidly when dimension is below a threshold
  value ?.

lt ?
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 Vi1,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-41 4
4
3
2
1
1
2
3
4
5
6
16
Counting Slivers

• Introduce a Boolean variable sl(i,i) for each
  pair of
• parallel edges whose distance lt ?

lt ?
ehi,j
xh(i,j) sl(i,i)
17
Integer Linear Programming Formulation
Minimizing
Subject to
Convexity constraints
Slant constraints
Shots counting
Slivers counting
dv,h i1,, horizontal rays and j1,,
vertical rays
18
Fracturing Results of a Polygon
sliver0
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
1
11
1
11
4
5
4
5
v1
h2
h2
6
6
9
10
9
10
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)

lt ?
lt ?
1
-1
0
1
1
-1
0
1
0
lt ?
0
lt ?
0
0
Weight distribution
Gain distribution
24
Gain-Based Ray Selection Algorithm (GRS)

• Initially, Active set All ray segments whose
  starting point is a concave point

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