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
KFUPM
11-Oct-03
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.

11-Oct-03
yosais
2
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:



11-Oct-03
Reduce amount of test data.
Reduce time a defective chip spends on a
tester.
yosais
3
Research Problems

Static compaction for combinational
circuits.


Reduce the size of a test set as much as
possible.
Test vector reordering for combinational
circuits.

11-Oct-03
Steepen the curve of fault coverage vs.
number of test vectors.
yosais
4
Contributions
Taxonomy of static compaction algorithms.
 Test vector decomposition.



Efficient static compaction algorithms.



Test vector can be eliminated if its components
can be moved to other test vectors.
IFC
CBC
Efficient test vector reordering algorithm.

11-Oct-03
Solutions to time and memory bottlenecks.
yosais
5
Taxonomy of Static Compaction
Algorithms
Static Compaction Algorithms for Combinational Circuits
Redundant Vector
Elimination
Set Covering
Test Vector
Reordering
Based on
Relaxation
11-Oct-03
Merging
Test Vector
Modification
Test Vector Addition &
Removal
Essential
Fault Pruning
Essential Fault
Pruning
Test Vector
Decomposition
Based on
ATPG
Based on
Raising
IFC
yosais
CBC
Based on
ATPG
Graph Coloring
6
Test Vector Decomposition (TVD)
Decompose a test vector into its atomic
components.
 Employ relaxation per a fault.
 tp = 010110 & Fp = {f1,f2,f3}





(f1,01xxxx)
(f2,0x01xx)
(f3,x1xx10)
Compaction modeled as graph coloring.
11-Oct-03
yosais
7
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.

11-Oct-03
yosais
8
Independent Fault Clustering
Algorithm Description
Fault simulate T without fault dropping.
 Match essential faults:



Extract atomic component cf from t.
Map to cf CFS.
Find IFSs.
 Match remaining faults:



11-Oct-03
Extract atomic component cf from t  Tf.
Map cf to CFS.
yosais
9
Independent Fault Clustering
Illustrative Example
Test Vector
v1
v2
v3
v4
v5
v6
11-Oct-03
0xx11x0x10
10x1xxxx00
0xx0xxx00x
111xxxx0x0
xx000x11x1
x0x01xxx1x
Fault
Detected
Fault Component
f1
xxx1xx0xxx
f2
0xxx1xxxx0
fe3
0xxxxx0x10
f1
x0x1xxxxxx
fe4
1xxxxxxx00
fe5
10x1xxxxxx
fe6
0xx0xxxxxx
fe7
xxxxxxx00x
f2
x11xxxxxx0
fe8
11xxxxx0xx
f9
xx000xxxxx
fe10
xx0xxx11x1
f9
xxx0xxxx1x
fe11
x0x01xxxxx
yosais
10
Independent Fault Clustering
Illustrative Example
After Mapping
Essential Faults
After Mapping IFSs
After
Merging
Components
Cluster
Fault
Fault
Component
Fault
Fault
Component
Test Vector
1
f3
0xxxxx0x10
f3
0xxxxx0x10
00x01x0x10
f6
0xx0xxxxxx
f6
0xx0xxxxxx
f11
x0x01xxxxx
f11
x0x01xxxxx
f2
0xxx1xxxx0
2
3
4
11-Oct-03
f4
1xxxxxxx00
f4
1xxxxxxx00
f5
10x1xxxxxx
f5
10x1xxxxxx
f7
xxxxxxx00x
f7
xxxxxxx00x
f1
xxx1xx0xxx
f8
11xxxxx0xx
f9
xx000xxxxx
f10
xx0xxx11x1
f8
f10
11xxxxx0xx
xx0xxx11x1
yosais
IFS1={f1,f9}
IFS2={f2}
10x1xx0000
11000xx0xx
xx0xxx11x1
11
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 nth 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.
11-Oct-03
yosais
12
Class-Based Clustering
Preliminaries

