Coverpoints y cross – Rincón de SystemVerilog

Veamos el siguiente ejemplo:

bit [1:0] b;
enum{a,b,c} letter;

covergroup cg @(negedge clk);
  bcov: coverpoint b;
  lettercov: coverpoint letter;
endgroup

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:

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

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

ignore bins

covergroup cg @(negedge clk);
  coverpoint v_a
  {
    ignore_bins ib = {0, 1, 2};
    bins three ={3};
    bins four = {4};
  }
endgroup

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

covergroup cg @(negedge clk);
  coverpoint v_a
  {
    illegal_bins ib = {0, 1, 2};
    bins three ={3};
    bins four = {4};
  }
endgroup

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:

bit [3:0] a, b;

covergroup cov @(posedge clk);
  aXb : cross a, b;
endgroup

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

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

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

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

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”

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

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