
Accellera’s approval of the Portable Test and Stimulus Standard (PSS) 3.1 marks an encouraging step toward a more connected, reusable approach to verification. Announced on November 11, the release is the first update since PSS 3.0 in August 2024 and addresses a challenge familiar to engineering teams: how to carry valuable verification intent across increasingly complex hardware and software systems without repeatedly rebuilding the same work.
The promise is straightforward. Engineers describe what they want to verify in a high-level, implementation-independent model, then realize those scenarios across different platforms. From simulation and emulation to FPGA prototyping and post-silicon validation, that approach can help teams preserve knowledge, improve consistency, and make better use of their verification investment.
PSS 3.1 strengthens that foundation with improvements spanning constraint modeling, model customization, software integration, heterogeneous execution, portable debug logging, and address and register abstraction. Together, these additions point toward a practical opportunity: verification content that can grow alongside a design rather than become tied to one project stage or execution environment.
One of the release’s most promising advances is more expressive constraint modeling. Generic constraints, soft constraints, and enhanced array-slice operations give engineers additional ways to express scenarios while keeping models reusable and maintainable. Generic constraints can be parameterized and reused across a model, and they replace the now-deprecated dynamic constraints. Soft constraints set defaults that more specific conditions can override at solve time. Action attributes that are not randomized can now be initialized inline when an action is traversed, which makes it simpler to pass data from an activity to its sub-actions. Greater flexibility can reduce duplication and make it easier to adapt verification intent as requirements evolve. For teams managing large scenario libraries, these capabilities offer a stronger basis for building content that remains useful over time.
Reuse also benefits from new customization mechanisms. Action overriding in component subtypes, mutable component attributes, and instance-qualified component references make verification models easier to adapt across projects and product families. With action overriding, an activity can be written against a base action, much like an interface. The component context then decides which implementation actually runs. Multi-dimensional arrays of component instances, action and monitor handles, flow objects, and resources make it easier to model regular structures such as CPU clusters or multi-channel DMA engines. That matters because reuse rarely means applying a model unchanged. It often means retaining proven intent while adjusting behavior to reflect a new architecture, configuration, or implementation. PSS 3.1 gives engineers more tools to make those adjustments systematically.
The release also recognizes software’s expanding role in system verification. Exported functions let the target environment call back into the PSS model. Exec block tags eliminate duplicate generated code. A general annotation mechanism attaches metadata to model elements, and its standard annotations can carry documentation through into generated code. String templates, written with mustache-style `{{expression}}` notation, can now be used in ordinary string expressions as well as target code. A standard `message()` function with verbosity levels now logs output the same way while the tool solves a scenario and while the generated test runs on the target, so teams no longer need a tool-specific print mechanism for each target. Together, these features improve the connection between portable models and their target implementations, provide greater control over realization, and can help teams integrate PSS content more effectively into software-driven environments.
Support for heterogeneous execution is another welcome development. Modern systems increasingly distribute work across processors and execution contexts, creating coordination challenges that extend beyond individual components. PSS 3.1 addresses this at two levels. At runtime, new synchronization and communication constructs, including typed FIFO channels, let test code running concurrently on different executors coordinate and exchange data. At build time, target execution units define how the code generated for each executor is organized. Each unit names an output file and a target language (C, C++, or SystemVerilog), and each executor is assigned to a unit. In an SoC that pairs a RISC-V core with a DSP, for example, the two cores need separate images built with different compilers. The test code for each core goes into its own source file, while actions driving SystemVerilog transactors are placed together in testbench code. Because this setup is now defined by the standard rather than by each vendor, the same target environment can be reused across tools. By addressing that complexity within the standard, PSS 3.1 broadens the scope of behavior teams can represent through portable intent.
Expanded address and register modeling brings similarly practical benefits. Shared address claims, negative address offsets, extensible memory-access controls, register collections, and symbolic register representation strengthen support for sophisticated memory and register architectures. For example, negative offsets help map one physical address space to different virtual addresses on different CPUs. Symbolic register names let generated code refer to the register definitions already in a project’s software stack, instead of hard-coded numeric addresses. These additions can help engineers describe the structures found in complex SoCs and embedded systems with greater flexibility.
Beyond individual features, the release demonstrates the value of sustained industry collaboration. Accellera’s working group has combined language enhancements with clarifications, semantic refinements, and corrections intended to support more consistent implementations and interoperability. That combination gives teams a clearer foundation for adoption while supporting continued evolution across tools and methodologies. Teams upgrading existing models should note a few compatibility points. The access functions now take an extra memory-access descriptor argument, so code that overrides functions such as `write32` in an executor needs a new signature. `annotation`, `overlap`, `mutable`, and `soft` are now reserved keywords. Dynamic constraints are deprecated.
The potential payoff extends beyond individual engineers. When teams share a common description of verification intent, they gain a stronger starting point for collaboration across disciplines. That shared foundation can support clearer handoffs and help preserve expertise as systems and organizations evolve.
Engineers also have resources to help translate the standard into practice. Accellera’s 16-part “Learning PSS” video series covers fundamentals through reusable model development and target realization. Tutorials, workshops, examples, and the Portable Stimulus Community Forum offer additional routes for learning and feedback.
PSS 3.1 does not remove the complexity of modern verification, but it offers a constructive way to manage it: capture intent clearly, adapt it thoughtfully, and carry it further. For organizations seeking greater continuity between hardware verification and software-driven validation, the release provides fresh reasons for optimism and a practical foundation for building more reusable verification workflows.
Also Read:
Accellera’s FSL 1.0 Gives Functional Safety Data a Common Language
Accellera Updates at DVCon 2026
Accellera Strengthens Industry Collaboration and Standards Leadership at DVCon U.S. 2026
Share this post via:

Comments
There are no comments yet.
You must register or log in to view/post comments.