Test Compaction Procedure Research Articles

Sharing of Compressed Tests Among Logic Blocks

In a design that consists of several logic blocks, each logic block may be tested separately using its own compressed test set and on-chip decompression logic. The decompression logic is typically based on a linear circuit, such as a linear-feedback shift register (LFSR), and tests are compressed into initial states (seeds). This article observes that even if different LFSRs of different lengths are used for different logic blocks, there is flexibility to select compressed tests that can be shared among the logic blocks. This article describes a test compaction procedure that accepts compact compressed test sets computed for the logic blocks individually. The procedure combines the test sets into a single test set and optimizes it considering all the logic blocks together. This is important for applications where storage of tests is a bottleneck. Experimental results are presented to demonstrate the effectiveness of the test compaction procedure when groups of benchmark circuits are considered as logic blocks in the same design. A procedure for constructing groups with significant sharing of compressed tests is also discussed.

Diagnostic Test Point Insertion and Test Compaction

Test points are inserted into a circuit to improve its testability or diagnosability. The diagnosability goal may be to reduce the number of indistinguished fault pairs, increase the accuracy of logic diagnosis, or reduce the number of diagnostic tests. This article describes a test point insertion procedure, combined with a test compaction procedure, whose goal is to reduce the number of tests in a diagnostic test set, and bring it closer to the number of tests in a fault detection test set. A test point allows a fan-out branch to assume values that are different from those of the fan-out stem. Effectively, the fan-out branch becomes an independent input. The test compaction procedure reduces the number of tests in two ways: 1) by utilizing the extra inputs created when test points are inserted and 2) a diagnostic test set typically consists of a fault detection test set followed by diagnostic tests. The test compaction procedure modifies the diagnostic test set to use all the tests as both fault detection and diagnostic tests. Experimental results for single stuck-at faults in benchmark circuits demonstrate the effectiveness of this approach in producing diagnostic test sets whose numbers of tests are closer to those of compact fault detection test sets while preserving the accuracy of logic diagnosis.

Preponing Fault Detections for Test Compaction Under Transparent Scan

A test compaction procedure under transparent scan can compact a scan-based test set that contains a minimum number of tests. The additional test compaction can be important in applications that require highly compacted test sets. Transparent scan views a scan-based test set as a sequence of scan shift and functional capture cycles and allows the two types of clock cycles to appear in arbitrary sequences. The contribution of this brief is to suggest that one of the reasons for the effectiveness of transparent scan for test compaction is its ability to prepone fault detections by replacing scan shift with functional capture cycles when faults are activated during scan shift cycles. When fault detections are preponed, clock cycles around the original detection clock cycles become unnecessary and can be omitted. This view results in a new test compaction procedure that focuses on steps that contribute to test compaction, thus reducing the computational effort of test compaction compared with general-purpose test compaction procedures.

Equivalent Faults under Launch-on-Shift (LOS) Tests with Equal Primary Input Vectors

A recent work showed that it is possible to transform a single-cycle test for stuck-at faults into a launch-on-shift (LOS) test that is guaranteed to detect the same stuck-at faults without any logic or fault simulation. The LOS test also detects transition faults. This was used for obtaining a compact LOS test set that detects both types of faults. In the scenario where LOS tests are used for both stuck-at and transition faults, this article observes that, under certain conditions, the detection of a stuck-at fault guarantees the detection of a corresponding transition fault. This implies that the two faults are equivalent under LOS tests. Equivalence can be used for reducing the set of target faults for test generation and test compaction. The article develops this notion of equivalence under LOS tests with equal primary input vectors and provides an efficient procedure for identifying it. It presents experimental results to demonstrate that such equivalences exist in benchmark circuits, and shows an unexpected effect on a test compaction procedure.

Test Compaction by Backward and Forward Extension of Multicycle Tests

