Functional Coverage 53g5

Functional Coverage

• Code Coverage • Functional Coverage

Covergroup The covergroup is just like defined type construct that encapsulates and specifies coverage. Each covergroup specification can include the following components: A clocking event that synchronizes the sampling of coverage points 1. A set of coverage points 2.Cross coverage between coverage points 3.Optional formal arguments 4.Coverage options It can be defined in a package, module, program,interface or class. 􀂊 Once defined multiple instances can be created using new covergroup cg; -- -endgroup cg cg_inst = new; // cg_inst is instance of covergroup cg using new operator

SAMPLE Coverage should be triggered to sample the coverage values. Sampling can be done using 1. Any event expression -edge, variable 2. End-point of a sequence 3. Event can be omitted 4. Calling sample() method.

1. Any event expression -edge, variable covergroup cg @(posedge clk); ... ... ... endgroup

The above example defines a covergroup named "cg". This covergroup will be automatically sampled each time there is a posedge on "clk" signal.

• covergroup cg; ... ... ... endgroup cg cg_inst = new; initial // or task or function or always block begin ... ...

cg_inst.sample(); ... ... end

Sampling can also be done by calling explicitly calling .sample() method in procedural code. This is used when coverage sampling is required based on some calculations rather than events.

• COVER POINTS • A covergroup can contain one or more coverage points. • A coverage point can be an integral variable or an integral expression. • A coverage point creates a hierarchical scope, and can be optionally labeled. If the label is specified then it designates the name of the coverage point.

• program main; bit [0:2] y; bit [0:2] values[$]= '{3,5,6}; covergroup cg; cover_point_y : coverpoint y; endgroup cg cg_inst = new(); initial foreach(values[i]) begin y = values[i]; cg_inst.sample(); end

endprogram

• In the above example, we are sampleing the cover point "y". The value of "y" is sampled when cg_inst.sample() method is called. • Total possible values for Y are 0,1,2,3,4,5,6,7. • The variable "y" is assigned only values 3,5,6. • The coverage engine should report that only 3 values are covered and there are 8 possible values.

• Report: VARIABLE : cover_point_y Expected : 8 Covered : 3 Percent : 37.50.

• NCSIM ncverilog -sv -access +rwc -coverage functional filename.sv iccr iccr.cmd iccr.cmd load_test * report_detail -instance -both -d *

•

Coverpoint Expression

A coverage point can be an integral variable or an integral Expression. SystemVerilog allows specifying the cover points in various ways. 1)Using XMR

Cover_xmr : coverpoint top.DUT.Submodule.bus_address; 2)Part select

Cover_part: coverpoint bus_address[31:2]; 3)Expression

Cocver_exp: coverpoint (a*b); 4)Function return value

Cover_fun: coverpoint funcation_call(); 5)Ref variable

covergroup (ref int r_v) cg; cover_ref: coverpoint r_v; endgroup

• Coverage Filter The expression within the iff construct specifies an optional condition that disables coverage for that cover point. If the guard expression evaluates to false at a sampling point, the coverage point is ignored. For example:

covergroup cg; coverpoint _varib iff(!reset); // filter condition endgroup

In the preceding example, cover point varible "_varib" is covered only if the value reset is low.

• GENERIC COVERAGE GROUPS Generic coverage groups can be written by ing their traits as arguments to the coverage constructor. This allows creating a reusable coverage group which can be used in multiple places.

For example, To cover a array of specified index range. covergroup cg(ref int array, int low, int high ) @(clk); coverpoint// sample variable ed by reference { bins s = { [low : high] }; } endgroup int A, B; rgc1 = new( A, 0, 50 );// cover A in range 0 to 50 rgc2 = new( B, 120, 600 );// cover B in range 120 to 600

• The example above defines a coverage group, gc, in which the signal to be sampled as well as the extent of the coverage bins are specified as arguments. Later, two instances of the coverage group are created; each instance samples a different signal and covers a different range of values.

• A coverage-point bin associates a name and a count with 1.a set of values or 2. a sequence of value transitions. If the bin designates a set of values, the count is incremented every time the coverage point matches one of the values in the set. If the bin designates a sequence of value transitions, the count is incremented every time the coverage point matches the entire sequence of value transitions. Bins can be created implicitly or explicitly.

• Implicit Bins While define cover point, if you do not specify any bins, then Implicit bins are created. The number of bins creating can be controlled by auto_bin_max parameter.

program main; bit [0:2] y; bit [0:2] values[$]= '{3,5,6}; covergroup cg; cover_point_y : coverpoint y { option.auto_bin_max = 4 ; } endgroup cg cg_inst = new(); initial foreach(values[i]) begin y = values[i]; cg_inst.sample(); end endprogram

