Documente Academic
Documente Profesional
Documente Cultură
Useless
Adnan Hamid, Breker Verification Systems - November 26, 2012
Abstract
For years, design productivity has been assisted by increasing levels of reuse. Many system-on-chip
(SoC) designs now contain 10s or even 100s of reused intellectual property (IP) blocks that can
constitute in excess of 90% of the gates in a chip. In addition, the size of IP blocks has risen from
small peripherals to entire subsystems.
What has happened to total productivity over this same period? Productivity is being constrained by
verification, but verification has not seen its reuse needs met by models and tools available on the
market. As a result, verification continues to take a greater percentage of total time and budget,
constraining product innovation that would otherwise be possible.
While some verification IP (VIP) is available, there is not enough and it does not provide the levels of
reuse necessary. As SoC design moves to platform IP, where is the corresponding platform VIP?
Where are the fully defined verification environments for platform IP that can be extended to add
additional functions without having to understand the parts of the platform that are not being
modified? Why is verification reuse so far behind design reuse?
These issues are explored in this article along with a way in which full IP-to-SoC verification reuse
can be enabled through the use of scenario models.
Introduction
Over the past decade, designer productivity has been boosted by reuse. Systems are composed of
intellectual property (IP) blocks, each having a well-defined function, and the implementation for
these blocks can be used in multiple designs and shared between multiple companies.
This is the IP methodology used to fill a significant portion of the real estate in a chip. IP reuse has
allowed companies to concentrate on key parts of their design parts that add value and make
products competitive. Over time, the size of IP blocks has grown and has extended to what is often
called platform-based design where a processor, interconnect and a significant number of
peripherals, accelerators and other functions are pre-integrated and pre-verified.
When IP is acquired from a third party, it is expected that a verification environment will be shipped
with it. This environment was used to verify the block or platform in isolation. It enables users of
that IP to ensure that the block has been integrated into their environment correctly and to see the
extent of the verification that was performed. The environment may also come with some verification
components that can be reused for system-level integration and verification, such as coverage
models. The standard Universal Verification Methodology (UVM) [1] enables the reuse of other
packets onto the bus that had been driven by a processor now removed. This solution allows the
maximum flexibility in terms of what can be sent into the rest of the hardware.
The problem is that this traffic is not realistic unless scenarios are created in the verification code to
perform functions representative of the systems operation. This involves knowing how to set up the
peripherals to perform certain functions and generating the correct sequence of events on the bus to
make data move through the system in a useful manner.
The UVM breaks down when a processor is added to the system, as shown in Figure 3. VIPs are not
available for processors and theres no way to write sequences that mimic the flow of data through a
processor. Thus, with a UVM verification strategy, the usual option is to remove the processor and
drive it with a bus functional model (BFM) that enables transactions to be driven onto the bus.
Again, this approach may not produce realistic system-level traffic.
Of course, it is possible to handwrite custom software to run on the processors and could be at two
different levels. First, directed tests could be written that move data through the system in a specific
manner. This may use some of the production software, such as drivers, to create a hardware
abstraction layer so that the test developer does not need to know details, including peripheral
configuration. Directed tests suffer from many of the same problems as running production
software, in addition to the time it takes to write the tests.
Alternatively, software could be written that is more specific for verification, analogous to the
process of writing code for built-in self-test (BIST). While multiple tests could be written, this tends
to be customized code that may not be useable when the platform is modified or extended. It gets
successively more difficult as additional processors are added into the system, especially if they are
heterogeneous in nature. Moreover, humans have trouble visualizing parallel activity within the SoC,
making it difficult to handwrite multi-threaded tests for multiple embedded processors.
A Solution for Platform VIP
When using platform IP, or when an integrated subsystem or system contains one or more
processors, it is important to ascertain the verification process objective. It is no longer to verify the
implementation of blocks, but rather to verify that data can move through the system correctly with
the expected latency and bandwidth. This requirement is not met by the UVM for systems that
contain processors because there is no suitable VIP that exists at the block level to support the
platform.
It is important that additional IP can easily be added to these platforms and the same demand should
be placed on the VIP that goes along with it. This requirement is not well met by the UVM either
since it requires rewriting virtual sequences. It would be ideal if the same model can be used as the
verification plan and coverage model rather than having to write additional models for each. The
current UVM methodology is cumbersome on both counts.
A solution exists that matches all VIP requirements and describes the flow of data through IP blocks
based on possible outcomes. All possible outcomes for a block are described along with the manner
in which that outcome can be created. When multiple blocks are connected together, more complex
flows are created with one block establishing demands and other blocks providing the necessary
data or conditions. Those blocks in turn establish demands. Thus, a cascade of demands and ways to
meet those demands are created by the VIP for each IP block.
When a verification target (one of the outcomes) is specified, a solver finds a possible path through
all of the blocks to achieve that outcome. A generator automatically writes the necessary C code to
run on the embedded processors. The combined VIP is the set of all possible behaviors and becomes
the coverage model as well as the source of both stimulus and result checking. The selection of
outcomes becomes part of the verification plan. This form of VIP is a scenario model that can be
built incrementally and, as additional scenarios are incorporated, more extensive tests can be
generated, or more ways to achieve desired outcomes explored.
Figure 4 shows a commercial example of this approach, the TrekSoC EDA product [4] from Breker
Verification Systems. TrekSoC reads in a hierarchy of graph-based scenario models that define all
the possible outcomes for the SoC as well as the ways to achieve these outcomes. It then solves for
paths through the SoC and automatically generated multi-threaded, self-verifying C test cases to run
on multiple embedded processors. Since some of these test cases will send or receive data on the
chips I/O ports, TrekSoC also coordinates the embedded processors with testbench BFMs, including
standard UVCs.
Conclusions
In order to continue increasing the productivity associated with the design and verification of
complex systems, reuse has to be made scalable and must have a similar impact on both design and
verification. Additional functionality is being instantiated at the system level and constrainedrandom generation is failing to provide capabilities required to verify this functionality.
While platform design IP has increased the efficiency of the design process, VIP has failed to deliver
similar gains. A new method of describing VIP, scenario models, is suitable for platform IP. It is
reusable and extensible with built in notions of coverage and verification planning.
Without a migration to scenario models, the SoC development process will become even more
constrained by the verification task.
References
[1] Universal Verification Methodology (UVM) 1.1 Users Guide, Accellera, 2011.
[2] ARM CTO asks: Are we getting value from verification? by Brian Bailey, EDN, June 13, 2012.
http://www.edn.com/design/integrated-circuit-design/4375333/ARM-CTO-asks--Are-we-getting-valuefrom-verification[3] Catch-22 by Joseph Heller, Simon & Schuster, 1961.
[4] Verifying SoCs from the Inside Out by Thomas L. Anderson, Chip Design, August 3, 2012.
http://chipdesignmag.com/display.php?articleId=5153
If you found this article to be of interest, visit EDA Designline where you will find the latest and
greatest design, technology, product, and news articles with regard to all aspects of Electronic
Design Automation (EDA).
Also, you can obtain a highlights update delivered directly to your inbox by signing up for the EDA
Designline weekly newsletter just Click Here to request this newsletter using the Manage
Newsletters tab (if you aren't already a member you'll be asked to register, but it's free and painless
so don't let that stop you).