1. Efficient Static Compaction Algorithms for Combinational Circuits Based on Test Relaxation Yahya E. Osais Advisor: Dr. Aiman H. El-Maleh Members: Dr. Sadiq Sait & Dr. Allaeldin Amin Dept. of Computer Engineering KFUPM11-Oct-03

2. 11-Oct-03yosais2 Outline  Motivation.  Research problems & contributions.  Taxonomy of static compaction algorithms.  Test vector decomposition.  Independent fault clustering.  Class-based clustering.  Test vector reordering.  Conclusions & future research.

3. 11-Oct-03yosais3 Motivation  Rapid advancement in VLSI led to SoC.  Testing SoCs requires large amount of data.  Impact on testing time & memory requirements of test equipment.  Challenges: Reduce amount of test data. Reduce time a defective chip spends on a tester.

4. 11-Oct-03yosais4 Research Problems  Static compaction for combinational circuits. Reduce the size of a test set as much as possible.  Test vector reordering for combinational circuits. Steepen the curve of fault coverage vs. number of test vectors.

5. 11-Oct-03yosais5 Contributions  Taxonomy of static compaction algorithms.  Test vector decomposition. Test vector can be eliminated if its components can be moved to other test vectors.  Efficient static compaction algorithms. IFC CBC  Efficient test vector reordering algorithm. Solutions to time and memory bottlenecks.

6. 11-Oct-03yosais6 Taxonomy of Static Compaction Algorithms Static Compaction Algorithms for Combinational Circuits Redundant Vector Elimination Test Vector Addition & Removal Test Vector Modification Set Covering Test Vector Reordering Essential Fault Pruning Based on ATPG Essential Fault Pruning Based on ATPG Merging Based on Relaxation Based on Raising Test Vector Decomposition IFC CBCGraph Coloring

7. 11-Oct-03yosais7 Test Vector Decomposition (TVD)  Decompose a test vector into its atomic components.  Employ relaxation per a fault.  t p = 010110 & F p = {f 1,f 2,f 3 } (f 1,01xxxx) (f 2,0x01xx) (f 3,x1xx10)  Compaction modeled as graph coloring.

8. 11-Oct-03yosais8 Preliminaries Independent Fault Clustering Preliminaries  Two faults are independent if they cannot be detected by a single test vector.  Two faults are compatible if their components are compatible.  A set of faults is independent (IFS) if no two faults can be detected by the same test vector.  A set of faults is compatible (CFS) if all faults can be detected by the same test vector.

9. 11-Oct-03yosais9  Fault simulate T without fault dropping.  Match essential faults: Extract atomic component c f from t. Map to c f CFS.  Find IFSs.  Match remaining faults: Extract atomic component c f from t  T f. Map c f to CFS. Algorithm Description Independent Fault Clustering Algorithm Description

10. 11-Oct-03yosais10 Illustrative Example Independent Fault Clustering Illustrative Example Fault ComponentFault Detected Test Vector xxx1xx0xxxf1f1 0xx11x0x10v1v1 0xxx1xxxx0f2f2 0xxxxx0x10fe3fe3 x0x1xxxxxxf1f1 10x1xxxx00v2v2 1xxxxxxx00fe4fe4 10x1xxxxxxfe5fe5 0xx0xxxxxxfe6fe6 0xx0xxx00xv3v3 xxxxxxx00xfe7fe7 x11xxxxxx0f2f2 111xxxx0x0v4v4 11xxxxx0xxfe8fe8 xx000xxxxxf9f9 xx000x11x1v5v5 xx0xxx11x1f e 10 xxx0xxxx1xf9f9 x0x01xxx1xv6v6 x0x01xxxxxf e 11

11. 11-Oct-03yosais11 Illustrative Example Independent Fault Clustering Illustrative Example After Merging Components After Mapping IFSsAfter Mapping Essential Faults Cluster Test VectorFault Component FaultFault Component Fault 00x01x0x100xxxxx0x10f3f3 f3f3 1 0xx0xxxxxxf6f6 f6f6 x0x01xxxxxf 11 x0x01xxxxxf 11 0xxx1xxxx0f2f2 10x1xx00001xxxxxxx00f4f4 f4f4 2 10x1xxxxxxf5f5 f5f5 xxxxxxx00xf7f7 f7f7 xxx1xx0xxxf1f1 11000xx0xx11xxxxx0xxf8f8 f8f8 3 xx000xxxxxf9f9 xx0xxx11x1 f 10 xx0xxx11x1f 10 4 IFS 1 ={f 1,f 9 } IFS 2 ={f 2 }