•

In the above example, the auto_bin_max is declared as 4. So, the total possible values are divided in 4 parts and each part correspoits to one bin. The total possible values for variable "y" are 8. They are divided in to 4 groups.

Bin[0] for 0 and 1 Bin[1] for 2 and 3 Bin[2] for 4 and 5 Bin[3] for 6 and 7 Varible Y is assigned values 3,5 and 6. Values 3,5 and 6 belongs to bins bin[1],bin[2] and bin[3] respectively. Bin[0] is not covered. • Coverage report: -------------------VARIABLE : cover_point_y Expected : 4 Covered : 3 Percent: 75.00 Uncovered bins -----------------auto[0:1] Covered bins -----------------auto[2:3] auto[4:5] auto[6:7]

• typedef enum { A,B,C,D } alpha; program main; alpha y; alpha values[$]= '{A,B,C}; covergroup cg; cover_point_y : coverpoint y; endgroup cg cg_inst = new(); initial foreach(values[i]) begin y = values[i]; cg_inst.sample(); end endprogram

• In The above example, the variable "y" is enum data type and it can have 4 enum A,B,C and D. Variable Y is assigned only 3 Enum A,B and C.

Coverage report: --------------------VARIABLE : cover_point_y Expected : 4 Covered : 3 Percent: 75.00 Uncovered bins -------------------auto_D Covered bins -------------------auto_C auto_B auto_A

•

EXPLICIT BIN CREATION

Explicit bin creation is recommended method. Not all values are interesting or relevant in a cover point, so when the knows the exact values he is going to cover, he can use explicit bins. You can also name the bins. program main; bit [0:2] y; bit [0:2] values[$]= '{3,5,6}; covergroup cg; cover_point_y : coverpoint y { bins a = {0,1}; bins b = {2,3}; bins c = {4,5}; bins d = {6,7}; } endgroup cg cg_inst = new(); initial foreach(values[i]) begin y = values[i]; cg_inst.sample(); end endprogram

• Coverage report: ------------------VARIABLE : cover_point_y Expected : 4 Covered : 3 Percent: 75.00

Uncovered bins -------------------a Covered bins -------------------b c d

•

Array Of Bins To create a separate bin for each value (an array of bins) the square brackets, [], must follow the bin name. program main; bit [0:2] y; bit [0:2] values[$]= '{3,5,6}; covergroup cg; cover_point_y : coverpoint y { bins a[] = {[0:7]}; } endgroup

• cg cg_inst = new(); initial foreach(values[i]) begin y = values[i]; cg_inst.sample(); end endprogram

• Coverage report: -------------------VARIABLE : cover_point_y Expected : 8 Covered : 3 Percent: 37.50 Uncovered bins ------------------a_0 a_1 a_2 a_4 a_7 Covered bins ------------------a_3 a_5 a_6

•

To create a fixed number of bins for a set of values, a number can be specified inside the square brackets.

program main; bit [0:3] y; bit [0:2] values[$]= '{3,5,6}; covergroup cg; cover_point_y : coverpoint y { bins a[4] = {[0:7]}; } endgroup cg cg_inst = new(); initial foreach(values[i]) begin y = values[i]; cg_inst.sample(); end endprogram

•

In the above example, variable y is 4 bit width vector. Total possible values for this vector are 16. But in the cover point bins, we have giving the interested range as 0 to 7. So the coverage report is calculated over the range 0 to 7 only. In this example, we have shown the number bins to be fixed to size 4.

Coverage report: -------------------VARIABLE : cover_point_y Expected : 4 Covered : 3 Percent: 75.00 Uncovered bins ------------------a[0:1] Covered bins -----------------a[2:3] a[4:5] a[6:7]

•

Default Bin

The default specification defines a bin that is associated with none of the defined value bins. The default bin catches the values of the coverage point that do not lie within any of the defined bins. However, the coverage calculation for a coverage point shall not take into the coverage captured by the default bin. program main; bit [0:3] y; bit [0:2] values[$]= '{3,5,6}; covergroup cg; cover_point_y : coverpoint y { bins a[2] = {[0:4]}; bins d = default; }

endgroup cg cg_inst = new(); initial foreach(values[i]) begin y = values[i]; cg_inst.sample(); end endprogram

•

In the above example, we have specified only 2 bins to cover values from 0 to 4. Rest of values are covered in default bin ~Sd~T which is not using in calculating the coverage percentage.