Movable CC
A CC ci is movable to a test vector t if the
components in t incompatible with ci can be
moved to other test vectors.

Candidate Test Vectors
Set of test vectors to which the CC ci can be
moved.

Potential Test Vector
A test vector whose CCs are all movable.
11-Oct-03
yosais
13
Class-Based Clustering
Algorithm Description









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.
11-Oct-03
yosais
14
Class-Based Clustering
Component Generation

For every test vector t:

For every fault detected by t:

If f is essential
 Extract atomic component cf 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.
11-Oct-03
yosais
15
Class-Based Clustering
Blockage Value
NumComp
TVB (t )


Blockage value
of component ci
CB (ci )
i 1
CB (ci )
11-Oct-03



Min CB (ci , t j )
yosais
Number of
class ZERO test
vectors blocked
when ci is
moved to tj.
16
Class-Based Clustering
Blockage Value
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:




11-Oct-03
If Scomp of a component is modified.
If a test vector receives new components.
If ci is in conflict with cj, Scomp(cj) modified, and
Scomp(cj) = 1.
yosais
17
Class-Based Clustering
Illustrative Example
Test
Vector
Class
Fault
Component
Set of
Compatible
Test Vectors
v1
0
f3
0xxxxx0x10
{v6}
v2
0
f1
x0x1xxxxxx
{v1,v5}
f4
1xxxxxxx00
{v4}
f5
10x1xxxxxx
{v5}
f6
0xx0xxxxxx
{v1,v5,v6}
f7
xxxxxxx00x
{v2,v4}
f2
x11xxxxxx0
{v1,v3}
f8
11xxxxx0xx
{}
v3
v4
11-Oct-03
0
1
v5
0
f10
xx0xxx11x1
{v6}
v6
0
f9
xxx0xxxx1x
{v1,v4,v5}
f11
x0x01xxxxx
{v1,v3,v5}
yosais
18
Class-Based Clustering
Illustrative Example
Test
Vector
Class
Fault
Component
Set of
Compatible
Test Vectors
v2
0
f1
x0x1xxxxxx
{v5}
f4
1xxxxxxx00
{v4}
f5
10x1xxxxxx
{v5}
f6
0xx0xxxxxx
{v5,v6}
f7
xxxxxxx00x
{v2,v4}
f2
x11xxxxxx0
{v3}
f8
11xxxxx0xx
{}
v3
f7
f6
11-Oct-03
v4
0
1
v5
1
f10
xx0xxx11x1
{}
v6
1
f9
xxx0xxxx1x
{v4,v5}
f11
x0x01xxxxx
{v3,v5}
f3
0xxxxx0x10
{}
yosais
19
Class-Based Clustering
Illustrative Example
f4
f5
f1
11-Oct-03
Test
Vector
Class
Fault
Component
Set of
Compatible
Test Vectors
v2
0
f1
x0x1xxxxxx
{v5}
f4
1xxxxxxx00
{v4}
f5
10x1xxxxxx
{v5}
f2
x11xxxxxx0
{}
f8
11xxxxx0xx
{}
f7
xxxxxxx00x
{v2}
v4
2
v5
1
f10
xx0xxx11x1
{}
v6
1
f9
xxx0xxxx1x
{v5}
f11
x0x01xxxxx
{v5}
f3
0xxxxx0x10
{}
f6
0xx0xxxxxx
{v6}
yosais
20
Class-Based Clustering
Illustrative Example
Test
Vector
Class
Fault
Component
Set of
Compatible
Test Vectors
v4
4
f2
x11xxxxxx0
{}
f8
11xxxxx0xx
{}
f7
xxxxxxx00x
{}
f4
1xxxxxxx00
{}
f10
xx0xxx11x1
{}
f1
x0x1xxxxxx
{}
f5
10x1xxxxxx
{}
f9
xxx0xxxx1x
{}
f11
x0x01xxxxx
{}
f3
0xxxxx0x10
{}
f6
0xx0xxxxxx
{}
v5
v6
11-Oct-03
3
4
yosais
21
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 ti from T such that ti detects the largest number
of faults.
Remove ti from T and append ti to the end of the ordered test set T*,
which is initially empty.
For each test vector tj in T, remove the faults detected by ti from the
set of faults detected by tj.
Return T*.
● Fault simulation without fault dropping is time consuming.
● Memory requirement is high since all faults detected by every
test vector are recorded.
11-Oct-03
yosais
22
Test Vector Reordering
Recently Proposed Solution

