Efficient Process-Hotspot Detection UsingRange Pattern Matching in Routing Stage

Efficient Process-Hotspot Detection UsingRange Pattern Matching in Routing Stage

Hailong Yao1 Subarna Sinha2 Charles Chiang2

Xianlong Hong1 Yici Cai1

1Department of Computer Science and Technology

Tsinghua University, Beijing, P.R. China

2Synopsys ATG, Mountain View, CA

This work is done during the author’s internship at Synopsys ATG

OutlineOutline

Motivation

Range Patterns and Matching

Process-Hotspot Detection System

Experimental Results

Conclusion

MotivationMotivation

Manufacturability-aware physical design is becoming a necessity

Certain layout configurations susceptible to stress and lithographic process fluctuations affect yield

Process-hotspots: layout configurations most susceptible to process issues

Remove process-hotspots and replace them with more yield-friendly configurations

Limitations of Recommended RulesLimitations of Recommended Rules

Fabs use design rules (like recommended rules) to represent process-hotspots

Limitations: Some effects are non-local Difficult to represent relationships between large group

of non-neighboring objects with a small set of rules Explosion of design rules slows down the router DRC tools are being supplemented with accurate

process simulators (for instance, for lithography)

Limitations of Process ModelsLimitations of Process Models

Lida Huang, et al at DAC’04 [1] and J. Mitra, et al at DAC’05 [2] proposed embedding an aerial image simulator in the router to identify process-hotspots

Limitations: Lack of knowledge of downstream steps and over-

estimation of process-hotspots Huge computational expense

[1] L.-D. Huang and M. D. F. Wong, “Optical proximity correction (OPC)-friendly maze routing,” In DAC, pages 186–191, June 2004.

[2] J. Mitra, P. Yu, and D. Z. Pan, “RADAR: Ret-aware detailed routing using fast lithography simulations,” In DAC, pages 369–372, June 2005.

Represent Process-hotspots with PatternsRepresent Process-hotspots with Patterns

A good representation of process-hotspots would be a 2D layout of rectangles, i.e. a pattern

Can be built off-line using test-structures or more accurate simulation tools

Process-hotspot detection during routing would complement current advances in yield enabling steps

Why Range Pattern?Why Range Pattern?

Layouts/patterns are quite similar with minor variations

Exact pattern: multiple similar patterns

Range pattern: a group of “similar” layouts with allowable variations in length, width and/or spacing

Ranges on the pattern parameters enable compact representation

S1S2

S1

Un-OPC-able

S2

Un-SRAF-able

Scattering Bar

Process-hotspot DetectionProcess-hotspot Detection

Collaborate with a fab or in-house accurate simulation and mask synthesis flows to build range patterns

Score the patterns in the set based on yield impact

Scores can be used by the router to give higher priority during correction

Represent process-hotspots as a library of range patterns

Process-hotspot detection: find all the locations where the layout is identical to one of the patterns contained in a range pattern

OutlineOutline

Motivation

Range Patterns and Matching Range Pattern Definitions Layout Representation Range Pattern Representation

Process-Hotspot Detection System

Experimental Results

Conclusion

Range Pattern DefinitionsRange Pattern Definitions

Range pattern: DRC-correct two-dimensional layout of rectangles with additional specifications:1. Widths and lengths of the rectangles can vary within

certain user-specified bounds2. Spacings between pairs of rectangles can vary within

certain user-specified bounds3. Optimal widths and lengths of the rectangles and

optimal spacings between pairs of rectangles can be specified

4. Constraints can be specified over linear combinations of the widths, lengths and spacings of the rectangles

Range Pattern ExampleRange Pattern Example

Range pattern Staircase with the following specifications:1. Optimal width of each rectangle = 90 nm2. Optimal spacing between adjacent rectangles = 90 nm3. Range of width of all rectangles = (90, 150) nm4. Range of spacing between adjacent rectangles = (90, 150) nm5. Range of length of central rectangle = (200, 500) nm6. Distance between the right edge of rectangle 1 and the left edge

of rectangle 3 cannot exceed 50 nm

A range pattern contains a multitude of exact patterns

Rectangle 1

Rectangle 2

Rectangle 3

Range Pattern Matching ProblemRange Pattern Matching Problem

The Range Pattern Matching (RPM) problem:

Given a layout and a range pattern, determine all occurrences of the range pattern in the layout and score these occurrences using the scoring mechanism for the range pattern

OutlineOutline

Motivation

Range Patterns and Matching Range Pattern Definitions Layout Representation Range Pattern Representation

Process-Hotspot Detection System

Experimental Results

Conclusion

