Learning PSS - Accellera Tutorial Series

Portable StimulusReleased in 2026

Accellera's “Learning PSS” video series is a 16-part educational course designed to help engineers understand and apply the Portable Stimulus Standard (PSS). Presented by Tom Fitzpatrick, a PSS expert and charter member of the Accellera PSS Working Group, the series builds from core concepts to practical applications.

Supplemental materials

Session 1: Why PSS

In this first video of Accellera’s “Learning PSS” video series, Tom Fitzpatrick introduces you to the Portable Stimulus Standard from Accellera. It gives a high-level overview of the reuse and portability issues in verification and shows how PSS is positioned to address the difficulties engineers face today in trying to apply UVM and C throughout the verification flow.

(7:03)

Session 2: Hello World

In Session 2 of Accellera’s “Learning PSS” video series, Tom Fitzpatrick builds on the classic C “Hello World” example to introduce the fundamentals of the Portable Stimulus Standard (PSS). Using a simple multilingual scenario, he demonstrates how PSS models behaviors, constraints, actions, and activity flows to generate multiple valid verification scenarios from a single model, highlighting the power of reusable, intent-driven verification. Watch the video to see how PSS enables smarter scenario creation and sets the stage for broader reuse across the verification flow.

(4:33)

Session 3: Reuse

In Session 3 of Accellera's “Learning PSS” video series, Tom Fitzpatrick explains how the Portable Stimulus Standard enables both vertical reuse, by composing system-level models from block-level models, and horizontal reuse by applying the same abstract modeling blocks from project to project. You'll also see how, by targeting the implementation of the model to SystemVerilog, C, or other target environments, PSS lets you reuse models throughout your verification flow. Watch now and discover how PSS helps teams improve portability, scalability, and reuse throughout the verification flow.

(6:09)

Session 4: Data Types

In Session 4 of Accellera's "Learning PSS" video series, Tom Fitzpatrick introduces Data Types such as Scalar, Compound, Collection, User-defined, and Template types. 

(7:25)

Session 5: Actions & Activities

In Session 5 of Accellera’s “Learning PSS” video series, Tom Fitzpatrick focuses on actions and activities. He demonstrates how to encapsulate behaviors in PSS using actions, how to schedule the behaviors using an activity, and how to define the control flow within an activity.

(7:48)

Session 6: PSS Communication

In Session 6 of Accellera’s “Learning PSS” video series, Tom Fitzpatrick focuses on PSS Communication. He describes how to model data communication between PSS actions, model state and state machines, manage communication protocols, and manage system resources.

(5:41)

Session 7: Components & Pools

In Session 7 of Accellera's "Learning PSS" video series, Tom Fitzpatrick demonstrates how PSS components organize actions into reusable, hierarchical structures that mirror the real system architecture. He also explains how to manage data flow between actions using pools. Watch now to learn how these concepts help create scalable and maintainable PSS models.

(6:56)

Session 8: Organizing PSS Code

In Session 8 of Accellera’s “Learning PSS” video series, Tom Fitzpatrick focuses on organizing PSS code for greater reuse. He explores how PSS supports object-oriented inheritance and type extensions, and shows how packages can help organize code and maximize reuse across PSS models.

(6:26)

Session 9: Constraints

In Session 9 of Accellera’s “Learning PSS” video series, Tom Fitzpatrick explores PSS constraints and the important role they play in verification modeling. Tom explains the two main types of constraints in PSS: algebraic constraints, which relate values in random fields of actions, structs, data flow objects, and resource objects; and scheduling constraints, which control how actions are ordered based on data flow semantics or explicit scheduling directives within an activity. Watch Session 9 to learn how PSS constraints give you greater control over the scenarios generated from your models.

(6:29)

Session 10: Randomization & Inferencing

In Session 10 of Accellera’s “Learning PSS” video series, Tom Fitzpatrick explores PSS randomization and inferencing and how they work together to generate valid verification scenarios. Learn how the PSS solver uses constraints and data flow requirements to randomize model elements, infer additional actions when needed, and generate multiple legal scenarios from a single PSS model. In this session, you’ll learn:

  • How randomization enables PSS models to generate multiple verification scenarios
  • How the PSS solver infers actions to satisfy constraints and data flow requirements
  • How constraints influence random values and inferred actions
  • How the solver looks ahead across actions to ensure constraints are satisfied
  • How pre-solve and post-solve exec blocks provide additional control over the solving process
  • How post-solve processing can be used to generate and propagate data through a scenario

Watch Session 10 to learn how randomization, constraints, inferencing, and data flow work together to turn PSS verification intent into executable scenarios.

(6:17)

Session 11: Memory Allocation

In Session 11 of Accellera’s “Learning PSS” video series, Tom Fitzpatrick explores PSS memory allocation and how memory planning at solve time helps create valid verification scenarios. Learn how PSS models different types of storage using address spaces and address regions, specifies allocation requirements using address claims, and enables the solver to allocate memory based on action, data flow, and capacity requirements—before simulation begins. In this session, you’ll learn:

  • Why memory allocation is performed at solve time in PSS
  • How PSS models memory and other storage elements using address spaces
  • How address traits and regions represent different types of storage
  • How address claims define memory allocation, alignment, compatibility, and lifetime requirements
  • How the solver prevents overlapping memory allocations
  • How solve-time memory planning helps avoid runtime memory conflicts

Watch Session 11 to learn how PSS memory allocation, address spaces, address regions, and address claims work together to create verification scenarios that meet your system’s storage requirements.