Double detection fault simulation

A fault is dropped once it is detected twice.


Not all faults are considered by a test vector.


Memory is always 2xF.
Impact on quality of final test sets

11-Oct-03
Significant reduction in fault simulation time.
If average number of test vectors detecting a fault is
much greater than two.
yosais
23
Test Vector Reordering
Our Proposed Solution to Time Problem

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.
11-Oct-03
yosais
24
Test Vector Reordering
Our Proposed Solution to Memory Problem

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.
11-Oct-03
yosais
25
Experimental Results
Benchmark Circuits
Cct
# Inputs
# Outputs
# Gates
# TVs
# CFs
# DFs
FC
c2670
233
140
1193
154
2747
2630
95.741
c3540
50
22
1669
350
3428
2895
84.452
c5315
178
123
2307
193
5350
5291
98.897
s13207.1f
700
790
7951
633
9815
9664
98.462
s15850.1f
611
684
9772
657
11725
11335
96.674
s208.1f
18
9
104
78
217
217
100
s3271f
142
130
1572
256
3270
3270
100
s3330f
172
205
1789
704
2870
2870
100
s3384f
226
209
1685
240
3380
3380
100
s38417f
1664
1742
22179
1472
31180
31004
99.436
s38584f
1464
1730
19253
1174
36303
34797
95.852
s4863f
153
120
2342
132
4764
4764
100
s5378f
214
228
2779
359
4603
4563
99.131
s6669f
322
294
3080
138
6684
6684
100
s9234.1f
247
250
5597
620
6927
6475
93.475
11-Oct-03
yosais
26
Experimental Results
Results by RM, GC, and IFC
Cct
ROF
RM
# TVs
# TVs
# Comp
# TVs
Time (sec.)
# TVs
Time (sec.)
c2670
106
100
761
99
8.03
96
6.95
c3540
83
80
657
83
9.08
83
8.98
c5315
119
106
1491
117
34.95
103
31
s13207.1f
476
252
3516
248
339.93
243
169
s15850.1f
456
181
4135
169
463.95
144
249
s208.1f
33
33
94
33
0.009
32
0.93
s3271f
115
76
1212
69
14.97
61
7.02
s3330f
277
248
1263
233
11.01
208
9
s3384f
82
75
1048
73
15.01
72
7.97
s38417f
822
187
12215
173
5327.3
145
2072
s38584f
819
232
16086
210
9250
145
2590
s4863f
65
59
607
52
24.01
49
25.96
s5378f
252
145
1460
130
34.95
123
23
s6669f
52
42
1286
40
60.01
35
37.91
375
202
2093
185
104.01
172
68.06
s9234.1f
11-Oct-03
GC
yosais
IFC
27
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.



11-Oct-03
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.
yosais
28
Experimental Results
Sources of Time Consumption in IFC
Cct
Time (Sec.)
FS
ND
Mat.
EFs
Build
IFSs
Mat.
Rem.
Faults
Total
c2670
0.95
0.06
1.96
3.96
6.95
c3540
0.95
0.07
0.97
7
8.98
c5315
1.93
1.03
4
24.1
31
s13207.1f
15
10
61.97
75
169
s15850.1f
23
15
56.05
151
249
s3271f
0.05
0.93
1.06
5
7.02
s3330f
1.04
0.96
3
3.94
9
s3384f
0.95
0.02
1.97
5
7.97
s38417f
87
74
753
1133
2072
s38584f
89
66
1212
1189
2590
s4863f
0.96
0.98
2.05
21.95
25.96
s5378f
2.04
1.01
5.96
14
23
s6669f
0.96
0.95
8.02
27.04
37.91
9
5.06
11
42.02
68.06
s9234.1f
11-Oct-03