Layout RepresentationLayout Representation

Layout is represented by a two-dimensional matrix LN1N2 where L[i,j] = 0 or 1 (0 i < N1, 0 j < N2)

Conversion: If a rectangle overlaps a grid location, the value at that location is set to 1. Otherwise, it is set to 0

Different grid sizes result in different layout matrix

OutlineOutline

Motivation

Range Patterns and Matching Range Pattern Definitions Layout Representation Range Pattern Representation

Process-Hotspot Detection System

Experimental Results

Conclusion

Cutting-slice RepresentationCutting-slice Representation

Horizontal (vertical) slice: 2D matrix where all the rows (columns) are equal

Fragment of a slice: sub-matrix where all the elements are equal

Cutting-slice: a set of horizontal (vertical) slices {S0, … , Sn-1} with the following specifications:1. Adjacent slices are not equal, i.e. Si Si+1, 0 i < n-12. Each slice Si is decomposed into fragments {Fi,0, … , Fi,m-1},

where Fi,j Fi,j+1, 0 j < m-13. If applicable, optimal values are specified for the fragments in

each slice and for the slices themselves4. If applicable, ranges are specified for each slice and/or fragments

within the slice5. If applicable, constraints between different fragments and/or slices

are specified as linear functions

Cutting-slice of Range Pattern StaircaseCutting-slice of Range Pattern Staircase

Totally 5 slices: S0,…,S4

Fragments in the ith slice have the same width as Si

Fragment length and slice width can vary

Si: slice width

Fi,j: fragment length

Item 6 translates to | F0,0 - F4,0 | 50

1. Optimal width of each rectangle = 90 nm

2. Optimal spacing between adjacent rectangles = 90 nm

3. Range of width of all rectangles = (90, 150) nm

4. Range of spacing between adjacent rectangles = (90, 150) nm

5. Range of length of central rectangle = (200, 500) nm

6. Distance between the right edge of rectangle 1 and the left edge of rectangle 3 cannot exceed 50 nm

R1

R2

R3

Slicing DirectionSlicing Direction

Slicing direction: direction used to generate the slices

Slicing direction affects the number of cutting-slices

The total number of cutting-slices is calculated by enumerating all the range overlapping cases

Choose the slicing direction with less cutting-slices

S0 S1 S2 S3 S4 S0 S1 S2 S3 S0 S1 S2S3 S4

Staircase: slicing direction: V 3 cutting-slices slicing direction: H 1 cutting-slice

S0S1S2S3S4

OutlineOutline

Motivation

Range Patterns and Matching

Process-Hotspot Detection System Overview Range Pattern Matching Sub-problem Scalability and Runtime Optimization

Experimental Results

Conclusion

OverviewOverview

Hierarchical dual-grid scheme with matching done on two grid sizes

The grid sizes are used to generate the layout matrices and the cutting-slices of the range pattern

Matching with the coarse grid identifies locations that are potential matches

Match locations are verified on the finer grid size

Fine grid size is equal to the manufacturing grid size

OutlineOutline

Motivation

Range Patterns and Matching

Process-Hotspot Detection System Overview Range Pattern Matching Sub-problem Scalability and Runtime Optimization

Experimental Results

Conclusion

Worm-like Movement of the Layout BlockWorm-like Movement of the Layout Block

Matching is done block by block

Layout matrix: L[N1][N2], Block: B[h][N2], where min h max

min (max): the minimum (maximum) possible number of rows of the range pattern

Enumerate all the blocks whose heights are between min and max on each row of the layout matrix

Worm-like enumeration: only the top and the bottom rows are changed each time to reuse work done in encoding the previous block

Enables incremental encoding and greatly improves runtime

minmax

max

min

KMP-based FilterKMP-based Filter

Basic idea: Encode both the block B and the cutting-slice C as 1D strings BE and CE, respectively. Search CE in BE to find all potential matches. All locations that are not matches are filtered out. The potential matches are examined more closely

The run-length compression of a column C[j][N] is equal to {b0, b1, …, bn-1}, where1. bi bi+1 (0 i < n-1)2. C[j][N] can be represented as a concatenation of n segments, i.e. b0

repeated 0 times, b1 repeated 1 times, and so on3.

Example: 111001111011000011 is compressed to 13021401120412

Binary encoding: with “1” added at the top to distinguish between “01” and “1”: 11010101 = 213

1

0

n

ii

N

Matching ExampleMatching Example

1. Encode the slices in the cutting-slice: 1D string: {3, 5, 13, 5, 3}

2. Identify the slices in the block