Multicycle tests are useful for test compaction even when full scan allows single- or two-cycle tests to be used. To avoid sequential test generation, multicycle tests can use the test data (scan-in states and primary input vectors) from a single- or two-cycle test set, possibly modified to make it more suitable for multicycle tests. However, the modification process requires repeated fault simulation to prevent a loss of fault coverage. This brief observes that the need to modify test data results from the fact that tests are only extended forward to increase their numbers of clock cycles starting from their (modified) scan-in states. The brief observes further that extending tests backward is a more computationally efficient way of obtaining multicycle tests with modified test data. The brief defines a new type of multicycle test to increase the effectiveness of backward extension and describes a test compaction procedure based on backward and forward extension. It presents experimental results for gate-exhaustive faults, requiring large numbers of tests, in benchmark circuits.

RETRO: Reintroducing Tests for Improved Reverse Order Fault Simulation

Reverse order fault simulation and its variations provide a test compaction option with a low computational effort that is applicable even when test constraints or complex fault models preclude the application of other conventional test compaction procedures. This is the scenario considered in this brief. Reverse order fault simulation procedures remove unnecessary tests from a test set without otherwise modifying it. Reverse order fault simulation is typically applied once after the complete test set has been generated. This brief observes that when other test compaction procedures are not applied, forward-looking reverse order fault simulation sometimes yields a smaller test set if it is applied more often during the test generation process. However, applying it more often also increases the computational effort. This brief explains this phenomenon and describes a procedure that uses the new insights to improve the ability of forward-looking reverse order fault simulation to achieve test compaction at a reduced computational effort. The experimental results for benchmark circuits are presented to support the discussion.

Broad-Brush Compaction for Sequential Test Generation

Test sequences that do not use scan chains have several advantages as manufacturing tests. Test sequences can be produced by sequential test generation procedures, and static test compaction can be applied to reduce the length of the sequence without losing fault coverage. A typical sequential test generation procedure that produces a single test sequence concatenates test subsequences to form the test sequence. Existing static test compaction procedures ignore the construction of the sequence from subsequences and consider every test vector individually for omission. This brief introduces a broad-brush static test compaction procedure that considers entire subsequences for omission to achieve test compaction. As additional subsequences are concatenated, subsequences concatenated earlier may become unnecessary. The procedure described in this brief identifies this situation. The advantage of a broad-brush approach is a low computational effort, which is demonstrated by experimental results for benchmark circuits.

PRESERVE: Static Test Compaction that Preserves Individual Numbers of Tests

A comprehensive test set targets faults of different types to ensure that defects of different types are detected. When test compaction is carried out for such a test set, it is advantageous if the compacted test set contains a compact test set for each fault type separately. In this case, if one (or more) of the fault types is found to be more important to detect, a compact test set for it can be extracted without further processing. This article describes the first test compaction procedure for transition and stuck-at faults, where by construction, the compact test set contains compact test sets for each fault type separately. The experimental results for benchmark circuits demonstrate the ability to compact a comprehensive test set under this condition.

Maximal Independent Fault Set for Gate-Exhaustive Faults

Dynamic test compaction procedures use independent fault sets to guide the generation of compact test sets. In addition, a maximal independent fault set provides a lower bound on the number of tests, and can thus be used for evaluating the level of test compaction. This article notes that defect-aware, cell-aware, and gate-exhaustive faults have certain properties that can be used in the computation of independent fault sets. This article focuses on gate-exhaustive faults and the computation of a maximal independent fault set. The experimental results for benchmark circuits support the discussion.

Target Faults for Test Compaction Based on Multicycle Tests

The use of multicycle tests, with several functional capture cycles between scan operations, contributes significantly to the ability to compact a test set. Multicycle tests have the added benefit that they can contribute to the detection of defects with complex behaviors that are not detected by single-cycle or two-cycle tests. To ensure that this benefit is materialized when test compaction is applied to transition faults, this article suggests to incorporate into the test compaction procedure an additional fault model whose fault coverage increases when multicycle tests are used. To ensure that the computational complexity of test compaction is not increased by a fault model with a large number of faults, or faults with complex behaviors, the added fault model is required to have the same characteristics as the transition fault model. A type of transition fault called unspecified transition fault satisfies these requirements. The article describes a test compaction procedure for transition faults that incorporates unspecified transition faults, and presents experimental results for benchmark circuits to demonstrate the levels of test compaction and fault coverage that can be achieved.