12. 11-Oct-03yosais12 Preliminaries Class-Based Clustering Preliminaries  Conflicting Component (CC) A component c of a test vector t belonging to a test set T is called a CC if it is incompatible with every other test vector in T.  Degree of Hardness of a Test Vector A test vector is at the n th degree of hardness if it has n CCs.  Class of a Test Vector A test vector belongs to class k if its degree of hardness is k.

13. 11-Oct-03yosais13  Movable CC A CC c i is movable to a test vector t if the components in t incompatible with c i can be moved to other test vectors.  Candidate Test Vectors Set of test vectors to which the CC c i can be moved.  Potential Test Vector A test vector whose CCs are all movable. Preliminaries Class-Based Clustering Preliminaries

14. 11-Oct-03yosais14  Fault simulate T without fault dropping.  Generate atomic components.  Remove redundant components using fault dropping simulation.  Classify test vectors.  Process class ZERO test vectors.  Re-classify test vectors.  Process class ONE test vectors.  Re-classify test vectors.  Process class i test vectors, where i > 1. Algorithm Description Class-Based Clustering Algorithm Description

15. 11-Oct-03yosais15  For every test vector t: For every fault detected by t:  If f is essential  Extract atomic component c f from t.  Else  Decrement the number of test vectors detecting f by one. Component of a fault is extracted from a test vector that detects a large number of faults. Component Generation Class-Based Clustering Component Generation

16. 11-Oct-03yosais16 Blockage Value Class-Based Clustering Blockage Value Blockage value of component c i Number of class ZERO test vectors blocked when c i is moved to t j.

17. 11-Oct-03yosais17  Components of a test vector whose blockage value is ZERO can be moved without blocking any class ZERO test vector.  Blockage value MUST be updated after moving components.  Update Rules: If S comp of a component is modified. If a test vector receives new components. If c i is in conflict with c j, S comp (c j ) modified, and S comp (c j ) = 1. Blockage Value Class-Based Clustering Blockage Value

18. 11-Oct-03yosais18 Illustrative Example Class-Based Clustering Illustrative Example Set of Compatible Test Vectors ComponentFaultClassTest Vector {v6}0xxxxx0x10f3f3 0v1v1 {v1,v5}x0x1xxxxxxf1f1 0v2v2 {v4}1xxxxxxx00f4f4 {v5}10x1xxxxxxf5f5 {v1,v5,v6}0xx0xxxxxxf6f6 0v3v3 {v2,v4}xxxxxxx00xf7f7 {v1,v3}x11xxxxxx0f2f2 1v4v4 {}11xxxxx0xxf8f8 {v6}xx0xxx11x1f 10 0v5v5 {v1,v4,v5}xxx0xxxx1xf9f9 0v6v6 {v1,v3,v5}x0x01xxxxxf 11

19. 11-Oct-03yosais19 Illustrative Example Class-Based Clustering Illustrative Example Set of Compatible Test Vectors ComponentFaultClassTest Vector {v5}x0x1xxxxxxf1f1 0v2v2 {v4}1xxxxxxx00f4f4 {v5}10x1xxxxxxf5f5 {v5,v6}0xx0xxxxxxf6f6 0v3v3 {v2,v4}xxxxxxx00xf7f7 {v3}x11xxxxxx0f2f2 1v4v4 {}11xxxxx0xxf8f8 {}xx0xxx11x1f 10 1v5v5 {v4,v5}xxx0xxxx1xf9f9 1v6v6 {v3,v5}x0x01xxxxxf 11 {}0xxxxx0x10f3f3 f6f6 f7f7

20. 11-Oct-03yosais20 Illustrative Example Class-Based Clustering Illustrative Example Set of Compatible Test Vectors ComponentFaultClassTest Vector {v5}x0x1xxxxxxf1f1 0v2v2 {v4}1xxxxxxx00f4f4 {v5}10x1xxxxxxf5f5 {}x11xxxxxx0f2f2 2v4v4 {}11xxxxx0xxf8f8 {v2}xxxxxxx00xf7f7 {}xx0xxx11x1f 10 1v5v5 {v5}xxx0xxxx1xf9f9 1v6v6 {v5}x0x01xxxxxf 11 {}0xxxxx0x10f3f3 {v6}0xx0xxxxxxf6f6 f1f1 f4f4 f5f5

