A scalable software-based self-test methodology for programmable processors

Li Chen, Srivaths Ravi, Anand Raghunathan, Sujit DeyProceedings of the 40th Conference on Design Automation - DAC '03 2003 · DOI

TL;DR

This paper introduces a novel, automated methodology for creating software-based self-test (SBST) programs for complex programmable processors. By systematically identifying suitable instruction sequences, extracting hardware constraints, and synthesizing test programs, they achieve high fault coverage with significantly reduced test lengths compared to traditional functional testing.

What Problem Does This Paper Address?

Testing modern, complex programmable processors and System-on-Chips (SoCs) is a major challenge. Traditional methods like scan testing and Built-In Self-Test (BIST) have limitations. Scan testing can degrade performance, while BIST often incurs significant hardware overhead. Functional testing, while good for catching speed-related defects, is notoriously difficult to scale and automate for high-coverage tests, requiring immense manual effort. This leads to long development times and high non-recurring engineering (NRE) costs. Software-Based Self-Test (SBST) offers a promising alternative by using the processor's own instructions to deliver tests, but previous approaches lacked scalability and automation for complex designs.

Methods

The paper proposes a four-step systematic and scalable methodology for SBST:

  1. Test Program Template Identification: They automatically identify "templates" – sequences of processor instructions that can be used to deliver test patterns to specific modules (sub-circuits) within the processor. They classify these into single-instruction and multi-instruction templates.
  2. Constraint Extraction (Input/Output Mapping Functions): This is a core innovation. Instead of relying on complex structural analysis, they use functional simulation and statistical regression to derive "mapping functions." These functions abstract the processor's behavior, capturing how settable fields in a test template influence the module-under-test's inputs and how the module's outputs are observable. This approach is "black-box" and agnostic to the specific HDL coding style.
  3. Module-Level Test Generation: They introduce "Virtual Constraint Circuits" (VCCs) to represent the extracted mapping functions. These VCCs are combined with the module-under-test (MUT) to create a composite circuit. A commercial Automatic Test Pattern Generation (ATPG) tool then generates test patterns for the MUT, respecting the instruction-imposed constraints.
  4. Software Self-Test Program Synthesis: The module-level test patterns (which specify values for settable fields in the template) are used to synthesize the final SBST program by filling these values into the chosen test program template. This process is automated and cross-compiled into a memory image.

The methodology also includes a novel template ranking mechanism using X-based simulation to evaluate controllability and observability metrics, and a dynamic update policy that refines template selection based on fault simulation feedback.

Datasets

The primary "dataset" used is the Tensilica Xtensa™ processor. The authors applied their methodology to a specific large logic module within this processor, referred to as EX1. This module was extracted from the processor's execution stage (EX) by tracing logic cones. EX1 has 335 input bits and 1 output port, and contains 24,962 stuck-at faults. The paper does not introduce new benchmark circuits but rather applies its methodology to a real-world commercial processor.

Key Insights and Ideas

  • Scalability through Abstraction: The key to handling complex processors is abstracting away the surrounding logic. The use of statistical regression to derive input/output mapping functions provides a scalable, "black-box" approach that avoids the complexity of structural analysis.
  • Bridging Functional and Structural Testing: SBST effectively bridges the gap between functional testing (at-speed delivery) and structural testing (fault-driven pattern generation). By generating module-level tests under instruction constraints, they achieve targeted fault detection.
  • Automated Test Program Synthesis: The VCC concept, adapted for instruction constraints, significantly simplifies the translation of module-level test patterns into executable software test programs.
  • Dynamic Template Selection: The iterative process of template ranking, test generation, and fault simulation allows the methodology to dynamically adapt and focus on the most effective templates for detecting remaining faults.

Key Results

  • High Fault Coverage: The synthesized SBST programs achieved 95.2% fault coverage on functionally testable faults for the EX1 module, significantly higher than the 85.3% achieved by a manually generated random functional test program.
  • Reduced Test Length: The SBST program had a size of 7602 instructions and 20373 bytes, compared to 9169 instructions and 25066 bytes for the functional test. The execution time was also reduced from 41844 cycles to 27248 cycles.
  • Efficient Constraint Extraction: The mapping functions derived were categorized as: Constant (48.9%), One-to-one (31.0%), and General (20.1%), indicating that a significant portion of the mapping could be captured efficiently.
  • Practical Demonstration: This work represents the first practical demonstration of SBST on a commercial processor of such complexity (Tensilica Xtensa™).

Limitations and Future Work

  • Functionally Untestable Faults: The paper acknowledges that some remaining faults are functionally untestable. While they provide an estimate of coverage for functionally testable faults, achieving 100% coverage for all faults might be impossible.
  • Template Space Exploration: While the methodology is scalable, the initial generation and ranking of templates still involve simulation. Further optimization in template selection could be explored.
  • Future Work: The authors suggest extending the methodology to other fault models (bridging, transistor-level) and to performance-related faults (e.g., path delay faults) by extending constraint extraction to multi-timeframe constraints. They also note that SBST can be used to guide the generation of pseudorandom tests and to "top-off" scan tests with deterministic patterns.

Summary updated

BibTeX
@inproceedings{chen2003scalable,
  author = {Li Chen and Srivaths Ravi and Anand Raghunathan and Sujit Dey},
  title = {{A scalable software-based self-test methodology for programmable processors}},
  booktitle = {Proceedings of the 40th Conference on Design Automation - DAC '03},
  year = {2003},
  doi = {10.1145/775972.775973},
}

Loading related content...

Figure