Scan-Chain Partition for High Test-Data Compressibility and Low Shift Power Under Routing Constraint

Abstract

The degree of achievable test-data compression depends on not only the compression scheme but also the structure of the applied test data. Therefore, it is possible to improve the compression rate of a given test set by carefully organizing the way that test data are present in the scan structure. The relationship between signal probability and test-data entropy is explored in this paper, and the results show that the theoretical maximum compression can be increased through a partition of scan flip-flops such that the test data present in each partition have a skewed signal distribution. In essence, this approach simply puts similar scan flip-flops in an adjacent part of a scan chain, which also helps to reduce shift power in the scan test process. Furthermore, it is shown that the intrapartition scan-chain order has little impact on the compressibility of a test set; thus, it is easy to achieve higher test compression with low routing overhead. Experimental results show that the proposed partition method can raise the compression rates of various compression schemes by more than 17%, and the average reduction in shift power is about 50%. In contrast, the increase in routing length is limited.

Full text

Page 1

716 IEEE TRANSACTIONS ON COMPUTER-AIDED DESIGN OF INTEGRATED CIRCUITS AND SYSTEMS, VOL. 28, NO. 5, MAY 2009
Scan-Chain Partition for High Test-Data
Compressibility and Low Shift Power
Under Routing Constraint
Sying-Jyan Wang, Member, IEEE, Katherine Shu-Min Li, Member, IEEE, Shih-Cheng Chen,
Huai-Yan Shiu, and Yun-Lung Chu
Abstract—The degree of achievable test-data compression de-
pends on not only the compression scheme but also the structure
of the applied test data. Therefore, it is possible to improve the
compression rate of a given test set by carefully organizing the way
that test data are present in the scan structure. The relationship
between signal probability and test-data entropy is explored in
this paper, and the results show that the theoretical maximum
compression can be increased through a partition of scan flip-flops
such that the test data present in each partition have a skewed
signal distribution. In essence, this approach simply puts similar
scan flip-flops in an adjacent part of a scan chain, which also helps
to reduce shift power in the scan test process. Furthermore, it is
shown that the intrapartition scan-chain order has little impact
on the compressibility of a test set; thus, it is easy to achieve
higher test compression with low routing overhead. Experimental
results show that the proposed partition method can raise the
compression rates of various compression schemes by more than
17%, and the average reduction in shift power is about 50%. In
contrast, the increase in routing length is limited.
Index Terms—Entropy theory, routing, scan-based design,
test power, test-data compression.
I. INTRODUCTION
T
they require not only large automatic-test-equipment (ATE)
memory but also significant test application time [1]. In order
to minimize test cost, compression techniques can be used to
reduce test-data volume. Existing test-data compression meth-
ods can be classified into three types [2]: code-based [3]–[19],
HELARGEamountoftestdatainmodernverylargescale
integration (VLSI) circuits become a great challenge, as
Manuscript received September 19, 2008; revised December 10, 2008.
Current version published April 22, 2009. This work was supported in part
by the National Science Council of Taiwan under Grants NSC-95-2221-E-005-
153-MY2 and NSC-96-2221-E-110-090-MY2 and in part by the Ministry of
Economic Affairs of Taiwan under Grant 97-EC-17-A-01-S1-104. This paper
was recommended by Associate Editor N. K. Jha.
S.-J. Wang and Y.-L. Chu are with the Department of Computer Science and
Engineering, National Chung Hsing University, Taichung 402, Taiwan (e-mail:
sjwang@cs.nchu.edu.tw; n9683008@cs.nchu.edu.tw).
K. S.-M. Li is with the Department of Computer Science and Engineering,
National Sun Yat-Sen University, Kaohsiung 804, Taiwan (e-mail: smli@cse.
nsysu.edu.tw).
S.-C. Chen is with Global Unichip Corporation, Hsinchu 300, Taiwan
(e-mail: collinnet@hotmail.com).
H.-Y. Shiu is with the Chinese Army, Taiwan (e-mail: s9456044@cs.
nchu.edu.tw).
Color versions of one or more of the figures in this paper are available online
at http://ieeexplore.ieee.org.
Digital Object Identifier 10.1109/TCAD.2009.2015741
linear-decompression-based [20]–[22], and broadcast-based
[23]–[25] schemes.
Code-based techniques achieve test compression by encod-
ing test cubes with data compression codes. In these schemes,
the original data are partitioned into symbols, and each symbol
is replaced by a codeword. Since a codeword is usually smaller
than the original symbol, smaller memory space and less ATE
channel bandwidth is consumed by the compressed test data.
Encoding schemes are usually classified according to how test
and encoded data are handled [2]. If the lengths of both symbols
and encoded codewords are fixed, this scheme is classified
as a “fixed-to-fixed” encoding technique [3], [4]. If a scheme
encodes fixed-length symbols into variable-length codewords,
it belongs to the “fixed-to-variable” category [5]–[8]. Similarly,
a “variable-to-fixed” scheme [9] encodes symbols of variable
lengths into codewords of a specified number of bits, while in
“variable-to-variable” schemes [10]–[14], the lengths of both
symbols and codewords are variable. Some schemes can en-
code symbols with both fixed and variable lengths [15], [16],
while others apply multilevel techniques to achieve even better
compression rates [17]–[19].
The effectiveness of a code-based compression scheme de-
pends on the encoding efficiency as well as the structure of
test data. It is usually difficult to compress random data, as all
symbols appear with roughly equal probability, and thus, no en-
coding method can achieve significant reduction in the amount
of compressed data. Hence, one possible way to improve the
test compression rate is to find a set of test data that is easier to
compress.
Entropy is associated with the amount of disorder in a
system. In information theory, the Shannon entropy [26] is a
measure of the amount of information contained in a set of data;
thus, it represents an absolute limit on the best possible lossless
compression of any communication. The idea of using entropy
to calculate the test-data compression limits was first applied
to frequency-directed run-length (FDR) codes with don’t cares
assigned to zeroes [27]. The concept was then extended to
incompletely specified test data [28]. In these studies, it is
shown that the maximum amount of compression of a test-data
set is directly related to the entropy.
The entropy in a test-data set is affected by how test data are
treated in an encoding scheme. For example, it is shown that
different ways of partitioning test data into symbols will affect
the entropy [28]. The proper use of don’t cares is helpful to
achieve lower entropy. In this paper, we explore the feasibility
0278-0070/$25.00 © 2009 IEEE
Authorized licensed use limited to: National Chung Hsing University. Downloaded on June 5, 2009 at 05:16 from IEEE Xplore. Restrictions apply.

