l Some materials from various sources! n Current course textbook! Soma 1! Soma 3!

Transcription

1 Ackwledgements! Test generation algorithms! Mani Soma! l Some materials from various sources! n r. Phil Nigh, IBM! n Principles of Testing Electronic Systems by S. Mourad & Y. Zorian! n Essentials of Electronic Testing by M.L. Bushnell and V.. Agrawal! n Current course textbook! Soma! Soma 2! Test generation! Stuck-at faults revisited! l Criteria:! n cost! Ø number of tests, types of tests! n quality (fault coverage)! l SSF model assumed! l Techniques: deterministic, random, behavioral, ad hoc (functional)! l Combinational & sequential circuits! Soma 3! Soma 4! Faults (after equivalence)! Test for X/! l fault excitation: X <-. Justify inputs! l fault propagation to outputs! l line justification back to inputs! l consistency check! A a C B b Soma 5! Soma 6!

2 flipflop test generation! l How to test flipflop (using only behavioral description)?! n test CLK line, Reset line, Set line! n static logic tests:! Ø all s! Ø all s! Ø...! Ø..! flipflop test (2)! l flipflop test generation! n dynamic timing tests! Ø set-up and hold time, edge-triggered test! Ø delay time! Ø CLK frequency! l Test plan for VLSI systems in general! n divide into combinational and sequential! n test critical lines first (V, CLK, Reset,...)! Soma 7! Soma 8! System test plan (con t)! l System test plan! n self-test blocks! n test all flipflops on scan paths! n test critical flipflops t on scan paths! n test combinational logic blocks! n test remainder logic! l Behaviors can be used to generate tests intelligently! Soma 9! System test plan (con t)! l Think BEFORE jumping into any test or test plan! n the larger the system, the more critical the thinking step is! n divide-and-conquer! n sequence of tests: what to test first, what to test next, etc.! n combine behavior with fault models! Soma! Major test generation algorithms! History of Algorithm Speedups! l algorithm: core technique! l POEM: improves on algorithm! l FAN: improves on POEM! l Alphabet soups:! n TG = test generation! n ATPG = automatic test pattern generation! n PI: primary input, PO = primary output! Algorithm -ALG POEM FAN TOPS SOCRATES Waicukauski et al. EST TRAN Recursive learning Tafertshofer et al. Est. speedup over -ALG ATPG System 289 ATPG System 8765 ATPG System 35 ATPG System Year Soma! Soma 2!

3 tation and concepts! 5-valued logic operations! l Logic values:, (good circuits)! l Faulty values: tation! n A = means A = in good circuit, in faulty circuit! n A = means A = in good circuit, in faulty circuit! l -algebra for basic gates! AN ʼ x ʼ x x ʼ ʼ ʼ x x x x x x OR ʼ x ʼ x x ʼ ʼ ʼ x x x x x x Soma 3! Soma 4! Basic operations! Basic algorithm! Justification W/ A= B= G E= Implication C G2 Sensitization or Propagation U = G G4 G6 H= Justification G3 F V G5 Z l set all nets to x! l justify a net A to (s-a- fault) or (s-a- fault) using failure -cube! l propagate or to output! l if all input assignments are consistent, test found; else, loop to select ather path until either test found or test exists! l loop to test for all nets in circuit! l end! Soma 5! Soma 6! Quick example ()! l Fault sensitization (fault site)! l Fault propagation (toward POs)! l Line justification (backward to PIs)! Try one path! Try path f h k L blocked at k, since there is way to justify the on i! AN gate: input= --> output cant be set to! see 5-valued logic table (slide 4)! Soma 7! Soma 8!

4 Try 2 paths simultaneously! Simultaneous paths f h k L and g i j k L blocked at k because -frontier (chain of or ) disappears! Try ather path! Final try: path g i j k L test found!! Soma 9! Soma 2! l Failure -cubes! -cubes (vectors)! n insert or generate faults via cube intersection! l Propagating & n-propagating -cubes! n to select / de-select paths and justify values! l Intersection rules to form cubes! n from logic descriptions! Failure- cubes! l Truth tables for fault-free and faulty cases! n good * bad : * =, * =, * =, * =! l 2-input NAN gate: failure cube for c2/ is 2 3! c c2 c3 (good) c3 (c2/) Soma 2! Soma 22! Fault propagation using! l Propagating -cubes: generation from ON and OFF arrays in good truth table! n a from ON array, b from OFF array! n NAN gate example! l Non-propagating -cubes:! n a and b are from same type of array (either both ON or both OFF)! n NAN gate example! NAN propagation -cubes! l intersect ON-cube with OFF-cube! n * =, * =, * =, * =! n a * d = 2 3, b * d = 2 3, c * d = 2 3! c c2 c3 (ON) cube a (ON) cube b (ON) cube c (OFF) cube d Soma 23! Soma 24!