Coverage report: -------------------VARIABLE : cover_point_y Expected : 2 Covered : 1 Percent: 50.00 Uncovered bins -----------------a[0:1] Covered bins ---------------a[2:4] Default bin ----------------d

• TRANSITION BINS Transitional functional point bin is used to examine the legal transitions of a value. SystemVerilog allows to specifies one or more sets of ordered value transitions of the coverage point. Type of Transitions:

Single Value Transition Sequence Of Transitions Set Of Transitions Consecutive Repetitions Range Of Repetition Goto Repetition Non Consecutive Repetition

•

Single Value Transition Single value transition is specified as: value1 => value2 program main; bit [0:3] y; bit [0:2] values[$]= '{3,5,6}; covergroup cg; cover_point_y : coverpoint y { bins tran_34 = (3=>4); bins tran_56 = (5=>6); } endgroup cg cg_inst = new(); initial foreach(values[i]) begin y = values[i]; cg_inst.sample(); end endprogram

• In the above example, 2 bins are created for covering the transition of point "y" from 3 to 4 and other for 5 to 6. The variable y is given the values and only the transition 5 to 6 is occurring.

Coverage report: -------------------VARIABLE : cover_point_y Expected : 2 Covered : 1 Percent: 50.00 Uncovered bins -----------------tran_34

Covered bins ---------------tran_56

Sequence Of Transitions A sequence of transitions is represented as: value1 => value3 => value4 => value5 In this case, value1 is followed by value3, followed by value4 and followed by value5. A sequence can be of any arbitrary length

•

program main; bit [0:3] y; bit [0:2] values[$]= '{3,5,6}; covergroup cg; cover_point_y : coverpoint y { bins tran_345 = (3=>4>=5); bins tran_356 = (3=>5=>6); } endgroup

•

Coverage report: -------------------VARIABLE : cover_point_y Expected : 2 Covered : 1 Percent: 50.00 Uncovered bins -----------------tran_345 Covered bins ----------------tran_356

• Set Of Transitions A set of transitions can be specified as: range_list1 => range_list2

program main; bit [0:3] y; bit [0:2] values[$]= '{3,5,6}; covergroup cg; cover_point_y : coverpoint y { bins trans[] = (3,4=>5,6); } endgroup

• Consecutive Repetitions Consecutive repetitions of transitions are specified using trans_item [* repeat_range ] Here, trans_item is repeated for repeat_range times. For example, 3 [* 5] is the same as 3=>3=>3=>3=>3

program main; bit [0:3] y; bit [0:2] values[$]= '{3,3,3,4,4}; covergroup cg; cover_point_y : coverpoint y { bins trans_3 = (3[*5]); bins trans_4 = (4[*2]); } endgroup

• Coverage report: -------------------VARIABLE : cover_point_y Expected : 2 Covered : 1 Percent: 50.00

Uncovered bins -----------------trans_3 Covered bins ---------------trans_4

• Range Of Repetition

An example of a range of repetition is: 3 [* 3:5] is the same as 3=>3=>3, 3=>3=>3=>3, 3=>3=>3=>3=>3

program main; bit [0:3] y; bit [0:2] values[$]= '{4,5,3,3,3,3,6,7}; covergroup cg; cover_point_y : coverpoint y { bins trans_3[] = (3[*3:5]); } endgroup

• In the above example, only the sequence 3=>3=>3=>3 is generated. Other expected sequences 3=>3=>3 and 3=>3=>3=>3=>3 are not generated.

Coverage report: -------------------VARIABLE : cover_point_y Expected : 3 Covered : 1 Percent: 33.33 Uncovered bins -----------------tran_3:3[*3] tran_3:3[*5] Covered bins ---------------tran_3:3[*4]

• Goto Repetition The goto repetition is specified using: trans_item [-> repeat_range]. The required number of occurrences of a particular value is specified by the repeat_range. Any number of sample points can occur before the first occurrence of the specified value and any number of sample points can occur between each occurrence of the specified value. The transition following the goto repetition must immediately follow the last occurrence of the repetition. For example: 3 [-> 3] is the same as ...=>3...=>3...=>3 where the dots (...) represent any transition that does not contain the value 3. A goto repetition followed by an additional value is represented as follows: 1 => 3 [ -> 3] => 5 is the same as 1...=>3...=>3...=>3 =>5

program main; bit [0:3] y; bit [0:2] values[$]= '{1,6,3,6,3,6,3,5};

covergroup cg; cover_point_y : coverpoint y { bins trans_3 = (1=>3[->3]=>5); } endgroup Coverage report: -------------------VARIABLE : cover_point_y Expected : 1 Covered : 1 Percent: 100.00

