System verilog constraint

SystemVerilog
,
1

write a SystemVerilog constraint for a 64-bit variable data. The requirements are as follows:

  1. The variable should be declared as rand bit [63:0] data.
  2. Whenever a 1 is detected in the pattern, it should be represented as nine consecutive 1s.
  3. All other bits in the data variable can be randomized to 0 or any other pattern, but there should not be any 1s in between the sequences of nine 1s.
  4. The total length of the data variable should remain 64 bits.

pattern looks like 011111111100000011111111100011111111100…0001111111110

2

What have you developed so far? What is working for you? What is not working for you? Have you posted your code on EDA Playground so that others can see what you have written?

Also, requirement number 3 is contradictory. If all other bits can be randomized to 0 or any other pattern, then having a ‘1’ is valid and contradicts that there should not be any 1s between the sequences of nine 1s.

3

Hi Rohit,

Could you run this code and see this what you are expecting.
module tb();

  class simple;    
    bit [63:0]a;
    int pos;
   rand bit b;
    bit flag;    
    constraint c_value{      
     flag == 1 -> b==0;       
    }    
    function void post_randomize();      
      if(pos <64) begin
        if(b ==1 && pos<=56) begin
          a[pos+:9] = 9'b111111111;
          pos = pos+9;
          flag =1;
        end
        if(b ==0) begin
          pos = pos+1;
          flag = 0;
        end        
      end      
    endfunction
  endclass
  
  initial begin    
    simple s;
    s= new();
    repeat(64) begin      
      s.randomize();      
    end
    $display("The array value = %0b", s.a);    
  end  
endmodule

output::

The array value = 1111111110111111111011111111101111111110111111111001111111110
4

@happysri30 Please format your code making your code easier for others to read. I have done that for you.

5

The code works.
Just a small suggestion for code optimization, the class is randomized 64 times even though it completed randomizing the array much earlier So avoid using fixed number “repeat(64)” and we can randomize the repeat loop==width_of_data and with the repeat loop just check if “s.pos ==data_width” just exit the loop.
eg:

repeat(DATA_WIDTH) begin
s.randomize();
if(s.pos==DATA_WIDTH)
break;
end

6

Thanks Dave. Let me do it from next time.

7 
class pattern;
  rand bit [63:0] data;
  rand int n_repeat;
  rand int idx[], n_zero[];
    
  constraint c1 {
    n_repeat inside {[4:6]};
    idx.size()    == n_repeat;
    n_zero.size() == n_repeat;
    n_zero.sum()  < (64-n_repeat*9);
    foreach(n_zero[i]) {
      i==0 -> n_zero[i] inside {[0:10]};
      i>=1 -> n_zero[i] inside {[1:10]};
    }
  }
    
  constraint c2 {
    foreach(idx[i]) { 
      i==0 -> idx[i] == n_zero[i];
      i>=1 -> idx[i] == idx[i-1]+9+n_zero[i];
    }
    
    foreach(idx[i]) { 
      { 
        foreach(data[j]) {
          if      (i==0          && j<idx[i])    { data[j]==1'b0; }     
            else if (j>=idx[i]     && j<idx[i]+9)  { data[j]==1'b1; }
              else if (i==n_repeat-1 && j>=idx[i]+9) { data[j]==1'b0; }
                else if (j>=idx[i]+9   && j<idx[i+1])  { data[j]==1'b0; }
        }
      }
    }
      
  }
                  
  function void post_randomize();
     int count;
          
     for(int i=0; i<64; i++) begin
       if(data[i]) count++;
       else begin
         assert(count inside {0,9});
         count = 0;
       end
     end
     assert(count inside {0,9});
  endfunction
          
endclass

module top;
  pattern p = new();
  
  initial begin
    repeat(100) begin
      assert(p.randomize());
      $display("data = %b_%b_%b_%b_%b_%b_%b_%b :: countOnes=%0d, pattern_position = %p",
               p.data[63:56], p.data[55:48], p.data[47:40], p.data[39:32], p.data[31:24], p.data[23:16], p.data[15:8], p.data[7:0], 
               $countones(p.data), p.idx);
      end
  end
  
endmodule

[u]**Simulator Output:**[/u]

data = 00000000_11111111_10000111_11111100_00111111_11100001_11111111_00000000 :: countOnes=36, pattern_position = '{8, 21, 34, 47} 
data = 00000111_11111100_00000000_11111111_10000000_00011111_11110001_11111111 :: countOnes=36, pattern_position = '{0, 12, 31, 50} 
data = 00001111_11111000_01111111_11011111_11110000_00111111_11101111_11111000 :: countOnes=45, pattern_position = '{3, 13, 28, 38, 51} 
data = 00000111_11111101_11111111_00000000_11111111_10011111_11110011_11111110 :: countOnes=45, pattern_position = '{1, 12, 23, 40, 50} 
data = 00111111_11101111_11111000_11111111_10111111_11101111_11111011_11111110 :: countOnes=54, pattern_position = '{1, 11, 21, 31, 43, 53}