Building IFSs.
Matching nonessential faults.
Non-dropping fault
simulation for large
circuits.
yosais
29
Experimental Results
Results by Iterative IFC
Cct
Iterative IFC
# TVs
# TVs
#
Iterations
Time (sec.)
c2670
96
85
6
42.07
c3540
83
75
3
26.95
c5315
103
86
4
88.04
s13207.1f
243
238
2
473.12
s15850.1f
144
129
1
374.95
s208.1f
32
32
1
0.01
s3271f
61
60
2
18.98
s3330f
208
196
3
30.02
s3384f
72
72
1
7.07
s38417f
145
120
2
3775.06
s38584f
145
124
3
8217.08
s4863f
49
42
3
70.88
s5378f
123
117
6
109
s6669f
35
30
4
175.01
155
4
200.93
s9234.1f
11-Oct-03
IFC
172
yosais
30
Experimental Results
Results by Iterative IFC

Improvement over RM:
3% - 46.6%

e.g. 35.8% for s38417f
Improvement over IFC:
1.6% - 17.2%
11-Oct-03
e.g. 14.5% for s38584f
yosais
31
Experimental Results
Results by CBC (ROF+RM)
Cct
RM
CBC
# TVs
# TVs
After Class 0
After Class 1
After Rem. Classes
Time
(sec.)
c2670
100
94
94
94
10
c3540
80
78
78
78
13.02
c5315
106
96
96
95
29.03
s13207.1f
252
243
243
243
443
s15850.1f
181
147
145
145
476.02
s208.1f
33
33
33
33
0.01
s3271f
76
66
65
65
15.95
s3330f
248
226
223
223
27
s3384f
75
72
72
72
11.02
s38417f
187
146
143
143
5750
s38584f
232
159
153
153
8813
s4863f
59
52
52
52
24.04
s5378f
145
122
117
116
52
s6669f
42
37
37
37
50.1
202
168
166
163
136
s9234.1f
11-Oct-03
yosais
32
Experimental Results
Statistics about Test Sets
Cct
# Elim.
Comp.
# TVs
Class 0
Class 1
Class 1
Potential
Maximum
Degree of
Hardeness
c2670
1869
12
46
0
18
c3540
2263
0
12
0
23
c5315
3758
77
21
0
29
s13207.1f
6219
252
150
0
49
s15850.1f
7283
180
63
4
39
s208.1f
123
0
22
0
15
s3271f
2090
76
39
1
7
s3330f
1595
194
134
5
21
s3384f
2363
3
24
0
3
s38417f
19055
186
24
24
70
s38584f
20386
232
10
10
41
s4863f
4173
58
17
0
9
s5378f
3085
144
17
16
14
s6669f
5426
41
15
0
13
s9234.1f
4414
194
64
2
28
11-Oct-03
yosais
33
Experimental Results
Results by CBC (ROF+RM)
Maximum reduction is 34%.
 2.5% for c3540; 23.5% for s38417f; 34%
for s38584f.