•

Non Consecutive Repetition

The nonconsecutive repetition is specified using: trans_item [= repeat_range]. The required number of occurrences of a particular value is specified by the repeat_range. Any number of sample points can occur before the first occurrence of the specified value and any number of sample points can occur between each occurrence of the specified value. The transition following the nonconsecutive repetition may occur after any number of sample points so long as the repetition value does not occur again. For example: 3 [= 2] is same as ...=>3...=>3 A nonconsecutive repetition followed by an additional value is represented as follows: 1 => 3 [=2] => 5 is the same as 1...=>3...=>3...=>5

• program main; bit [0:3] y; bit [0:2] values[$]= '{1,6,3,6,3,6,5}; covergroup cg; cover_point_y : coverpoint y { bins trans_3 = (1=>3[=2]=>5); } endgroup

• Coverage report: -------------------VARIABLE : cover_point_y Expected : 1 Covered : 1 Percent: 100.00

•

WILDCARD BINS

By default, a value or transition bin definition can specify 4-state values. When a bin definition includes an X or Z, it indicates that the bin count should only be incremented when the sampled value has an X or Z in the same bit positions. The wildcard bins definition causes all X, Z, or ? to be treated as wildcards for 0 or 1 (similar to the ==? operator). For example: wildcard bins g12_16 = { 4'b11?? }; The count of bin g12_16 is incremented when the sampled variable is between 12 and 16: 1100 1101 1110 1111

•

program main; reg [0:3] y; reg [0:3] values[$]= '{ 4'b1100,4'b1101,4'b1110,4'b1111}; covergroup cg; cover_point_y : coverpoint y { wildcard bins g12_15 = { 4'b11?? } ; } endgroup

• Coverage report: -------------------VARIABLE : cover_point_y Expected : 1 Covered : 1 Percent: 100.00 Covered bin --------------g12_15 Number of times g12_15 hit : 4

• IGNORE BINS A set of values or transitions associated with a coverage-point can be explicitly excluded from coverage by specifying them as ignore_bins. program main; bit [0:2] y; bit [0:2] values[$]= '{1,6,3,7,3,4,3,5};

covergroup cg; cover_point_y : coverpoint y { ignore_bins ig = {1,2,3,4,5}; } endgroup

• •

Expected values are 0,6 and 7. Out of these expected Coverage report: -------------------VARIABLE : cover_point_y Expected : 3 Covered : 2 Percent: 66.66 Uncovered bins -----------------auto[0] Excluded/Illegal bins ------------------------auto[1] auto[2] auto[3] auto[4] auto[5]

Covered bins ---------------auto[6] auto[7]

• ILLEGAL BINS A set of values or transitions associated with a coverage-point can be marked as illegal by specifying them as illegal_bins. All values or transitions associated with illegal bins are excluded from coverage. If an illegal value or transition occurs, a runtime error is issued.

program main; bit [0:2] y; bit [0:2] values[$]= '{1,6,3,7,3,4,3,5}; covergroup cg; cover_point_y : coverpoint y { illegal_bins ib = {7}; } endgroup • Result: -----------** ERROR ** Illegal state bin ib of coverpoint cover_point_y in covergroup cg got hit with value 0x7

•

CROSS COVERAGE Cross allows keeping track of information which is received simultaneous on more than one cover point. Cross coverage is specified using the cross construct. program main; bit [0:1] y; bit [0:1] y_values[$]= '{1,3}; bit [0:1] z; bit [0:1] z_values[$]= '{1,2};

•

covergroup cg; cover_point_y : coverpoint y ; cover_point_z : coverpoint z ; cross_yz : cross cover_point_y,cover_point_z ; endgroup cg cg_inst = new(); initial foreach(y_values[i]) begin y = y_values[i]; z = z_values[i]; cg_inst.sample(); end endprogram

• In the above program, y has can have 4 values 0,1,2 and 3 and similarly z can have 4 values 0,1,2 and 3. The cross product of the y and z will be 16 values (00),(01),(02),(03),(10),(11)........(y,z)......(3,2)(3,3) . Only combinations (11) and (32) are generated. Cross coverage report: cover points are not shown. Covered bins ----------------cover_point_y cover_point_z auto[3] auto[2] auto[1] auto[1]

•

ser-Defined Cross Bins

-defined bins for cross coverage are defined using bin select expressions. Consider the following example code: int i,j; covergroup ct; coverpoint i { bins i[] = { [0:1] }; } coverpoint j { bins j[] = { [0:1] }; } x1: cross i,j; x2: cross i,j { bins i_zero = binsof(i) intersect { 0 }; } endgroup Cross x1 has the following bins: Cross x2 has the following bins: i_zero

