How to code the dist statement with array in the constraint

SystemVerilog
,
1

I have a requirement as below.
the address is randomized and it’s expected to be selected in an array defined.


bit [31:0] my_exc_array[$] = {'h1234, 'h5678, 'hABCD, 'hFFFF};
rand bit [31:0] my_addr;
rand bit [31:0] start_addr;
rand bit [31:0] end_addr;
constraint my_cons {
     end_addr > start_addr;
     my_addr dist { [my_exc_array]  :/1,            <=  how to code this ?
                    [start_addr:end_addr]     :/1 };
}
2

In reply to zz8318:



// Code your testbench here
// or browse Examples
class tb;
bit [31:0] my_exc_array[$] = {'h1234, 'h5678, 'hABCD, 'hFFFF};
rand bit [31:0] my_addr;
rand bit [31:0] start_addr;
rand bit [31:0] end_addr;
constraint my_cons {
     end_addr > start_addr;
  my_addr dist { my_exc_array  :/1,            
                    [start_addr:end_addr]     :/1 };
}
  
endclass


module hello;
  tb m1;
  
  initial begin
    m1 = new();
    repeat (10) begin
    if (!m1.randomize()) $display ("Error");
    $display ("start_addr = %h, end_addr = %h,my_addr = %h",m1.start_addr,m1.end_addr, m1.my_addr);
    end
  end
  
  
endmodule
3

In reply to rag123:

I tried but still failed. The error message is below.

an array and arrays are not yet supported as a distribution item.

4

In reply to zz8318:

When a message reports “not yet supported”, this indicates that it is valid code yet the tool doesn’t support it.

Since this forum isn’t for tool related issues, you should contact the vendor support team for additional assistance.

5

In reply to zz8318:

A better way of coding this is using a separate mode variable with a distribution on that mode.

bit [31:0] my_exc_array[$] = {'h1234, 'h5678, 'hABCD, 'hFFFF};
rand enum {Range, Array} mode;
rand bit [31:0] my_addr;
rand bit [31:0] start_addr;
rand bit [31:0] end_addr;
constraint my_cons {
     mode dist { Range:=1, Array:=1};
     mode == Array -> my_addr inside {my_exc_array};
     mode == Range -> { my_addr inside {[start_addr:end_addr]};
                        end_addr > start_addr; }
}

In this way the mode can be used to control sets of constraints.

6

In reply to dave_59:

In reply to zz8318:
A better way of coding this is using a separate mode variable with a distribution on that mode.

bit [31:0] my_exc_array[$] = {'h1234, 'h5678, 'hABCD, 'hFFFF};
rand enum {Range, Array} mode;
rand bit [31:0] my_addr;
rand bit [31:0] start_addr;
rand bit [31:0] end_addr;
constraint my_cons {
mode dist { Range:=1, Array:=1};
mode == Array -> my_addr inside {my_exc_array};
mode == Range -> { my_addr inside [start_addr:end_addr];
end_addr > start_addr; };
}

In this way the mode can be used to control sets of constraints.

Hi Dave,
I have tried running the above code in the simulator every time i ran mode is taking the value 0 and starting addr is 30 , ending addr is 32 and my_addr is 20
what is the significance of my_exc_array i didn’t understand. The question is my_addr is should be in the reange of start-addr & end_addr right ?

7

In reply to Manikanta Kopparapu:

I had a typo in my code that I corrected (missing{}'s around the range). but once corrected it works for me. You’ll have to ask the original author of this question, but I believe they wanted either my_addr to be inside the start_/end_range or inside my_exc_array.

module top;
  
class A;
  
  bit [31:0] my_exc_array[$] = {'h1234, 'h5678, 'hABCD, 'hFFFF};
  rand enum {Range, Array} mode;
  rand bit [31:0] my_addr;
  rand bit [31:0] start_addr;
  rand bit [31:0] end_addr;
  constraint my_cons {
     mode dist { Range:=1, Array:=1};
     mode == Array -> my_addr inside {my_exc_array};
    mode == Range -> { my_addr inside {[start_addr:end_addr]};
                        end_addr > start_addr; }
   }
endclass
  
  
  A a = new;
  
  initial repeat(20) begin
    assert(a.randomize());
    $displayh(a.mode.name,, a.my_addr);
  end
endmodule
8

In reply to Manikanta Kopparapu:

the purpose for this is to random the my_addr to be selected either inside the start_addr and end_addr, or one of the elements in my_exc_array.

9

In reply to dave_59:

A better way to do this is as below. It can help u to control the weights. here is a sample code

rand bit[31:0] start_addr;
rand bit[31:0] end_addr;

bit [31:0] my_exc_array[$] = {'h1234, 'h5678, 'hABCD, 'hFFFF};

rand bit [31:0] my_addr;

rand bit [7:0] range_wt, array_wt;
  
constraint c1 {
  solve start_addr, end_addr, range_wt, array_wt before my_addr;
  start_addr < end_addr;
  range_wt + array_wt == 100;
}
 
constraint c2 {
    my_addr  == get_the_value(start_addr, end_addr);
  }
  
function int get_the_value(int min, int max);
   
    randcase
      range_wt: get_the_value = $urandom_range(min, max);
      array_wt: begin
            int i = $urandom_range(0, my_exc_array.size()-1);
            get_the_value = my_exc_array[i];
          end
    endcase
endfunction
10

@dave_59 . Can u please review the above solution with randcase ? I am receiving an error that we cannot use random variables range_wt, array_wt. Can u please help me understand the reason ?

I am looking for a scalable solution where there are multiple ranges and multiple exec_arrays and the distribution is not uniform

11

Calling a user defined function within a constraint is very restrictive. The solver determines variable ordering by looking solely at function arguments, not inside the function. You probably want to call the function in post_randomize()

There are a number of memory manager algorithms you can search for.