Ignores with crosses

[sopanTT]

Hi, I'm struggling with getting a past a seemingly easy coverage issue. I have the two coverpoints below as well as the associated cross-coverpoint. I would like to exclude few bins from the cross-coverpoint. Any ideas ?

Without exclude:
<1,1> : 0
<1,2> : 0 <--remove
<1,4> : 0 <--remove
<1,8> : 0 <--remove
<2,1> : 0
<2,2> : 0
<2,4> : 0<--remove
<2,8> : 0<--remove
<4,1> : 0
<4,2> : 1
<4,4> : 0
<4,8> : 0<--remove
<8,1> : 0
<8,2> : 0
<8,4> : 0
<8,8> : 0
<16,1> : 0
<16,2> : 0
<16,4> : 0
<16,8> : 0
With exclude:
<1,1> : 0
<2,1> : 0
<2,2> : 0
<4,1> : 0
<4,2> : 1
<4,4> : 0
<8,1> : 0
<8,2> : 0
<8,4> : 0
<8,8> : 0
<16,1> : 0
<16,2> : 0
<16,4> : 0
<16,8> : 0

Coverpoint1:
self.cp_doremi = vsc.coverpoint(
self.blah,
bins={"1": vsc.bin(1),
"2": vsc.bin(2),
"4": vsc.bin(4),
"8": vsc.bin(8),
"16": vsc.bin(16)}
)

Coverpoint2:
self.cp_fasolati = vsc.coverpoint(
self.fasolati,
bins={"1": vsc.bin(1),
"2": vsc.bin(2),
"4": vsc.bin(4),
"8": vsc.bin(8)}
)

Cross:
self.cr_doremi_X_fasolati = vsc.cross(
target_l=[self.cp_doremi, self.cp_fasolati]
}

[mballance]

Hi @sopanTT,
While PyVSC supports ignore bins on individual coverpoints, it doesn't currently do so for cross points. It certainly makes sense to enhance the library in this direction, and is just a question of how best to do so. SystemVerilog largely expresses bins to exclude from a cross in terms of intersections between bins of the component coverpoints. Modeling this in Python could be a bit involved, and it may not be what we want from a usability perspective anyway.
I'm thinking a good approach might be to allow the user to specify a filter function for ignore bins. In your case, that might look like this:

self.cr_doremi_X_fasolati = vsc.cross(
  target_l=[self.cp_doremi, self.cp_fasolati],
  ignore_bins=dict(
    exclude_1=my_exclude_func
  )
}

In order to properly filter cross bins, the function might need to know:

• The bin name
• The bin index
• Bin intervals

Let's assume the function will be invoked with one of these objects for each coverpoint from the cross:

def my_exclude_func(doremi, fasolati):
   for d in (1,2,4):
    if doremi.intersect(d) and fasolati.intersect((d << 1)):
      return False
  return True

This function is identifying all combinations where doremi in [1,2,4] and fasolati > doremi.

Do you think this approach would cover your requirements?

Thanks,
Matthew

[sopanTT]

Thanks for the suggestion. Yes, this would be a great start and we can gradually fine-tune the function inputs. As of now, I had to resort to tricks to create the illusion of cross , using coverpoint + cross-bins flattened out, to make progress (See below). I got away with this because the legal cross-space was small.

    self. cp_doremi_X_fasolati = vsc.coverpoint(
        target=lambda: (self.doremi << 8) | self.fasolati,
        bins={
            "1x1": vsc.bin([(1 << 8) | 1, (1 << 8) | 1]),
            "2x1": vsc.bin([(2 << 8) | 1, (2 << 8) | 1]),
            "2x2": vsc.bin([(2 << 8) | 2, (2 << 8) | 2]),
            "4x1": vsc.bin([(4 << 8) | 1, (4 << 8) | 1]),
            "4x2": vsc.bin([(4 << 8) | 2, (4 << 8) | 2]),
            "4x4": vsc.bin([(4 << 8) | 4, (4 << 8) | 4]),
            "8x1": vsc.bin([(8 << 8) | 1, (8 << 8) | 1]),
            "8x2": vsc.bin([(8 << 8) | 2, (8 << 8) | 2]),
            "8x4": vsc.bin([(8 << 8) | 4, (8 << 8) | 4]),
            "8x8": vsc.bin([(8 << 8) | 8, (8 << 8) | 8]),
            "16x1": vsc.bin([(16 << 8) | 1, (16 << 8) | 1]),
            "16x2": vsc.bin([(16 << 8) | 2, (16 << 8) | 2]),
            "16x4": vsc.bin([(16 << 8) | 4, (16 << 8) | 4]),
            "16x8": vsc.bin([(16 << 8) | 8, (16 << 8) | 8])
        }
    )