•

COVERAGE OPTIONS

Options control the behavior of the covergroup, coverpoint, and cross. There are two types of options: those that are specific to an instance of a covergroup and those that specify an option for the covergroup type as a whole. Weight Syntax : weight= number default value: 1 Description : If set at the covergroup syntactic level, it specifies the weight of this covergroup instance for computing the overall instance coverage of the simulation. If set at the coverpoint (or cross) syntactic level, it specifies the weight of a coverpoint (or cross) for computing the instance coverage of the enclosing covergroup. The specified weight shall be a non-negative integral value.

Goal Syntax :goal=number default value: 100 Description : Specifies the target goal for a covergroup instance or for a coverpoint or a cross of an instance.

Name Syntax :name=string default value:unique name Description : Specifies a name for the covergroup instance. If unspecified, a unique name for each instance is automatically generated by the tool.

•

Comment Syntax :comment=string default value: "" Description : A comment that appears with a covergroup instance or with a coverpoint or cross of the covergroup instance. The comment is saved in the coverage database and included in the coverage report. At_least Syntax :at_least=number default value: 1 Minimum number of hits for each bin. A bin with a hit count that is less than number is not considered covered. Detect_overlap Syntax :detect_overlap=Boolean default value: 0 When true, a warning is issued if there is an overlap between the range list (or transition list) of two bins of a coverpoint. Auto_bin_max Syntax :auto_bin_max=number default value: 64 Maximum number of automatically created bins when no bins are explicitly defined for a coverpoint. Cross_num_print_missing Syntax :cross_num_print_missing=number default value: 0 Number of missing (not covered) cross product bins that shall be saved to the coverage database and printed in the coverage report. Per_instance Syntax :per_instance=Boolean default value: 0 Each instance contributes to the overall coverage information for the covergroup type. When true, coverage information for this covergroup instance shall be saved in the coverage database and included in the coverage report. When false, implementations are not required to save instance-specific information. Get_inst_coverage Syntax :get_inst_coverage=Boolean default value: 0 Only applies when the merge_instances type option is set . Enables the tracking of per instance coverage with the get_inst_coverage built-in method. When false, the value returned by get_inst_coverage shall equal the value returned by get_coverage following Table summarizes the syntactical level (covergroup, coverpoint, or cross) in which type options can be specified.

• SYSTEM TASKS

SystemVerilog provides the following system tasks and functions to help manage coverage data collection. $set_coverage_db_name ( name ) : Sets the filename of the coverage database into which coverage information is saved at the end of a simulation run.

$load_coverage_db ( name ) : Load from the given filename the cumulative coverage information for all coverage group types. $get_coverage ( ) : Returns as a real number in the range 0 to 100 the overall coverage of all coverage group types. This number is computed as described above.

•

COVER PROPERTY Cover statement can be used to monitor sequences and other behavioral aspects of the design. The tools can gather information about the evaluation and report the results at the end of simulation. When the property for the cover statement is successful, the statements can specify a coverage function, such as monitoring all paths for a sequence. The statement shall not include any concurrent assert, assume or cover statement. A cover property creates a single cover point. Coverage results are divided into two: coverage for properties, coverage for sequences. For sequence coverage, the statement appears as: Cover property ( sequence_expr ) statement_or_null Cover Property Results The results of coverage statement for a property shall contain: Number of times attempted Number of times succeeded Number of times failed Number of times succeeded because of vacuity In addition, statement_or_null is executed every time a property succeeds. (S) Coverage property can be declared in

•

A design or a separate module Packages Interfaces Program block Cover properties are not allowed in class.

•

Comparison Of Cover Property And Cover Group.

Cover groups can reference data sets where as cover property references a temporal expression. Cover group can be triggered using .sample method () Cover property dont have this option. Cover group has multiple bins options. Cover property has only one bin. Cover group cannot handle complex temporal relationships. Cover properties can cover complex temporal expressions. Cover group automatically handles the crosses. Cover properties cannot do crosses. Cover group has lot of filtering options. Cover property has no specific filtering constructs but it can be filtered. Cover properties cannot be used in classes. Cover groups can be used in classes. So, cover groups can reference the variables in class. Cover groups are most useful at a higher level of abstractions where as cover property makes sense to use when we want to work at low level signals. We can mix cover group and cover property to gain the OO and temporal advantages. Using properties for temporal expressions and trigger the cover group.