TrekSoC-Si automatically generates self-verifying C test cases to run on the embedded processors in SoCs in in-circuit emulation (ICE), FPGA prototyping, and production silicon. This verifies your chips more quickly and more thoroughly than hand-written diagnostics or running only production code on the processors. TrekSoC-Si’s generated test cases target all aspects of full-SoC verification and work in a variety of different environments. TrekSoC-Si is a companion to TrekSoC, which generates test cases for simulation and acceleration. TrekSoC-Si extends the benefits of TrekSoC into hardware platforms.
- TrekSoC-Si Flow
- TrekSoC-Si Scenario Models
- TrekSoC-Si Services
- TrekSoC-Si Incremental Deployment
- TrekSoC-Si Visual Coverage
- TrekSoC-Si Test Case Visualization
TrekSoC-Si supports a natural thought process about SoC verification, helping you “mind map” how the SoC should work and what the verification flow should be. It helps you create scenario models that define your verification space in a textual or an intuitive graphical form, allowing you to deliver a modular, extensible and scalable solution for the functional verification of SoCs.
From your scenario models, TrekSoC-Si generates the embedded C test cases and connects to the input and outputs of your SoC without requiring a testbench. This provides completely automated controllability and monitoring of your SoC. The TrekSoC-Si flow for hardware platforms is similar to the TrekSoC flow for simulation and acceleration.
The benefits of TrekSoC-Si include:
- Modular, extensible and scalable solution for SoC verification
- Flexible, incremental deployment with high return on investment (ROI)
- Visualization and coverage analysis of verification scenarios
- Reusable verification modules
TrekSoC-Si Scenario Models
TrekSoC-Si takes as input a hierarchy of scenario models. Lower-level models provide randomized services to higher-level models, and higher-level models may apply constraints on lower-level models to control randomization of the provided services. TrekSoC-Si provides a number of generic system services. These services are extensible to use SoC specific information about memory maps, bus functional models (BFMs) and system management operations.
These system services are used by driver scenario models that focus on individual IP-level operations. Application scenario models constrain and combine driver scenarios to define use cases. Performance scenario models constrain and combine application scenarios to define performance benchmarks.
This hierarchy of scenario models is used for generation of SoC tests. Each test, written out as C code for each of the processors within the SoC, takes the form of a constrained-random micro-kernel running constrained-randomized applications. Applications call randomized drivers for each IP component to test possible system interactions. Applications and drivers can request randomized services that are provided by the micro-kernel.
Scenario models are developed in C using a simple paradigm of graphs and graph constraints. There are only a small number of constructs to learn. The TrekSoC-Si hierarchy of scenario models has been designed to mimic the hierarchy of services provided by a Linux kernel. This allows for a simple software metaphor that unifies all scenario models.
At test generation time, as opposed to test run time, TrekSoC-Si makes constrained-random decisions about services in order to stress system interactions. This strategy yields individual test cases that are efficient, repeatable and simple to debug while allowing sophisticated decisions to be made for each of the services.
TrekSoC-Si Incremental Deployment
The modular and extensible nature of scenario models allows verification components to be incrementally constructed and enhanced as project priorities dictate. As verification modules are added or enhanced, the verification search space grows, allowing the generation of additional constrained-random tests. This makes it attractive to start with a limited deployment of TrekSoC-Si and incrementally expand the verification scope and coverage as resource and project priorities allow.
TrekSoC-Si provides a framework of scenario models that are used to generate C test cases. Each test case takes the form of a randomized micro-kernel running applications that drive individual hardware devices to verify possible system interactions. TrekSoC provides the same set of services, so the following applies to both products.
Scenario models may request system services that are provided by TrekSoC-Si. The key services available to scenario models include:
|Memory Management||Allocates/frees memory buffers on demand
|Register Access||Allows scenario models to request randomization, writing and checking of register value
|Scheduler||Enables tasks to be flexibly scheduled sequentially
|Interrupts and Polls||Automatically generates interrupt handlers and non-blocking poll loops|
|System Management||Randomly switches clocking and power modes (scenario models may ask for a specific device to be powered up for the duration of an operation, possibly allowing for intermittent power downs during the operation to test state retention)|
|Testbench Actions||Allows scenario models to request arbitrary testbench activity to drive and check I/O interfaces or other testbench events|
|GPIO||Allows scenario models to request specific system GPIO routings|
|Debug Facilities||Allows scenario models to log various levels of diagnostic messages through automatic generation of diagnostics on thread progress and memory state|
|Data Checking||Allows scenario models to request checking of memory data buffers against an array of expected data|
|Timing Checks||Allows scenario models to request checking that the elapsed time between two events falls within a specified range; timing checks may be implemented using either elapsed simulation time or, if available, an onboard timer|
TrekSoC-Si Visual Coverage
The modular graph-based structure of scenario models makes it possible to visualize the possible paths and the constraints applied to those paths. TrekSoC-Si provides reachability analysis on the scenario model that highlights unreachable test cases. These visualization capabilities make it convenient to review the SoC verification model for completeness.
TrekSoC- tracks the paths through the model that have been exercised. The achieved coverage can be visualized as a hot-spot graph and analyzed to ensure that cross-coverage cases of interest have been exercised. This scenario-level coverage is complementary to traditional coverage metrics.
The modular organization of scenario models enables reuse from the IP component to the SoC level and across projects, derivatives and new SoC platforms. For example, an IP driver scenario model contains no system-specific information and can be used with any SoC that incorporates the IP component.
TrekSoC-Si Test Case Visualization
TrekSoC-Si provides industry-leading visualization of the multi-threaded, multi-processor C test cases that it generates. These test cases are far more complex than could be written manually, so this visualization is essential for debug when a test case uncovers an error in the SoC design.
As an example, the scenario model for a digital camera may includes multiple, parallel data paths. TrekSoC-Si will analyze this scenario model and generate a test case that stress-tests the design by running multiple streams of multiple user scenarios in parallel, with the streams crossing back and forth between multiple threads on multiple processors.
The complex test case generated for the digital camera design by TrekSoC-Si can be visualized in a display that shows all threads across all processors and how the streams of user scenarios are scheduled across these threads. The red arrows follow a typical real-world user scenario built from three driver scenarios: reading a JPEG-encoded image on a USB port, decoding it using the still image processor, and displaying it on one of the camera’s screens.
This unique visualization display is generated by TrekBox, the module of TrekSoC-Si that runs in the same host system used to download code to the hardware platform. TrekBox updates this display in real time as the run progresses, coloring driver scenarios green as they are completed. In this example, the test case has hit a user-defined breakpoint in the code for the driver scenario colored white.