The literature for many of today’s testbench verification methodologies (such as UVM) often reference various software or object-oriented related patterns in their discussions. For example, the UVM Cookbook (available out on the Verification Academy) references the observe pattern when discussing the Analysis Port. One problem with the discussion of patterns in existing publications is that it is generally difficult to search, reference, and leverage the solutions these patterns provide since these publications are distributed across multiple heterogeneous platforms and databases and documented using multiple varied formats. In addition, most of the published examples of a verification design deal more with the software implementation details of constructing a testbench. To address these concerns, we have decided to extend the application of patterns across the entire domain of verification (i.e., from specification to methodology to implementation—and across multiple verification engines such as formal, simulation, and emulation) and have just released a comprehensive pattern library out on the Verification Academy.
But first, we should answer the question, “What is a pattern?” In the process of designing something (e.g., a building, a software program, or an airplane) the designer often makes numerous decisions about how to solve specific problems. It would be nice if the knowledge gained from solving a specific problem could be shared, and this is where patterns help out. That is, if the designer can identify common factors contributing to the derived solution in such a way that it can be applied to other similar recurring problems, then the resulting generalized problem-solution pair is known as a pattern. Documenting patterns provides a method of describing good design practices within a field of expertise and enables designers to improve the quality in their own designs by reusing a proven solution on a recurring problem.
Design patterns are not a new concept. In fact, they originated as a contemporary architectural concept from Christopher Alexander in 1977, and they have been applied to the design of buildings and urban planning . In 1987, Kent Beck and Ward Cunningham proposed the idea of applying patterns to programming . However, it was Gamma et al., also known as the Gang of Four (GoF) who popularized the concept of patterns in computer science after publishing their book Design Patterns: Elements of Reusable Object-Oriented Software in 1994 .
ORGANIZING THE PATTERNS IN OUR LIBRARY
Our Verification Academy Pattern Library contains a collection of pattern entries—where each documented pattern entry provides a solution to a single problem. To facilitate learning, ease of use, and quick access when searching for verification pattern content, we gave careful thought into organizing the library into searchable categories whose patterns solutions are related and exhibit similar characteristics. Since our goal in creating verification patterns is to broaden the application of patterns beyond the software domain, we decided that our categories should align from a high level with the digital design and verification process. Hence, we have identified two main verification pattern categories, which should be familiar to any design and verification engineer working in this domain. That is, Specification Patterns and Implementation Patterns, as illustrated in the following figure.
Figure 1: Specification Patterns and Implementation Patterns.
We believe that it is important, when creating a pattern library, that each documented pattern follow a consistent format and style. This consistency simplifies learning and facilitates ease of use when reviewing different patterns contained in the library. The documentation for a verification pattern should describe the context in which the pattern is used—a problem within this context that the pattern is seeking to address—and a suggested solution.
All patterns within the Verification Academy Patterns Library adhere to the following template, which can be downloaded out on the Verification Academy so that users can document their own patterns:
- Pattern Name: A unique (descriptive) name that helps in identifying and referencing the pattern.
- Intent: A very brief description of the goal behind the pattern and the reason for using it.
- Motivation: A description of a specific scenario consisting of a problem and a specific context in which this pattern can be applied. Think of this as a problem statement that describes a concrete example (the solution to the problem will be discussed in the subsequent Implementation and Example sections).
- Applicability: Situations in which this pattern is usable; the general context for the pattern.
- Structure: (Required for Implementation Patterns and optional for Specification Patterns) Abstract graphical representation of the pattern (e.g., UML class diagrams, interaction diagrams, etc.).
- Implementation: A description of an implementation of the pattern; the solution part of the pattern.
- Example: A code (or pseudo-code) example of how the pattern can be used. It is suggested that the example addresses the original problem scenario presented in the motivation section.
- Scope: (Recommended for Specification Patterns and optional for Implementation Patterns) A scope defines the extent of the verification execution over which the pattern must hold. More property scope details will be discussed in section 3.2, and an example is provided in section 4.1.
- Consequences: (Optional) A description of the results, side effects, and tradeoffs caused by using this pattern.
- Related Patterns: (Optional) Other patterns that have some relationship with the pattern with a discussion of the differences and similarities between the related patterns.
- Contribution: Identification of person and/or references for this pattern contribution to the library.
The following example is provided to help illustrate how we document a pattern in the Verification Academy Pattern Library using the template we just described in the previous section. This unique example demonstrates a pattern that is targeted at both simulation and emulation.
Pattern Name: The BFM-Proxy Pair Pattern.
Intent: The BFM-Proxy Pair Pattern is categorized as an Environment Pattern and facilitates the design of transactors like drivers and monitors for dual domain partitioned testbenches that can be used for both simulation and emulation, and across verification engines (or platforms) in general.
Motivation: In order to enable and promote a verification process that is abstracted from underlying verification engines, particularly a software simulator and a hardware emulator, modern testbenches should exhibit (from conception) a dual domain architecture with partitioned HVL and HDL module hierarchies targeted for the simulator and emulator, respectively, and linked together to run in unison. Fundamental to this architecture is the employment of BFM-proxy pairs to devise so-called split transactors, where components in the HVL domain typically implemented as classes act as proxies to BFMs implemented as interfaces or modules in the (synthesizable) HDL domain. An HVL proxy provides a surrogate or placeholder for the associated cross-domain HDL BFM to control access to it via a transaction-based HVL-HDL communication model using remote function and task calls. Effectively, the proxy embodies the transactor API to upper testbench layers, abstracting the cross-domain communication and the implementation details of the BFM’s bus cycle state machines.
Applicability: The BFM-Proxy Pair Pattern is applicable in any situation demanding a common dual domain partitioned testbench architecture (i.e., separated HVL and HDL module hierarchies) for both simulation and emulation, and across verification engines in general.
Structure: The diagrams below illustrate the dual domain testbench architecture and the according UVM agent structure, respectively, with the transactors depicted as BFM-proxy pairs.
Implementation: A transactor following the prescribed BFM-Proxy Pair Pattern implements a BFM as a SystemVerilog interface (or module) with dedicated functions and tasks to be called from a class proxy through a virtual (or DPI-C) interface to execute bus cycles, set parameters, or get status information. Additionally, a BFM interface (or module) may call functions defined in the class proxy via a proxy object back-pointer mechanism to provide notifications of transactions and other interesting events and conditions for control and analysis. Transaction-based cross-domain communication is thus enabled in both directions with either the HVL proxy or the HDL BFM as initiator. Each proxy-BFM pair is regarded as a joint pair representing a single transactor.
Example: BFM-Proxy Pair Pattern source code examples for a UVM driver and monitor are provided below:
Consequences: The dual domain partitioned testbench architecture enabled by this BFM-Proxy Pair Pattern offers maximum leverage of established simulation-based verification practices into emulation, including the benefits of using SystemVerilog and UVM for creating modular, reusable verification components and environments.
Related Patterns: A precursor to this BFM-Proxy Pair Pattern is the Dual Domain Hierarchy Pattern, which advocates the HVL and HDL domain partitioning as a sound and necessary separation of concerns fundamental to emulation and other hardware-assisted verification platforms. Additionally, the BFM-Proxy Pair Pattern resembles the proxy pattern as one of the structural patterns of the GoF’s OOP design patterns (though applying instead between a dynamic proxy object and a static interface or module).
CREATING A COMMUNITY OF PATTERN EXPERTISE
For the Verification Academy Patterns Library, we felt it important to set goals on the pattern creation process and how to effectively populate the library. On a related note, you might have wondered why there is such a large set of authors listed on this article (we refer to ourselves as the Gang of Five). The reality is that verification is a diverse field, and it often requires expertise in varied areas, such as methodologies, technologies, tools, and languages. No single person is a master in every aspect of verification. Thus, to create patterns across the broad field of verification, we built a team made up from experts in assertion-based verification, formal verification, constrained-random and coverage-driven verification, UVM, hardware-assisted verification, and emulation. However, even with this diverse team of experts we recognize that there is still additional verification expertise required for solving verification problems in specific application domains. Hence, for our verification patterns library, we set a goal that the pattern creation process should harness the power of online social communities made up from a diverse set of verification experts that work in multiple application domains. In turn, this community of experts would foster collective problem solving for the creation of novel patterns and provide alternative, optimized solutions for existing pattern content. To achieve these goals, we developed a web-based infrastructure that allows new content to be contributed in a consistent format from this community of experts, and decided to release our library out on the Verification Academy, since it consists of an existing online social community with over 35,000 design and verification engineers. In addition, the Verification Academy provides us an existing online infrastructure, which enabled the creation of a patterns knowledge base that is easily discoverable, referenceable, and relatable.
To learn more about the Verification Academy Patterns Library, check out www.verificationacademy.com/patterns.
 C. Alexander. (1979) The Timeless Way of Building, New York: Oxford University Press.
 Beck, Kent; Cunningham, Ward (1987). “Using Pattern Languages for Object-Oriented Program,” OOPSLA ‘87 workshop on Specification and Design for Object-Oriented Programming.
 E. Gamma et al. (1994) Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley.
Back to Top