21. 11-Oct-03yosais21 Illustrative Example Class-Based Clustering Illustrative Example Set of Compatible Test Vectors ComponentFaultClassTest Vector {}x11xxxxxx0f2f2 4v4v4 {}11xxxxx0xxf8f8 {}xxxxxxx00xf7f7 {}1xxxxxxx00f4f4 {}xx0xxx11x1f 10 3v5v5 {}x0x1xxxxxxf1f1 {}10x1xxxxxxf5f5 {}xxx0xxxx1xf9f9 4v6v6 {}x0x01xxxxxf 11 {}0xxxxx0x10f3f3 {}0xx0xxxxxxf6f6

22. 11-Oct-03yosais22 Bottlenecks Test Vector Reordering Bottlenecks Algorithm: Rorder  Using non-fault dropping fault simulation, set of all faults detected by each test vector is recorded.  Repeat the following steps until no test vector is left in T: Select a test vector t i from T such that t i detects the largest number of faults. Remove t i from T and append t i to the end of the ordered test set T *, which is initially empty. For each test vector t j in T, remove the faults detected by t i from the set of faults detected by t j.  Return T *. ● Fault simulation without fault dropping is time consuming. ● Memory requirement is high since all faults detected by every test vector are recorded.

23. 11-Oct-03yosais23  Double detection fault simulation A fault is dropped once it is detected twice.  Significant reduction in fault simulation time. Not all faults are considered by a test vector.  Memory is always 2xF. Impact on quality of final test sets  If average number of test vectors detecting a fault is much greater than two. Recently Proposed Solution Test Vector Reordering Recently Proposed Solution

24. 11-Oct-03yosais24  Use of CRItical Path Tracing (CRIPT) as a fault simulator. Cost of fault simulation without dropping is the same as that of fault simulation with dropping.  Experimental results reported by the inventors show that CRIPT is faster than concurrent fault simulation.  CRIPT does not solve the memory problem although it considers less faults. Our Proposed Solution to Time Problem Test Vector Reordering Our Proposed Solution to Time Problem

25. 11-Oct-03yosais25  For i = 1 to n: Run CRIPT. Do not store faults. Store only the number of faults detected by every test vector. Select the best m test vectors. Drop all faults detected by the selected test vectors.  Run algorithm Reorder. Use CRIPT as a fault simulator. Our Proposed Solution to Memory Problem Test Vector Reordering Our Proposed Solution to Memory Problem

26. 11-Oct-03yosais26 Benchmark Circuits Experimental Results Benchmark Circuits FC# DFs# CFs# TVs# Gates# Outputs# InputsCct 95.741263027471541193140233c2670 84.4522895342835016692250c3540 98.897529153501932307123178c5315 98.462966498156337951790700s13207.1f 96.67411335117256579772684611s15850.1f 100217 78104918s208.1f 1003270 2561572130142s3271f 1002870 7041789205172s3330f 1003380 2401685209226s3384f 99.436310043118014722217917421664s38417f 95.852347973630311741925317301464s38584f 1004764 1322342120153s4863f 99.131456346033592779228214s5378f 1006684 1383080294322s6669f 93.475647569276205597250247s9234.1f

27. 11-Oct-03yosais27 Results by RM, GC, and IFC Experimental Results Results by RM, GC, and IFC IFCGCRMROFCct Time (sec.)# TVsTime (sec.)# TVs# Comp# TVs 6.95968.0399761100106c2670 8.98839.08836578083c3540 3110334.951171491106119c5315 169243339.932483516252476s13207.1f 249144463.951694135181456s15850.1f 0.93320.009339433 s208.1f 7.026114.9769121276115s3271f 920811.012331263248277s3330f 7.977215.017310487582s3384f 20721455327.317312215187822s38417f 2590145925021016086232819s38584f 25.964924.01526075965s4863f 2312334.951301460145252s5378f 37.913560.014012864252s6669f 68.06172104.011852093202375s9234.1f

