| Login | | Don't have an account yet? You can create one. As a registered user you have some advantages like theme manager, comments configuration and post comments with your name. | |
| Who's Online | There are currently, 64 guest(s) and 0 member(s) that are online.
You are Anonymous user. You can register for free by clicking here | |
 | |
|
Verification Guild: Forums |
|
| View previous topic :: View next topic |
| Author |
Message |
charleslll
Senior
Joined: May 12, 2009
Posts: 27
|
 Posted: Tue Jan 31, 2012 2:55 am Post subject: Question for observation of the signals buried in the DUT |
 |
|
Hi, everyone, I have one question about the observation for the group of signals buried in the DUT. I want to monitor them, and when they are valid, I want to sample them into transaction and pass them directly to the scoreboard in order to check the part functions of the DUT correctness.
Since this group of signals are deeply buried in the DUT, if I do some stimulus via interface (boundary of the DUT), it's cumbersome and difficult. Because there are so many kinds of stimulus that will trigger this group of signals, whereas I have to build several channels(each belongs to one kind of stimulus) to connect to the scoreboard. It will brings a lot of work to build the testbench. While now, in the constrast, I just want to directly grab and sample this group signals inside of the DUT and send the corresponding transaction (by some way of sampling, I'm not sure how to do this actually) directly into the scoreboard.
Therefore, my question has 3 part:
1. How to sample this group of signal and transform them into transaction?
2. Is there any other way to handle this situation?
3. Is it a good way? It seems not comply with the rule of OVM or other methodology. Do u have better plan for this? |
|
| Back to top |
|
 |
mog70
Senior
Joined: Feb 25, 2005
Posts: 26
|
| Posted: Sun Mar 04, 2012 12:41 pm Post subject: |
|
|
I have encountered similar situations, where I wanted to capture some internal DUT signals and pass that info to the scoreboard.
A simple mechanism I have used works something like this:
* Inside the DUT module of interest, I have code:
| Code: |
`ifdef SIMULATION
always @(transaction valid) begin
<Top level testbench hierarchy>.report_transaction(trans_addr, trans_len, trans_data,...);
end
`endif
|
* At the top level of my testbench, I have:
| Code: |
// Global vars
trans_obj trans;
bit trans_for_scoreboard_valid = 0;
task report_transaction(instance_num, trans_addr, trans_len, trans_data, ...);
// Copy info over to global transaction
trans.addr = trans_addr;
trans.len = trans_len;
trans.addr = trans_addr;
for (int i=0;i<trans_len;i++) begin
trans.data[i] = trans_data[i];
end
...
// Assert valid so that scoreboard knows we got something...
trans_for_scoreboard_valid = 1;
trans_for_scoreboard_valid = 0;
endtask
|
* Finally, in my scoreboard, I have:
| Code: |
always @(posedge <Top Level Testbench Hierarchy>.trans_for_scoreboard_valid) begin
`ovm_info(get_type_name(),"Transaction seen at DUT:",OVM_LOW)
<Top Level Testbench Hierarchy>.trans.print();
...
|
Keep in mind that I haven't compiled the code above, so maybe some syntax errors etc. This is a simple examlpe to demonstrate the concept, but there are some extensions that make it much better:
* Instead of having a single transaction at the top-level, you can have a SV queue, so that multiple transactions can be pushed onto the queue simultaneously, and there are no race conditions.
* In addition to passing the transaction to the top-level, you can also pass information about the instance that is passing the transaction up to the scoreboard. Imagine you have N instances inside your DUT that could be receiving a transaction at any time. If you pass the instance number (0 thru N-1) in the report_transaction() task, you can display and route it properly in the scoreboard.
Hope this is useful --
Dan S. |
|
| Back to top |
|
|
dave_59
Senior
Joined: Jun 22, 2004
Posts: 974
Location: Fremont, CA
|
| Posted: Sun Mar 04, 2012 4:34 pm Post subject: |
|
|
My DVCon paper addresses this and has an example using the UVM in the appendix. The only thing different from OVM is it uses the uvm_config_db instead of wrapping a handle on an ovm_object.
http://events.dvcon.org/2012/proceedings/papers/01P_3.pdf |
|
| Back to top |
|
|
|
|
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum
|
| |
|
|
Forum FAQ
Search
Usergroups
Profile
Digest
Log in