5 NAN n-propagating cubes! l intersect cubes from same array (output)! n * =, * =, * =, * =! n a * b = 2 3, a * c = 2 3, b * c = 2 3! c c2 c3 (ON) cube a (ON) cube b (ON) cube c (OFF) cube d l Cell name! l Logic description! Cell library information! n truth table, behavior, equation, state table! l Layout parameters! n cell size, I/O! l Performance parameters! n delay, timing, power! l Test parameters! n cubes, test set, fault coverage! Soma 25! Soma 26! Basic tasks in test generation! l Line justification! n start from a gate output! n justify output by setting gate inputs (multiple ways to do so) (J-frontier)! Ø select one and remember it! Ø re-select if did t work! n recursion back to PIs! l Propagation! Basic tasks (2)! n set gate inputs to propagate a fault value to output (-frontier)! n justify these gate inputs! Ø same process as justification! n recursion till reaching POs! Soma 27! Soma 28! ecision process to select path! l How to select a path to justify or propagate a signal! n backtracking strategy to explore paths systematically! n decision tree for path objectives! n compute all values determined by implication or setting of a specific signal! n consistency check! The -algorithm! l Complete algorithm flow (next slide)! n PCF = primitive -cube for failure! n eventual exhaustive search of all paths! l core of all test generation software using path sensitization! l variations! n select single path to propagate! n restrict run-time vs. test existence! Soma 29! Soma 3!

6 -algorithm flowchart! START POEM algorithm! Pattern More lines to justify? Select a Line to Justify all other lines, if any Inconsistency? Select a Fault Generate the PCF Is there a or a ' on any primary ouput? Propagate the -cube and intersect Inconsistency? Mark the lines to be justified l POEM (Path-Oriented Ecision Making)! n improves on algorithm: assign only PI values (t intermediate signal values)! Ø backtracing with objectives till PI! Ø set PI then simulate to see if objective is met! Alternativepath for justification? Alternative gate for propagation? a c e f Backtrack one Level and select ather path Revisiting a de? Backtrack one Level and select ather path Reached PFC? b d No Pattern Exists Soma 3! Soma 32! Objective backtrace! l obj (f,): select path fdb -> obj (d,) -> obj (b,) and (c,). Simulate with b =! l obj (f,) t met. obj (c,) -> obj (a,). Simulate with a=, b=. Obj (f,) met.! a c b e d f Soma 33! POEM improvements! l Expand decision tree only around variables on interest, t all circuit paths! l epth-first search back to PI! n backtrace : operation to determine which PI should be set to achieve objective, with controllability / observability measures! n pick easiest objective first! l Set PI and forward simulate (implication) instead of too much backtracking ( alg.)! Soma 34! POEM features! l complete algorithm (next slide)! l need to check for consistency at PI after all paths were backtracked ( alg.)! l J-frontier ( backward justification)! l only forward propagation of values set by PI! n simulation used to replace backtracking! l suitable for large systems! POEM flowchart! START Assign a binary value to an unassigned primary input etermine implications of all primary inputs Test has been Is there a or a generated on any primary ouput? Test possible with the additional assigned primary inputs? maybe Is there an No Pattern untried combination of Exists values on assigned primary inputs? Soma 35! Set untried combination of values on assigned primary inputs Soma 36!