28. 11-Oct-03yosais28 Results by RM, GC, and IFC Experimental Results Results by RM, GC, and IFC  GC computes smaller test sets. As much as 11.9% smaller compared to RM. 1% for c2670; 9.5% for s38584f; 11.9% for s4863f.  Results by IFC are better compared to RM & GC. Improvement over RM: 3% for s208.1f – 37.5% for s38584f Improvement over GC: 1.4% for s3384f – 31% for s38584f Runtime of IFC is better than that of GC.

29. 11-Oct-03yosais29 Sources of Time Consumption in IFC Experimental Results Sources of Time Consumption in IFC  Building IFSs.  Matching non- essential faults. Time (Sec.)Cct TotalMat. Rem. Faults Build IFSs Mat. EFs FS ND 6.953.961.960.060.95c2670 8.9870.970.070.95c3540 3124.141.031.93c5315 1697561.971015s13207.1f 24915156.051523s15850.1f 7.0251.060.930.05s3271f 93.9430.961.04s3330f 7.9751.970.020.95s3384f 207211337537487s38417f 2590118912126689s38584f 25.9621.952.050.980.96s4863f 23145.961.012.04s5378f 37.9127.048.020.950.96s6669f 68.0642.02115.069s9234.1f Non-dropping fault simulation for large circuits.

30. 11-Oct-03yosais30 Results by Iterative IFC Experimental Results Results by Iterative IFC Iterative IFCIFCCct Time (sec.)# Iterations # TVs 42.0768596c2670 26.9537583c3540 88.04486103c5315 473.122238243s13207.1f 374.951129144s15850.1f 0.01132 s208.1f 18.9826061s3271f 30.023196208s3330f 7.07172 s3384f 3775.062120145s38417f 8217.083124145s38584f 70.8834249s4863f 1096117123s5378f 175.0143035s6669f 200.934155172s9234.1f

31. 11-Oct-03yosais31  Improvement over RM: 3% - 46.6%e.g. 35.8% for s38417f  Improvement over IFC: 1.6% - 17.2%e.g. 14.5% for s38584f Results by Iterative IFC Experimental Results Results by Iterative IFC

32. 11-Oct-03yosais32 Results by CBC (ROF+RM) Experimental Results Results by CBC (ROF+RM) CBCRMCct Time (sec.) # TVs After Rem. ClassesAfter Class 1After Class 0 1094 100c2670 13.0278 80c3540 29.039596 106c5315 443243 252s13207.1f 476.02145 147181s15850.1f 0.0133 s208.1f 15.9565 6676s3271f 27223 226248s3330f 11.0272 75s3384f 5750143 146187s38417f 8813153 159232s38584f 24.0452 59s4863f 52116117122145s5378f 50.137 42s6669f 136163166168202s9234.1f

33. 11-Oct-03yosais33 Statistics about Test Sets Experimental Results Statistics about Test Sets Maximum Degree of Hardeness # TVs# Elim. Comp. Cct Class 1 Potential Class 1Class 0 18046121869c2670 2301202263c3540 29021773758c5315 4901502526219s13207.1f 394631807283s15850.1f 150220123s208.1f 7139762090s3271f 2151341941595s3330f 302432363s3384f 7024 18619055s38417f 4110 23220386s38584f 9017584173s4863f 1416171443085s5378f 13015415426s6669f 282641944414s9234.1f

34. 11-Oct-03yosais34  Maximum reduction is 34%.  2.5% for c3540; 23.5% for s38417f; 34% for s38584f. Results by CBC (ROF+RM) Experimental Results Results by CBC (ROF+RM)

35. 11-Oct-03yosais35 Sources of Time Consumption in CBC Experimental Results Sources of Time Consumption in CBC  Component generation.  Component elimination.  Blockage value computation. Time (sec.)Cct TotalPeoc. Class 1 Proc. Class 0 TV Block. Comp. Elim. Comp. Gen FS ND 100.010.0020.0015.0330.05c2670 13.020.0001007.025.030.96c3540 29.030.0041.96116.947.051.01C5315 4430.9925717412326.928.01s13207.1f 476.026.9120011617773.939.01s15850.1f 0.010.00010.0000100.0020.0030.001s208.1f 15.950.035.0246.932.050.94s3271f 27214.0175.922.031.02s3330f 11.020.010.0010.00056.972.060.94s3384f 575011929192310110258820s38417f 881325653404092136973025.04s38584f 24.040.00031.030.11210.920.06s4863f 522.0519.03101951.92s5378f 50.10.00264.9325.9618.030.06s6669f 1362.0148.0324.0254.02124s9234.1f Non-dropping fault simulation for large circuits.

