The question about the useage of "always@*" in verilog 2001

S

shinningstar

Guest
As we all know, verilog 2001 support the useage of "always@*" in the
combination logic block. It's a good news for us because we don't need to
care about the integrity of sensitive list which will cause mismatch
between pre and post simulation.
My question is: Does this useage will impact on the speed of simulation?
 
shinningstar wrote:
As we all know, verilog 2001 support the useage of "always@*" in the
combination logic block. It's a good news for us because we don't
need to
care about the integrity of sensitive list which will cause mismatch
between pre and post simulation.
My question is: Does this useage will impact on the speed of
simulation?
Click to expand...

Will depend on the simulator, of course; though one
can safely suspect that any self respecting simulator would
auto generate the sensitivity list during elaboration
time of the event queue. So it may hurt your compilation
time (only in terms of millisecs, perhaps), but not the
run time.

--
SystemVerilog DPI tutorial on Project VeriPage:
http://www.project-veripage.com/dpi_tutorial_1.php
For subscribing to Project VeriPage mailing list:
<URL: http://www.project-veripage.com/list/?p=subscribe&id=1>
 
shinningstar wrote:

My question is: Does this useage will impact on the speed of
simulation?
Click to expand...

I can't speak for other implementors, but we simply replace the @* with
the expanded event control containing all the identifiers that were
read.
The speed will be exactly the same as if you had written that expanded
event control yourself.

Now it is possible that this will run slower if the expanded list is
not
the same as the list you would have used. For example, the list for @*
may include things that are not primary inputs to the combinational
block,
but are just local temporaries written and read within the block. Or
you
may only be reading one bit of an input, but the definition of @* will
put
the entire thing into the event control. However, this is unlikely to
have
much impact on performance.
 
Hi
Definetely @ * is a very useful feature. But there is a loop hole in the
standard. The standard says that when @ * is used all the variables in the
RHS of any expression should be considered to be sensitive. however
consider the following code.

always @ *
begin
ram[addr] = data;
end

in this code only "data" will be considered to be sensitive and not
"addr". i.e. the behaviour may be tool dependent. In that case there may
be synthesis simulatioin mismatch

I am not very sure with this. However i would be very happy if a more
knowledgeable person can clarify this.

Thanks and regards
 
Hi
Definetely @ * is a very useful feature. But there is a loop hole in the
standard. The standard says that when @ * is used all the variables in the
RHS of any expression should be considered to be sensitive. however
consider the following code.

always @ *
begin
ram[addr] = data;
end

in this code only "data" will be considered to be sensitive and not
"addr". i.e. the behaviour may be tool dependent. In that case there may
be synthesis simulatioin mismatch

I am not very sure with this. However i would be very happy if a more
knowledgeable person can clarify this.

Thanks and regards
 
Hi
Definetely @ * is a very useful feature. But there is a loop hole in the
standard. The standard says that when @ * is used all the variables in the
RHS of any expression should be considered to be sensitive. however
consider the following code.

always @ *
begin
ram[addr] = data;
end

in this code only "data" will be considered to be sensitive and not
"addr". i.e. the behaviour may be tool dependent. In that case there may
be synthesis simulatioin mismatch

I am not very sure with this. However i would be very happy if a more
knowledgeable person can clarify this.

Thanks and regards
 
Hi
Definetely @ * is a very useful feature. But there is a loop hole in the
standard. The standard says that when @ * is used all the variables in the
RHS of any expression should be considered to be sensitive. however
consider the following code.

always @ *
begin
ram[addr] = data;
end

in this code only "data" will be considered to be sensitive and not
"addr". i.e. the behaviour may be tool dependent. In that case there may
be synthesis simulatioin mismatch

I am not very sure with this. However i would be very happy if a more
knowledgeable person can clarify this.

Thanks and regards
 
Hi
Definetely @ * is a very useful feature. But there is a loop hole in the
standard. The standard says that when @ * is used all the variables in the
RHS of any expression should be considered to be sensitive. however
consider the following code.

always @ *
begin
ram[addr] = data;
end

in this code only "data" will be considered to be sensitive and not
"addr". i.e. the behaviour may be tool dependent. In that case there may
be synthesis simulatioin mismatch

I am not very sure with this. However i would be very happy if a more
knowledgeable person can clarify this.

Thanks and regards
 
Hi
Definetely @ * is a very useful feature. But there is a loop hole in the
standard. The standard says that when @ * is used all the variables in the
RHS of any expression should be considered to be sensitive. however
consider the following code.

always @ *
begin
ram[addr] = data;
end

in this code only "data" will be considered to be sensitive and not
"addr". i.e. the behaviour may be tool dependent. In that case there may
be synthesis simulatioin mismatch

I am not very sure with this. However i would be very happy if a more
knowledgeable person can clarify this.

Thanks and regards
 
