Coverage across multiple interfaces

[imajeeth]

I need to implement coverage across multiple interfaces. For example in the arbitor designs, it is of interest to see if multiple requests from different agents are driven at the same time. All the texts have only discussed coverage specific to the interface or transaction. I have an idea of implementing this, but not sure if it is the right way forward. 

 

Here is my idea:

First place, instead of extending the coverage class from uvm_subscriber, I intend to extend it from uvm_scoreboard. This is because, uvm_subscriber is tied to a transaction type, whereas uvm_scoreboard is not. The code below might not be syntactically right, and I intentionally leave the factory registration, new(), build() etc. in order to be concise. 

 

`uvm_analysis_imp_decl(_transaction_A)

`uvm_analysis_imp_decl(_transaction_B  )

`uvm_analysis_imp_decl(_transaction_C )

 

class coverage_class extends uvm_scoreboard;

 

  bit         req_a; //request coming from transaction A

  bit         req_b; //request coming from transaction B 

  bit         req_c; //request coming from transaction C

 

  uvm_analysis_imp_transaction_A        #(trans_a, coverage_class)       trans_a_port;

  uvm_analysis_imp_transaction_B        #(trans_b, coverage_class)       trans_b_port;

  uvm_analysis_imp_transaction_C        #(trans_c, coverage_class)       trans_c_port;

 

  covergroup cg;

    coverpoint req_a;

    coverpoint req_b;

    coverpoint req_c;

    cross req_a, req_b, req_c; //Want to capture a case where all 3 requests go high at the same time from 3 different interfaces. 

  endgroup

 

  //write function to capture trans_a

  virtual function void write_transaction_A(trans_a   t);

    req_a = t.req;

    cg.sample();

  endfunction

  

  //write function to capture trans_b

  virtual function void write_transaction_B(trans_b   t);

    req_b = t.req;

    cg.sample();

  endfunction

  //write function to capture trans_c

  virtual function void write_transaction_C(trans_c   t);

    req_c = t.req;

    cg.sample();

  endfunction

endclass

 

I also realize that, when 2 requests are high at the same time,  there might be a delta delay between the two. Say "write_transaction_A" happens a delta before "write_transaction_B" (still the same timestamp). So when transaction_A happens, req_a is set to 1 and the covergroup is sampled. At this delta time, transaction_B has not occurred so, req_b is still 0. In the next delta cycle, write_transaction_B happens and so, req_A as well as req_B is asserted, and covergroup is sampled again. I see 2 issues here:

1. We are sampling the covergroup more than actually required. Is there a better way of sampling the covergroup? 

2. Where do we clear the req_A/req_B/req_C variables in order to be sampled again.

 

Is there a better way of accomplishing the same task? Please share your thoughts.