starting same TCM multiple times.

I'm not sure what TCM stands for but I assume you are referring to the enabling condition of an assertion. So if you have an assertion that checks for a ACK to be issued after a REQ:

property p_reqack; $rose(req) |=> ##[0:5]ack;endproperty
a_reqack: assert (p_reqack);

The $rose(req) would be the enabling condition. Your question is what happens if 'req' has more than one posedge before 'ack' goes high? In this case, there would be multiple executions of this property that would all be fulfilled when 'ack' goes high.

You can actually see this effect in the SimVision waveform browser.Add the assertion to the waveform window (via source code browser or assertion browser). If the assertion is executed multiple times, there will be a '+' next the assertion name that expands the waveform to show the status of each branch.

Tim

 Hi,

As per specman/e, TCM stands for time consuming method. This is equivalent to "task"in verilog which consumes simulation time.

The issue is that if the task(TCM) is executed multiple time, does all the threads close when acknowledgement is generated. As Each request is associated with its respective grant, can each task(TCM) threads close when corresponding grant comes up.

Thanks,

Harip 

Hari,

Can you describe the exact type of check that you would like to do?  It sounds like you want to check that for each request there will be a grant occurring with some number of cycles?  If that is what you want to check, it might be easier to write an e temporal check using expect.  For example, let's assume you have an event defined for request and another event defined for grant, and you want to make sure that each time their is a request, there will be a grant within 5 cycles.  The easiest way to write that would be:

expect @request => {[..5] * cycle; @grant} @clk else dut_error(...

Mike

Mike,

What hapeens if event 'request' rose on clocks 1 and 3 and event 'grant' rose once on clock 4? There were two requests and only one grant. Will the expect statment expect this?

Hi,

The issue is when multiple (say 5) requests are followed by a grant. Does the expect statement execute for multiple requests and points out that there is no grant for other than first request.

Please suggest how to check this.

Thanks,

Hari

So, I think the question you are asking is how to handle the check for pipelined behavior.  If there are multiple requests before the first grant occurs, you need to check that each request will have a grant within 5 cycles.  If that is your question, you need to build a simple queue or list to model the pipeline of requests and then check each of them receives a grant.  There might be simpler ways to do it, but here is an example I created quickly to demonstrate one approach:

<'

extend sys {
 monitor: monitor_s;
};

// Need to build a list of request/grant pairs to track
struct gnt_chk_s {
 event clk is @sys.any;
 event grant;

 expect req_gnt_chk is
  {[0..5];@grant exec {out("Grant checked ", sys.time)}} @clk
  else dut_error("No Grant within 5 cycles");
};

struct monitor_s {
 !gnt_chk: gnt_chk_s;
 !gnt_chk_list: list of gnt_chk_s;

 event clk is @sys.any;
 event dut_request;
 event dut_grant;

 on dut_request {
  out("New Request ", sys.time);
  gen gnt_chk;
  gnt_chk_list.add0(gnt_chk);
 };

 on dut_grant {
  out("New Grant ", sys.time);
  emit gnt_chk_list.top().grant;
  gnt_chk_list.top().quit();
  gnt_chk_list.delete(gnt_chk_list.last_index(TRUE));
 };

 // Simulate some combination of pipelined requests/grants
 req_gnt_gen() @clk is {
  wait [1];
  emit dut_request;
  wait [1];
  emit dut_request;
  wait [1];
  emit dut_grant;
  wait [6];
  emit dut_grant;
  wait [10];
  stop_run(); 
 };

 run() is also {
  start req_gnt_gen();
 };
};

'>

Thanks for the detailed example.

Regards,

Hari