Yield- and Cost-Driven Fracturing for Variable Shaped-Beam Mask Writing Andrew B. Kahng CSE and ECE...

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 Extraction

RET

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 trapezoids

Such 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) =1

y(4,3) =0

xh(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 3

4 5

6

78

910

11 h1

h2

h1 h2

v1

(c)

1

2 3

4 5

6

78

910

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