Reseeding-based Test Set Embedding with Reduced Test Sequences

Reseeding-based Test Set Embedding with Reduced Test Sequences

E. Kalligeros1, 2, D. Kaseridis1, 2, X. Kavousianos3 and D. Nikolos1, 2

1Computer Engineering & Informatics Dept., University of Patras, Greece

2Research Academic Computer Technology Institute, Greece

3Computer Science Dept., University of Ioannina, Greece

MotivationMotivation

• Core-oriented way of designing contemporary Systems on Chip (SoCs) is placing a severe burden on the Automatic Test Equipment (ATE)

• This designing style leads to larger and denser circuits that require greater test data volumes and longer test-application times

MotivationMotivation

• IP protected systems (unknown structure): ways of test

1. Deterministic test set generation: TPG for precisely reproduction of test set

2. Test-pattern compression: Compressed vectors stored on tester and decompressed on chip with small built-in circuit

3. Test set embedding: Encodes test patterns in longer sequences

• Therefore Test-set embedding techniques with short test sequences are required

Outline of the presentationOutline of the presentation

I. Seed-selection algorithm

II. Test-sequence reduction scheme

III. Evaluation-Comparisons

Seed-selection algorithmSeed-selection algorithm

• We consider the classical LFSR-based reseeding scheme: LFSR of length n and a Vector Counter

• The algorithm receives as input the size L of the window that each seed expands to and a set of test cubes T

• For determining a new seed the seed-algorithm makes uses of the well-known concept of solving systems of linear equations (i.e. assuming Gauss-Jordan elimination) [Koenemann ETC’91]

• If each bit of the seed of the LFSR were replaced by a binary variable then each one of the L window states would be a symbolic vector


• The algorithm examines all possible linear systems and chooses one to solve

• If no system can be solved for any of the remaining test cubes the above procedure stops and a new window has been determined

Since at each step of algorithm, linear systems corresponding to more than one test cubes will be solvable at more than one positions of the window, as set of heuristics is needed for selecting the system that will be actually solved


Five heuristics are utilized• Three basic of the algorithm proposed in [Kalligeros et al,

ISQED’02]

• Two new heuristics that significantly refine the selection process (improved encoding ability of proposed algorithm)


• First criterionAt each step of the algorithm the system that is actually selected to be solved is the one that leads to the replacement of the fewest variables in the initial window state

• Second criterionThe cube containing the maximum number of defined bits is the first to be selected for each new seed

• Third criterionTest cube set is split in two different groups:

1. High priority: Cubes that contain many defined bits2. Low priority: Rest cubes of set T

At each step of the algorithm, cubes of 1 are targeted first and only if no such cube can be covered then the cubes of 2 are targeted


• Although the application of the previous heuristics leads to good result in terms of resulting seed volumes they are not elaborate enough

• At each step of the algorithm there are many solvable systems that require the same minimum number of variables to be replaced

• The choice among them is a random choice that does not improve the efficiency of the algorithm.

For that reason two new criteria are introduced


• Fourth criterionFrom the systems that require the elimination of the same minimum number of variables, those corresponding to the test cubes with the maximum number of defined bits are preferred

• Fifth criterionIn the case the fourth criterion gives more than one cube then the systems corresponding to the cube which can be covered at the fewest positions within the L-state window are preferred

The addition of those two criteria improves significantly the encoding ability of the seed-selection algorithm resulting in 25% smaller seed sets on average

Test-sequence reduction schemeTest-sequence reduction scheme

• Seed-selection algorithm assumes a L state window for every seed

• Only some of these states of each window are actually being used for reproducing a test cube of T

• If the last state of a window is not a useful one then all states from the last useful one to the last state of each window are redundant

L-statewindow

First Window State

Last Useful State

Last Window State

RedundantStates

New Seed

• As more seeds are selected by the algorithm, more variables are replaced and thus fewer cubes are encoded in each seed more useless states at the end of these windows


• This problem is much more important in the case of test set embedding since the increased number of seeds leads to much longer test sequences

• Most efficient way (in terms of test-sequence length):

“Maximum reduction” approach which stops the expansion of each seed after the clock cycle in which the last useful state was generated by the LFSR number of redundant states will be zero

Problem:

Vector Counter has to be initialized with a different value at each reseeding Excessive test data storage


• An intermediate approach has to be followed

Proposed approach:

• Each window is segmented into a number (m) of equal-sized groups of LFSR states

• The useful states of the window are included in the first k segments and thus the remaining m-k segments contain redundant states and can be dropped during test generation

• Segment-Vectors Counter: Generate the states of each group (counts from Segment_Size-1 to 0)


Useful States

RedundantStates

Segment 1

Window of Size LPartitioning the window in

m segments

Segment 2

Segment k(Last useful segment)

Segment k+1(First redundant segment)

Segment m(Last segment - redundant)


• With proper selection of Segment_Size, the distance between the last useful state and the end of last useful segment can be minimized

• The Upper limit of number of eliminated redundant states is the one of the “Maximum reduction” approach

A low hardware-overhead solution for generating the useful segment of each window is required


