'covergroup' and 'coverpoint'

SystemVerilog Assertions and Functional Coverage From Scratch SystemVerilog Functional Coverage Language Features
12 minutes
Share the link to this page
Copied
  Completed
You need to have access to the item to view this lesson.
One-time Fee
$39.95
List Price:  $149.95
You save:  $110
₹1,480
List Price:  ₹9,995
You save:  ₹8,515
€36.82
List Price:  €138.22
You save:  €101.39
£31.35
List Price:  £117.69
You save:  £86.33
CA$54.61
List Price:  CA$205
You save:  CA$150.38
A$60.23
List Price:  A$226.10
You save:  A$165.86
S$53.93
List Price:  S$202.44
You save:  S$148.51
HK$311.97
List Price:  HK$1,170.98
You save:  HK$859.01
CHF 36.57
List Price:  CHF 137.29
You save:  CHF 100.71
NOK kr422.78
List Price:  NOK kr1,586.89
You save:  NOK kr1,164.11
DKK kr274.91
List Price:  DKK kr1,031.86
You save:  DKK kr756.95
NZ$65.26
List Price:  NZ$244.95
You save:  NZ$179.69
د.إ146.73
List Price:  د.إ550.76
You save:  د.إ404.03
৳4,680.55
List Price:  ৳17,568.19
You save:  ৳12,887.63
RM187.94
List Price:  RM705.43
You save:  RM517.49
₦58,378.88
List Price:  ₦219,121.76
You save:  ₦160,742.87
₨11,100.64
List Price:  ₨41,665.63
You save:  ₨30,564.99
฿1,461.83
List Price:  ฿5,486.92
You save:  ฿4,025.08
₺1,286.90
List Price:  ₺4,830.33
You save:  ₺3,543.42
B$206.42
List Price:  B$774.80
You save:  B$568.38
R735.85
List Price:  R2,761.99
You save:  R2,026.14
Лв71.98
List Price:  Лв270.20
You save:  Лв198.21
₩54,599.66
List Price:  ₩204,936.66
You save:  ₩150,337
₪146.18
List Price:  ₪548.70
You save:  ₪402.51
₱2,325.26
List Price:  ₱8,727.76
You save:  ₱6,402.49
¥6,269.95
List Price:  ¥23,533.90
You save:  ¥17,263.95
MX$667.15
List Price:  MX$2,504.13
You save:  MX$1,836.97
QR145.50
List Price:  QR546.15
You save:  QR400.64
P542.15
List Price:  P2,034.93
You save:  P1,492.78
KSh5,207.28
List Price:  KSh19,545.24
You save:  KSh14,337.95
E£1,882.63
List Price:  E£7,066.37
You save:  E£5,183.73
ብር2,292.75
List Price:  ብር8,605.70
You save:  ብር6,312.95
Kz33,891.94
List Price:  Kz127,211.43
You save:  Kz93,319.49
CLP$36,219.86
List Price:  CLP$135,949.16
You save:  CLP$99,729.30
CN¥284.06
List Price:  CN¥1,066.21
You save:  CN¥782.15
RD$2,349.84
List Price:  RD$8,820.01
You save:  RD$6,470.17
DA5,371.51
List Price:  DA20,161.67
You save:  DA14,790.16
FJ$90.59
List Price:  FJ$340.03
You save:  FJ$249.44
Q309.96
List Price:  Q1,163.43
You save:  Q853.46
GY$8,348.51
List Price:  GY$31,335.65
You save:  GY$22,987.14
ISK kr5,521.09
List Price:  ISK kr20,723.09
You save:  ISK kr15,202
DH398.02
List Price:  DH1,493.97
You save:  DH1,095.94
L707.89
List Price:  L2,657.05
You save:  L1,949.15
ден2,267.94
List Price:  ден8,512.61
You save:  ден6,244.66
MOP$321.11
List Price:  MOP$1,205.29
You save:  MOP$884.17
N$733.36
List Price:  N$2,752.65
You save:  N$2,019.28
C$1,468.65
List Price:  C$5,512.51
You save:  C$4,043.85
रु5,306.59
List Price:  रु19,917.99
You save:  रु14,611.39
S/149.17
List Price:  S/559.92
You save:  S/410.75
K155.07
List Price:  K582.06
You save:  K426.98
SAR149.80
List Price:  SAR562.28
You save:  SAR412.47
ZK1,065.01
List Price:  ZK3,997.46
You save:  ZK2,932.45
L183.21
List Price:  L687.70
You save:  L504.48
Kč907.36
List Price:  Kč3,405.72
You save:  Kč2,498.36
Ft14,132.58
List Price:  Ft53,045.85
You save:  Ft38,913.26
SEK kr426.20
List Price:  SEK kr1,599.72
You save:  SEK kr1,173.52
ARS$35,575.87
List Price:  ARS$133,531.97
You save:  ARS$97,956.09
Bs275.73
List Price:  Bs1,034.94
You save:  Bs759.21
COP$154,396.52
List Price:  COP$579,518.37
You save:  COP$425,121.85
₡20,458.11
List Price:  ₡76,788.33
You save:  ₡56,330.22
L986.09
List Price:  L3,701.25
You save:  L2,715.16
₲300,135.95
List Price:  ₲1,126,542.82
You save:  ₲826,406.87
$U1,535.64
List Price:  $U5,763.95
You save:  $U4,228.31
zł156.61
List Price:  zł587.85
You save:  zł431.23
Subscription
$149.95
$39.95
per week
Payment Plan
$149.96
$39.95
per week
4 payments
Already have an account? Log In

