Coverpoints y cross

Contenidos mostrar

Veamos el siguiente ejemplo:

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
  • 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

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

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

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

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

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

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