7 Test for E/ with POEM! Test for G/ with POEM! U W X Y G G2 E F G3 G4 H G G5 Z X W U E W X V U H G G2 G3 F G4 G G5 I Y Z E V X W Soma 37! Soma 38! FAN! l Fan-out oriented test generation! n faster backtracing for fan-outs! n backtracing stops at headlines of fan-outs! l Multiple-backtrace objectives! head lines bound lines FAN improvements! l Reduce test generation time! l Simultaneous and immediate implications to set unique signals to achieve objective! n breadth-first search! n multiple backtrace! l Unique sensitization when there is only one path choice for fault propagation! l Use of headlines to eliminate backtrace / backtracks! Soma 39! Soma 4! FAN vs. POEM!! Computing Time Average Backtracks % of Faults Aborted Circuit POEM FAN POEM FAN POEM FAN Soma 4! SOCRATES! l Use learning to reduce test generation time! n perform signal implication faster! (p " q) # ( q " p) [(a = ) " (i = )] $ [(a = ) " (i = )] " (i = ) l 3-input AN (abc) =f! n a= -> f= equivalent to f= -> a=! l Static and dynamic learning! n run learning algorithms! Soma 42!

8 Summary of key algorithms! l algorithm! n algebra (5-valued, 9-valued, etc.)! n systematic exhaustive path search! n core concepts! l POEM and FAN: very popular! n faster path search! n reduced conflicts and backtracking! n better fan-out handling! Path selection algorithms! l How to select a good path?! n cost function! l Controllability concepts! l Observability concepts! l Testability to combine controllability values and observability values! Soma 43! Soma 44! SCOAP! l Sandia C/O Analysis Program! l C (controllability) values:! n relative difficulty in setting output! n depth of logic block from input! l O (observability) values:! n relative difficulty in observing input! n depth of logic block from output! Example! l 3-input AN: Y = A*B*C! n C(Y=) = min (C(A=), C(B=), C(C=)) +! n C(Y=) = C(A=)+C(B=)+C(C=) +! n O(A) = O(Y) + C(B=) + C(C=) +! l PIs: C =, POs: O =.! l Higher values = worse! l Issues: fan-out, sequential logic C/O! Soma 45! Soma 46! Probabilistic measures! l Stephenson & Grason, 976.! l CY: controllability, OY: observability! l Component-level models! l Solution of systems of equations for entire network! Testability measures! l How good are they?! n high values mean test exists?! Ø consistency between controllability and observability! n correlation with actual test difficulty! n dynamic measures! l Useful mostly as a guide to path selection! l Testability : define when use! Soma 47! Soma 48!

9 Random test generation! l pseudo-random techniques! l ease of generating tests! l test vectors: uniformly distributed (PI equally likely to be or ), independent, biased or weighted! l test set size: tends to be larger (random test length)! l quality: best measure is fault coverage! Random test generation (2)! l Estimation of detection probabilities and test lengths (without fault simulation)! l RAPS:! n select PO randomly and assign a value! n random backtrace to justify (random path selection)! n forward simulation to check (like POEM)! l Basis for many built-in self-test (BIST) methods! Soma 49! Soma 5! Random test generation flowchart! Test generation systems! l Fault list! n redundant faults (undetectable), collapsing faults! l Test generation: random then deterministic! n fault selection order! l Test set compaction! n compact vectors with x values for PIs! n static or dynamic compaction! Soma 5! Soma 52! Test compaction example! Sequential test generation! l t=x! l t2=x! l t3=x! l t4=x! (t, t3) t3= t2=x t4=x (t2,t4) t3= t24= l ifficulty in sequential ATPG! n sequential depth: depth of latches before a!controllable point is reached during backtracking! n feedback loops: during backtracking, the frequency!of encountering the same latches! (t,t2) t2= t3=x t4=x l Largest design a state-of-the-art sequential ATPG tool can handle is 2-3K logic gates.! n for reference: combinational ATPG tools handle over million logic gates! l Use scan design to solve this problem! Soma 53! Soma 54!

10 Sequential test generation (2)! l Iterative arrays of identical memory elements! n space expansion of time components! n issue of test length vs. number of states! n generation of sequences (initialization, homing, etc.)! n propagation both forward and backward in time! Sequential test generation (3)! l Multiple-clock in one or more domains! l Theoretical solutions t practically feasible! n complexity too high! n still open problems! l Asynchrous systems! n issues of races and hazards! n dependence on delays! n practically feasible?! Soma 55! Soma 56! Behavior-based test generation! l FF example! l Speed-up justification and propagation! l Feasible in sequential test generation! l Heuristic search of behavioral space during test generation! l Open problems for general systems! Conclusion! l NP-complete problems in most cases! l Practical algorithms exist for realistic systems (random and deterministic)! l Combination of fault and behavioral models! l ivide-and-conquer! l FT techniques (scan in sequential test)! l New techniques, e.g. AI, etc.! Soma 57! Soma 58!