11-Oct-03
yosais
34
Experimental Results
Sources of Time Consumption in CBC
Cct
Time (sec.)
FS
ND
Comp.
Gen
Comp.
Elim.
TV
Block.
Proc.
Class 0
Peoc.
Class 1
Total
c2670
0.05
3
5.03
0.001
0.002
0.01
10
c3540
0.96
5.03
7.02
0
0
0.0001
13.02
C5315
1.01
7.05
16.94
1
1.96
0.004
29.03
s13207.1f
8.01
26.92
123
174
257
0.99
443
s15850.1f
9.01
73.93
177
116
200
6.91
476.02
s208.1f
0.001
0.003
0.002
0
0.00001
0.0001
0.01
s3271f
0.94
2.05
6.93
4
5.02
0.03
15.95
s3330f
1.02
2.03
5.92
7
14.01
2
27
s3384f
0.94
2.06
6.97
0.0005
0.001
0.01
11.02
s38417f
20
588
1102
2310
2919
119
5750
s38584f
25.04
730
1369
4092
5340
256
8813
s4863f
0.06
10.92
12
0.1
1.03
0.0003
24.04
s5378f
1.92
5
19
10
19.03
2.05
52
s6669f
0.06
18.03
25.96
4.93
6
0.002
50.1
s9234.1f
4
12
54.02
24.02
48.03
2.01
136
11-Oct-03
yosais



Component
generation.
Component
elimination.
Blockage value
computation.
Non-dropping
fault simulation
for large
circuits.
35
Experimental Results
Results by CBC (ROF+IFC & ROF+Iter_IFC)
Cct
ROF+IFC
ROF+IFC+CBC
ROF+Iter_IFC
ROF+Iter_IFC+CBC
# TVs
# TVs
Time (sec.)
# TVs
# TVs
Time (sec.)
c2670
96
93
10
85
83
9.97
c3540
83
78
13.95
75
73
13
c5315
103
78
31.96
86
70
33
s13207.1f
243
239
174
238
236
180
s15850.1f
144
134
248
129
126
250
s208.1f
32
32
0.01
32
32
0.01
s3271f
61
59
9.98
60
58
10
s3330f
208
201
11.93
196
188
7
s3384f
72
72
11
72
72
11.96
s38417f
145
122
4684
120
111
3433
s38584f
145
129
5322
124
121
3563
s4863f
49
44
24
42
42
25.96
s5378f
123
113
37.96
117
112
26.97
s6669f
35
35
43
30
30
44
172
156
82
155
143
72
s9234.1f
11-Oct-03
yosais
36
Experimental Results
Results by CBC (ROF+IFC & ROF+Iter_IFC)

ROF+IFC+CBC



ROF+Iter_IFC+CBC



1.1% - 18%
ROF+Iter_IFC+CBC vs. ROF+RM+CBC


Maximum reduction is 18.6%.
7.7% for s9234.1f; 18.6% for c5315.
ROF+IFC+CBC vs. ROF+RM+CBC


Maximum reduction is 23.5%.
16% for s38417f; 23.5% for c5315.
3% - 26.3%
ROF+Iter_IFC+CBC vs. ROF+IFC+CBC

11-Oct-03
1.3% - 14.3%
yosais
37
Experimental Results
Runtimes spent by reordering procedures
Cct
#
TVs
Time (sec.)
Greedy
DD
CPT
CPT+
s13207.1f
633
11.97
14.04
37
74
s15850.1f
657
28
28
166
204
s38417f
1472
807
183
1800
2569
s38584f
1174
702
124
1410
2188
s5378f
359
1.97
1.12
6.01
15
s9234.1f
620
8
11
17
38
● 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.
11-Oct-03
yosais
38
Experimental Results
Memory Required for Circuits
Cct
11-Oct-03
#
Faults
Total Memory (bytes)
Memory
Reduction
(%)
DD
CPT
CPT+
DD
CPT
s13207.1f
9815
19630
1364941
17886
9
98.7
s15850.1f
11725
23450
1546227
29359
0
98
s38417f
31180
62360
9745991
287771
0
97
s38584f
36303
72606
9317334
321100
0
96.6
s5378f
4603
9206
353358
5594
39.2
98.4
s9234.1f
6927
13854
640525
16631
0
97.4
yosais
39
Experimental Results
Fault Coverage Curves for s5378f
11-Oct-03
yosais
40
Experimental Results
Fault Coverage Curves for s38417f
11-Oct-03
yosais
41
Experimental Results
Efficiency of Reordering Procedures
11-Oct-03
yosais
42
Experimental Results
Efficiency of Reordering Procedures
11-Oct-03
yosais
43
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




