Jump to content

Coverage across multiple interfaces

Recommended Posts

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_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. 
  //write function to capture trans_a
  virtual function void write_transaction_A(trans_a   t);
    req_a = t.req;
  //write function to capture trans_b
  virtual function void write_transaction_B(trans_b   t);
    req_b = t.req;
  //write function to capture trans_c
  virtual function void write_transaction_C(trans_c   t);
    req_c = t.req;
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. 


Link to comment
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

  • Create New...