Page 2

WANG et al.: SCAN-CHAIN PARTITION FOR HIGH TEST-DATA COMPRESSIBILITY AND LOW SHIFT POWER717
of reducing entropy in a test set from a different perspective.
In a scan-based test, a symbol is the bit patterns appearing in
a set of consecutive scan flip-flops (also known as scan cells).
Thus, by altering the order of scan cells in the scan chain, the
symbols to be encoded are changed and so is the entropy of
the test-data set. If it is possible to put similar scan cells (in
terms of test data appearing in them) close to each other in
the scan chain, one can effectively reduce the entropy in a test
set. As a result, a higher compression can be achieved for the
same test set. Conceptually, this can be analogous to the fact
that multiple crystal structures of the same material exhibit very
different physical properties. Furthermore, since adjacent scan
cells contain similar data, the shift power, which is caused by
bit transitions between adjacent scan cells, will also be reduced.
Another way to look at the test power problem is that, since the
entropy represents the disorder in the system, a low-entropy test
set means fewer random bit transitions in symbols and, thus,
lower shift power.
The scan-chain ordering has been applied to various prob-
lems, including shift power reduction [29], [30] and the en-
hancement of delay fault coverage (FC) in launch-off-shift
delay tests [31]. However, scan-chain reorder may adversely
affect scan-chain routing by creating very long routing paths,
and in some cases, the reorder algorithm can be rather involved.
In this paper, the scan-chain ordering is achieved by a simple
partition of all scan cells. It is shown that intrapartition orders
have modest impact on the entropy, and thus, the scan cells can
be ordered to minimize routing length. Experimental results
show that the proposed method can effectively improve the
compression results of all encoding techniques with very small
routing-length penalty.
The proposed partition scheme is based on a given test-data
set; therefore, a change of test set may be problematic when the
design is finished. Experimental results suggest that a partition
derived from a given test set is also helpful in reducing test
data in a different test set for the same circuit, which implies
that the proposed method is less affected by the change of
test set.
The remaining part of this paper is organized as follows.
The next section gives a brief survey of existing compres-
sion techniques and introduces how to calculate entropy in
such methods. In Section III, an analysis on the entropy of
a test-data set with respect to the probability distribution of
bits is given. According to the entropy analysis, a scan-cell
partition scheme that effectively reduces the entropy of a test-
data set is proposed in Section IV. In order to restrict the
overall scan-chain length, a partition scheme targeted for low
routing overhead is further explored. The revised partition
algorithm can improve the compression rates in various com-
pression schemes with low routing-length overhead. Experi-
mental results are presented in Section V and VI concludes
this paper.
II. PRELIMINARIES
This section provides an overview of the classification of
compression schemes and introduces the entropy in these
schemes [27], [28].
A. Fixed-Symbol-Length Codes
For encoding schemes that fall in the fixed-to-fixed and
fixed-to-variable categories, the test data are partitioned into
fixed-length symbols, which are replaced by the corresponding
codewords. An example of a fixed-to-fixed scheme is the dic-
tionary coding [3], [4]. In this scheme, the original test cubes
are partitioned into fixed n-bit symbols, which are encoded by
b-bit codewords. The decoding process is carried out by looking
up a dictionary, which is essentially a table. Each codeword is
a table index, and the corresponding symbol is the table entry.
For an n-bit symbol block, in all, there are 2npossible
symbols. Assume that there are only S distinct symbols ap-
pearing in all test cubes. One can encode the symbols with
b-bit codewords if 2b> S is true. If the overhead due to the
dictionary is ignored, the compression ratio is roughly n/b.
The best example of fixed-to-variable coding is the Huffman
codes [5]–[8]. Huffman codes are statistical coding schemes,
in which codewords are assigned according to each symbol’s
frequency of occurrence. The more frequent a symbol occurs,
the fewer bits are assigned to its codeword. As a result, the
average length of a codeword is minimized. A Huffman code
is obtained by constructing a Huffman tree, in which a path
from the root to a leaf gives the codeword for the symbol
corresponding to the leaf. The full Huffman coding achieves
good compression but requires significant hardware overhead
for the decompressor. To alleviate this problem, some modified
Huffman encoding schemes have been proposed [6]–[8].
For the fixed-symbol-length schemes, the entropy is defined
as follows [28].
Definition 1: Assume that S is the set of all distinct symbols
in a test set, and Z is a random variable. Let Pr(Z = zi) be
the probability of occurrence of symbol ziin the test set. The
entropy of the test set is
?
The entropy is the lower bound on the average number of bits
required for each codeword. Thus, the maximum achievable
compression is defined as follows.
Definition 2: The maximum achievable compression in a
fixed-symbol-length scheme is [28]
H = −
zi∈S
Pr(Z = zi) · logPr(Z = zi).
Max_compression_rate =symbol_length − entropy
symbol_length
.
B. Variable-Symbol-Length Codes
Variable-symbol-length schemes are based on run-length
codes. A run is a sequence of consecutive 0s or 1s, which is the
symbol to be encoded. Therefore, the symbol length is variable.
The codeword corresponding to a symbol is the length of the
run. The simplest way for run-length coding is to use fixed-
length codewords [9], and thus, it is a variable-to-fixed scheme.
However, better compression ratio is usually achieved by using
variable-length codewords. Examples of variable-length codes
include Golomb code [10], [11], FDR code [12], and variable-
input-length Huffman codes [13], [14]. In some schemes, only
Authorized licensed use limited to: National Chung Hsing University. Downloaded on June 5, 2009 at 05:16 from IEEE Xplore. Restrictions apply.

