covergroup cg_single_bit with function sample(bit value);
  option.per_instance = 1;
  coverpoint value;
endgroup
class monitor;
  cg_single_bit cg_wdata[16];
  function new();
    foreach(cg_wdata[i])
      cg_wdata[i] = new;
  endfunction
  task monitor_write();
    //...
    foreach(cg_wdata[i])
      cg_wdata[i].sample(sram_vif.wdata[i]);
  endtask
endclass
/////

bit [7:0] v_a, v_b; 
covergroup cg;
  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   {
    bins c1 = ! binsof(a) intersect {[100:200]};// 4 cross products
    bins c2 = binsof(a.a2) || binsof(b.b2);// 7 cross products
    bins c3 = binsof(a.a1) && binsof(b.b4);// 1 cross product
  }
endgroup

cross a, b{
  ignore_bins ignore = binsof(a) intersect { 5, [1:3] };
}
cross x, y{
  illegal_bins illegal = binsof(y) intersect {bad};
}
///

cp_x: coverpoint x{
  bins mod3[] = {[0:255]} with (item % 3 == 0);
}
cp_b: coverpoint b{
  bins func[] = cp_b with (myfunc(item));
}
{
bit [7:0] va, vb; 
covergroup cg;
  cp_a: coverpoint va;
  cp_b: coverpoint vb;
  aXb: cross cp_a,cp_b {
    bins small_ab = aXb with (cp_a+cp_b<100);
  }
endgroup 
///
class sram_monitor;
  virtual sram_interface sram_vif;
  
  covergroup cg_read with function sample(int addr, );
    cp_addr: coverpoint addr {
               bins valid[] = {[0:63]};
               
             }
    cp_addr_region: coverpoint addr{
      bins min = {0};
      bins max = {63};
      bins boundary[] = {1,2,61,62};//4 bins: boundary_1,boundary_2,...
      bins others[] = default;//values not lie within any of the above
    }
  endgroup
  bins fixed[4] = { [1:10], 1, 4, 7 };
  covergroup cg_sram_rw with function sample(mem_rw req);
    cp_rw:    coverpoint req.rw;    
    cp_addr:  coverpoint req.addr {bins valid[] = {[0:63]};}
    cp_wdata: coverpoint req.wdata iff(req.rw==WRITE);
    cp_rdata: coverpoint req.wdata iff(req.rw==READ);
    cp_rw_X_cp_addr: cross cp_rw, cp_addr;
  endgroup
coverpoint a
{
  bins valid[] = {[4:6]};
  ignore_bins ignore_vals = {7,8};
  illegal_bins bad_vals = {1,2,3};
}

endgroup 
  
  function new();
    cg_read = new();
  endfunction
  
  task monitor_read();
    while (1) begin
      @(posedge sram_vif.clk);
      if (sram_vif.cs & (~sram_vif.we)) begin
        $display("@%0t:sample coverage for addr=%0d!", $time(), sram_vif.read_addr);
        cg_read.sample(sram_vif.read_addr);
      end
    end
  endtask
endclass

// Code example of functional coverage model
covergroup tx_word_format_cg
   WORD_LENGTH: coverpoint lcr[1:0] {
       bins bits_5 = {0};
       bins bits_6 = {1};
       bins bits_7 = {2};
       illegal_bins bits_8 = {3};
       }
   STOP_BITS: coverpoint lcr[2] {
       bins stop_1 = {0};
       bins stop_2 = {1};
       }
   PARITY: coverpoint lcr[5:3] {
       bins no_parity = {3’b000, 3’b010, 3’b100, 3’b110};
       bins even_parity = {3’b011};
       bins odd_parity = {3’b001};
       bins stick1_parity = {3’b101};
       bins stick0_parity = {3’b111};
       }
  WORD_FORMAT: cross WORD_LENGTH, STOP_BITS, PARITY;
endgroup: tx_word_format_cg

functional coverage