3. Run-length compression on each slice and encode the slices: {2, 10, 10, 2, 3, 5, 13, 5, 3, 2, 10, 10, 2}

4. Search the encoded cutting-slice {3, 5, 13, 5, 3} in the encoded block by KMP string matching algorithm

Columns 5-14 of the block are examined more closely for a true match and the remaining locations are filtered out

11

11

33 1313

11 11 11 11

111100 00

11 11 11

3355 55

00hh

NN22

22 110011

0022 33 55 11

3355 33 22 11

0011

0022

Complexity Analysis of the RPM AlgorithmComplexity Analysis of the RPM Algorithm

Layout matrix: L[N1][N2] , Layout block: B[h][N2] where min h max

Slice identification: O(N2)

Let the number of identified slices be s (1 s N2), run-length compression takes O(s U), where U is the average time for updating the run-length compression of each slice

Incremental binary encoding: O(s)

KMP string matching: O(s)

The verification process for each potential match: O(1)

RPM algorithm for one layout block: max(N2, sU)

Total number of different blocks in the layout matrix L[N1][N2] is less than (N1-min+1)(max-min+1)

Total time complexity: O(max(N2, sU) (N1-min+1) (max-min+1))

Key factors: Size of the layout (N1, N2), the variation range in the height of the cutting-slice (min, max)

OutlineOutline

Motivation

Range Patterns and Matching

Process-Hotspot Detection System Overview Range Pattern Matching Sub-problem Scalability and Runtime Optimization

Experimental Results

Conclusion

Scalability and Runtime OptimizationScalability and Runtime Optimization

Scalability: window-by-window matching

Consecutive windows overlap to avoid loss of matches

Runtime: matching on a fine grid size is slow

Hierarchical matching strategy: dual grid matching scheme of coarse grid matching followed by fine grid matching

OutlineOutline

Motivation

Range Patterns and Matching

Process-Hotspot Detection System

Experimental Results

Conclusion

Experimental ResultsExperimental Results

Platform: Linux 2.4 system, two 2.2 GHz CPUs, 2 GB RAM (only a single CPU used)

Totally 5 layouts: D1, D2, D3: metal layers of 0.60.6 mm2 design; D4, D5: metal layers of 1.81.8 mm2 design. All are 65 nm designs

The process-hotspot library:

Range Pattern # Rects. Overlap Multiple Patterns?

Bird 5 Yes Yes

Bridge 6 Yes Yes

Weave 4 No Yes

Zigzag 3 Yes Yes

Experimental Results (cont.)Experimental Results (cont.)

Range Pattern

Design Name

# of Matches Runtime (s)Score Range

Hier. Single-Grid Hier. Single-Grid

Bird D1 212 212 156.43 3189.94 [87.81,97.29]

Bird D2 52 52 14.86 2166.80 [85.99,96.84]

Bird D3 5 5 15.75 2862.74 [93.22,96.84]

Bird D4 5480 5480 264.07 15933.31 [80.11,96.84]

Bird D5 36 36 73.24 13397.48 [80.56,92.01]

Bridge D1 2062 2062 137.98 11517.72 [98.32,98.74]

Weave D4 14 14 358.59 17694.92 [93.40,95.88]

Weave D5 2 2 83.46 16036.56 [93.40,93.40]

Zigzag D2 2474 2474 19.47 2142.57 [93.23,98.73]

Zigzag D3 1642 1642 13.31 3130.89 [97.46,97.46]

Zigzag D4 12939 12939 358.59 14888.53 [93.23,98.73]

Zigzag D5 3038 3038 95.08 12878.50 [97.46,97.46]

Mountain D4 10 10 157.99 16598.91 [91.00,92.50]

Staircase D4 349 349 188.11 22865.83 [99.15,99.43]

DiscussionDiscussion

Maximum memory used is about 21MB

Hierarchical matching runs from a few seconds to 6 minutes

Can be embedded in the router to detect process-hotspots

Identified process-hotspots can be eliminated by local wire-spreading and/or widening

Rip up and reroute with new DRC rules based on the constraints of the range pattern

OutlineOutline

Motivation

Range Patterns and Matching

Process-Hotspot Detection System

Experimental Results

Conclusion

ConclusionConclusion

Represent process-hotspots as range patterns

Propose range pattern matching problem and algorithm

Process-hotspot detection system developed to find and score process-hotspots in a given layout

Scalable and fast, can work on large layouts, practical for efficiently detecting process-hotspots during routing

Future work: Handle range patterns with “don’t care” regions Algorithmic process-hotspot correction scheme Combination with recommended rules to reduce the runtime

burden on routers More thorough comparisons with model-based approaches