(6:43)

Session 12: PSS Realization

In Session 12 of Accellera’s “Learning PSS” video series, Tom Fitzpatrick explores PSS realization and how portable verification intent is transformed into executable code for specific target platforms. Learn how the PSS realization layer separates reusable, abstract scenario intent from target-specific implementation details, enabling the same PSS model to support different platforms and languages while minimizing duplicated code. In this session, you’ll learn:

  • How exec body blocks define target-specific implementations for PSS actions
  • How target templates map PSS model values directly into target-language code
  • How procedural interfaces and constructs improve reuse and reduce duplicated implementation code
  • How PSS can support different target languages, including C and SystemVerilog
  • How exec blocks work together to provide setup, declarations, scheduled behavior, and cleanup
  • How separating the abstract model and realization layer enables one portable scenario model to drive multiple platform-specific implementations

Watch Session 12 to learn how PSS realization, exec blocks, target templates, and procedural interfaces help turn portable verification intent into target-specific executable tests while preserving model reuse across platforms. 

(6:42)

Session 13: Memory Accesses & Executors

How Do the PSS Memory Access API and Executors Enable Portable Execution?

In Session 13 of Accellera’s “Learning PSS” video series, Tom Fitzpatrick, PSS expert and charter member of Accellera’s Portable Stimulus Working Group, explores the PSS Memory Access API and executors and how they help bridge the abstract PSS model with target-specific implementations. Learn how PSS uses address handles to keep memory operations independent of final numeric addresses, and how executors allow elements of a portable model to run on specific agents in the target environment. In this session, you’ll learn:

  • How address handles separate abstract memory allocation from concrete target addresses
  • How the Memory Access API provides portable read and write operations
  • How executors represent runtime agents such as processors, BFMs, and transactors
  • How executor claims and traits allow the solver to select compatible target executors
  • How executors map portable API calls to the appropriate target-specific implementation
  • How resources can control shared or exclusive access to executors
  • How separating the abstract and realization layers helps maximize PSS model portability and reuse

Watch Session 13 to learn how address handles, the Memory Access API, executors, claims, and resources work together to keep verification intent portable while supporting target-specific execution.

(6:41)

Session 14: Registers

How Does PSS Make Register Modeling Portable Across Target Implementations?

In Session 14 of Accellera’s “Learning PSS” video series, Tom Fitzpatrick, PSS expert and charter member of Accellera’s Portable Stimulus Working Group, explores PSS registers and how register models can remain portable while being mapped to target-specific addresses and memory accesses. In this session, you’ll learn:

  • How to model registers using packed structs, including register fields, layouts, and endianness
  • How PSS provides portable methods for reading, writing, and updating register fields
  • How to organize individual registers into hierarchical register groups that reflect the hardware register map
  • How to define and calculate register offsets, including registers organized in arrays and nested groups
  • How to associate register groups with address regions and address handles
  • How register references and offsets are translated into target memory accesses
  • How packed layouts, register groups, offsets, and handles work together to create a portable register model 

(7:17)

Session 15: Data Coverage

How Does Portable Stimulus Data Coverage Help Measure Verification Quality?

In Session 15 of Accellera’s “Learning PSS” video series, Tom Fitzpatrick explores PSS data coverage and how it can be used to track critical values and ranges, measure scenario quality, and help ensure required verification scenarios are exercised. In this session, you’ll learn:

  • How cover groups, cover points, and bins turn model values into meaningful coverage goals
  • How different types of bins can categorize, filter, ignore, or identify illegal values
  • How to create reusable cover groups that can be applied across actions and other model elements
  • How cross-coverage tracks combinations of values and identifies which scenario combinations have been exercised
  • How PSS determines when coverage is sampled for actions, data flow objects, resources, and structs
  • How IFF expressions can control when values contribute to coverage
  • How coverage options help manage reporting, bin behavior, and the relative importance of coverage goals
  • How data coverage can help evaluate the quality of generated scenarios and determine whether verification goals are being exercised

Watch Session 15 to learn how PSS data coverage helps turn generated scenarios into measurable verification progress.

(5:09)

Session 16: Review & Key Concepts

What Have We Learned? Bringing the Portable Stimulus Journey Full Circle.

In the final session of Accellera’s “Learning PSS” video series, Tom Fitzpatrick looks back at the key concepts explored throughout the series and shows how they work together to support the larger goal of the Portable Stimulus Standard: capturing verification intent once and reusing it across platforms, abstraction levels, and projects.

In this session, you’ll review:

  • How PSS separates portable verification intent from target-specific realization, enabling reuse from IP to subsystem, SoC, software, and silicon
  • How actions, activities, and control flow describe what needs to happen without hand-coding individual test sequences
  • How constraints, randomization, scheduling, and inferencing allow tools to generate multiple legal scenarios from the same verification intent
  • How flow objects, states, resources, components, pools, and binding help build scalable and reusable PSS models
  • How packages, inheritance, and type extensions support reusable libraries and project-specific customization
  • How address spaces, regions, and claims bring portable memory planning into generated scenarios
  • How address handles, the Memory Access API, and executors connect portable models to target-specific execution
  • How register models, groups, offsets, and handles enable portable register programming
  • How PSS brings these capabilities together in a reusable, hierarchical abstract model that can generate verification scenarios across different target platforms

Watch Session 16 for a recap of the “Learning PSS” journey and see how the concepts covered throughout the series come together to enable greater portability, reuse, and verification productivity.

(5:06)