What's the next step to get this library change going ?

[mballance]

Thanks for the confirmation. I've started looking at the required changes to support this enhancement this evening. Looks like around a calendar week of time to support this. Hopefully this fits your needs.

[mballance]

I just released 0.9.5 that includes support for marking cross-bins as ignore. You can see a test here:

pyvsc/ve/unit/test_coverage_igore_bins.py

Lines 284 to 332 in a82c2bf

	def test_cross_ignore_1(self):
	import sys
	import vsc
	from io import StringIO
	from ucis.xml.xml_factory import XmlFactory
	from ucis.report.text_coverage_report_formatter import TextCoverageReportFormatter
	from ucis.report.coverage_report_builder import CoverageReportBuilder
	def filter(a, b):
	v_set = (1, 2, 4, 8)
	for i,v in enumerate(v_set):
	b_set = v_set[i+1:]
	if len(b_set) and a.intersect(v) and b.intersect(b_set):
	print("Intersect: a: %s ; b: %s" % (str(a.range), str(b.range)))
	return True
	return False
	@vsc.covergroup
	class cg_t(object):
	def __init__(self):
	self.with_sample(dict(
	a=vsc.int8_t(),
	b=vsc.int8_t()))
	self.cp_a = vsc.coverpoint(self.a,
	bins=dict(rng=vsc.bin_array([], 1, 2, 4, 8)))
	self.cp_b = vsc.coverpoint(self.b,
	bins=dict(rng=vsc.bin_array([], 1, 2, 4, 8)))
	self.cr = vsc.cross([self.cp_a, self.cp_b], ignore_bins=dict(b1=filter))
	cg = cg_t()
	i_set = (1, 2, 4, 8)
	for i,iv in enumerate(i_set):
	for j,jv in enumerate(i_set):
	if j <= i:
	print("%d,%d" % (i_set[i], i_set[j]))
	cg.sample(i_set[i], i_set[j])
	out = StringIO()
	vsc.write_coverage_db(out)
	# vsc.report_coverage(details=True)
	db = XmlFactory.read(StringIO(out.getvalue()))
	report = CoverageReportBuilder(db).build(db)
	# Confirm that the ignore bin was properly saved/restored
	self.assertEqual(report.covergroups[0].covergroups[0].crosses[0].coverage, 100.0)
	# self.assertEqual(
	# len(report.covergroups[0].covergroups[0].coverpoints[0].ignore_bins), 1)
	reporter = TextCoverageReportFormatter(report, sys.stdout)
	reporter.details = True
	reporter.report()

[sopanTT]

Hi @mballance , reusing this thread to check the following with you. Does the "cross + ignore" support that you added work with crosses having >2 coverpoints ?

I'm experiencing issues where the bins are all getting filtered out.

Example:

    self.cp_fruit = vsc.coverpoint(
        self.fruit,
        bins = { "Apple":       vsc.bin(Fruit.Apple),
                      "Orange":    vsc.bin(Fruit.Orange),
                      "Peach":      vsc.bin(Fruit.Peach),
                      "Mango":     vsc.bin(Fruit.Mango)}
    )
    self.cp_country = vsc.coverpoint(
        self.country,
        bins = { "Canada":       vsc.bin(Country.Canada),
                      "US":              vsc.bin(Country.US),
                      "Mexico":       vsc.bin(Country.Mexico)}
    )
    self.cp_season = vsc.coverpoint(
        self.season,
        bins = { "Spring":       vsc.bin(Season.Spring),
                      "Summer":    vsc.bin(Season.Summer),
                      "Fall":            vsc.bin(Season.Fall),
                      "Winter":       vsc.bin(Season.Winter)}
    )
    
    self.cr_fruit_country_season = vsc.cross(
        [self.cp_fruit, self.cp_country, self.cp_season],
        ignore_bins=dict(a=ignore_bins_apple_canada_summer)
    )

    def ignore_bins_apple_canada_summer(fruit, country, season):
            if fruit == Fruit.Apple:
               return True
            if country == Country.Canada:  
               return True
            if season == Season.Summer:
               return True  
            return False

[sopanTT]

I think I figured it out. It was most likely the comparison logic within the ignore function which was wrongly done on my end for enums. I will re post here if I'm still stuck