Methods to get bins name with hit counts

[suchi2108]

Hi All,

I have looked into the documentation to find way to print bins name with their hit counts. (P.S:- I even digged into source code, it's difficult to conclude). Is there any way out ?

[mballance]

You should be able to see the bin name and their counts when creating a text coverage report. See: https://pyvsc.readthedocs.io/en/latest/coverage.html#coverage-reports

[suchi2108]

Yes, I can see that in the coverage report. But I would like to get bin information with each time it's sampled and collect it for further computation. Can I please guide me if that is possible ?

[mballance]

Hmm... This may be a use case that the PyVSC coverage model is not designed to support. From your response, I understand that you want to register a Python method callback that is called when a bit hit occurs. Is this the case?

[suchi2108]

Yes exactly! It would be great if it's supported. Otherwise I need to write a method on my own.

[mballance]

Let me give this a little thought. A first step might be a utility class implemented on top of the library (ie not deeply-integrated)

[mballance]

I created a simple utility class that can be used as the base class for a covergroup. You can register a callback function with this class and be notified whenever a bin is hit. Have a look at the test here:

pyvsc/ve/unit/test_covergroup_sampling.py

Lines 224 to 269 in cec1810

	def test_object_sample_cb_1(self):
	import vsc
	@vsc.randobj
	class BranchInstr:
	def __init__(self):
	self.type = vsc.rand_bit_t(1)
	self.disp = vsc.rand_bit_t(19)
	@vsc.constraint
	def short_offset_cnstr(self):
	self.disp <= 4096
	def __str__(self):
	return(f"type = {self.type}, displacement = {self.disp}")
	# Note: Covergroup must inherit from CovergroupCallbackBase
	@vsc.covergroup
	class BranchInstr_cg(vsc.util.CovergroupCallbackBase):
	def __init__(self):
	super().__init__()
	self.with_sample(
	item = BranchInstr()
	)
	self.type = vsc.coverpoint(self.item.type)
	self.disp_cp = vsc.coverpoint(self.item.disp, bins = {
	"small_pos" : vsc.bin_array([4], [0, 4096])
	})
	branchInstr = BranchInstr()
	branchInstr_cg = BranchInstr_cg()
	# Note: Callback function accepts bin name and new hit count
	def callback(bin, hit):
	print("Hit: %s %d" % (bin, hit))
	# Note: Register the callback with the covergroup
	branchInstr_cg.set_cb(callback)
	for i in range(32):
	branchInstr.randomize()
	# Note: Call 'sample_cb' instead of 'sample'
	branchInstr_cg.sample_cb(branchInstr)
	print(branchInstr)

Let me know if this is the type of functionality that you're requesting.

[suchi2108]

Yes, it works perfectly :) Thank you!

[mballance]

By the way, the 'Note' comments in the test above highlight the key steps needed to make it work properly

[suchi2108]

Hi Matthew,

I am not sure, it is a bug, or something wrong I am doing. The bin name is calculated wrong with the above callback function.

I have added a coverage model, which covers a, b, op. The op bin count is fine, but a and b have issues.

cp_dict = {
'cp_a': {'bin_num':7},
'cp_b': {'bin_num':7},
'cp_op':{'bin_num':8}
}

@vsc.covergroup
class my_covergroup(CovergroupCallbackBase):
def init(self):
super().init()
self.with_sample(
a=vsc.uint32_t(),
b=vsc.uint32_t(),
op=vsc.bit_t(3)
)
self.cp_a = vsc.coverpoint(self.a, bins={
"bin" : vsc.bin_array([cp_dict['cp_a']['bin_num']],
[1, 866],
[867, 1300000000],
[1300000000, 1456798755],
[1456798756, 2456798755],
[2456798756, 3099999999],
[3100000000, 3294967294],
[3294967295, 4294967295])
})
self.cp_b = vsc.coverpoint(self.b, bins={
"bin" : vsc.bin_array([cp_dict['cp_b']['bin_num']],
[1, 866],
[867, 1300000000],
[1300000000, 1456798755],
[1456798756, 2456798755],
[2456798756, 3099999999],
[3100000000, 3294967294],
[3294967295, 4294967295])
})
self.cp_op = vsc.coverpoint(self.op, bins={
"bin" : vsc.bin_array([cp_dict['cp_op']['bin_num']],
[0, 7])
})

The log shows, even the a or b value do not lie in coverpoint array, callback function says bin[0] is covered in both cases.

Can you please suggest me something ?

[mballance]

Hi Suruchi,
As written, the coverpoint bins for 'a' and 'b' will be created by concatenating the specified value ranges then partitioning them based on the specified number of bins. This will cause the first bin to cover the first 536,870,912 values, which includes 136956257.
You mention that you don't expect the sampled value to fall in any bin. This makes me wonder whether you need to specify a list of individual values instead of a list of value ranges when defining the bin.
Please provide a bit more detail on what you intend to describe, and we can determine what PyVSC API calls need to be used.

Thanks,
Matthew

[suchi2108]

Hi Matthew,

Thank you for reply! Before I thought, the bin ranges I have defined in the bin array, will allow me to have multiple bins (in above case, 7 bins) and if the sampled value falls in those ranges, the particular bins would be hit. But I guess that is not the case.

Previously, I meant the sampled value 136956257 falls in cp_a.bin[1], but cp_a.bin[0] was hit. So I thought there is some issue with API.

Although I have fixed my concern using according to your answer, using indiviual bins, instead of bin array. But I would still like to know how bin array is working with my defined model. Also ' 536,870,912 values' as mentioned in your answer, how is it calculated ?