36. 11-Oct-03yosais36 Results by CBC (ROF+IFC & ROF+Iter_IFC) Experimental Results Results by CBC (ROF+IFC & ROF+Iter_IFC) ROF+Iter_IFC+CBCROF+Iter_IFCROF+IFC+CBCROF+IFCCct Time (sec.)# TVs Time (sec.)# TVs 9.978385109396c2670 13737513.957883c3540 33708631.9678103c5315 180236238174239243s13207.1f 250126129248134144s15850.1f 0.0132 0.0132 s208.1f 1058609.985961s3271f 718819611.93201208s3330f 11.9672 1172 s3384f 34331111204684122145s38417f 35631211245322129145s38584f 25.9642 244449s4863f 26.9711211737.96113123s5378f 4430 4335 s6669f 7214315582156172s9234.1f

37. 11-Oct-03yosais37  ROF+IFC+CBC Maximum reduction is 23.5%. 16% for s38417f; 23.5% for c5315.  ROF+Iter_IFC+CBC Maximum reduction is 18.6%. 7.7% for s9234.1f; 18.6% for c5315.  ROF+IFC+CBC vs. ROF+RM+CBC 1.1% - 18%  ROF+Iter_IFC+CBC vs. ROF+RM+CBC 3% - 26.3%  ROF+Iter_IFC+CBC vs. ROF+IFC+CBC 1.3% - 14.3% Results by CBC (ROF+IFC & ROF+Iter_IFC) Experimental Results Results by CBC (ROF+IFC & ROF+Iter_IFC)

38. 11-Oct-03yosais38 Runtimes spent by reordering procedures Experimental Results Runtimes spent by reordering procedures Time (sec.)# TVs Cct CPT+CPTDDGreedy 743714.0411.97633s13207.1f 20416628 657s15850.1f 256918001838071472s38417f 218814101247021174s38584f 156.011.121.97359s5378f 3817118620s9234.1f ● In Greedy, fault simulation is performed using HOPE. ● In CPT, fault simulation is performed using CRIPT. ● DD is run for four iterations. ● In CPT+, n = 4 & m = 4. ● In Greedy, fault simulation is performed using HOPE. ● In CPT, fault simulation is performed using CRIPT. ● DD is run for four iterations. ● In CPT+, n = 4 & m = 4. Effect of non-dropping fault simulation on the performance of TVR procedures.

39. 11-Oct-03yosais39 Memory Required for Circuits Experimental Results Memory Required for Circuits Memory Reduction (%) Total Memory (bytes)# Faults Cct CPTDDCPT+CPTDD 98.79178861364941196309815s13207.1f 9802935915462272345011725s15850.1f 97028777197459916236031180s38417f 96.6032110093173347260636303s38584f 98.439.2559435335892064603s5378f 97.4016631640525138546927s9234.1f

40. 11-Oct-03yosais40 Fault Coverage Curves for s5378f Experimental Results Fault Coverage Curves for s5378f

41. 11-Oct-03yosais41 Fault Coverage Curves for s38417f Experimental Results Fault Coverage Curves for s38417f

42. 11-Oct-03yosais42 Efficiency of Reordering Procedures Experimental Results Efficiency of Reordering Procedures

43. 11-Oct-03yosais43 Efficiency of Reordering Procedures Experimental Results Efficiency of Reordering Procedures

44. 11-Oct-03yosais44 Conclusions & Future Research  Contributions Taxonomy of static compaction algorithms for combinational circuits. Test vector decomposition. Efficient static compaction algorithms.  IFC  CBC Efficient test vector reordering algorithm.  Future Work Investigate the impact of CRIPT & DD on the quality of compacted test sets. Consider reducing the complexity of non-essential fault matching in IFC. Improve the current implementation of building the IFSs. Consider improving the time consuming phases in CBC.