Multicycle Broadside and Skewed-Load Tests for Test Compaction

This paper describes a test compaction procedure that combines the advantages of using multicycle tests for test compaction with the advantages of using both broadside and skewed-load tests for increasing the fault coverage and achieving test compaction. The procedure is the first to combine these two concepts in a single procedure. The combination is made possible by a definition of a multicycle skewed-load test that is suggested in this paper, and complements the definition of a multicycle broadside test. Experimental results demonstrate the effectiveness of multicycle broadside and skewed-load tests in achieving test compaction for benchmark circuits.

Selection of Primary Output Vectors to Observe Under Multicycle Tests

Test compaction benefits from the use of multicycle tests that have several clock cycles between their scan-in and scan-out operations. For maximum benefit, primary output vectors should be observed during all the clock cycles between the scan operations of a multicycle test. This allows the test to detect all the faults whose fault effects reach the primary outputs, in addition to the ones whose fault effects are latched onto the flip-flops before the scan-out operation. However, for consistency with single-cycle tests for single stuck-at faults, or two-cycle tests for transition faults, only one primary output vector should be observed per test. This can be the last primary output vector of the test, as in the case of single-cycle and two-cycle tests, but other options are more useful, as demonstrated in this article. In particular, this article suggests that the primary output vector to be observed should be selected individually for every test. It also describes a static procedure for selecting a single primary output vector to observe individually for every test based on a given compact multicycle test set and a dynamic test compaction procedure that produces multicycle test sets with this property.

Skewed-Load Tests for Transition and Stuck-at Faults

Test generation procedures target a variety of fault models in order to produce test sets that are effective for defect detection. This paper considers the likely scenario where two-cycle skewed-load tests are generated to detect single transition faults, and the test set is complemented with tests for single stuck-at faults that are not detected by the transition fault test set. For this scenario, this paper makes several unique observations that can be utilized to produce a single compact test set that consists only of two-cycle skewed-load tests for both fault models. The first observation is that a single-cycle test for a stuck-at fault can be transformed into a skewed-load test that is guaranteed to detect the stuck-at fault without performing logic or fault simulation. The second observation is that skewed-load tests, which are transformed from single-cycle tests for stuck-at faults, sometimes detect more transition and stuck-at faults than tests that were generated for transition faults. The third observation is that a static test compaction procedure, which is based on the modification and removal of tests, is effective in this context because it allows tests for stuck-at faults to detect more transition faults and vice versa. This paper describes a test compaction procedure based on these observations and presents experimental results for benchmark circuits to demonstrate the effectiveness of the procedure.

Observation Points on State Variables for the Compaction of Multicycle Tests

Multicycle tests support test compaction by including several functional capture cycles in every test. However, even highly compacted multicycle test sets typically contain single-cycle or two-cycle tests for faults that cannot be detected using tests with larger numbers of clock cycles. An analysis of such tests reveals that the tests can be extended to include larger numbers of functional capture cycles if observation points are placed in the circuit. Moreover, the analysis shows that it is sufficient to place observation points on selected present-state or next-state variables. This is advantageous for the detection of delay faults without changing the paths they traverse. Based on this analysis, this brief describes a test compaction procedure for multicycle tests that places observation points on present-state variables in order to enable additional test compaction. Experimental results demonstrate the existence of cases where the observation points are effective in reducing the number of tests in a test set that is already highly compacted.

Static test compaction procedure for large pools of multicycle functional broadside tests