Hi
Definetely @ * is a very useful feature. But there is a loop hole in the
standard. The standard says that when @ * is used all the variables in the
RHS of any expression should be considered to be sensitive. however
consider the following code.

always @ *
begin
ram[addr] = data;
end

in this code only "data" will be considered to be sensitive and not
"addr". i.e. the behaviour may be tool dependent. In that case there may
be synthesis simulatioin mismatch

I am not very sure with this. However i would be very happy if a more
knowledgeable person can clarify this.

Thanks and regards
 
Hi
Definetely @ * is a very useful feature. But there is a loop hole in the
standard. The standard says that when @ * is used all the variables in the
RHS of any expression should be considered to be sensitive. however
consider the following code.

always @ *
begin
ram[addr] = data;
end

in this code only "data" will be considered to be sensitive and not
"addr". i.e. the behaviour may be tool dependent. In that case there may
be synthesis simulatioin mismatch

I am not very sure with this. However i would be very happy if a more
knowledgeable person can clarify this.

Thanks and regards
 
Hi
Definetely @ * is a very useful feature. But there is a loop hole in the
standard. The standard says that when @ * is used all the variables in the
RHS of any expression should be considered to be sensitive. however
consider the following code.

always @ *
begin
ram[addr] = data;
end

in this code only "data" will be considered to be sensitive and not
"addr". i.e. the behaviour may be tool dependent. In that case there may
be synthesis simulatioin mismatch

I am not very sure with this. However i would be very happy if a more
knowledgeable person can clarify this.

Thanks and regards
 
Hi
Definetely @ * is a very useful feature. But there is a loop hole in the
standard. The standard says that when @ * is used all the variables in the
RHS of any expression should be considered to be sensitive. however
consider the following code.

always @ *
begin
ram[addr] = data;
end

in this code only "data" will be considered to be sensitive and not
"addr". i.e. the behaviour may be tool dependent. In that case there may
be synthesis simulatioin mismatch

I am not very sure with this. However i would be very happy if a more
knowledgeable person can clarify this.

Thanks and regards
 
Hi
Definetely @ * is a very useful feature. But there is a loop hole in the
standard. The standard says that when @ * is used all the variables in the
RHS of any expression should be considered to be sensitive. however
consider the following code.

always @ *
begin
ram[addr] = data;
end

in this code only "data" will be considered to be sensitive and not
"addr". i.e. the behaviour may be tool dependent. In that case there may
be synthesis simulatioin mismatch

I am not very sure with this. However i would be very happy if a more
knowledgeable person can clarify this.

Thanks and regards
 
Mrithyunjay wrote:

Definetely @ * is a very useful feature. But there is a loop hole in the
standard. The standard says that when @ * is used all the variables in the
RHS of any expression should be considered to be sensitive. however
consider the following code.

always @ *
begin
ram[addr] = data;
end

in this code only "data" will be considered to be sensitive and not
"addr".
Click to expand...
(snip)

And what result do you expect when changing the address on
a RAM while write is enabled? Unless this is inside another
ALWAYS block, it would seem WE is always active.

-- glen
 
Hi
Definetely @ * is a very useful feature. But there is a loop hole in the
standard. The standard says that when @ * is used all the variables in the
RHS of any expression should be considered to be sensitive. however
consider the following code.

always @ *
begin
ram[addr] = data;
end

in this code only "data" will be considered to be sensitive and not
"addr". i.e. the behaviour may be tool dependent. In that case there may
be synthesis simulatioin mismatch

I am not very sure with this. However i would be very happy if a more
knowledgeable person can clarify this.

Thanks and regards
 
On Sun, 09 Jan 2005 11:41:49 -0500, "Mrithyunjay"
<maha_mrithyunjay@yahoo.com> wrote:

Hi
Definetely @ * is a very useful feature. But there is a loop hole in the
standard. The standard says that when @ * is used all the variables in the
RHS of any expression should be considered to be sensitive. however
consider the following code.

always @ *
begin
ram[addr] = data;
end

in this code only "data" will be considered to be sensitive and not
"addr". i.e. the behaviour may be tool dependent. In that case there may
be synthesis simulatioin mismatch
Click to expand...
Actually the standard says "Nets and variables which appear on the
right-hand side of assignments, ... , as an index variable on the
left-hand side of assignments, ... , shall all be included by these
rules." So index variables on the LHS are taken care of too.
 
Mrithyunjay wrote:

Definetely @ * is a very useful feature. But there is a loop hole in the
standard. The standard says that when @ * is used all the variables in the
RHS of any expression should be considered to be sensitive. however
consider the following code.

always @ *
begin
ram[addr] = data;
end

in this code only "data" will be considered to be sensitive and not
"addr".
Click to expand...
(snip)

And what result do you expect when changing the address on
a RAM while write is enabled? Unless this is inside another
ALWAYS block, it would seem WE is always active.

-- glen
 
You must log in or register to reply here.

Welcome to EDABoard.com

Sponsor

Back
Top