Transcript

Hello and welcome to lecture number three. In this lecture we will cover the fundamentals of this language mainly the cover group and the cover point. Okay, let's start with the basics of a cover group. If you look at this particular blog, what I'm doing is first you have to declare a cover group with the keyword cover group. And you also need to provide it with a name a label, so to say, and it is required, you cannot omit the name and and then you also need to provide it with a sampling edge. This sampling edges when the cover points and bins of these cover groups will be sampled, or in other words evaluated to see if they have been covered.

So the sampling edge is required but in case Let's say you omit the sampling age then you have to procedurally trigger the coverage sampling using a built in method called sample. And I will show an example in upcoming lectures on how you can do that. But I personally suggest that always provide a sampling age. Also, the sampling as should be meaningful here, I'm simply giving it a clock that means that every pauses of clock evaluate to see if your score points have been covered. But you can have more meaningful edges as I will show you in one of the examples. So declare a cover group give it a name, provide a sampling edge.

Now inside this cover group, you have to provide cover points, cover points for the variables of your design. And here I'm saying cover point offset. offset is a variable to meet variable and now also saying cover using the keyboard cover point address. Which is also a variable a big wide and you're you may or you may not provide labels to these PowerPoints, I very highly recommend that you provide the labels meaningful labels, if you don't provide this labels in the simulator will provide its own naming convention, which I can assure you will not make much sense to you. So after you declare the PowerPoints, you enter group with the keyboard and group and then you have to instantiate this group until then the memory won't be allocated for it and the cover group is simply sit there. So we take the cover group name, we give it an instance name and equal to new and new This is a very basic way you women insane share the class.

So this is where we instantiate a cover group. Now these are very basic points of how you Get going, declaring a cover group. And we can see a lot more detail on this. One final note here is that if you do not provide any cover points in the core cover group, then the covered rope is basically meaningless. It's not going to cover anything. But the bad part is the compilers normally don't give you any warnings or errors when the cover group is empty, because you make it empty for a while.

And later, you can put some more points in it. So compiler doesn't want to give you unnecessary warnings or errors. So this is basically fundamentals of a covered group. Let's continue with the same core group and I'm only showing one variable of set. The goal group has been defined here. And here's our point offset.

And you can provide a condition saying that if and only if reset is not asserted that this PowerPoint should be evaluated. To see if it has been covered, which makes sense because during the reset, we're really not doing anything the design is still under the reset condition. The other thing I'm showing here is two squiggly brackets. In the earlier slide, you didn't see those, which is fine. And I will tell you what happens if you don't put those in the upcoming slides. But if you do put the squiggly brackets, it means that you haven't specified explicit bins.

Now you don't know what a bin is. But basically a bin is something where you collect the coverage information. So for example, when I put this squiggly brackets, it basically says that create four automatically generated means why four because offset is two bit wide. So in in auto, auto means zero. This is the name that the simulator will provide because I'm not saying anything about the base. I'm just saying create as many bins as necessary, because I'm providing this tool squiggly brackets.

