Hardware Reference
In-Depth Information
11.1.7
First Match of a Sequence
It is sometimes convenient to discard all sequence matches but the first one. This
can be achieved using the operator
first_match
. Sequence
first_match
(s)
has
a match in clock tick t iff sequence s has a match in clock tick t , and it has no match
in any clock tick <t.
Example 11.22.
If
a
and
b
have values 1 in clock ticks 0-4 then sequence
a[
*
1:2] ##1 b[
*
2:3]
has matches in clock ticks 2, 3, and 4. In contrast, sequence
first_match
(a[
*
1:2] ##1 b[
*
2:3])
has only one match in clock tick 2.
t
Example 11.23.
When request
req
is issued and thereafter the first data chunk is
received as identified by
data
bit asserted, acknowledgment
ack
should be sent.
Solution:
a1:
assert property
(
first_match
(req ##[+] data) |-> ack);
Discussion:
Here, the
first_match
operator guarantees that the acknowledgment
is only sent when
data
is asserted for the first time. The same assertion rewritten
using the goto repetition should be more efficient:
a2:
assert property
(req ##1 data[->1] |-> ack);
t
Example 11.24.
Let us modify the requirement of Example
11.23
: Acknowledg-
ment
ack
should be sent in response to a request, when two data chunks are received
in consecutive clock ticks for the first time. The first solution can be easily adapted
as follows:
a3:
assert property
(
first_match
(req ##[+] data[
*
2]) |-> ack);
The second solution can also be modified in the following way:
a4:
assert property
(req ##1 data[->1] ##1 data |-> ack);
Again, assertion
a4
is likely to be more efficient than
a3
.
t
Trailing
first_match
in Sequential Properties.
Trailing
first_match
in sequen-
tial properties, both weak and strong is redundant and can be omitted. For
simplicity we explain this statement for strong sequential properties. Property
strong
(r ##1 s)
is true iff there exists a match of sequence
r ##1 s
. This match
exists if there exists a match of
r
followedbyamatchof
s
, but this is equivalent
to the statement that there exists a match of
r
followedbythe
first
match of
s
.
Therefore,
strong
(r ##1 s)
is equivalent to
strong
(r ##1
first_match
(s))
.
Similarly, it can be shown that a trailing
first_match
in the outermost
and
or
or
branch in a sequential property is redundant. For example, the sequential property
r1 ##1
first_match
(s)
or
r2
is equivalent to
r1 ##1 s
or
r2
.
Example 11.25.
The
property
a |-> b ##1
first_match
(c[
*
] ##1 d)
is
equivalent
to
a |-> b ##1 c[
*
] ##1 d
.
The
following
properties
are
not
equivalent (see Exercise
11.13
):
Search WWH ::
Custom Search