Page 3

718 IEEE TRANSACTIONS ON COMPUTER-AIDED DESIGN OF INTEGRATED CIRCUITS AND SYSTEMS, VOL. 28, NO. 5, MAY 2009
Fig. 1.Entropy versus p0in fixed-length schemes.
runs of 0s are encoded to simplify the decoder design, while in
others, both runs of 0s and 1s are encoded.
The entropy of a variable-length code is calculated in the
same way as fixed-length codes; the only difference is that the
symbols are now variable-length runs. However, the maximum
achievable compression is different.
Definition 3: The maximum achievable compression in a
variable-symbol-length scheme is [28]
Max_compression_rate =avg_symbol_length − entropy
avg_symbol_length
.
III. ANALYSIS ON ENTROPY AND
MAXIMUM COMPRESSION
Inthis section, ananalytical model for entropy and maximum
compression versus the distribution of 0s and 1s in a test set is
given. For simplicity, it is assumed that the size of the test-data
set is infinity, and the probabilities of 0, 1, and X (i.e., don’t
cares) in the set are p0, p1, and pX, respectively.
A. Fixed-Symbol-Length Codes
First, we assume that the test-data set is fully specified; in
other words, it is assumed that pX= 0 and p0+ p1= 1. Let
the symbol length be n, and the probability of occurrence of
a symbol consisting of i 0s is equal to pi
Definition 1, the entropy is
0pn−i
1
. According to
H(p0)=−
n
?
i=0
Cn
i·?pi
0(1−p0)n−i?· log?pi
0(1−p0)n−i?
(1)
where Cn
symbol.
The entropy versus p0 is shown in Fig. 1 for n = 2,4,6,
8, and 10. As expected, the maximum entropy equals n with
p0= 1/2, and the entropy function is symmetric with respect to
p0= 1/2. In other words, the maximum entropy occurs when
the symbols are truly random. The maximum compression is
(n − H(p0))/n,accordingtoDefinition2.Thus,theachievable
compression rate will be higher if the difference between p0
and p1becomes larger. The maximum compression is shown
in Fig. 2 for n = 10. The plots of maximum compression for
other symbol lengths are hardly distinguishable from the one in
Fig. 2 and, thus, are not shown here.
iis the number of combinations of i 0s in an n-bit
Fig. 2.Maximum compression of fixed-length schemes (n = 10).
According to the aforementioned discussion, the best way to
derive an easy-to-compress test-data set with don’t cares is to
assign X’s to the bit (0 or 1) that occurs more frequently in the
test set.
B. Variable-Symbol-Length Codes
In order to derive the maximum compression of run-length
codes, we need to calculate both the average run lengths and
the entropy (Definition 3). In test cubes consisting of 0, 1, and
X, the X bits are assigned in such a way to maximize the run
length. To achieve this goal, a simple yet effective approach is
to assign X to the same value of its preceding bit. The expected
value of run length can be calculated as follows.
First, consider the case where runs of both 0s and 1s are
encoded.Assumethatthelengthofarunof0sisl.Insucharun,
the first bit must be 0. Assume that the run starts at position p
in a cube; the next l − 1 bits should be either 0 or X. Since this
run terminates at the p + l − 1, the bit at position p + l must
be 1. Let random variable RL0be the length of the run of 0s.
Therefore, the probability that RL0= l is
Pr(RL0= l) = (p0+ pX)l−1× p1.
It is easy to verify that Pr(RL0= l) is a probability distrib-
ution function. Similarly, we have
(2)
Pr(RL1= l) = (p1+ pX)l−1× p0.
Theorem 1: The expected length of a run of 0s is 1/p1, and
the expected length of a run of 1s is 1/p0.
Proof: The expected length of a run of 0s is
∞
?
Let y = (p0+ pX), and denote the expected run length as
L0. Rewrite (4), with i + 1 = l
(3)
E[RL0] =
l=1
l × (p0+ pX)l−1× p1.
(4)
L0=p1×
∞
?
∞
?
∞
?
l=1
l × yl−1
=p1×
i=0
(i + 1) × yi
=p1×
i=0
i × yi+ p1×
∞
?
i=0
yi.
(5)
Authorized licensed use limited to: National Chung Hsing University. Downloaded on June 5, 2009 at 05:16 from IEEE Xplore. Restrictions apply.

