1. Multiple-Vector Column-Matching BIST Design Method Petr Fišer, Hana Kubátová Department of Computer Science and Engineering Czech Technical University in Prague

2. 2 Outline Motivation Motivation Basic BIST design Basic BIST design Output decoder Output decoder Column-Matching Column-Matching Mixed-Mode BIST Mixed-Mode BIST... well, these topics of mine are quite old. Sorry ATPG modes ATPG modes Test set compaction Test set compaction Multiple-Vector Column-Matching Multiple-Vector Column-Matching Results Results Conclusions Conclusions

3. 3 Motivation We want to reduce the BIST area overhead This is done by fully exploiting ATPG capabilities But for a cost of an increase of the BIST design time “They say”, that it does not matter that much. If the circuit design time is one year, one week of BIST design time is nothing...

4. 4 BIST Structure Test-per-clock BIST structure Notice that this is a general structure used in most of currently used BIST methods: Bit-flipping Bit-flipping Bit-fixing Bit-fixing Weighted-pattern testing Weighted-pattern testing Column-matching Column-matching......

5. Figure from "Chatterjee, Pradhan: A novel pattern generator for near-perfect fault coverage, VTS, 1995" 5 Output Decoder Modifies pseudo-random LFSR vectors into deterministic test patterns Decoder is purely combinational block We are testing combinational (or full-scan) circuits => order of test patterns is insignificant

6. 6 Output Decoder  Example

7. 7 Column-Matching Based on “matching” columns having same values => no logic needed Recall: by properly assigning the rows y0 = x4’ + x1 y1 = x3’ y2 = x2 x3’ + x2’ x4’ y3 = x0’ y4 = x4

8. 8 Column-Matching But how to find a good row assignment? (so that maximum columns are matched)   B-Matrix based approach Rows are LFSR vectors, columns are test patterns Initialization: fill with ‘1’s => each of the test patterns can be assigned to any LFSR vector Select two columns randomly Set B-matrix vales to ‘0’, when opposite values are in respective column and row positions => rows containing opposite values in the matched columns cannot be assigned to each other Repeat, while there is a possibility for a new match The aim: to assign all test patterns to some LFSR vectors

9. 9 Making Row Assignment From the B-Matrix NP-Hard - similar to binate covering problem LCLR But efficient heuristic can be used: LCLR Find the column having the least number of “1”s Find the column having the least number of “1”s (i.e., the test pattern that is the hardest one to cover) Find the row having a “1” value in this column and having the least number of “1”s in other columns Find the row having a “1” value in this column and having the least number of “1”s in other columns (i.e., the least useful LFSR pattern) Assign them together, remove them from the matrix Repeat, while there are some columns left

10. 10 Column-Matching Anyway... More “freedom” involves more column matches don’t cares “Freedom” = test don’t cares less area overhead More column matches = less area overhead

11. 11 Mixed-Mode BIST Combination of pseudo-random and deterministic testing Combination of pseudo-random and deterministic testing Two disjoint phases Two disjoint phases   Easy-to-detect faults are detected by pseudorandom patterns   The rest by deterministic patterns

12. 12 Mixed-Mode Column-Matching  Example

13. 13 Ugh...

14. 14 ATPG Modes Alias what test sets can be beaten out of an ATPG Non-compacted test without don’t cares Compacted test set without don’t care values Compacted test set with don’t cares Non-compacted test with don’t cares One test vector for each fault More than one test vector for each fault All the possible test vectors for each fault

15. 15 ATPG Modes Alias what test sets can be beaten out of an ATPG Non-compacted test without don’t cares Compacted test set without don’t care values Compacted test set with don’t cares Non-compacted test with don’t cares One test vector for each fault More than one test vector for each fault All the possible test vectors for each fault random-pattern simulation deterministic test set generation  long (-)  no freedom for a choice (-)

16. 16 ATPG Modes Alias what test sets can be beaten out of an ATPG Non-compacted test without don’t cares Compacted test set without don’t care values Compacted test set with don’t cares Non-compacted test with don’t cares One test vector for each fault More than one test vector for each fault All the possible test vectors for each fault random-pattern simulation deterministic test set generation test set compaction don’t care substitution  the most common ATPG mode  minimum test vectors (+)  but no don’t cares are there (-)  no freedom for a choice (-)

17. 17 ATPG Modes Alias what test sets can be beaten out of an ATPG Non-compacted test without don’t cares Compacted test set without don’t care values Compacted test set with don’t cares Non-compacted test with don’t cares One test vector for each fault More than one test vector for each fault All the possible test vectors for each fault random-pattern simulation deterministic test set generation test set compaction no don’t care substitution  minimum test vectors (+)  but not much more don’t cares (?)  little bit freedom for a choice (?)

18. 18 ATPG Modes Alias what test sets can be beaten out of an ATPG Non-compacted test without don’t cares Compacted test set without don’t care values Compacted test set with don’t cares Non-compacted test with don’t cares One test vector for each fault More than one test vector for each fault All the possible test vectors for each fault deterministic test set generation  no random phase  no compaction  many don’t cares in the test (+)  more freedom for a choice (+)

