Veamos el siguiente ejemplo:
1 2 3 4 5 6 7 |
bit [1:0] b; enum{a,b,c} letter; covergroup cg @(negedge clk); bcov: coverpoint b; lettercov: coverpoint letter; endgroup |
- En principio, cuando se muestrea las variables “b” y “letter” se crea 4 “bins” para bcov, 3 para lettercov (uno por cada valor posible)
- Para tipos de datos de 4 valores lógicos, X y Z nunca se graban
- Los “bins” son como contadores: cada vez que se activa el grupo de cobertura , el “bin” se incrementa en uno.
“Automatic bins”
Estos “bins” son automáticamente creados y tienen un límite cuando los casos posibles para la variable afectada son muy elevados (por ejemplo un entero).
- Hay un número máximo de “automatically-created bins”, por defecto 1024. Si el número de valores que puede tomar un punto de cobertura es superior a 1024, el conjunto de todos los valores posibles se “distribuye” automáticamente
- En este caso se crearán 1024 contenedores – with MAXINT=2^32:
- [0 , … , MAXINT/1024-1]
- [MAXINT/1024 , … , 2*MAXINT/1024-1]
- …
- [1022*MAXINT/1024 , … , 1023*MAXINT/1024-1]
- [1023*MAXINT/1024 , … , MAXINT-1]
Definición manual de bins
Veamos el siguiente ejemplo:
1 2 3 4 5 6 7 8 9 10 11 |
bit [9:0] v_a; covergroup cg @(negedge clk); coverpoint v_a { bins a = { [0:63],65 }; // values from 0 to 63 or 65 bins b[] = { 200,201,202 }; // creates 3 bins bins c = { [1000:$] }; // from 1000 to 1023 bins d[] = { [10:14], [16:18]}; // creates 7 bins bins others = default; // everything else } endgroup |
- a: 1 bin, Incrementado si v_a es 65 o está entre 0 y 63
- b: 3 bins, cada uno de ellos se incrementa cuando v_a toma los valores 200, 201, 202
- c: 1 bin, incrementado cuando v_a está entre 1000 y 1023
- d: 8 bins, cada uno de ellos se incrementa cuando v_a toma los valores 10, 11, 12, 13, 14, 16, 17, 18
- otros: 1 bin, incrementado cuando v_a toma cualquier valor que no esté cubierto por los otros “bins”
wildcard bins
wildcard bins a={4’b11xx};
Válido para 1100, 1101, 1110 y 1111
Como símbolo para el “wildcard” podemos usar
- x
- z
- ?
ignore bins
1 2 3 4 5 6 7 8 |
covergroup cg @(negedge clk); coverpoint v_a { ignore_bins ib = {0, 1, 2}; bins three ={3}; bins four = {4}; } endgroup |
No nos importa cuando v_a toma los valores 0, 1, 2 .
- Estos valores se excluyen de la cobertura
- La herramienta no señalará ninguna falta de cobertura si v_a nunca fue 0, 1 o 2.
- Si v_a nunca fue 3 entonces ese “bin” esta no cubierto – coverage hole
- Puede ser útil para los valores que el banco de pruebas nunca debe generar
- Ejemplo: el banco de pruebas genera números pares aleatorios, todos los números impares se pueden definir como ignore_bins.
illegal bins
1 2 3 4 5 6 7 8 |
covergroup cg @(negedge clk); coverpoint v_a { illegal_bins ib = {0, 1, 2}; bins three ={3}; bins four = {4}; } endgroup |
Si v_a toma los valores 0, 1 o 2 obtenemos un error en tiempo de ejecución.
- Puede ser útil para los valores que el DUT nunca debe generar
- Ejemplo: si el DUT debe dar en la salida un número par, todos los números impares se pueden definir como illegal_bins. Si se encuentra un número impar, significa que hay un error en el DUT.
Cross coverage
Veamos el siguiente ejemplo:
1 2 3 4 5 |
bit [3:0] a, b; covergroup cov @(posedge clk); aXb : cross a, b; endgroup |
16×16 automatic bins, una por cada combinación de valores de a y b
- ¿cuántas veces a fue 0 y b fue 0 en el mismo ciclo?
- ¿cuántas veces a fue 0 y b fue 1 en el mismo ciclo?
- …
- ¿cuántas veces a fue 15 y b fue 14 en el mismo ciclo?
- ¿cuántas veces a fue 15 y b fue 15 en el mismo ciclo?
“Automatic cross bins”
cross entre varias variables
1 2 3 4 5 6 7 8 9 |
enum { red, green, blue } color; bit [3:0] pixel_adr, pixel_offset, pixel_hue; covergroup g2 @(posedge clk); Hue: coverpoint pixel_hue; // 16 bins Offset: coverpoint pixel_offset; // 16 bins AxC: cross color, pixel_adr; // 3*16 bins all: cross color, Hue, Offset; // 3*16*16 bins endgroup |
cross entre una variable y un coverpoint
1 2 3 4 5 6 |
bit [31:0] a_var; bit [3:0] b_var; covergroup cov3 @(posedge clk); A: coverpoint a_var { bins yy[] = { [0:9] }; } CC: cross b_var, A; endgroup |
Tenemos 16×10 bins en CC.
“Manual cross bins”
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
bit [7:0] v_a, v_b; covergroup cg @(posedge clk); a: coverpoint v_a { bins a1 = { [0:63] }; bins a2 = { [64:127] }; bins a3 = { [128:191] }; bins a4 = { [192:255] }; } b: coverpoint v_b { bins b1 = {0}; bins b2 = { [1:84] }; bins b3 = { [85:169] }; bins b4 = { [170:255] }; } c : cross a, b { // 16 bins bins c1 = !binsof(a.a4); // 12 bins illegal_bins c2 = binsof(a.a2) || binsof(b.b2);// 7 cross products ignore_bins c3 = binsof(a.a1) && binsof(b.b4);// 1 cross product } endgroup |
Bins de transiciones
Hasta ahora hemos muestreado situaciones monociclo de las variables implicadas en coverpoints y cross. Pero los bins a cubrir, podrían hacer referencias a situaciones multiciclo
bins a = (value1 => value2;
- cuenta cuántas veces la variable tenía valor1 y en el siguiente tiempo de muestreo tenía valor2
bins a = (1 => 3 => 4);
- cuenta cuántas veces variable tenía valor 1, entonces 3, entonces 4.
bins a = (1,5 => 6, 7);
- cuenta cuántas veces la variable tenía valor 1 o 5 y luego tenia el valor 6 o 7 (transiciones 1=>6, 1=>7, 5=>6, 5=>7)
bins sa = (4 => 5 => 6), ([7:9],10=>11,12);
- Un bin que es incrementado para las siguientes transiciones:
- 4=>5=>6
- 7=>11
- 8=>11
- 9=>11
- 10=>11
- 7=>12
- 8=>12
- 9=>12
- 10=>12
bins sa [] = (4 => 5 => 6), ([7:9],10=>11,12);
- 9 bins que son incrementados para las siguientes transiciones:
- 4=>5=>6
- 7=>11
- 8=>11
- 9=>11
- 10=>11
- 7=>12
- 8=>12
- 9=>12
- 10=>12
wildcard bins T0 = (2’b0x => 2’b1x);
- Este Bin se incrementa si tenenos las siguientes transiciones
- 00 => 10;
- 01 => 10;
- 00 => 11;
- 01 => 10;
illegal_bins bad_trans = (4=>5=>6);
ignore_bins bad_trans = (4=>5=>6);
bins sa = (3 [* 3])
- es equivalente a (3 => 3 => 3)
- Note: si tenemos cuatro 3 consecutivos, entonces el “bin” se incrementará en dos: SOLAPAMIENTO
- (3 [*3:5]) es equivalente a (3 => 3 => 3), (3 => 3 => 3 => 3), (3 => 3 => 3 => 3 => 3)
bins sa = (2 => 3 [* 3] => 1)
- es equivalente a
- (2 => 3 => 3 => 3 => 1)
bins sa = (1 => 3 [*3:5]) 3] => 1)
- es equivalente a
- (1=>3=>3=>3),(1=>3=>3=>3=>3),(1=>3=>3=>3=>3=>3)
bins sa = (1 => 3 [*4:$] => 2)
- es equivalente a
- que hay un 1 seguido de al menos 4 veces un 3, seguido de un 2.
bins sa = 1=>3 [-> 3]=>5
- es equivalente a
- 1=>…=>3=>…=>3=>…=>3=>5