11-Oct-03
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.
yosais
44
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.
11-Oct-03
yosais
45
11-Oct-03
yosais
46
Class-Based Clustering
Blockage Value
Technique is NOT exact.
 Although v1 has a ZERO blockage value, it
blocks v2.

Test
Vector
Component
Set of Compatible
Test Vectors
v1
c11
{v3}
c12
{v4}
c21
{v3,v4}
v2
11-Oct-03
yosais
47
Worst-Case Analysis
Methodology







Test set, fault list, and circuit structure are given
as inputs.
NT = No. of test vectors in given test set.
NPI = Size of a test vector.
NF = Number of faults in given circuit.
NG = Number of gates in given circuit.
Logic simulation of a test vector requires O(NG)
basic operations.
Fault simulation of a test vector for a single fault
requires O(NG) basic operations.
11-Oct-03
yosais
48
Worst-Case Analysis
Space Complexity of IFC
O(NFNT)
Storing the indexes of test vectors detecting every fault.
O(NPI)
Storing a component when it is generated.
O(NTNPI)
Storing test vectors of compatibility sets.
O(NF)
Memory space required for building IFSs.
O(NT(NF+NPI))
11-Oct-03
yosais
49
Worst-Case Analysis
Space Complexity of CBC
O(NFNT)
Storing set of faults detected by every test vector.
O(NFNPI)
Storing all components.
O(NT)
Storing the indexes of compatible/candidate test vectors for every
component.
O(NT)
Storing blockage values for every component belonging to class
zero test vector.
O(NF(NT+NPI))
11-Oct-03
yosais
50
Worst-Case Analysis
Time Complexity of IFC
O(NFNTNG)
Fault simulation without dropping.
O(NF)
Finding essential faults.
O(NG)
Extracting a single component.
O(NTNPI)
Mapping a single component.
O(N2FN2T)
Computing IFSs.
O(NFlog NF)
Sorting IFSs.
O(NFNTlog NT)
Sorting test vectors detecting every fault.
2
2
• Dominating sources of time consumption:
• Computing IFSs = O(N2FN2T).
• Matching non-essential faults = O(NFNT(NTNPI+NG)).
11-Oct-03
yosais
51
Worst-Case Analysis
Time Complexity of CBC
O(NFNTNG)
Fault simulation without fault dropping.
O(NTlog NT)
Sorting test vectors.
O(NFNG)
Component generation.
O(N2FNG)
Dropping redundant components using fault simulation with dropping.
O(NF)
Merging components.
O(NFNTNPI)
Classification of test vectors.
O(N2FNTNPI)
Computing blockage values for all class zero test vectors.
O(NFNT)
Moving components to appropriate test vectors.
O(NFNTNPI)
Updating Scomp for all components belonging to class zero test vectors.
O(N2FN2TNPI)
Updating blockage values for all class zero test vectors.
O(NFN2TNPI)
Processing remaining class zero test vectors.
O(NT)
Finding class i test vectors.
O(NFNPI)
Computing Scand of a CC belonging to class one test vector.
2
11-Oct-03
yosais
52
Worst-Case Analysis
Time Complexity of CBC
O(NFN2TNPI)
Processing class one test vectors.
O(NFN2TNPI)
Processing remaining classes.
• Dominating sources of time consumption in class zero
algorithm:
• Computing blockage value = O(N2FNTNPI).
• Updating Scomp = O(NFNTNPI).
• Updating blockage values of components = O(N2FN2TNPI).
• Dominating sources of time consumption in CBC:
• Component generation = O(NFNG).
• Component elimination = O(N2FNG).
• Blockage value computation = O(N2FNTNPI).
11-Oct-03
yosais
53