This study describes a static test compaction procedure that is applicable in the scenario where (i) a large pool of tests can be generated efficiently, but (ii) test compaction that modifies tests, and covering procedures, are not applicable, and (iii) reverse order fault simulation procedures are not sufficient for test compaction. The procedure has the ability to identify tests in the pool that are effective for test compaction even when they do not increase the fault coverage. This ability is achieved using only fault simulation with fault dropping. The procedure is designed for the case where multicycle functional broadside tests are extracted from functional test sequences. The use of multicycle tests results in higher levels of test compaction than possible with two-cycle functional broadside tests. It adds another dimension to the procedure that also needs to select a number of clock cycles for every test.

Clock Sequences for Increasing the Fault Coverage of Functional Test Sequences

A functional test sequence for a design may not be effective as a manufacturing test for a logic block in the design because it achieves a low gate-level fault coverage. This paper describes a procedure for selecting a clock sequence that increases the gate-level fault coverage of a functional test sequence when it is used for testing a subset of logic blocks. The procedure deactivates the clocks to the logic blocks in the subset when a primary input vector has a negative effect on their fault coverage. The procedure is different from earlier test generation and test compaction procedures in that it increases the fault coverage without modifying the functional test sequence. It thus preserves some of the functional characteristics and the test application process for the sequence. Experimental results for benchmark circuits are presented to demonstrate the effectiveness of the procedure.

Balancing the Numbers of Detected Faults for Improved Test Set Quality

Test set quality benefits from tests that detect large numbers of faults. However, test compaction procedures target decreasing numbers of faults as they generate more tests and drop faults from consideration. This paper describes a procedure that balances the numbers of faults that tests in a given test set detect in order to improve its quality. In the first step of an iteration, the procedure moves tests from the beginning to the end of the test set. This allows fault simulation with fault dropping to create target faults for tests that were generated with small numbers of target faults. In the second step, the procedure constructs a new test set where tests with small numbers of detected faults are modified to detect additional faults. Experimental results are presented to demonstrate the ability of the procedure to improve the quality of a test set for single stuck-at faults as measured by its bridging fault coverage, and the numbers of detections of single stuck-at faults.

Static test compaction for circuits with multiple independent scan chains

This study describes a static test compaction procedure for transition faults in circuits with multiple scan chains where each scan chain can operate independently in functional or shift mode. The procedure mixes parts of different broadside and skewed-load tests, where the parts coincide with the scan chains, in order to create new tests that detect more faults. This allows the number of tests to be reduced without reducing the fault coverage. By mixing parts of tests with different types, different scan chains are assigned different modes of operation within the same test. Experimental results are presented to demonstrate that this allows the number of tests to be reduced below the number of tests in a compact test set that consists of broadside and skewed-load tests.

Enhanced Test Compaction for Multicycle Broadside Tests by Using State Complementation

Multicycle tests support test compaction by allowing each test to detect more target faults. The ability of multicycle broadside tests to provide test compaction depends on the ability of primary input sequences to take the circuit between pairs of states that are useful for detecting target faults. This ability can be enhanced by adding design-for-testability (DFT) logic that allows states to be complemented. This article describes a test compaction procedure that uses such DFT logic to form a compact multicycle broadside test set for transition faults where the tests use constant primary input vectors. The use of complemented states also allows the procedure to increase the transition fault coverage beyond the transition fault coverage of a broadside test set. The procedure has the option of increasing the switching activity of the tests gradually in order to explore the tradeoff between the number of tests, the fault coverage, and the switching activity.

Test Compaction by Sharing of Functional Test Sequences Among Logic Blocks

This paper describes a test compaction procedure that considers a set of functional test sequences for a set of logic blocks in a design. The logic blocks may have different numbers of primary inputs, and functional test sequences of different lengths. The procedure expands the test sequences such that every sequence is applicable to every logic block. It then concatenates and compacts the sequences into a single sequence. In this process, it considers the logic blocks one at a time to avoid the need to store and simulate all the logic blocks simultaneously. The resulting test sequence can be applied to all the logic blocks in parallel. The experimental results demonstrate the levels of test compaction that can be achieved by this approach. The results also demonstrate that the resulting sequence has an improved coverage of faults that were not targeted during the generation of the functional test sequences or the test compaction procedure.