Rearrangement techniqueMain idea: • Order the seeds according to the number of useful segments • if these volumes for every two successive windows differs at most

by one Only a single extra bit per seed is needed for indicating this relation.

Extra bit=0 Same number of useful segment Extra bit=1 One segment difference

Problem: The difference in the number of useful segment between two successive (ordered) seeds may be greater than one

Solution:Some useless segments should be maintained in the window with the smaller number of useful segments


ca

bd

ac

bd

e

e

a) Initial windows and useful segment volumes

7

3

8

5

7

c) Final windows and extra bits

7

3

5

78

Seed 1

Extra Bits

Redundant

Seed 2 Seed 5Seed 4Seed 3

1 0 1 1 0

Seed 1 Seed 2Seed 5 Seed 4Seed 3

ac

bd

e

756

78

Seed 1 Seed 2Seed 5 Seed 4Seed 3

b) Reordering

Segments

Example of rearrangement technique


Load Counter : Down counter that maintains the necessary number of segments for each window

• Initially loaded with maximum number of segments required among all windows

• The value of the extra bit of each window determines the operation of the counter

Extra bit=1 Load counter decreases by oneExtra bit=0 Load counter stays unchanged


In order to actually control the generation of the patterns of a window, two counters are need:

1. Segment-Vectors Counter : Counts from Segment_Size-1 to 0 and controls the generation of the vectors of a segment

2. Segment Counter : Counts the requiring number of segments in each window and thus initialized with the value of Load Counter at the beginning of a new window

These two counters constitute a combined counterSegment Counter’s value is decreased by one every time Segment-Vectors Counter signals that Segment_Size patterns have been applied to the CUT


ControlLogic

LFSR

CUTSeg

men

tC

ount

er

Seg

men

t-V

ecto

rsC

ount

er

2-to-1 MUX

1

0Lo

adC

ount

er

Enable

Seeds

(controlled by extra bit)Enable

TRC

New window generation:

1. Next stored seed is loaded into LFSR

2. Segment Counter is loaded with current Load Counter’s Value3. Load Counter is triggered (or not) according to value of seed’s

stored extra bit

4. Segment-Vectors Counter is enabled


The previous process is repeated until all the seeds

have been expanded to their corresponding vector-segments

Extra hardware overhead of Control Logic:

• The combination of Segment and Segment-Vectors Counters is equal to the Vector Counter of the classical reseeding approach

• Therefore H/W overhead is only the Load Counter

Evaluation-ComparisonsEvaluation-Comparisons

• First Important issue: Choice of window size L

Affects both number of final selected seeds and the length of the resulting test sequences

As ↑ L # of required seeds ↓

But # of required seeds is gradually saturated as ↑ L resulting in larger test sequences with small benefits for the # of seeds


• Second Important issue: Choice of Segment_Size

Can be calculated easily by a very-fast brute force procedure

This procedure tests all possible segment_size values and chooses the best one with respect to:

1. Number of allowed redundant segments in seed’s windows2. Number of redundant vectors in the last useful segment of each

window

Running time on Pentium 2.6 GHz workstation was less than 2 sec


0%

10%

20%

30%

40%

50%

60%

70%

80%

90%

100%

c2670 c7552 s420 s641 s713 s838 s953 s1196 s1238 s5378 s9234 s13207 s15850 s38417 s38584

Results of proposed technique:() Reduction of test-sequence lengths of segmentation-rearrangement technique

compared to unreduced sequences of the seed-selection algorithm() Percentage of test-sequence reduction over those of “maximum reduction” technique


0

50000

100000

150000

200000

250000

300000

s420 s641 s713 s838 s953 s1196 s1238

Tes

t S

equ

ence

Len

gth

Comparison with Twisted-Ring Counters approach

Resulting Test Sequences:() Twisted-Ring with Mintest() Twisted-Ring with Atalanta() Proposed technique

0 11808

1652508

6113250

4034745

217310

1000000

2000000

3000000

4000000

5000000

6000000

s5378 s9234

Proposed technique


Comparison with Twisted-Ring Counters approach

Test Data Storage: () ROM bits of Twisted-Ring with Mintest() ROM bits of Twisted-Ring with Atalanta() ROM bits of Proposed technique

0

2000

4000

6000

8000

10000

12000

14000

s641 s713 s838 s953 s1196 s1238 s5378 s9234

RO

M b

its

ConclusionsConclusions

• Segmentation-rearrangement techniques achieves on average 20,17% reduction in final test-sequence lengths having on average 74,76% of the reduction of the “maximum reduction” approach

• The combination of the two proposed techniques (seed-selection algorithm + segmentation-rearrangement techn.) requires on average 85,39% and 74,04% fewer test vectors than Twisted-Ring Counter for Mintest and Atalanta cases respectively

• On average, compared to Twisted-Ring Counters our technique requires 27,79% and 39,94% less test-data storage for Mintest and Atalanta cases respectively

Reseeding-based Test Set Embedding with Reduced Test Sequences

Documents

Transcript of Reseeding-based Test Set Embedding with Reduced Test Sequences