Tallinn Technical University, Estonia
Current paper presents an overview of recently proposed fast methods for static compaction of sequential circuit tests divided into independent test sequences. The methods include greedy and deterministic approaches. I shortly explain the algorithms and present some expected results. At the moment results can be only compared on small test sets, because my version of Branch-and-bound is still in development. In addition to comparison, optimizing small test sets with branch-and-bound, it is shown that branch-and-bound ads some key test sequences to complete the minimal test set pattern.
First I would like to say that this paper is strongly based on
[1].Majority of the earlier works in the field of static compaction consider the case, where there is a single test sequence that we are trying to minimize by removing some patterns from it. This requires iterative fault simulation during the compaction process in order to check that the fault coverage has not decreased. Thus the run times are very long.
In this paper I consider the above-mentioned case of static compaction, where the test set is divided into test sequences. This should considerably decrease run time. I also shortly explain the algorithms.
2. STATIC COMPACTION OF FAULT MATRICES
A test set T consists of test sequences t i

T, i = 1, ... , n. Each sequence t i
contains in turn L i test vectors . We refer to L i
as the test length of sequence t i
. The set of faults f j
, j = 1, ..., m detected by T is denoted by F. Total test length of test set T can be viewed as a sum i n 

1
L i
In the problem of static compaction of test sequences, our task is to find values for the L i
such that the above sum would be minimal while the number of faults that the test set T detects would still be |F|.
Consider the test set example shown in Fig. 1 that consists of three test sequences s
1
, s
2
and s
3
, respectively.
Sequence s
1
consists of four test vectors covering fault f
2
at the third vector and f
1
at the fourth vector. Sequence s
2 consists of three test vectors covering f
1
at the first vector and f
3
at the third vector. Finally, sequence s
3
consists of four test vectors covering f
2
at the first vector, f
3
at the second vector and f
4
at the fourth vector. sequence s
1 sequence s
2 sequence s
3 f
3 f
2 f
3 f
4 detected f
2 f
1 faults: f
1
Fig.1
. Test set compaction example
Initial test length of this test set is 11 vectors. It can be found that the optimal solution for the static compaction problem is selecting sequence s3 and the first vector from sequence s2. Hence, the length of the optimal compacted test set will be 5 vectors. The fault matrix representation for the test set in Fig. 1 is shown below.
Table 1. Fault matrix for the test set of Fig. 1 f
1 f
2 f
3 f
4 s
1
4 s
2
1 s
3
0
3
0
1
0
3
2
0
0
4
In the following two methods, three relationships are implemented to prune the search space for the compaction algorithm.
If fault f j
is detected by the k -th vector of test sequence s i
and is not detected by any other sequence belonging to the test set then k first vectors of sequence s i
are called essential. After selecting the essential vectors I remove them from the test sequences. In addition I remove the columns corresponding to

faults covered by these vectors from matrix T . This simple pre-processing step allows to significantly reduce the search space for the static compaction algorithm.
Column f a
is said to be dominated by column f b
and will be removed from matrix T if i m


1 t s i
, f b

0
 t s i
, f a

0 , t s i
, f b
 t s i
, f a
.
The motivation for removing dominated faults is the following. Let us assume that a fault f b
dominates fault f a
. The above relationship shows that no matter by which sequence selection we cover fault f b
we will also cover fault f a
. Since in order to achieve full matrix coverage we will have to cover f b in any case, column f a
represents redundant information for the optimization problem.
A row corresponding to sequence s b
is said to be a dominating sequence of s a
and will be removed from matrix T if j n


1 t s b
, f j

0
 t s a
, f j

0 , t s a
, f j
 t s b
, f j
.
A dominating sequence can be removed because the sequence dominated by it covers all the same faults in a shorter or equal vector range.
Let us denote by Minrange ( f j
) the minimal number of vectors that has to be selected from any test sequence in order to detect a fault f j
. Let Maxrange be the maximum Minrange ( f j
) of all the faults.
The selection function selects Maxrange vectors from the corresponding test sequence. If there exist multiple maximal
Minrange ( f j
) values then the algorithm prefers the sequences that detect more faults in Maxrange first vectors.
In this paper I present a branch-and-bound algorithm for static compaction of independent test sequences. Unlike the abovedescribed genetic algorithms and greedy optimization, branchand-bound is capable of finding the globally optimal solution for this type of compaction problem.
The algorithm uses depth-first approach for the decision tree traversal. While the breadth-first approach would limit the search space further it was not implemented due to its excessive memory requirements. (In the breadth-first search we would have to trace all the decisions in parallel, while in the depth-first approach only one decision is considered at a time). Differently from the greedy approach, this algorithm does not stop after finding the first solution but it checks all the consistent solutions until the optimal is found.
The search problem for the branch-and-bound approach can be further simplified by discarding decision combinations equivalent to previously traversed ones, i.e. the ones which contain exactly the same set of decisions that were tried before but in a different order. Equivalent search state identification requires that the decisions are ordered (ranked) in the systematic search process. In current implementation the primary decision ordering criterion is the number of vectors to be selected, the secondary criterion is index of the test sequence. During decision making we never consider a decision whose rank is less than the one of the previously made decision in the decision tree. The general idea is not new and it has been successfully implemented in automatic test pattern generation.
If we do not consider equivalent search states the total number of decisions to be considered will be: n!(1/0! + 1/1! +1/2! + … + 1/(n-1)!), which approaches asymptotically e

n! .
However, by identifying equivalent search states we have to consider 2 n -1 decisions in the worst case. While this is still a problem of high complexity, it is considerably less so than the traditional full search considered above.
In Fig.2, the representation of Branch-and-Bound algorithm is shown.
Fig.2
. Branch-and-Bound algorithm
With that algorithm I have optimized a small test by hand and the result was that I gained important extra test vector.
That vector increased fault coverage to full 100%, before it was 95.5%. So far results are promising.
In this paper, the case of static compaction, where the test set is divided into test sequences was considered. Two different recently proposed methods were compared, including greedy optimization and branch-and-bound based approaches. With current testing Branch-and-Bound algorithm is very promising.
[1] Raik, J.; Jutman, A.; Ubar, R. (2002). Fast Static Compaction of Tests Composed of Independent Sequences: Basic Properties and Comparison of Methods.
In: Proc. of 9th IEEE International
Conference on Electronics, Circuits and Systems (ICECS’2002),
Dubrovnik, Croatia, Sept. 15-18, 2002, Vol. 2 , pp445 - 448.