Another year passed by and the verification world saw further
advancements on how better to verify the rising complexity. At the core of
verification there exist two pillars that have been active in simplifying the
complexity all throughout. First is REUSABILITY at various levels i.e. within
project from block to top level, across projects within an organization and
deploying VIPs or a methodology like UVM across the industry. Second is raising
ABSTRACTION levels i.e. from signals to transaction and from transaction to
further abstraction layers so as to deal with complexity in a better way. Sequence
layering is one such concept that incorporates the better of the two.
What is layering?
In simple terms, the concept of layering is where one encapsulates a detailed/complex
function or a task and moves it at a higher level. In day to day life layering
is used everywhere e.g. instead of calling a human being as an entity with 2
eyes, 1 nose, 2 ears, 2 hands, 2 legs etc. we simply refer to it as human
being. When we go to a restaurant & ask for an item from the menu say
barbeque chicken, we don’t explain the ingredients & process to prepare it.
Latest is apps on handhelds where by just a click of an icon everything relevant
is available. In short, we avoid the complexity of implementation & details
associated while making use of generic stuff.
What is sequence layering?
Applying the concept of layering to sequences in UVM (any methodology)
improves the code reusability by developing at a
higher abstraction level. This is achieved by adding a layering agent derived
from uvm_agent. The layering agent doesn’t have a driver though. All it has is
a sequencer & monitor. The way it works is that there is a high level
sequence item now associated with this layering sequencer. It would connect to
the sequencer of the lower level protocols using the same mechanism as used by
sequencer & driver in an uvm_agent. The lower level sequencer would have
only 1 sequence (translation sequence that takes the higher level sequence item
& translates it into lower level sequence item) running as a forever
thread. Inside this sequence we have a get_next_item similar to what we do in a
uvm_driver. The item is received from the higher level sequencer. It is
translated by this lower level sequence & given to its driver. Once done,
the same item_done kind of response is passed back from this lower level
sequence to the layered sequencer indicating that it is ready for the next
item.
Figure 1 : Concept diagram of the layering agent
On the analysis front, the same layering agent can also have a monitor at
higher level. This monitor is connected to the monitor of the lower layer
protocol. Once a lower layer packet is received it is passed on to this higher
level monitor wherein it is translated into a higher level packet based on the
configuration information. Once done, the higher level packet is given to the
scoreboard for comparison. So we need only 1 scoreboard for all potential configurations
of an IP & the layering agent monitor does the job of translation.
Example Implementation
I recently co-authored a paper on this subject at CDNLive 2013, Bangalore
and we received the Best Paper Award! In this paper we describe the application
of Sequence Layering where our team was involved in verifying a highly
configurable memory controller supporting multiple protocols from the processor
side and a no. of protocols on the DRAM memory controller front. A related blog post here.
I would like to hear from you in case you implemented the
above or similar concepts in any of your projects. If you would like to see any
other topic covered through this blog do drop in an email to siddhakarana@gmail.com (Anonymity
guaranteed if requested).
Wish you all a happy & healthy new year!!!
