Specman : how to constraint a list to be all iterations of a variable but not only?

Question

I've defined the following struct :

struct my_struct {
    var_a : bit;
    var_b : bit;
};

In another struct, I've instantiated a list of this struct :

struct another_struct {
    my_list   : list of my_struct;
    list_size : uint;

    keep list_size >= 4;
};

What I want to do is to constraint my_list to have at least all the possible iterations of both var_a and var_b but not only, i.e. to combine both constraints :

extend another_struct {
    keep my_list.is_all_iterations(.var_a, .var_b);
    keep my_list.size() ==  list_size;  
};

Is there any way to achieve that ?

Thanks

score 0 · Answer 1 · answered Sep 03 '20 at 13:09

I suggest to create a helper list and constrain it to be a sublist of my_list:

list_all_i: list of my_struct;
keep list_all_i.is_all_iterations(.var_a, .var_b);
keep list_all_i in my_list;

Not sure if that works, but I expect the last constraint to be bi-directional.

score 0 · Answer 2 · answered Nov 30 '20 at 13:00

One approach is to first generate list which contains only variations, and then append desired number of other elements, in post_generate.

<'

struct mys_s {
   a: int [0..3];
   b: int [10, 11];
};

extend sys {
   mys_l: list of mys_s;
   keep mys_l.is_all_iterations(.a,.b);

   !rand_struct: mys_s;

   upper_limit: uint;
   keep upper_limit == 20;

   old_size: uint;
   keep old_size in [read_only(mys_l.size())];

   new_size: uint;
   keep new_size >= read_only(old_size);
   keep new_size < upper_limit;

   post_generate() is {
      for i from 1 to new_size-old_size {
         gen rand_struct;
         mys_l.add(rand_struct);
      };
   };


   run() is also {
      print mys_l;
   };

};


'>

Afer this code, your list will have all variations you wanted, but also arbitrary number of other structures, defined by the "upper_limit".

Output for random seed:

Starting the test ...
Running the test ...
  mys_l = 
item   type        a           b           
---------------------------------------------------------------------------
0.     mys_s       0           10          
1.     mys_s       0           11          
2.     mys_s       1           10          
3.     mys_s       1           11          
4.     mys_s       2           10          
5.     mys_s       2           11          
6.     mys_s       3           10          
7.     mys_s       3           11          
8.     mys_s       3           11          
9.     mys_s       3           10          
10.    mys_s       1           11          
11.    mys_s       1           11          
12.    mys_s       3           10          
13.    mys_s       2           11          
14.    mys_s       0           10          
15.    mys_s       2           11          
16.    mys_s       2           11          
17.    mys_s       2           11

Note that the first 10 elements (0-9) contain variations, and remaining list elements are random sturctures.

I can improve my solution: if you want to randomize list so that variations are not always the first, then you can randomize index and use list pseudo method "insert()" to insert random structure. In that way, you will end up with random list which contains variations + random structures. — Milos Mirosavljevic, Dec 01 '20 at 08:28

Specman : how to constraint a list to be all iterations of a variable but not only?

2 Answers2