19. 19 ATPG Modes Alias what test sets can be beaten out of an ATPG Non-compacted test without don’t cares Compacted test set without don’t care values Compacted test set with don’t cares Non-compacted test with don’t cares One test vector for each fault More than one test vector for each fault All the possible test vectors for each fault deterministic test set generation one test vector for each fault  no random phase  no compaction  many many don’t cares in the test (++)  long test (-)  much more freedom for a choice (++)

20. 20 ATPG Modes Alias what test sets can be beaten out of an ATPG Non-compacted test without don’t cares Compacted test set without don’t care values Compacted test set with don’t cares Non-compacted test with don’t cares One test vector for each fault More than one test vector for each fault All the possible test vectors for each fault deterministic test set generation more test vectors for each fault  no random phase  no compaction  many many don’t cares in the test (++)  long test (-)  much much more freedom for a choice (+++)

21. 21 ATPG Modes Alias what test sets can be beaten out of an ATPG Non-compacted test without don’t cares Compacted test set without don’t care values Compacted test set with don’t cares Non-compacted test with don’t cares One test vector for each fault More than one test vector for each fault All the possible test vectors for each fault deterministic test set generation all test vectors for each fault  no random phase  no compaction  many many don’t cares in the test (++)  little bit longer test (...)  much much much more freedom for a choice (++++) After obtaining 10 000 000 vectors for the 1 st fault for c432, I have resigned...

22. 22 ATPG Modes Alias what test sets can be beaten out of an ATPG Non-compacted test without don’t cares Compacted test set without don’t care values Compacted test set with don’t cares Non-compacted test with don’t cares One test vector for each fault More than one test vector for each fault All the possible test vectors for each fault deterministic test set generation more test vectors for each fault  no random phase  no compaction  many many don’t cares in the test (++)  long test (-)  much much more freedom for a choice (+++) That’s it!

23. 23 Test Set Compaction Requirements: Short test Many don’t cares Our algorithm: Based on joining test vectors Vectors can be joined, when they have non- empty intersection Vectors having the “biggest” intersection are joined

24. 24 Test Set Compaction Our algorithm: Let a test vector t 1 detects a fault set F 1 and a test vector t 2 detects a fault set F 2 Then their intersection t 1  t2 detects faults F 1  F 2  Example 10-0- 1100101001 1-10- 0100100100 1010- 1100101101

25. 25 Test Set Compaction Results benchvct/fltATPGcompactDC c19081423650 % 1038234025 % c267012017483 % 10182482577 % c35401312572 % 1011710165 % c7552121510669 % 102141120668 % s11961935559 % 10039225956 % s12381453357 % 1001409552 % s53781231992 % 10028925892 % s9234.113219982 % 102899100381 % s13207.114667496 % 10153836296 %

26. 26 Column-Matching But how to find a good row assignment? (so that maximum columns are matched)   B-Matrix based approach Rows are LFSR vectors, columns are test patterns Initialization: fill with ‘1’s. Each test patterns can be assigned to each LFSR vector Select two columns randomly Set B-matrix vales to ‘0’, when opposite values are in respective column and row positions => rows containing opposite values in the matched columns cannot be assigned to each other Repeat, while there is a possibility for a new match The aim: to assign all test patterns to some LFSR vectors

27. 27 Multiple-Vector Column-Matching But how to find a good row assignment? (so that maximum columns are matched)   B-Matrix based approach Rows are LFSR vectors, columns are test patterns Initialization: fill with ‘1’s. Each test patterns can be assigned to each LFSR vector Select two columns randomly Set B-matrix vales to ‘0’, when opposite values are in respective column and row positions => rows containing opposite values in the matched columns cannot be assigned to each other Repeat, while there is a possibility for a new match The aim: to detect all faults Only the Row assignment algorithm has to be slightly changed (B-matrix solution)

28. 28 Making Row Assignment From the B-Matrix Not all columns have to be covered Not all columns have to be covered Different heuristic: Different heuristic: Find the column (test pattern) detecting most of faults Find the row having a “1” value in this column and having the least number of “1”s in other columns Find the row having a “1” value in this column and having the least number of “1”s in other columns (i.e., the least useful LFSR pattern) Remove detected faults from the fault list Repeat, until the fault list is empty

29. 29 Experimental Results benchPR/detvct/fltcompactMtime [s]overheadimprovement c19081 K / 1 K13628/336.75.7 % 1034030/3355.93.0 %48 % c35401 K / 1K13148/503.92.2 % 1010148/5019.11.6 %27 % 10055549/5090.01.3 %42 % c755210 K / 1K1106152/2071104.817.0 % 101206159/20716124.714.8 %13 % s11961 K / 1 K15527/325.511.1 % 1025928/32109.07.8 %30 % s12383 K / 1 K13327/322.96.7 % 1009528/3216.74.6 %31 % s537810 K / 1 K119214/2147.71.5 % 100258213/214181.50.9 %40 % s9241.1200 K / 1 K152224/247160.75.3 % 10564225/2473508.64.9 %10 %

30. 30 Conclusions An enhancement of our Column-matching method is proposed An enhancement of our Column-matching method is proposed The improvement is based on exploiting ATPG capabilities to produce more vectors for each fault The improvement is based on exploiting ATPG capabilities to produce more vectors for each fault The BIST area overhead is reduced, for a cost of a longer BIST design time The BIST area overhead is reduced, for a cost of a longer BIST design time