Re: SV Functional Coverage : Instruction sequence?

On Mon, 25 Jun 2007 13:40:31 -0700,
Alex <agnusin@xxxxxxxxx> wrote:

Simple, but single-threaded and therefore somewhat
fragile, surely?

By itself, each instantiation of sequence matching component is single-
threaded. However, another instantiation of sequence matching
component adds another thread. Just instantiate the number of
components to match all required patterns.

Alex, I understand the motivation to get a simple replacement
for SVA that works in (let's say) 80% of simple cases, but I
don't understand how your implementation is robust enough
to be worth deploying widely. For example, suppose you write
a sequence {conditionA, conditionB, conditionC} and on the
first cycle it happens that both conditionA and conditionC
are true. Your sequence counter will reset! So in fact
when you write a sequence

{A, B, C}

your sequence detector is *really* looking for

{ A && !B && !C, !A && B && !C, !A && !B && C }

And my "single-thread" accusation stands: you have only one
state variable, count, in the module - so a single instance of
the module cannot detect overlapping sequences. If you instance
the module more than once on the same set of signals, you STILL
cannot detect overlapping sequences because all your instances
will do exactly the same thing, in lockstep.

I also have the same objection to your example that I have
to OVL: it's completely opaque to users. A SVA sequence is
written using a standardised language; users can read the
code and see what it does. SVA empowers users. Your module,
and the OVL checker modules, DISempower users by providing
opaque functionality for something that is quite hard to
document. Indeed, sequential regular expression languages
such as SVA are probably the clearest and most effective
way to document such things. So why not simply execute
the documentation? Programming doesn't get better than that.

Historically, the field of assertion languages is "owned"
by a community of very sophisticated and clever theorists.
So some parts of the languages are very difficult indeed.
But those same clever theorists have given us something
that is extremely clear, well-defined, and (in simple
cases) quite easy to use. It's extremely easy to learn
the basics of SVA or PSL, and extremely hard to make a
good job of replicating their functionality for yourself.
--
Jonathan Bromley, Consultant

DOULOS - Developing Design Know-how
VHDL * Verilog * SystemC * e * Perl * Tcl/Tk * Project Services

Doulos Ltd., 22 Market Place, Ringwood, BH24 1AW, UK
jonathan.bromley@xxxxxxxxxxxxx
http://www.MYCOMPANY.com

The contents of this message may contain personal views which
are not the views of Doulos Ltd., unless specifically stated.
.

Relevant Pages