Page 4

WANG et al.: SCAN-CHAIN PARTITION FOR HIGH TEST-DATA COMPRESSIBILITY AND LOW SHIFT POWER719
By changing the index in (5), the equation becomes
L0=p1×
∞
?
l=0
l × yl+ p1×
∞
?
i=0
yi
=p1× y ×
∞
?
l=0
l × yl−1+ p1×
∞
?
i=0
yi.
(6)
Therefore
L0= y × L0+ p1×
∞
?
i=0
yi= y × L0+
p1
1 − y.
(7)
Rearrange (7), and given that 1 − y = p1
(1 − y) × L0= 1.
As a result, L0= 1/p1. The expected length of a run of 1s
can be calculated in the same way.
In many run-length codes, only runs of 0s are encoded. In
this case, the X bits are assigned to 0s.
Corollary 1: The expected run length L0= 1/p1in case X
bits are assigned to 0s.
The proof of Corollary 1 is the same as the L0 part of
Theorem 1, except that pX is 0 as all X bits become 0.
This result can be explained as follows. Since a run of 0s is
interrupted by a 1, the expected run length of 0s is decided
by the occurrence frequency of 1s. Thus, in both cases, the
expected run lengths of 0s are the same. Similarly, the expected
run length L1= 1/p0in case X bits are assigned to 1s.
The next step is to calculate the entropy associated with
a run-length code. For simplicity, we only consider the case
where X bits are assigned to 0s. According to Definition 1 and
(2), the entropy of run-length codes is
(8)
?
H= −
∞
?
∞
?
∞
?
l=1
Pr(RL0= l) · logPr(RL0= l)
= −
l=1
(p0+ pX)l−1p1· log?(p0+ pX)l−1p1
(p0+ pX)l−1p1· [(l − 1)·log(p0+ pX) + logp1].
?
= −
l=1
(9)
As before, let y = (p0+ pX), and (9) becomes
H = −
∞
?
l=1
yl−1p1· [(l − 1) · logy + logp1]
= − p1· logy
∞
?
l=1
l · yl−1+ p1· (logy − logp1)
∞
?
l=1
yl−1.
(10)
Note that the left summation in (10) is similar to the calcula-
tion for average run lengths [see (5)] and the right summation
in (10) is a power series with y < 1. Therefore
H = (logy − logp1) −logy
p1
.
(11)
Fig. 3.Entropy versus p1in variable-length schemes.
Fig. 4. Maximum compression of variable-length schemes.
The entropy H in this scheme (i.e., all X bits are assigned
to 0) versus probability p1is shown in Fig. 3. In Fig. 3, the
entropy is shown only for p1≥ 0.05, as (11) indicates that the
entropy of run-length codes becomes infinity as p1approaches
0, and it becomes 0 when p1= 1. However, what really matters
is the maximum compression, which is given in Definition 3
for run-length codes. The average symbol length (run length)
is 1/p1 as shown in Corollary 1. The plot of the maximum
compression for variable-length schemes is shown in Fig. 4.
The compression is plotted with respect to p1 since X bits
are assigned to 0s. As in the fixed-symbol-length schemes, no
compression is possible for random data (i.e., 0s and 1s appear
with the same frequency), and the compression rate will be
higher if the difference between p0and p1increases.
In summary, for all compression schemes, the minimum
compression occurs at p0= p1= 1/2, which represents true
random data. The compression rate is maximized at either
p0= 1 or p1= 1; unfortunately, in this case, the symbols
hardly contain any useful information. To increase the compres-
sion rate, one possible solution is to assign 0 to all X bits in a
test set, and in this way, the frequencies of occurrence of 0s and
1s are skewed. In the next section, we will explore another way
to improve achievable compression.
IV. SKEW-DISTRIBUTION SCAN-CHAIN PARTITIONING
From the discussion in Section III, the compression effi-
ciency of any given code is decided by the distribution of 0s
Authorized licensed use limited to: National Chung Hsing University. Downloaded on June 5, 2009 at 05:16 from IEEE Xplore. Restrictions apply.