45. 11-Oct-03yosais45 Publications  Aiman H. El-Maleh and Yahya E. Osais, "Test Vector Decomposition-Based Static Compaction Algorithms for Combinational Circuits", ACM Transactions on Design Automation of Electronic Systems, Special issue on VLSI Testing, pp. 430-459, vol. 8, issue 4, Oct. 2003.  Yahya E. Osais and Aiman H. El-Maleh, "A Static Test Compaction Technique for Combinational Circuits Based on Independent Fault Clustering", To appear in Proc. of the 10th IEEE Int'l Conference on Electronics, Circuits, and Systems, Dec. 2004.  Aiman H. El-Maleh and Yahya E. Osais, "A Class-Based Clustering Static Compaction Technique for Combinational Circuits", Submitted to ISCAS 2004.  Aiman H. El-Maleh and Yahya E. Osais, "On Test Vector Reordering for Combinational Circuits", Submitted to ISCAS 2004.

46. 11-Oct-03yosais46

47. 11-Oct-03yosais47  Technique is NOT exact.  Although v 1 has a ZERO blockage value, it blocks v 2. Blockage Value Class-Based Clustering Blockage Value Set of Compatible Test Vectors ComponentTest Vector {v 3 }c 11 v1v1 {v 4 }c 12 {v 3,v 4 }c 21 v2v2

48. 11-Oct-03yosais48 Methodology Worst-Case Analysis Methodology  Test set, fault list, and circuit structure are given as inputs.  N T = No. of test vectors in given test set.  N PI = Size of a test vector.  N F = Number of faults in given circuit.  N G = Number of gates in given circuit.  Logic simulation of a test vector requires O(N G ) basic operations.  Fault simulation of a test vector for a single fault requires O(N G ) basic operations.

49. 11-Oct-03yosais49 Space Complexity of IFC Worst-Case Analysis Space Complexity of IFC Storing the indexes of test vectors detecting every fault.O(N F N T ) Storing a component when it is generated.O(N PI ) Storing test vectors of compatibility sets.O(N T N PI ) Memory space required for building IFSs.O(N F ) O(N T (N F +N PI ))

50. 11-Oct-03yosais50 Space Complexity of CBC Worst-Case Analysis Space Complexity of CBC Storing set of faults detected by every test vector.O(N F N T ) Storing all components.O(N F N PI ) Storing the indexes of compatible/candidate test vectors for every component. O(N T ) Storing blockage values for every component belonging to class zero test vector. O(N T ) O(N F (N T +N PI ))

51. 11-Oct-03yosais51 Time Complexity of IFC Worst-Case Analysis Time Complexity of IFC Fault simulation without dropping.O(N F N T N G ) Finding essential faults.O(N F ) Extracting a single component.O(N G ) Mapping a single component.O(N T N PI ) Computing IFSs.O(N 2 F N 2 T ) Sorting IFSs.O(N F log 2 N F ) Sorting test vectors detecting every fault.O(N F N T log 2 N T ) Dominating sources of time consumption: Computing IFSs = O(N 2 F N 2 T ). Matching non-essential faults = O(N F N T (N T N PI +N G )).

52. 11-Oct-03yosais52 Time Complexity of CBC Worst-Case Analysis Time Complexity of CBC Fault simulation without fault dropping.O(N F N T N G ) Sorting test vectors.O(N T log 2 N T ) Component generation.O(N F N G ) Dropping redundant components using fault simulation with dropping.O(N 2 F N G ) Merging components.O(N F ) Classification of test vectors.O(N F N T N PI ) Computing blockage values for all class zero test vectors.O(N 2 F N T N PI ) Moving components to appropriate test vectors.O(N F N T ) Updating S comp for all components belonging to class zero test vectors.O(N F N T N PI ) Updating blockage values for all class zero test vectors.O(N 2 F N 2 T N PI ) Processing remaining class zero test vectors.O(N F N 2 T N PI ) Finding class i test vectors.O(N T ) Computing S cand of a CC belonging to class one test vector.O(N F N PI )

53. 11-Oct-03yosais53 Time Complexity of CBC Worst-Case Analysis Time Complexity of CBC Processing class one test vectors.O(N F N 2 T N PI ) Processing remaining classes.O(N F N 2 T N PI ) Dominating sources of time consumption in class zero algorithm: Computing blockage value = O(N 2 F N T N PI ). Updating S comp = O(N F N T N PI ). Updating blockage values of components = O(N 2 F N 2 T N PI ). Dominating sources of time consumption in CBC: Component generation = O(N F N G ). Component elimination = O(N 2 F N G ). Blockage value computation = O(N 2 F N T N PI ).