Community Hub0 Subscribers
Community hub
Automatic test pattern generation
View on Wikipediafrom Wikipedia
ATPG (acronym for both automatic test pattern generation and automatic test pattern generator) is an electronic design automation method or technology used to find an input (or test) sequence that, when applied to a digital circuit, enables automatic test equipment to distinguish between the correct circuit behavior and the faulty circuit behavior caused by defects. The generated patterns are used to test semiconductor devices after manufacture, or to assist with determining the cause of failure (failure analysis[1]). The effectiveness of ATPG is measured by the number of modeled defects, or fault models, detectable and by the number of generated patterns. These metrics generally indicate test quality (higher with more fault detections) and test application time (higher with more patterns). ATPG efficiency is another important consideration that is influenced by the fault model under consideration, the type of circuit under test (full scan, synchronous sequential, or asynchronous sequential), the level of abstraction used to represent the circuit under test (gate, register-transfer, switch), and the required test quality.
Basics
[edit]A defect is an error caused in a device during the manufacturing process. A fault model is a mathematical description of how a defect alters design behavior. The logic values observed at the device's primary outputs, while applying a test pattern to some device under test (DUT), are called the output of that test pattern. The output of a test pattern, when testing a fault-free device that works exactly as designed, is called the expected output of that test pattern. A fault is said to be detected by a test pattern if the output of that test pattern, when testing a device that has only that one fault, is different than the expected output. The ATPG process for a targeted fault consists of two phases: fault activation and fault propagation. Fault activation establishes a signal value at the fault model site that is opposite of the value produced by the fault model. Fault propagation moves the resulting signal value, or fault effect, forward by sensitizing a path from the fault site to a primary output.
ATPG can fail to find a test for a particular fault in at least two cases. First, the fault may be intrinsically undetectable, such that no patterns exist that can detect that particular fault. The classic example of this is a redundant circuit, designed such that no single fault causes the output to change. In such a circuit, any single fault will be inherently undetectable.
Second, it is possible that a detection pattern exists, but the algorithm cannot find one. Since the ATPG problem is NP-complete (by reduction from the Boolean satisfiability problem) there will be cases where patterns exist, but ATPG gives up as it will take too long to find them (assuming P≠NP, of course).
Fault models
[edit]- single fault assumption: only one fault occur in a circuit. if we define k possible fault types in our fault model the circuit has n signal lines, by single fault assumption, the total number of single faults is k×n.
- multiple fault assumption: multiple faults may occur in a circuit.
Fault collapsing
[edit]Equivalent faults produce the same faulty behavior for all input patterns. Any single fault from the set of equivalent faults can represent the whole set. In this case, much less than k×n fault tests are required for a circuit with n signal line. Removing equivalent faults from entire set of faults is called fault collapsing.
The stuck-at fault model
[edit]In the past several decades, the most popular fault model used in practice is the single stuck-at fault model. In this model, one of the signal lines in a circuit is assumed to be stuck at a fixed logic value, regardless of what inputs are supplied to the circuit. Hence, if a circuit has n signal lines, there are potentially 2n stuck-at faults defined on the circuit, of which some can be viewed as being equivalent to others. The stuck-at fault model is a logical fault model because no delay information is associated with the fault definition. It is also called a permanent fault model because the faulty effect is assumed to be permanent, in contrast to intermittent faults which occur (seemingly) at random and transient faults which occur sporadically, perhaps depending on operating conditions (e.g. temperature, power supply voltage) or on the data values (high or low voltage states) on surrounding signal lines. The single stuck-at fault model is structural because it is defined based on a structural gate-level circuit model.
A pattern set with 100% stuck-at fault coverage consists of tests to detect every possible stuck-at fault in a circuit. 100% stuck-at fault coverage does not necessarily guarantee high quality, since faults of many other kinds often occur (e.g. bridging faults, opens faults, delay faults).
Transistor faults
[edit]This model is used to describe faults for CMOS logic gates. At transistor level, a transistor maybe stuck-short or stuck-open. In stuck-short, a transistor behaves as it is always conducts (or stuck-on), and stuck-open is when a transistor never conducts current (or stuck-off). Stuck-short will produce a short between VDD and VSS.
Bridging faults
[edit]A short circuit between two signal lines is called bridging faults. Bridging to VDD or Vss is equivalent to stuck at fault model. Traditionally both signals after bridging were modeled with logic AND or OR of both signals. If one driver dominates the other driver in a bridging situation, the dominant driver forces the logic to the other one, in such case a dominant bridging fault is used. To better reflect the reality of CMOS VLSI devices, a Dominant AND or Dominant OR bridging fault model is used. In the latter case, dominant driver keeps its value, while the other one gets the AND or OR value of its own and the dominant driver.
Opens faults
[edit]Delay faults
[edit]Delay faults can be classified as:
- Gate delay fault
- Transition fault
- Hold Time fault
- Slow/Small delay fault
- Path delay fault: This fault is due to the sum of all gate propagation delays along a single path. This fault shows that the delay of one or more paths exceeds the clock period. One major problem in finding delay faults is the number of possible paths in a circuit under test (CUT), which in the worst case can grow exponentially with the number of lines n in the circuit.
Combinational ATPG
[edit]The combinational ATPG method allows testing the individual nodes (or flip-flops) of the logic circuit without being concerned with the operation of the overall circuit. During test, a so-called scan-mode is enabled forcing all flip-flops (FFs) to be connected in a simplified fashion, effectively bypassing their interconnections as intended during normal operation. This allows using a relatively simple vector matrix to quickly test all the comprising FFs, as well as to trace failures to specific FFs.
Sequential ATPG
[edit]Sequential-circuit ATPG searches for a sequence of test vectors to detect a particular fault through the space of all possible test vector sequences. Various search strategies and heuristics have been devised to find a shorter sequence, or to find a sequence faster. However, according to reported results, no single strategy or heuristic out-performs others for all applications or circuits. This observation implies that a test generator should include a comprehensive set of heuristics.
Even a simple stuck-at fault requires a sequence of vectors for detection in a sequential circuit. Also, due to the presence of memory elements, the controllability and observability of the internal signals in a sequential circuit are in general much more difficult than those in a combinational logic circuit. These factors make the complexity of sequential ATPG much higher than that of combinational ATPG, where a scan-chain (i.e. switchable, for-test-only signal chain) is added to allow simple access to the individual nodes.
Due to the high complexity of the sequential ATPG, it remains a challenging task for large, highly sequential circuits that do not incorporate any Design For Testability (DFT) scheme. However, these test generators, combined with low-overhead DFT techniques such as partial scan, have shown a certain degree of success in testing large designs. For designs that are sensitive to area or performance overhead, the solution of using sequential-circuit ATPG and partial scan offers an attractive alternative to the popular full-scan solution, which is based on combinational-circuit ATPG.
Nanometer technologies
[edit]Historically, ATPG has focused on a set of faults derived from a gate-level fault model. As design trends move toward nanometer technology, new manufacture testing problems are emerging. During design validation, engineers can no longer ignore the effects of crosstalk and power supply noise on reliability and performance. Current fault modeling and vector-generation techniques are giving way to new models and techniques that consider timing information during test generation, that are scalable to larger designs, and that can capture extreme design conditions. For nanometer technology, many current design validation problems are becoming manufacturing test problems as well, so new fault-modeling and ATPG techniques will be needed.
Algorithmic methods
[edit]Testing very-large-scale integrated circuits with a high fault coverage is a difficult task because of complexity. Therefore, many different ATPG methods have been developed to address combinational and sequential circuits.
- Early test generation algorithms such as boolean difference and literal proposition were not practical to implement on a computer.
- The D Algorithm was the first practical test generation algorithm in terms of memory requirements. The D Algorithm [proposed by Roth 1966] introduced D Notation which continues to be used in most ATPG algorithms. D Algorithm tries to propagate the stuck at fault value denoted by D (for SA0) or D (for SA1) to a primary output.
- Path-Oriented Decision Making (PODEM) is an improvement over the D Algorithm. PODEM was created in 1981, by Prabhu Goel, when shortcomings in D Algorithm became evident when design innovations resulted in circuits that D Algorithm could not realize.
- Fan-Out Oriented (FAN algorithm) is an improvement over PODEM. It limits the ATPG search space to reduce computation time and accelerates backtracing.
- Methods based on Boolean satisfiability are sometimes used to generate test vectors.
- Pseudorandom test generation is the simplest method of creating tests. It uses a pseudorandom number generator to generate test vectors, and relies on logic simulation to compute good machine results, and fault simulation to calculate the fault coverage of the generated vectors.
- Wavelet Automatic Spectral Pattern Generator (WASP) is an improvement over spectral algorithms for sequential ATPG. It uses wavelet heuristics to search space to reduce computation time and accelerate the compactor. It was put forward by Suresh kumar Devanathan from Rake Software and Michael Bushnell, Rutgers University. Suresh kumar Devanathan invented WASP as a part of his thesis at Rutgers.[citation needed]
Relevant conferences
[edit]ATPG is a topic that is covered by several conferences throughout the year. The primary US conferences are the International Test Conference and The VLSI Test Symposium, while in Europe the topic is covered by DATE and ETS.
See also
[edit]- ASIC
- Boundary scan (BSCAN)
- Built-in self-test (BIST)
- Design for test (DFT)
- Fault model
- JTAG
- VHSIC
References
[edit]- Electronic Design Automation For Integrated Circuits Handbook, by Lavagno, Martin, and Scheffer, ISBN 0-8493-3096-3 A survey of the field, from which the above summary was derived, with permission.
- Microelectronics Failure Analysis. Materials Park, Ohio: ASM International. 2004. ISBN 0-87170-804-3.
- ^ Crowell, G; Press, R. "Using Scan Based Techniques for Fault Isolation in Logic Devices". Microelectronics Failure Analysis. pp. 132–8.
Automatic test pattern generation
View on Grokipediafrom Grokipedia
Introduction
Definition and Objectives
Automatic Test Pattern Generation (ATPG) is an electronic design automation (EDA) technology that automatically creates input test patterns, or vectors, to verify the functionality of digital circuits against modeled faults, enabling automatic test equipment to differentiate between correct and defective behavior in very-large-scale integration (VLSI) chips.[1] This process is essential in semiconductor manufacturing to detect defects introduced during fabrication, ensuring high product reliability without manual intervention in test vector creation.[9] The primary objectives of ATPG include achieving high fault coverage to detect the maximum number of potential defects, minimizing the number of test patterns to reduce storage and application costs, and shortening test application time to improve throughput in production testing environments. These goals balance test quality with economic efficiency, as excessive patterns increase data volume and testing duration, while insufficient coverage risks shipping faulty devices.[10] In ATPG, test vectors consist of input sequences designed to activate a fault at an internal circuit node and propagate its effect through the logic to an observable primary output, where the discrepancy between expected and actual responses indicates the presence of a defect.[11] Key performance metrics for evaluating ATPG effectiveness encompass fault coverage percentage, which measures the proportion of targeted faults detected; test length, representing the total number of vectors or clock cycles required; and backtrack count, indicating the computational effort in search-based algorithms during pattern generation.[12] ATPG emerged as a formalized discipline in the mid-1960s, with the introduction of the D-algorithm by J. Paul Roth, which provided the foundational calculus for generating tests to detect faults in combinational logic circuits.[13] This breakthrough laid the groundwork for subsequent advancements in the 1970s, enabling automated testing for increasingly complex VLSI designs.Historical Development
The development of automatic test pattern generation (ATPG) began in the 1960s and 1970s amid the growing complexity of digital circuits, transitioning from manual test vector creation to systematic automation. Early efforts focused on combinational logic, where manual methods were labor-intensive and error-prone for even modest circuit sizes. The seminal breakthrough came with J. Paul Roth's D-algorithm in 1966, the first complete algorithmic approach to ATPG, which introduced D-calculus—a symbolic notation using D (difference) and \bar{D} to represent fault propagation from the error site to observable outputs in stuck-at fault models.[14] This method enabled deterministic test generation by forward implication and backward justification, laying the foundation for fault-oriented ATPG and influencing subsequent techniques.[14] The 1980s saw refinements to address the D-algorithm's inefficiencies, such as excessive backtracking in circuits with reconvergent fanout. Prabhakar Goel's PODEM (Path-Oriented Decision Making) algorithm, introduced in 1981, improved upon this by employing implicit enumeration at primary inputs only, guided by path sensitization objectives, which reduced computational overhead and handled XOR gates more effectively.[15] Building on PODEM, Hideo Fujiwara and Takeshi Shimono's FAN algorithm in 1983 incorporated fan-out stemming, multiple backtrace, and headline heuristics to limit decision branches. These advancements made ATPG viable for VLSI-era designs, as transistor counts began scaling rapidly under Moore's Law, from thousands to millions by the decade's end.[16] In the 1990s and 2000s, ATPG extended to sequential circuits, driven by the adoption of full-scan designs that inserted shift registers to expose internal states, simplifying testing but increasing pattern volume. Commercial tools proliferated, with Mentor Graphics' FastScan, launched in the mid-1990s, providing robust sequential ATPG through time-frame expansion and fault simulation integration, routinely attaining over 95% stuck-at fault coverage in industrial chips with millions of gates.[17] As Moore's Law propelled transistor densities to billions by the 2010s, challenges like nanometer effects (e.g., process variations) prompted a shift to Boolean satisfiability (SAT)-based ATPG around 2000, which reformulated test generation as a satisfiability problem solvable by advanced solvers, offering robustness for hard-to-detect faults without structural limitations.[18] This era also saw the evolution of fault models from stuck-at to include delay faults, necessitating temporal expansions in ATPG frameworks.[19] The 2010s and 2020s have integrated machine learning (ML) and AI to optimize ATPG amid escalating design scales, where traditional methods struggle with exponential complexity. SAT-based tools dominated for handling billion-gate SoCs, but ML enhancements, such as neural networks guiding decision heuristics, reduced backtracks by 20-50% on industrial benchmarks.[20] Recent works, like deep reinforcement learning (DRL)-based ATPG in 2024, treat pattern generation as a Markov decision process to minimize search space, achieving higher efficiency in compressed scan environments.[8] As of 2025, with transistor counts exceeding 100 billion in advanced nodes (e.g., Nvidia Blackwell GPU with 208 billion transistors), AI-driven ATPG continues to adapt, prioritizing pattern compaction and multi-objective optimization to counter test cost inflation from scaling.[21]Fundamentals
Digital Circuit Representations
In automatic test pattern generation (ATPG), digital circuits are primarily represented at the gate level using netlists that describe the interconnections of primitive logic gates such as AND, OR, NAND, NOR, XOR, and NOT, along with flip-flops for sequential elements.[22] This structural representation captures the exact topology of the circuit, enabling precise fault simulation and test vector computation by modeling signal flow through gates and wires.[23] Gate-level netlists serve as the standard input for ATPG tools, as they provide a detailed, synthesizable description derived from higher-level hardware description languages (HDLs) after logic synthesis; Verilog, standardized in 1984, and its extension SystemVerilog (as of 2025) are commonly used.[24] Boolean algebra forms the mathematical foundation for manipulating these representations in ATPG, where circuit signals are treated as binary variables taking values 0 (false) or 1 (true).[25] A literal is a variable or its complement (e.g., or ), while a cube is a product of literals representing a set of minterms in the Boolean space, often using ternary logic with 0, 1, and X (unknown or don't care) to denote partial assignments during fault propagation.[25] In ATPG algorithms like the D-algorithm, cubes are extended to D-cubes to model differences between good and faulty circuit behaviors, facilitating efficient implication and justification steps.[26] Simplification of Boolean expressions in netlists often employs the consensus method, which applies the consensus theorem to eliminate redundant terms by resolving pairs of cubes that differ in exactly one variable, reducing complexity without altering functionality.[27] While behavioral models describe circuit functionality at a higher abstraction (e.g., via register-transfer level equations), ATPG predominantly relies on structural models like gate-level netlists for their explicit connectivity, which is essential for structural fault analysis.[28] In structural representations, fan-in refers to the number of inputs converging on a gate (e.g., two inputs to an AND gate), influencing signal controllability, while fan-out denotes the number of gates driven by a node's output, potentially complicating observability due to multiple propagation paths.[29] For instance, high fan-out in a circuit like a decoder increases the difficulty of propagating a fault effect to all outputs, as seen in benchmark circuits such as ISCAS-85.[30] Key concepts in these representations include controllability, the ease of driving a node to a specific value (0 or 1) from primary inputs, and observability, the ease of propagating a node's value change to primary outputs.[29] These metrics guide ATPG by quantifying testability; low controllability at internal nodes may require design modifications to sensitize faults. The Sandia Controllability/Observability Analysis Program (SCOAP) provides structural estimates of these measures, where 0-controllability for a line approximates the minimum number of primary inputs to specify to set it to 0, and observability approximates the minimum number of signals to specify to observe a change at . Testability can be assessed by metrics like , with lower values indicating easier testing.[31] For practical implementation, ATPG software such as Synopsys TetraMAX or Mentor Graphics FastScan accepts gate-level netlists in formats like Verilog, which describe the circuit hierarchy, gates, and connections in a synthesizable subset.[32] The Berkeley Logic Interchange Format (BLIF), developed in the 1990s, is also commonly used, particularly in academic and open-source tools, as a flattened, technology-mapped representation that supports hierarchical models and is generated from Verilog or VHDL during synthesis flows.[30] These formats ensure compatibility for fault injection and pattern generation, with Verilog enabling direct simulation integration via standard cell libraries.[33]Design for Testability Concepts
Design for Testability (DFT) encompasses a set of strategies and techniques incorporated into digital circuit designs to improve controllability and observability, thereby facilitating more efficient automatic test pattern generation (ATPG) without compromising the circuit's primary functionality.[34] Controllability refers to the ease of setting internal nodes to specific logic values (0 or 1), while observability measures the ability to propagate node values to primary outputs for fault detection.[35] These enhancements address inherent testability challenges in complex VLSI circuits, where random or deterministic test patterns alone may fail to achieve high fault coverage due to limited access to internal states.[36] Scan design is a structured DFT technique that integrates flip-flops into shift-register chains, enabling the loading of test patterns and the capturing of responses as if the circuit were combinational. Concepts of scan design originated in the 1960s, with practical implementations like the scan path introduced by researchers at NEC in the 1970s. In full scan, all flip-flops are replaced with scannable elements connected in one or more chains, maximizing controllability and observability for ATPG tools.[37] Partial scan, by contrast, scans only a subset of flip-flops, balancing testability gains with reduced area overhead and performance impact, though it may require more sophisticated ATPG algorithms.[38] Scan chains effectively convert sequential circuits into combinational ones during test mode by unrolling time frames, allowing standard combinational ATPG methods to be applied iteratively.[36] Widespread industry adoption occurred in the 1980s as VLSI complexity grew and ATPG tools matured.[39] Built-in self-test (BIST) is an on-chip DFT approach where the circuit generates its own test patterns and compacts responses, reducing reliance on external automatic test equipment. A common BIST architecture employs a linear feedback shift register (LFSR) as a pseudo-random pattern generator, which produces sequences approximating random inputs to detect faults with high probability, often achieving over 90% coverage for stuck-at faults in combinational logic.[40] Response compaction in BIST typically uses a multiple-input signature register (MISR), also based on LFSR principles, to condense output signatures into a compact form for fault diagnosis, minimizing test data volume.[41] BIST complements ATPG by enabling at-speed testing and self-diagnosis in system-level environments, particularly for embedded cores.[42] Testability metrics quantify controllability and observability to guide DFT insertion and predict ATPG effort. Fanout-oriented (COP) metrics provide probabilistic estimates, such as observability of a fanout stem approximated as the minimum or product of branch observabilities, assuming uniform signal probabilities and highlighting high-fanout reconvergent structures as testability bottlenecks.[43] In contrast, SCOAP (Sandia Controllability/Observability Analysis Program) uses structural analysis to compute deterministic measures: CC0 and CC1 for the number of signals needed to control a node to 0 or 1, and CO for the number needed to observe a fault effect, enabling precise identification of hard-to-test nodes.[31] SCOAP is favored for its computational efficiency in guiding test point placement, while COP offers quicker but approximate random-pattern testability assessments.[44] Ad-hoc DFT techniques involve manual or semi-automated modifications to improve testability without structured overhead, such as inserting control points (e.g., multiplexers to override inputs) to enhance controllability and observe points (e.g., latches to capture internal signals) to boost observability. These target random-pattern-resistant structures like long chains of inverters or XOR gates by breaking feedback loops or reducing fan-in/fan-out imbalances.[45] Though less systematic than scan or BIST, ad-hoc methods were prevalent in early VLSI designs and remain useful for performance-critical paths where structured DFT incurs excessive delay.[46] DFT techniques significantly reduce ATPG computational complexity by improving access to internal nodes; for instance, scan chains allow time-frame unrolling, transforming sequential ATPG into repeated combinational problems that scale linearly with cycle depth rather than exponentially.[36] This can decrease backtrack counts in D-algorithm-based ATPG by orders of magnitude, enabling higher fault coverage for million-gate designs within practical runtime limits. Overall, DFT shifts testing from ad-hoc probing to automated, scalable processes, essential for modern semiconductor manufacturing.Fault Models
Stuck-at Fault Model
The stuck-at fault model represents a foundational abstraction in automatic test pattern generation (ATPG) for modeling logic-level defects in digital circuits, where a signal line or node is assumed to be permanently fixed at a logic value of 0 (stuck-at-0, or SA0) or 1 (stuck-at-1, or SA1), irrespective of the applied inputs or the intended circuit behavior.[47] This model simplifies the representation of manufacturing defects, such as opens, shorts, or transistor failures, by assuming the faulty behavior manifests as a constant logic value at the affected site.[48] Introduced in the late 1950s, the model gained prominence through early work on test generation for combinational logic, laying the groundwork for subsequent ATPG algorithms despite not explicitly using the "stuck-at" terminology at the time. Fault collapsing techniques reduce the number of unique faults that must be targeted during ATPG by identifying relationships such as equivalence and dominance among potential stuck-at faults. Two faults are equivalent if every test vector that detects one also detects the other, allowing one representative fault per equivalence class to suffice for testing; for instance, in a fanout structure, a stuck-at fault at the stem is equivalent to the same stuck-at fault at all branches, collapsing multiple faults into one.[49] Dominance occurs when all tests for one fault (the dominated fault) also detect another (the dominating fault); an example is a SA0 fault on an input to an AND gate, which is dominated by a SA0 fault on the gate's output, since any test sensitizing the input fault will propagate the error through the output.[50] These structural relationships can reduce the fault set size by 40-60% in typical circuits, with exact collapsing algorithms computing disjoint equivalence classes for efficient simulation.[51] In fault simulation, multiple stuck-at faults are evaluated concurrently against test patterns using parallel pattern simulation, where the good circuit response is computed once, and faulty responses are derived bitwise using fault-specific masks to accelerate the process for large fault lists.[52] A fault $ f $ at node $ v $ with stuck value $ s $ (0 or 1) is activated by an input vector if the good circuit value at $ v $ is the complement $ \overline{s} $, ensuring the fault effect differs from the fault-free behavior; mathematically, activation occurs when $ g(v) = \overline{s} $, where $ g(v) $ is the good value at $ v $. For detection, the fault effect must then propagate to an observable output via path sensitization: for a SA0 fault, the faulty 0 must be propagated by setting controlling values on the path (e.g., 0 on AND inputs or 1 on OR inputs) while justifying non-controlling values on side inputs to avoid masking.[53] Achieving high stuck-at fault coverage, typically targeting 95-99% of collapsible faults, is a primary goal in ATPG to ensure robust defect detection, with modern tools routinely attaining over 99% in well-designed circuits.[54] For example, a simple combinational circuit with 10 gates might have 20 lines, yielding up to 40 potential stuck-at faults before collapsing, but equivalence and dominance reduce this to around 20-25 representative faults for targeted generation.[55] This model is central to classical combinational ATPG methods, such as the D-algorithm, which explicitly targets stuck-at faults through decision trees for activation and propagation. Design-for-testability (DFT) techniques, like scan chains, further enhance stuck-at coverage by improving controllability and observability in sequential circuits. Despite its ubiquity, the stuck-at fault model has limitations, as it abstracts away timing variations and physical defect mechanisms, such as resistive opens or multiple interacting failures, potentially underestimating certain real-world defects.[56] Originating in the 1960s era of discrete logic testing, it remains the baseline for ATPG but is often supplemented with more advanced models for comprehensive validation.[57]Bridging and Short Faults
Bridging faults, also known as short faults, arise from unintended electrical connections between two or more nodes in a digital circuit, altering the intended logic behavior by forcing the nodes to share the same voltage level. This short circuit can manifest as a wired-AND effect, where the bridged nodes exhibit a dominant 0 logic value equivalent to the logical AND of their intended signals, or a wired-OR effect, with a dominant 1 equivalent to the logical OR. These behaviors were first formalized in early fault modeling for technologies like TTL, where the pull-down network strength determines dominance in wired-AND scenarios.[58] Bridging faults are categorized into intra-gate types, which occur within a single logic gate such as between source/drain terminals of transistors, and inter-gate types, which connect nodes across different gates, often modeled using the AND or OR bridge assumptions based on signal directions. Intra-gate bridges may require transistor-level simulation for accurate behavior due to complex internal interactions, while inter-gate bridges are more commonly abstracted at the gate level for ATPG efficiency. In CMOS circuits, a more realistic representation uses the voting model, where the logic outcome depends on the relative drive strengths of the transistors connected to the bridged nodes, with the stronger driver "winning" the vote to set the voltage.[59][60] Detection of bridging faults in ATPG involves generating test patterns that sensitize the bridged nodes to conflicting logic values—one driven to 0 and the other to 1—propagating the resulting discrepancy to an observable output. This contrasts with stuck-at faults, which affect single nodes, and requires fault simulation to verify the excitation and propagation conditions under the chosen model (e.g., wired-OR or voting). The voting model enhances realism for CMOS by accounting for non-ideal voltage levels, improving test quality over simplistic wired models.[60] In nanometer-scale VLSI chips, bridging faults become significantly more prevalent than opens due to increased interconnect density and reduced feature sizes, with defect data indicating higher occurrences of bridges in layouts with closely spaced metal lines; a common example is shorts between adjacent interconnects in the metal layers.[61][62] This rise necessitates layout-extracted fault lists for targeted ATPG, as random physical proximity dictates likely bridge sites rather than functional connectivity. Simulating bridging faults poses unique challenges, as the fault universe consists of potentially millions of node pairs, each non-equivalent and requiring individual simulation, unlike the linear scaling of stuck-at faults. ATPG tools must enumerate realistic pairs from layout geometry to avoid computational explosion, yet bridging coverage often achieves only 80-90% in industrial flows, lower than stuck-at due to unmodeled resistive effects and feedback loops.[63] Bridging fault models gained prominence in the 1970s with initial definitions tying them to physical shorts beyond stuck-at limitations, but layout-aware approaches emerged in the 1980s to incorporate geometric probabilities, enabling more accurate simulation and test generation. Specialized tools, such as the BridgeFault Simulator, were developed during this period to support these models in commercial ATPG environments.[64][58]Delay and Timing Faults
Delay and timing faults represent defects in digital circuits that cause excessive propagation delays, potentially leading to timing violations under operational clock speeds, which is critical for high-performance designs where at-speed testing is essential to detect these dynamic issues.[65] These faults are broadly classified into gross delay faults and small delay faults; gross delay faults involve permanent increases in path delays that exceed the clock period, often due to major defects like large resistive opens, while small delay faults arise from distributed defects such as minor process variations or subtle resistive changes that cumulatively affect timing without immediately failing the circuit at nominal speeds.[66] Gross delay faults are typically easier to detect as they manifest as clear failures in at-speed tests, whereas small delay faults require more sensitive methods to identify their cumulative impact along signal paths.[67] Key models for these faults include the transition fault model, which treats delay defects as analogous to stuck-at faults but for signal transitions, manifesting as slow-to-rise or slow-to-fall behaviors at a gate output, and the path delay fault model, which targets specific timing violations along an entire combinational path from input to output. The transition fault model, introduced in 1987, simplifies ATPG by focusing on local gate-level delays and is widely used for gross delay detection, while the path delay fault model, proposed in 1985, accounts for cumulative delays but is computationally intensive due to the exponential number of paths in complex circuits. Test generation for these faults employs at-speed testing protocols involving launch-capture cycles, where a two-pattern test (vector pair and ) is applied: initializes the circuit state, and launches the transition to be captured within the subsequent clock cycle to verify timing.[68] For transition fault coverage, the test requires detecting both 0→1 and 1→0 toggles at the fault site within the clock period , ensuring the signal transition completes before the capture edge, as formalized by the condition that the faulty delay causes a capture failure.[69]
Challenges in ATPG for delay faults include handling multiple clock domains, where asynchronous interactions can invalidate timing assumptions, and fault grading, which relies on timing-accurate simulations using Standard Delay Format (SDF) files to back-annotate gate-level delays and assess test effectiveness.[65] Coverage metrics typically aim for over 90% transition fault coverage to ensure robust detection, with examples like gross delays on critical paths detected via a two-pattern test where sets the initial value and shifts to provoke the transition, failing capture if the delay exceeds the clock.[70] Brief reference to design-for-testability features, such as scan chains enabling launch-on-capture (LOC) or launch-on-shift (LOS) methods, supports these tests by facilitating vector application at speed.[68]
The evolution of delay fault modeling began in the 1990s with gate delay models emphasizing transition faults for initial at-speed coverage, progressing through the 2000s to path delay refinements for small defects, and into the 2020s with cell-internal delay faults that target intra-cell timing variations due to nanoscale process effects, enhancing defect detection in advanced nodes.[65][70]
Advanced Fault Models
Cell-aware fault models address intra-cell defects, such as resistive opens and shorts within transistors, by deriving defect-specific behaviors from layout-extracted simulations at the transistor level. These models enable ATPG to target internal cell structures directly, rather than relying solely on gate boundaries, improving detection of physical defects that traditional models overlook.[71] Introduced in the early 2010s for sub-45 nm technologies, cell-aware ATPG uses defect decision matrices (DDMs) generated via analog fault simulation to create patterns that propagate fault effects through cell internals. In practice, this approach has been applied to advanced nodes, including a 2023 study on diverse circuits in 3-nm CMOS libraries, where cell-aware patterns enhanced defect coverage by approximately 2.5% over standard stuck-at tests without substantially increasing pattern volume.[72][73] Soft defects, primarily single-event transients (SET) and single-event upsets (SEU) induced by radiation particles like cosmic rays or neutrons, manifest as temporary bit-flips or signal perturbations in sensitive nodes. These are modeled in ATPG as transient stuck-at faults or delay faults, often using SAT-based techniques to simulate bit-flips in lookup tables (LUTs) and constant values in interconnects, achieving combined coverages exceeding 99% in benchmark evaluations through exhaustive emulation.[74] Process variation faults encompass both systematic variations, such as lithography-induced distortions across the die, and random variations from doping or oxide thickness fluctuations, which alter timing and logic behavior. ATPG for these faults incorporates process corners like fast-fast (FF) for optimistic delays and slow-slow (SS) for pessimistic ones, enabling robust pattern generation that accounts for variability impacts on defect detectability.[75][76] Hybrid simulation models combine classical stuck-at faults with process variability effects to grade test patterns more realistically, capturing parametric shifts in delay and strength. Commercial tools like Synopsys TetraMAX support such hybrid evaluations by integrating variability-aware fault simulation with ATPG flows for comprehensive defect analysis.[77][78] Despite these advances, advanced fault models introduce limitations, including significantly higher pattern counts—often 10-20% more than stuck-at ATPG—which can extend test application time and increase costs, particularly in high-volume manufacturing for sub-45 nm designs. Optimizations, such as DDM manipulation, help reduce these overheads while preserving coverage gains.[10]Combinational ATPG
Classical Decision-Making Algorithms
The classical decision-making algorithms for automatic test pattern generation (ATPG) in combinational circuits primarily rely on path sensitization techniques, using decision trees and implication procedures to activate and propagate faults to observable outputs. These algorithms target stuck-at faults in gate-level circuit representations, employing a five-valued logic system (0, 1, X for unknown, D for discrepancy, and \bar{D} for its complement) to model fault effects. These methods are grounded in the core principle of detecting stuck-at faults by satisfying fault excitation—creating an error at the fault site—and propagation—ensuring the error reaches a primary output. Mathematically, for a stuck-at-1 fault on signal s, this requires assigning s=0 in the fault-free circuit (g(X)=0) and the Boolean derivative ∂f/∂s=1; for stuck-at-0, s=1 (g(X)=1) and ∂f/∂s=1. Equivalently, the input vector X satisfies f(X) ⊕ f'(X)=1, where f' is the faulty output.[79] The foundational approach involves generating input assignments that sensitize paths from the fault site to primary outputs while justifying signal values through forward and backward implications. The D-algorithm, introduced by Roth in 1966, was the first complete ATPG method suitable for computer implementation. It uses cube notation to represent signal states, where a D-cube captures the difference between fault-free and faulty circuit behaviors (e.g., D indicates the fault effect, \bar{D} its complement). The algorithm operates through a five-step process: (1) fault activation, modeling the primitive D-cube of failure (PDF) at the faulty gate; (2) propagation, selecting D-cubes to drive the fault effect from the D-frontier (set of gates with D or \bar{D} on inputs but unknown outputs) to a primary output; (3) line justification, using singular cover cubes to assign values to internal lines; (4) D-propagation, extending the fault effect along sensitized paths; and (5) consistency checking, resolving conflicts via backtracking if implications lead to incompatibilities (e.g., assigning both 0 and 1 to a line).[26] This structured procedure ensures completeness by exhaustively exploring implications but often requires significant backtracking for complex paths. Building on the D-algorithm, the PODEM (Path-Oriented Decision Making) algorithm, developed by Goel in 1981, improves efficiency by restricting decisions to primary inputs only, forming a backtrack tree where each node represents an input assignment. It uses forward implications to propagate values through the circuit and backward implications to justify objectives (required signal values) from outputs to inputs. The X-path method checks for sensitizable paths by verifying the existence of a D-frontier and ensuring non-controlling values (X or appropriate literals) on side inputs to avoid desensitization. PODEM reduces backtracks compared to the D-algorithm by limiting the search space and incorporating path constraints early, achieving faster test generation for circuits with reconvergent fanouts.[80] A simple implication procedure in PODEM can be outlined as follows, using a breadth-first traversal for forward propagation:function IMPLY(node, value):
if node is assigned and node.value != value:
return false // conflict
node.value = value
for successor in node's fanout:
compute successor.value based on gate function and inputs
if successor.value is determined:
if not IMPLY(successor, successor.value):
return false
return true
Boolean Satisfiability-Based Approaches
Boolean Satisfiability (SAT)-based approaches to automatic test pattern generation (ATPG) formulate the problem of detecting faults in combinational circuits as a satisfiability problem in propositional logic. The circuit under test is encoded as a set of Conjunctive Normal Form (CNF) clauses that represent the logical behavior of its gates and interconnections. To target a specific fault, such as a stuck-at fault, additional clauses are introduced to model the faulty behavior and ensure that the primary outputs differ between the fault-free and faulty circuits, capturing the Boolean difference. If the resulting CNF formula is satisfiable, the satisfying assignment provides a test pattern that detects the fault; unsatisfiability proves the fault is untestable.[84] The encoding process begins by representing each gate with implication clauses converted to CNF. For example, an AND gate with inputs and and output is encoded as the clauses , , and , ensuring if and only if both inputs are 1. For a stuck-at-0 fault on a node , a clause is added to force the faulty value; for stuck-at-1, is used. The faulty circuit is modeled by duplicating variables and connections up to the fault site, with output difference enforced via constraints at observable points, such as primary outputs. Modern implementations often hybridize this with structural simulation to propagate known values and reduce the CNF size before invoking the SAT solver, improving efficiency.[84][85] Prominent SAT solvers for ATPG include MiniSat, a lightweight, extensible solver that employs Conflict-Driven Clause Learning (CDCL) for efficient backtracking, and ABC, a logic synthesis framework that integrates SAT-based reasoning for verification and test tasks. In the CDCL process, the solver performs unit propagation and decision making; upon conflict, it analyzes the implication graph to learn new clauses that prune future search, enabling rapid resolution even for complex instances. For instance, consider an inverter with input and output stuck-at-1. The gate clauses for the fault-free inverter are and . For the faulty output stuck at 1, add clause . To ensure detection, force the fault-free output to differ by adding (since ); this propagates to via the gate clauses, yielding , , , where the output differs.[86][87] These approaches advanced significantly in the 2000s, surpassing classical structural methods by leveraging CDCL-based solvers to achieve 100% fault coverage on ISCAS-85 benchmarks and scale to industrial circuits with millions of gates, often in average polynomial time due to the empirical efficiency of modern SAT heuristics. Unlike heuristic approximations in classical ATPG, SAT provides exact solutions and naturally handles non-modeled faults by adjusting the CNF without structural assumptions. If the formula is UNSAT, it rigorously proves untestability, aiding fault grading. As of 2025, SAT-based ATPG remains integral for testing large combinational blocks in nanometer designs, with recent optimizations reducing solve times for multi-fault scenarios in complex SoCs.[84][88][89]Sequential ATPG
Scan Chain and Time-Frame Methods
Scan-based automatic test pattern generation (ATPG) for sequential circuits relies on design-for-testability (DFT) structures, particularly scan chains, to manage state dependencies and facilitate test application. In shift-DR (design register) mode, test patterns are loaded into scan chains by shifting data bit-by-bit through flip-flops configured as a linear chain, allowing control over internal states as if they were primary inputs.[22] During the capture phase, the scan enable signal is deactivated, enabling the circuit to operate normally for one or more clock cycles to capture fault effects at flip-flop outputs, which are then shifted out for observation.[22] Full scan architectures incorporate all flip-flops into scan chains, transforming the sequential circuit into an equivalent combinational one for ATPG, while partial scan designs include only a subset of flip-flops to reduce area overhead (typically 5-10%) and wiring complexity, though they retain some sequential challenges.[22][90] Time-frame expansion is a core technique in scan-based sequential ATPG that unrolls the circuit across multiple clock cycles, modeling it as a large combinational circuit to apply standard combinational ATPG algorithms.[22] For instance, expanding over 2-5 time frames accommodates delay faults by capturing transitions across cycles, where flip-flop outputs from one frame become inputs to the next, and primary inputs/outputs are extended accordingly.[22] This approach adapts combinational methods like PODEM to the temporal domain, with flip-flops represented as wires or pseudo-inputs in the expanded array.[22] State justification in sequential ATPG involves finding an input sequence that drives the circuit to a specific state required for fault excitation or propagation, often using guided simulation from a combinational solver.[22] Starting from the target state in the final time frame, the process backtracks through prior frames, employing heuristics to resolve conflicts and generate the justifying sequence, which is then prepended to the test pattern.[22] The HITEC algorithm, introduced in 1991, exemplifies an early influential sequential ATPG tool that integrates the PODEM decision-making framework with temporal implications to handle state transitions across time frames. It propagates implications forward and backward in time while accounting for sequential elements, using a nine-valued logic system to model uncertainties, and employs iterative time-frame expansion to manage cycles by gradually increasing the number of time frames until a test is found or the fault is deemed untestable. HITEC does not require scan but benefits from partial scan to reduce the search space. A representative example of time-frame expansion is detecting a transition fault on a flip-flop output using a 2-frame model: the first frame initializes the flip-flop to the opposite value of the expected transition (e.g., 0 for a slow-to-rise fault), and the second frame applies the activating vector to propagate the faulty transition to an observable point, treating the expanded structure as combinational for ATPG.[22] Despite these advances, scan-based ATPG faces challenges such as state explosion, where the computational complexity grows exponentially with the number of time frames due to the increasing size of the search space (with circuit model size linear in T), limiting scalability for large circuits.[22] Typical stuck-at fault coverage with full scan achieves over 95%, often 98-99% or higher, in industrial benchmarks, though sequential elements may leave some faults untestable without additional DFT.[91]Optimization Techniques for Sequential Circuits
Optimization techniques for sequential circuits aim to enhance the efficiency and fault coverage of automatic test pattern generation (ATPG) by addressing the challenges of state-dependent behavior and large search spaces in time-frame unrolling methods. These approaches build upon basic sequential ATPG frameworks, such as time-frame expansion, by incorporating advanced search strategies, state space reduction, and simulation accelerations to generate compact test sequences that detect stuck-at faults and other defects with minimal computational overhead. Key methods include evolutionary algorithms, structural modeling, hybrid solvers, and simulation optimizations, which collectively reduce backtracking and improve scalability for circuits with hundreds of flip-flops.[22] Genetic algorithms represent a simulation-based optimization technique for evolving test sequences in sequential ATPG. These algorithms maintain a population of candidate test vectors or sequences, evaluating their fitness based on metrics such as fault coverage achieved through fault simulation. High-fitness individuals are selected, and new sequences are generated via crossover (combining parts of parent sequences) and mutation (randomly altering bits) to explore the input space efficiently. For instance, Prinetto et al. introduced a GA-based ATPG that uses deductive-parallel fault simulation to compute fitness, enabling the evolution of sequences that propagate faults through sequential elements without exhaustive enumeration. Advanced variants, such as those proposed by Corno et al., incorporate logic simulation feedback to guide the evolutionary process, improving convergence by biasing mutations toward undetected faults and achieving up to 95% fault coverage on ISCAS-89 benchmarks with 20-30% fewer patterns than random simulation. In a representative application to a finite state machine (FSM) with approximately 100 states, genetic ATPG generated test sequences attaining 98% stuck-at fault coverage using only 15 patterns, compared to over 50 required by unoptimized methods.[92][93][94] The iterative logic array (ILA) model offers a structural optimization by representing the sequential circuit as an array of repeated combinational time frames, allowing precomputation of reachable states to prune the search space during ATPG. In this approach, the state transition graph is analyzed iteratively to identify valid state sequences, reducing the need for full backtracking in fault activation and propagation. Agrawal and Cheng's foundational work on ILA-based ATPG precomputes initialization sequences and reachable states using breadth-first search on the unfolded array, limiting time-frame depth to the circuit's sequential depth and improving average-case performance by 40% on benchmarks like the ITC-99 suite. This technique is particularly effective for non-scan sequential circuits, where it minimizes redundant state justifications by focusing on fault-specific paths within the precomputed state set.[95] Hybrid approaches combine Boolean satisfiability (SAT) solvers with simulation to balance exactness and speed in sequential ATPG, often employing multi-valued logics to handle unknown states. For example, SAT-based methods encode time-unrolled circuits into CNF formulas, while simulation prunes inconsistent partial assignments; a common extension uses four-valued logic—0 (false), 1 (true), X (unknown), and S (symbolic for fault effects)—to model state uncertainties and fault propagation across cycles accurately. Erb et al. demonstrated that this hybrid SAT-simulation framework, using three-valued encoding for X-dependent signals, reduces clause count by 60% and runtime by 20% compared to pure two-valued SAT, enabling multi-cycle ATPG for circuits with reconvergent fanout. Such methods enhance coverage for delay faults in sequential contexts by ensuring precise fault effect observation over multiple time frames.[96] Fault dropping and parallel fault simulation further optimize the evaluation phase of sequential ATPG by accelerating coverage computation. Fault dropping removes detected faults from the simulation list immediately after detection, avoiding redundant evaluations in subsequent patterns and reducing overall simulation time by up to 50% in large fault sets. Parallel fault simulation exploits bit-parallelism in hardware, simulating multiple faults (up to word length, e.g., 64) concurrently per time frame, which is crucial for validating evolved or SAT-generated sequences in genetic and hybrid methods. Waicukauski et al. integrated parallel simulation with fault dropping in their PROOFS tool, achieving 10-20x speedup for sequential benchmarks while maintaining accurate coverage reporting. These techniques are essential for iterative ATPG processes, where frequent simulations guide search refinement.[97] In the 2020s, weighted random pattern testing has emerged as an update to these optimizations, introducing biases toward hard-to-detect faults in sequential circuits to boost coverage with pseudo-random sequences. This method assigns non-uniform probabilities to input bits based on fault simulation feedback, prioritizing vectors that target random-pattern-resistant faults like those in dense state machines. Recent proposals incorporate weight-aware techniques for BIST-integrated ATPG, where biased patterns improve fault coverage for hard faults in automotive ICs using fewer patterns than uniform random testing while integrating with genetic initialization.[98]Modern Challenges
ATPG in Nanometer Technologies
As semiconductor processes scale to sub-10nm nodes, automatic test pattern generation (ATPG) faces significant challenges from increased interconnect resistance, higher defect densities, and pronounced process-voltage-temperature (PVT) variations, which can invalidate test patterns by altering timing and logic behavior. IR-drop effects, exacerbated by denser power grids and higher current densities, lead to voltage fluctuations that mask faults or cause false positives during testing, while crosstalk noise between closely packed wires introduces additional delay uncertainties. These scaling issues demand ATPG adaptations, such as pre-silicon simulations incorporating PVT corners to validate pattern robustness, ensuring that generated tests remain effective despite significant intra-die variations in threshold voltage at 7nm and below.[62][99] For at-speed testing of delay faults in nanometer circuits, ATPG employs two primary launch strategies: launch-on-capture (LOC), which uses functional clock cycles for transition launch and offers simpler scan chain control with lower pattern overhead, and launch-on-shift (LOS), which leverages shift operations for launch to achieve higher fault coverage but requires more complex timing control to avoid overtesting. In sub-10nm processes, LOC is often preferred for its robustness against PVT-induced timing skews, as LOS can amplify crosstalk and IR-drop impacts in high-speed paths; however, hybrid approaches combining both are used to balance coverage and escapism in designs like 5nm FinFET-based SoCs.[100][75] Cell-aware ATPG addresses defect-specific issues in nanometer libraries by extracting transistor-level fault models from cell layouts, targeting opens and bridges in FinFET structures that traditional stuck-at models miss, such as via opens in multi-fin transistors. In advanced 3-nm technologies, studies demonstrate that cell-aware patterns improve defect coverage by up to 5-10% over gate-exhaustive methods, with one 2024 analysis on industrial circuits reporting a 7% gain in undetected cell-internal defects through targeted analog simulations and ATPG integration. This approach enhances diagnostic resolution for yield improvement in high-density nodes.[101][102] Variability modeling in ATPG for nanometer technologies relies on corner-based analysis to simulate worst-case PVT conditions, ensuring test patterns detect faults under extreme variations like slow-fast process corners or high-temperature drops. Integration with statistical timing analysis (STA) allows probabilistic fault grading, where Monte Carlo simulations quantify variation impacts, reducing overtesting compared to deterministic methods in 7nm designs. This hybrid modeling is essential for maintaining pattern validity amid random dopant fluctuations and line-edge roughness dominant at scales below 5nm.[103] In 5-nm system-on-chips (SoCs) exceeding 10^9 gates, ATPG runtime can double due to exploding design complexity and fault simulation overhead, often requiring days for full coverage on multi-core systems; solutions like multi-patterning in test generation—dividing patterns into parallel subsets for distributed processing—mitigate this by achieving 30-50% runtime reductions without coverage loss. Tool advancements, such as Synopsys TestMAX ATPG, incorporate nanometer-specific diagnostics for IR-drop aware pattern validation and cell-aware fault extraction, enabling faster convergence to 99%+ coverage in billion-gate designs.[104][1]Test Compression and Power-Aware Testing
Test compression techniques in automatic test pattern generation (ATPG) address the escalating test data volume associated with large-scale integrated circuits by embedding decompression and compaction hardware to minimize the bits transferred from automatic test equipment (ATE) to the device under test. Linear feedback shift registers (LFSRs) serve as a foundational method for on-chip decompression, where seeds are stored externally and expanded into full scan patterns via LFSR reseeding, enabling efficient encoding of sparse test cubes with low hardware overhead. XOR networks complement this by compacting scan chain responses into signatures, reducing output data volume through multiple-input signature registers (MISRs) that detect faults without full response capture. These approaches exploit the don't-care bits (X-bits) in ATPG-generated patterns, which often constitute over 90% of the data, to achieve significant reductions in test application time and storage requirements. A prominent implementation is embedded deterministic test (EDT), which integrates a continuous-flow decompressor using a ring generator and phase shifters to solve linear equations for pattern expansion, combined with deterministic ATPG to target faults precisely. EDT achieves compression ratios ranging from 30:1 to 500:1 in industrial designs, with examples demonstrating over 100x reduction in both test data volume and application time compared to conventional scan testing, while maintaining high fault coverage. The compression ratio is formally defined as:
where uncompressed volume is typically measured in patterns per pin, reflecting the total bits needed for full scan loading without optimization—for instance, millions of patterns for million-gate designs. Test data volume scales with circuit size, often reaching billions of bits uncompressed in modern systems-on-chip (SoCs), necessitating such techniques to fit within ATE memory limits of 100-500 Mb.[105][106]
Power-aware testing integrates with compression to mitigate excessive switching activity during scan shift and capture cycles, which can exceed functional mode power by 2-5x and cause supply voltage droop or thermal issues. X-filling methods assign logic values (0 or 1) to unspecified X-bits in test cubes to minimize transitions, particularly during capture for at-speed testing, using heuristics like preferred fill to balance power reduction with fault coverage. Average power models, based on signal probability and toggle rates, guide ATPG to constrain peak power below 80-90% of functional limits, preventing over-testing where excessive power induces false failures or masks real defects due to voltage droop. In nanometer technologies, power variations amplify these risks, but brief adaptations in sequential scan chains help maintain timing margins. Challenges include managing over-testing from power-induced droop in large SoCs, where uncompressed test sets can approach 10^{10} bits, leading to impractical application times without compression.[107][108]
The Illinois scan architecture exemplifies hybrid compression, connecting multiple internal scan chains to a reduced set of external pins via LFSRs and XOR trees, achieving up to 50x volume reduction by overlapping seeds across patterns and supporting incremental ATPG for fault targeting. Hybrid built-in self-test (BIST) and ATPG approaches further enhance low-power testing by combining pseudorandom patterns from on-chip LFSRs with deterministic ATPG fills, reducing external data needs while controlling shift power through segmented chains. Commercial tools like Siemens Tessent (formerly Mentor Graphics) implement these in EDT frameworks, yielding test times under 1 second per die for billion-gate SoCs and pattern counts reduced by 100x or more, ensuring scalable manufacturing test for high-volume production.[109][110][111]