Page 5

720 IEEE TRANSACTIONS ON COMPUTER-AIDED DESIGN OF INTEGRATED CIRCUITS AND SYSTEMS, VOL. 28, NO. 5, MAY 2009
Fig. 5. Partition example.
and 1s in the test vectors. If we can divide a scan chain into
parts so that the distribution of 0s and 1s can be optimized
according the applied code, improved compression rate can be
achieved.
A. Scan-Chain Partition
The distribution of 0s and 1s may vary widely from one scan
cell to another, and we can exploit the variance to partition scan
chains. The basic idea is explained by the example in Fig. 5,
in which a test set of six vectors is applied to a scan chain
consisting of eight scan cells. For scan cells 1, 2, and 8, there
are more 0s than 1s in the test set, and thus, they are assigned to
the 0-dominant part. On the other hand, in scan cells {3,4,5},
1s outnumber 0s, and they are put into the 1-dominant part.
In scan cells 6 and 7, the number of 0s and 1s are equal, and
they are assigned randomly to equalize the lengths of chains,
as shown in Fig. 5(b). The 0- and 1-dominant parts are referred
to as chain-0 and chain-1 henceforth for simplicity. As a result,
even though the number of 0s and 1s are roughly the same in
the test set in Fig. 5, we have p0= 2p1in chain-0 and p1= 2p0
in chain-1.
The proposed scan-chain partition creates two chains in
which the probabilities of p1and p0are skewed. The reason that
this method can improve compression efficiency follows the
resultspresentedinSectionIII,whereitisshownthatmaximum
compression in all schemes will be higher if the frequencies of
the occurrences of 0s and 1s become uneven.
1) Variable-Symbol-Length Codes: Consider the run-length
codes. Let p0and p1be the probability of 0 and 1 in a given test
set. If the scan chain is partitioned according to the procedure
described in this section, the probabilities will be changed in
both chains. Let p0,0and p0,1be the probabilities of 0 and 1 in
chain-0, respectively. The probabilities p1,0and p1,1are defined
similarly. Obviously, p0,1< p1, and p1,0< p0. Since all X’s in
chain-0 will be filled by 0 and those in chain-1 are assigned
to 1, runs in chain-0 are mostly 0s while runs in chain-1 are
mostly 1s. As a result, the expected run lengths in either chain
are longer than those in the initial chain. Thus, the efficiency
of run-length code-based compression methods can be greatly
improved.
Fig. 6. Modified scan chain.
Fig. 7. Graph representation of two-bit symbol blocks and clique partition.
A drawback of the aforementioned coding scheme is that
runs of both 0s and 1s have to be encoded, which some-
what complicates the decoder design. The problem can be
easily solved by including a bit inversion between chain-0 and
chain-1, as shown in Fig. 6. This can be done by inserting
an inverter between chain-0 and chain-1, or one can simply
connect the Q?output of the last scan cell in chain-0 to chain-1.
In this example, vectors t1, t2, and t3of the test set in Fig. 5(b)
are to be applied. First, the X bits in the vectors are filled,
and then, test data in chain-1 are complemented and stored.
When stored vectors are shifted into the scan chain, data to
be sent to chain-1 are complemented and become the vectors
to be applied. Since the majority bits in stored vectors are 0s,
multivector run-length encoding is possible. For example, the
last seven 0-bits in stored t1and the first six 0-bits in t2can be
encoded as a single run of 0s.
2) Fixed-Symbol-Length Codes: The compressibility of
fixed-symbol-length schemes also benefits from skewed prob-
ability distribution in scan chains. For example, the Huffman
code achieves better results when some patterns appear more
frequently than others, and the partition of chain-0 and chain-1
can achieve this goal. We shall explain the reason through an
example. First, in Example 1, we consider fixed-length-symbol
blocks with n = 2 where p0and p1are equal. Fig. 7 shows
the graph representation of the compatibility among symbol
blocks. In this figure, each vertex represents a distinct pattern
in a two-bit block, and an edge connecting two vertices implies
that these two patterns are compatible. For example, vertices
(00) and (X0) are compatible, and they will become the same
symbol if X is assigned to 0.
Authorized licensed use limited to: National Chung Hsing University. Downloaded on June 5, 2009 at 05:16 from IEEE Xplore. Restrictions apply.