Hi there,

I've got a confusion regarding usage of two cross statements in the same analog process. Following is the code section..
Quote:


As you can see I'm upadating a variable named count in the first cross statement and then trying to use the same count variable in the second cross statement. I'm not sure whether the next cross block would see the updated value or an older value of count, evaluated in the previous simulation time point. From simulation results I found it is seeing the updated value, which means the 2 cross blocks here are not truely concurrent!! But then their triggering condition is same and they are supposed to be simulated at a single time point. I'm pretty confused. Following are the 2 questions, I think are fundamental to this confusion.

1. Is it semantically defined what would be the value of count in the second cross block?? count is an integer variable, what if it was an electrical signal??
2. Are the = statements blocking statements like Verilog??

Thanks!
Rajdeep

In your example you can combine the @cross blocks, which would eliminate any confusion.

-Ken

Statements in verilog-a are all non-blocking. By this I mean that no statement will pause execution of the model.

In an initial or always block (in Verilog), if you have

@(posedge clk) ...

the execution of the model will pause at that statement until a rising edge occurs on clk, then execution proceeds. Similarly, if you have

x =#10 y;

then execution pauses 10 ticks before moving on to the next statement.

These things do not occur in analog blocks (in Verilog-A). First off, blocking constructs such as # and wait are not supported in an analog block. @ statements are supported, but code included in the @ block is simply skipped except when the event triggers their execution. In this way, execution is never blocked. The entire analog block is evaluated at every timestep except for code within if and @ statements that are not active, which is simply skipped.

Thus in your example, the code is always evaluated in order, and the code within the event blocks is skipped except at the falling threshold crossings of V(clk). Since both @ blocks are triggered with the same event, they will always execute together, and of course, in order.

-Ken

With assignments in Verilog there are several different things going on at once. In particular ...
1. The time when the right-hand side is evaluated.
2. The time when the assignment to the left-hand side occurs.
3. Whether assignment includes delay.
4. Whether the delay blocks execution.

Assignments using the "=" operator are considered blocking assignments because if they include delays they will block execution during the delay. In this case, the order of evaluation is ...
1. evaluate the right-hand side.
2. block execution for the length of the delay.
3. assign the value to the left-hand side.
4. execute the next statement.

Assignments using the "<=" operator are considered non-blocking assignments because they do not block execution even if they include delays. In this case, the order of evaluation is ...
1. evaluate the right-hand side.
2. execute the next statement.
3. continue execution while waiting for the length of the delay.
4. assign the value to the left hand side.

Analog assignments never block. So the order of evaluation is ...
1. evaluate the right-hand side
2. assign value to the left-hand side
3. execute the next statement.

So the point is analog statements are all non-blocking. But this does not mean that analog assignments act in the same way that traditional verilog non-blocking assignments act. Traditional verilog non-blocking assignments have behavior in addition to the fact that they do not block execution that is different from the behavior of analog assignments.

The behavior of analog assignments is the same as the behavior of assignments in traditional programming languages. It is also the same as simple verilog assignments that contain no delay.

For example,
Code:

analog begin
    a = b;
    c = a;
end 

would end up with c getting the value of b, as you say.

-Ken