Documente Academic
Documente Profesional
Documente Cultură
M
1
I
2m
M
2
(1)
where I
2m
is the identity matrix of size 2m and M
1
, M
2
are matrices
of size m m
2
. The matrix M
1
has m ones in each row. For
the rth row, the ones are at positions (r 1) m + 1,(r 1)
m + 2,(r 1) m + m 1, (r 1) m + m. The matrix
M
2
is constructed as follows:
M
2
= [I
m
I
m
. . . I
m
]. (2)
For m = 4, the matrices M
1
and M
2
can be clearly observed in
Fig. 1. The encoding matrix G is just the H matrix on which the
check bits are removed
G =
M
1
M
2
. (3)
In summary, the encoder takes k = m
2
data bits (d
i
) and computes
2tm parity check bits (c
i
) using a matrix G, which is derived from
Latin squares and has the following properties.
1) Each data bit participates exactly in 2t parity checks.
2) A pair of data bits participates (both bits) in at most one of the
parity checks.
These properties are used in the next section to discuss the
proposed technique.
III. PROPOSED CONCURRENT ERROR DETECTION TECHNIQUE
Before describing the proposed error detection techniques, the
standard denition of self-checking circuits that are used in this
section is presented. During normal, or fault-free, operation, a circuit
receives only a subset of the input space, called the input code space,
and produces a subset of the output space, called the output code
space. The outputs that are not members of the output code space
form the output error space. In general, a circuit may be designed
to be self-checking only for an assumed fault set. In this brief, we
consider the fault set F corresponding to the single stuck-at fault
model [20].
A circuit is self-checking [20] if and only if it satises the
following properties: 1) it is self-testing, and 2) fault-secure.
A circuit is self-testing if, for each fault f in the fault set F, there
is at least one input belonging to the input code space, for which the
circuit provides an output belonging to the output error space.
d
1
d
2
d
3
d
4
c1
d
5
d
6
d
7
d
8
c2
d
9
d
10
d
11
d
12
c3
d
13d
14
d
15d16
c4
d
1
d
5
d
9
d
13
c5
d
2
d
6
d
10d
14
c6
d
3
d
7
d
11
d
15
c7
d
4 d
8
d
12d16
c8
r
2
ENCODER
r1
Fig. 2. Proposed self-checking encoder for OLS code with k = 16 and t = 1.
A circuit is fault-secure if, for each fault f in the fault set F and
for each input belonging to the input code space, the circuit provides
the correct output, or an output belonging to the output error space.
The fault-secure property guarantees that the circuit gives the
correct response, or signals the presence of a fault that provides an
output in the error space. Faults are always detected, since there is an
input that produces an output that identies the presence of the fault.
This property is related to the assumption that the interval between
the occurrences of two faults is enough to permit to all the elements
belonging to the input code space to appear as circuit inputs before
the occurrence of the second fault. Thus, an output belonging to the
output error space appears at the circuit output before the occurrence
of the second fault.
The technique that we propose is based on the use of parity
prediction, which is one of the techniques commonly used to detect
error in general logic circuits [21], [22]. In our case, the problem
is substantially simpler, given the structure of the OLS codes. For
the encoder, it is proposed that the parity of the computed check
bits (c
i
) is compared against the parity of all the check equations.
The parity of all the check equations is simply the equation obtained
by computing the parity of the columns in G. For OLS codes, since
each column in G has exactly 2t ones, the null equation is obtained
(see, for example, Fig. 1). Therefore, the concurrent error detection
(CED) scheme is simply to check
c
1
c
2
c
3
c
2t m
= 0. (4)
This enables an efcient implementation that is not possible in
other codes. For example, in a Hamming code a signicant part of
the columns in G has an odd weight and for some codes the number
is even larger as they are designed to have odd weights [23].
The input code space of the OLS encoder corresponds to the
input space, since the encoder can receive all the possible 2
k
input congurations. The output code space of the OLS encoder is
composed by the outputs satisfying (4), while the output error space
is the complement of the output code space.
A fault that occurs in one of the gates composing the OLS encoder
can change at most one of the c
i
check bits. When this change occurs,
the OLS encoder provides an output that does not satisfy (4), i.e., an
output belonging to the output error space. Hence, this guarantees the
fault-secure property for this circuit. Additionally, since the encoder
is composed only by XOR gates, no logic masking is performed in the
circuit. Therefore, when a fault is activated the error is propagated
to the output. This ensures the self-testing property of the circuit.
In order to check if the output of the OLS encoder belongs to
the output code space or the output error space, a self-checking
implementation of a parity checker is used [20]. The checker controls
the parity of its inputs and is realized with a repetition code. The
two outputs (r
1
, r
2
) are each equal to the parity of one of two
disjoint subsets of the checker inputs (c
i
), as proposed in [24].
When a set of inputs with the correct parity is provided, the output
2336 IEEE TRANSACTIONS ON VERY LARGE SCALE INTEGRATION (VLSI) SYSTEMS, VOL. 21, NO. 12, DECEMBER 2013
code {r
1,
r
2
} takes the values 00 or 11. When the checker receives
an erroneous set of inputs, the checker provides the output codes
01 or 10. Also, if a fault occurs in the checker, the outputs are
01 or 10. This guarantees the self-checking property of the parity
checker [24]. The proposed encoder is illustrated in Fig. 2 for the
code with k = 16 and t = 1.
The proposed circuit can detect any error that affects an odd
number of c
i
bits. For a general code, in most cases there is logic
sharing among the computations of the c
i
bits [18]. This means
that an error may propagate to more than one c
i
bit, and if the
number of bits affected is even, then the error is not detected by
the proposed scheme. To avoid this issue, the computation of each
c
i
bit can be done separately. This, however, increases the circuit
area of the encoder as no logic sharing is allowed. Another option is
to control the logic in such a way that errors can only propagate
to an odd number of outputs. This would also increase the cost
compared to an unrestricted implementation. Additionally, even if
the error propagates to an odd number of outputs, the delay of each
path can be different. This may cause registering of only some of the
output errors at the clock edge.
For OLS codes, as discussed in the previous section a pair of data
bits shares at most one parity check. This guarantees that there is
no logic sharing among the computation of the c
i
bits. Therefore,
the proposed technique detects all errors that affect a single circuit
node.
For the syndrome computation, the parity prediction can be imple-
mented by checking that the following two equations take the same
value
r
1
= s
1
s
2
s
3
s
2t m
(5)
r
2
= c
1
c
2
c
3
c
2t m
(6)
where s
i
are the computed syndrome bits. The proposed circuit is
shown in Fig. 3 for the code with k = 16 and t = 1.
For syndrome computation, the input code space is only a subset
of the possible 2
k+2t m
input congurations as only up to t errors are
considered. This subset is given by the valid OLS codewords and the
non-valid OLS codewords that are at a Hamming distance of t or less
from a valid codeword. Those correspond to the input congurations
in which there are no errors or at most t errors on the d
i
inputs such
that the errors can be corrected.
The output code space of the OLS syndrome computation is
composed by the outputs given by (5) and (6) satisfying r
1
= r
2
,
while the output error space is the complement of the output code
space.
The fault-secure property for the syndrome computation is easily
demonstrated for the faults in F by observing that the circuits that
compute r
1
and r
2
do not share any gate and both circuits are only
composed of XOR gates. Therefore, a single fault could propagate
to only one of the outputs, producing an output on the output error
space.
To prove the self-testing property for the syndrome computation,
suppose that a fault occurs in one of the gates computing (5). If the
input conguration is a valid OLS codeword, all the syndrome bits
are 0, detecting all stuck-at-1 faults in the XOR gates computing (5).
Instead, if the input is a non-OLS codeword that is affected by a t
or less errors, some syndrome bits are 1, allowing the detection of
a stuck-at-0 faults in the XOR gates computing (5). Finally, suppose
that a fault occurs in one of the gates computing (6). Since any
combination of the 2tm check bits is allowed, any fault can be
activated and the error propagated to the output r
2
.
For OLS codes, the cost of the encoder and syndrome computation
in terms of the number of two-input XOR gates can be easily
calculated (note that for the calculations an l input XOR gate is
c
1
SYNDROME COMPUTATI ON
c
2
c
3
c
4
c
5
c
6 c
7 c8
s
1
s
2 s
3
s
4
s
5
s
6 s
7
s
8
c1 c2 c
3
c
4
c
5
c
6 c
7
c
8
r
2
r
1
d1 d2 d3 d4 d5 d6 d7 d8 d9 d10 d11d12d13d14
d15d
16
d1 d5 d9 d13 d2 d6 d10d14
d3 d7 d11d15 d4 d8
d12d
16
Fig. 3. Proposed self-checking syndrome computation for OLS code with
k = 16 and t = 1.
TABLE I
OVERHEAD OF PROPOSED CED FOR SEC-OLS CODES
k m Encoder Syndrome
16 4 29.17% 43.75%
64 8 13.39% 23.44%
256 16 6.46% 12.11%
assumed to be equivalent to l 1 two-input XOR gates). For a code
with k = m
2
and that can correct t errors, there are 2tm parity check
bits and the computation of each of them requires m 1 two input
XOR gates. Therefore, the encoder requires 2tm(m 1) two-input
XOR gates. For the syndrome computation, an additional XOR gate is
needed for each parity check bit, giving a total of 2tm
2
two-input XOR
gates. The proposed method requires 2tm1 two-input XOR gates
for the encoder and 4tm-2 two-input XOR gates for the syndrome
computation. This means that the overhead required to implement
our method for the encoder is
o
encoder
=
(2tm1)
(2tm(m 1))
(7)
and for the syndrome computation is
o
syndrome
=
(4tm 2)
(2tm
2
)
. (8)
For large values of m, the rst equation can be approximated by
1/m and the second by 2/m. This shows that as the block size of the
code k = m
2
grows, the overhead becomes smaller and independent
of t . This is illustrated in Table I, where the overheads predicted by
(7) and (8) are illustrated for t = 1 and different values of k.
The overhead in terms of delay is signicant as the proposed parity
computation is done over the results of the encoder or syndrome
computation. This means that the delay of the new logic adds directly
to the encoding or syndrome computation delay. However, the effect
on the memory access time can be minimized by noting that for the
encoder the error checking can be done in parallel with the writing
of the data into the memory. Then if an error is detected, the data is
encoded and written again. For the syndrome computation, the error
detection can be performed in parallel with the majority logic voting
IEEE TRANSACTIONS ON VERY LARGE SCALE INTEGRATION (VLSI) SYSTEMS, VOL. 21, NO. 12, DECEMBER 2013 2337
TABLE II
LAYOUT AREA FOR ENCODER (in m
2
)
k m Unprotected With CED Overhead
16 4 184.6 236.2 27.9%
64 8 847.0 948.7 12.0%
256 16 3594.1 3820.1 6.2%
TABLE III
LAYOUT AREA FOR SYNDROME COMPUTATION (in m
2
)
k m Unprotected With CED Overhead
16 4 237.7 344.1 45.1%
64 8 951.1 1176.4 23.6%
256 16 3804.4 4276.8 12.4%
TABLE IV
DELAY ESTIMATES FOR ENCODER (in ns)
k m Unprotected With CED Overhead
16 4 1.26 1.65 30%
64 8 1.52 2.01 28%
256 16 1.71 2.41 40%
and the error correction such that again, the impact on access time
is minimized.
Finally, it is worth noting that the overhead of implementing the
proposed technique for other codes is much larger. This is because
the CED check becomes more complex and also because logic
sharing must be avoided in the parity check computation.
IV. EVALUATION
The proposed CED mechanisms have been implemented in
VHDL for codes with t = 1 and the values of k used in
Table I. The designs have been implemented for the 45-nm OSU
free PDK standard cell library [25] using synopsys design com-
piler for the synthesis and cadence encounter for placement and
routing.
To evaluate the area overhead, synthesis was run with maximum
effort on area optimization and then place and route was done to
obtain the circuit layout. The area of the circuit layouts for the
encoder is shown in Table II and for the syndrome computation is
shown in Table III. The overhead required to implement our proposed
technique is also shown in the tables. It can be observed that the
results are in good agreement with the analytical estimates presented
in Table I.
To evaluate the impact on delay, synthesis was run with
maximum effort on delay optimization. The results are shown in
Tables IV and V. It can be observed that the proposed scheme
introduces a signicant delay. This is expected from the discussion
in the previous section. However, as explained there, the impact on
memory access time can be minimized by performing error checking
in parallel with the writing of the data for the encoder. For the
syndrome computation, the checking can be done in parallel with
the majority voting and error correction.
It was mentioned in the previous sections that the proposed
approach was not effective for other codes. This is in part because
to ensure the detection of errors no logic sharing among the parity
bits computation can be allowed. This results in a signicant area
increase. As an example, the encoder for a parity extended Hamming
code with k = 32 was implemented with and without logic sharing.
TABLE V
DELAY ESTIMATES FOR SYNDROME COMPUTATION (in ns)
k m Unprotected With CED Overhead
16 4 1.32 1.75 32%
64 8 1.54 2.05 33%
256 16 1.75 2.42 38%
The area overhead of avoiding logic sharing was 35%. The cost of the
checker is also larger for Hamming. In this particular case, the total
overhead for the proposed scheme was over 80%. This conrms that
the proposed checker is not effective in a general case and relies on
the properties of OLS codes to achieve an efcient implementation.
V. CONCLUSION
In this brief, a CED technique for OLS codes encoders and
syndrome computation was proposed. The proposed technique took
advantage of the properties of OLS codes to design a parity prediction
scheme that could be efciently implemented and detects all errors
that affect a single circuit node. The technique was evaluated for
different word sizes, which showed that for large words the overhead
is small. This is interesting as large word sizes are used, for
example, in caches for which OLS codes have been recently proposed
[13]. The proposed error checking scheme required a signicant
delay; however, its impact on access time could be minimized.
This was achieved by performing the checking in parallel with
the writing of the data in the case of the encoder and in parallel
with the majority voting and error correction in the case of the
decoder.
In a general case, the proposed scheme required a much larger
overhead as most ECCs did not have the properties of OLS codes.
This limited the applicability of the proposed CED scheme to OLS
codes. The availability of low overhead error detection techniques
for the encoder and syndrome computation is an additional reason
to consider the use of OLS codes in high-speed memories and
caches.
REFERENCES
[1] C. L. Chen and M. Y. Hsiao, Error-correcting codes for semiconductor
memory applications: A state-of-the-art review, IBM J. Res. Develop.,
vol. 28, no. 2, pp. 124134, Mar. 1984.
[2] E. Fujiwara, Code Design for Dependable Systems: Theory and Practical
Application. New York: Wiley, 2006.
[3] A. Dutta and N. A. Touba, Multiple bit upset tolerant memory using a
selective cycle avoidance based SEC-DED-DAEC code, in Proc. IEEE
VLSI Test Symp., May 2007, pp. 349354.
[4] R. Naseer and J. Draper, DEC ECC design to improve memory reli-
ability in sub-100nm technologies, in Proc. IEEE Int. Conf. Electron.,
Circuits, Syst., Sep. 2008, pp. 586589.
[5] G. C. Cardarilli, M. Ottavi, S. Pontarelli, M. Re, and A. Salsano, Fault
tolerant solid state mass memory for space applications, IEEE Trans.
Aerosp. Electron. Syst., vol. 41, no. 4, pp. 13531372, Oct. 2005.
[6] S. Lin and D. J. Costello, Error Control Coding, 2nd ed. Englewood
Cliffs, NJ: Prentice-Hall, 2004.
[7] S. Ghosh and P. D. Lincoln, Dynamic low-density parity check codes
for fault-tolerant nano-scale memory, in Proc. Found. Nanosci., 2007,
pp. 15.
[8] H. Naeimi and A. DeHon, Fault secure encoder and decoder for
nanoMemory applications, IEEE Trans. Very Large Scale Integr. (VLSI)
Syst., vol. 17, no. 4, pp. 473486, Apr. 2009.
[9] S. Liu, P. Reviriego, and J. A. Maestro, Efcient majority logic
fault detection with difference-set codes for memory applications,
IEEE Trans. Very Large Scale Integr. (VLSI) Syst., vol. 20, no. 1,
pp. 148156, Jan. 2012.
2338 IEEE TRANSACTIONS ON VERY LARGE SCALE INTEGRATION (VLSI) SYSTEMS, VOL. 21, NO. 12, DECEMBER 2013
[10] M. Y. Hsiao, D. C. Bossen, and R. T. Chien, Orthogonal latin
square codes, IBM J. Res. Develop., vol. 14, no. 4, pp. 390394,
Jul. 1970.
[11] S. E. Lee, Y. S. Yang, G. S. Choi, W. Wu, and R. Iyer, Low-power,
resilient interconnection with Orthogonal Latin Squares, IEEE Design
Test Comput., vol. 28, no. 2, pp. 3039, Mar.Apr. 2011.
[12] R. Datta and N. A. Touba, Generating burst-error correcting codes from
orthogonal latin square codesa graph theoretic approach, in Proc. IEEE
Int. Symp. Defect Fault Tolerance VLSI Nanotechnol. Syst., Oct. 2011,
pp. 367373.
[13] A. R. Alameldeen, Z. Chishti, C. Wilkerson, W. Wu, and S.-L. Lu,
Adaptive cache design to enable reliable low-voltage operation, IEEE
Trans. Comput., vol. 60, no. 1, pp. 5063, Jan. 2011.
[14] G. C. Cardarilli, S. Pontarelli, M. Re, and A. Salsano, Concurrent
error detection in Reed-Solomon encoders and decoders, IEEE Trans.
Very Large Scale Integr. (VLSI) Syst., vol. 15, no. 7, pp. 842846,
Jul. 2007.
[15] I. M. Boyarinov, Self-checking circuits and decoding algorithms
for binary hamming and BCH codes and Reed-Solomon codes over
GF(2
m
), Prob. Inf. Transmiss., vol. 44, no. 2, pp. 99111, 2008.
[16] H. Jaber, F. Monteiro, S. J. Piestrak, and A. Dandache, Design
of parallel fault-secure encoders for systematic cyclic block trans-
mission codes, Microelectron. J., vol. 40, no. 12, pp. 16861697,
Dec. 2009.
[17] S. J. Piestrak, A. Dandache, and F. Monteiro, Designing fault-secure
parallel encoders for systematic linear error correcting codes, IEEE
Trans. Reliab., vol. 52, no. 4, pp. 492500, Apr. 2003.
[18] J. A. Maestro, P. Reviriego, C. Argyrides, and D. K. Pradhan, Fault
tolerant single error correction encoders, J. Electron. Test., Theory
Appl., vol. 27, no. 2, pp. 215218, Apr. 2011.
[19] J. Dnes and A. D. Keedwell, Latin Squares and Their Applications.
San Francisco, CA: Academic, 1974.
[20] P. K. Lala, Self-Checking and Fault-Tolerant Digital Design. San Mateo,
CA: Morgan Kaufmann, 2001.
[21] K. De, C. Natarajan, D. Nair, and P. Banerjee, RSYN: A system
for automated synthesis of reliable multilevel circuits, IEEE Trans.
Very Large Scale Integr. (VLSI) Syst., vol. 2, no. 2, pp. 186195,
Jun. 1994.
[22] N. A. Touba and E. J. McCluskey, Logic synthesis techniques for
reduced area implementation of multilevel circuits with concurrent
error detection, in Proc. IEEE/ACM Int. Conf. Comput.-Aided Design,
Nov. 1994, pp. 651654.
[23] M. Y. Hsiao, A class of optimal minimum odd-weight column
SEC-DED codes, IBM J. Res. Develop., vol. 14, no. 4, pp. 395301,
Jul. 1970.
[24] E. J. McCluskey, Design techniques for testable embedded error check-
ers, IEEE Computer, vol. 23, no. 7, pp. 8488, Jul. 1990.
[25] J. E. Stine, I. Castellanos, M. Wood, J. Henson, F. Love, W. R.
Davis, P. D. Franzon, M. Bucher, S. Basavarajaiah, J. Oh, and
R. Jenkal, FreePDK: An open-source variation-aware design kit,
in Proc. IEEE Int. Conf. Microelectron. Syst. Educ., Jun. 2007,
pp. 173174.
Oscillation and Transition Tests for Synchronous
Sequential Circuits
Katherine Shu-Min Li
AbstractIn this brief, we propose an oscillation-ring test methodology
for synchronous sequential circuits under the scan test environment. This
approach provides the following features: 1) it is at-speed testing, which
makes delay defects detectable; 2) the automatic test pattern generation is
much easier, and the test set is usually smaller; and 3) test responses are
directly observable at primary outputs and, thus, it greatly reduces the
communication bandwidth between the automatic test equipment and
the circuit under test. A modied scan register design supporting the
oscillation-ring test is presented and an effective oscillation test generation
algorithm for the proposed test scheme is given. Experimental results on
LGSyn91 benchmarks show that the proposed test method achieves high
fault coverage with a smaller number of test vectors.
Index TermsAt-speed test, oscillation test, scan design, synchronous
sequential circuit.
I. INTRODUCTION
Decreasing feature sizes and increasing clock speeds have com-
bined to dramatically alter the defect effects. Recent evidence indi-
cates that delay defects can no longer be ignored [1]. The detection
of delay faults requires at-speed test techniques, which creates signal
transitions to be captured at normal speed. In the past, it was typically
accomplished with functional patterns, but it was undesirable mainly
due to the cost consideration. Scan-based test techniques [2] offer
a viable alternative for at-speed testing. However, there are many
complicating factors that use slow scan-based tests for stuck-at faults
to delay test delay faults. Thus, a cost-effective test methodology for
the at-speed test is desirable, and it is the motivation of this brief.
Sequential testing is difcult due to the lack of controllability and
observability in internal storage elements. Sequential automatic test
pattern generation (ATPG) is much more complicated [3], and it may
not be able to achieve high fault coverage with sequential testing.
The scan-based designs are the most popular design for testability
(DFT) technique for testing sequential circuits. However, scan tests
are usually carried out in lower speed, and thus they are mainly
targeted for stuck-at faults.
An oscillation ring is a closed loop with an odd number of signal
inversions. If the circuit under test (CUT) is fault-free, an oscillation
signal appears on the ring. Otherwise, the CUT is deemed faulty. The
oscillation-based test is an efcient and effective method to detect
faults in a circuit or a device. It has been applied to test analog
circuits [4], digital circuits [5], and system-level interconnects [6].
We propose an oscillation test methodology for sequential testing
in this brief. The proposed method modies storage elements such
that oscillation signals can be generated according to the functional
and timing specications of the CUT. This approach provides the
following features; 1) in this architecture, testing is conducted at-
speed, which makes delay defects detectable; 2) test vectors can
be directly derived from the nite-state machine (FSM) model,
Manuscript received January 23, 2012; revised July 20, 2012 and
September 16, 2012; accepted November 25, 2012. Date of publica-
tion January 11, 2013; date of current version October 14, 2013. This
work was supported in part by the National Science Council of Taiwan,
under Grant NSC-98-2221-E-110-060-MY2, Grant NSC-99-2220-E-110-009,
Grant 99-EC-17-A-01-S1-104, and Grant NSC-100-2221-E-110-087.
The author is with the Department of Computer Science and Engineer-
ing, National Sun Yat-Sen University, Kaohsiung 80424, Taiwan (e-mail:
smli@cse.nsysu.edu.tw).
Color versions of one or more of the gures in this paper are available
online at http://ieeexplore.ieee.org.
Digital Object Identier 10.1109/TVLSI.2012.2230654
1063-8210 2013 IEEE