So it creates four bins in named Sam, you can end up being yourself as we'll see in upcoming slides. And you base the similar basically says auto bin zero we'll cover offset zero or been one, we'll keep track of how many times offset one has been covered and so on and so forth. So, we have introduced you to new concepts here. One is the reset condition control condition as I call it, and also a very high level view of how you can provide or as a simulator to create explicit veins. Now here's a log that comes from one of the popular simulators your simulator may be different and the log may look different. But here basically the simulator created for auto been zero 123 and this log shows that they have been covered thousands of times which is rather redundant, but this is just an example.

And it says that the all the core points have been covered. And hence the covered group also have been covered 100%. So at the end of the day, we need to make sure that the cover group is covered, and if not, we need to look at the bins and the PowerPoint. In this case, everything is covered. Now, let's look at an example of how we can use a PowerPoint. So, I have an enum and I'm from the old fashioned parallel PCI bus service you may or may not be familiar with.

But a PCI bus has a lot of different cycle types. I ag IO read I write memory, read, memorize, so on and so forth. So I've created an enum with this 12 different Second types and give it a name, PCI commands. Then I create a cover group and give it a name PCI commands underscore cover, always give a meaningful name. And as I was just telling you the sampling edge also should be meaningful. I could have said add pauses of clock here, but then it is very redundant and it will slow down my simulation.

So what I'm doing is always a negative frame. What in the PC or the PCI cycle starts at the negative of the frame? So what I'm saying is that the edge of the frame, evaluate this PowerPoint called PowerPoint for the nm PC commands. Here is a PCI commands, goer evaluate PCI command to see if it has been covered. And I've given it a meaningful label. We can say you should.

So you you can now see that the How you can cover all possible cycles of this particular verse, PCI command and byte enable bus. Now again, I'm not providing it any beans because I haven't discussed beans yet, but if you don't provide any bids, simply put a semicolon there or two squiggly brackets as I just showed you. Then implicit set of 12 auto generated beans are created for 12 values in the enumerated IP segments. So basically, whenever you cover point, a given variable, and don't tell doesn't matter what kind of beans you want to create, it will create all possible beans based on the width of this variable. In this case, it's an enum time so the number of enums enum values you have in this particular enum type, so it will create 12 of those. Now this is again basic of how you can start with some coverage.

Now, some of you who are familiar with code coverage may say wait a minute, code coverage also covers enum type. So why do I need this cover group and the whole functional coverage code and everything? The answer is yes, code coverage will cover these two. but bear with me. What I'm going to do is I'm going to take the same example and then expand it and expand it further, so that you will see how effective your functional coverage becomes. And that's where you will see the code coverage will fail.

I some more points on goer groups. So back to the same goer group but what I've now done is I have parameterised the cover group of each I highly recommend because you may create certain cover groups and then you can instantiate it multiple times for different values. So I have in claw Hi, and big 720 address of reference type. And I'll tell you why you need a reference type here. And my sampling edges and pauses of code. Inside the cover group, I'm saying cover point address name or take our point.

And inside this God mind is the first time I'm trying to do some bins which again, bear with me We will discuss in detail. I'm saying in this ADR bin goer the address at r1 from low to high and I'm what I'm doing is when I insane shed, like we discussed that all the girls intervene Sanchez. I'm gonna take the same code group and instantiate it twice. And at one time, I'm going Give it zero to 127. And I'm going to give it 80 or 180, or one is this particular variable that we declared here. Note that in our group, I have a generic name called address.

And that's why I'm saying called mind address. But when I instantiate I'm going to give you the real name of the variable that's in the in the design. Now, the reason for the ref type is because address one and address two are variables, they are not constants. So if you have which makes sense. You have multiple instances with the variables, then you have to declare the formal as of as of type reference. So that's all pretty much it here.

You can, you should as a matter of fact, as part of your methodology, create what I call generic cover groups, and then use them multiple times rather than creating a new cover group for different addresses and different low to high bins that you want. Cover. So that's all folks, this is rather straightforward. We have seen how to declare a cover group, how to declare a cover point, what's the sampling age that you need to provide to make sure that you sample or evaluate the variables at the right time. Thanks a lot for your time and I'll see you in the next lecture.

Sign Up

Share

Share with friends, get 20% off
Invite your friends to LearnDesk learning marketplace. For each purchase they make, you get 20% off (upto $10) on your next purchase.