add min/max to repeatable random inst

2 files changed, 55 insertions, 9 deletions

diff --git a/src/stateless/cp/trex_stream_vm.cpp b/src/stateless/cp/trex_stream_vm.cpp
index 0f1ea682..bdfca36e 100644
--- a/src/stateless/cp/trex_stream_vm.cpp
+++ b/src/stateless/cp/trex_stream_vm.cpp
@@ -26,6 +26,7 @@ limitations under the License.
 #include <trex_stateless.h>
 #include <common/Network/Packet/IPHeader.h>
 #include <common/basic_utils.h>
+#include <inttypes.h>
 
 /**
  * provides some tools for the fast rand function 
@@ -170,7 +171,7 @@ void StreamVmInstructionFlowMan::sanity_check(uint32_t ins_id,StreamVm *lp){
 
 void StreamVmInstructionFlowRandLimit::Dump(FILE *fd){
     fprintf(fd," flow_var_rand_limit  , %s ,%lu,   ",m_var_name.c_str(),(ulong)m_size_bytes);
-    fprintf(fd," (%lu:%lu:%lu) \n",m_limit,(ulong)m_size_bytes,(ulong)m_seed);
+    fprintf(fd," (%lu:%lu:%lu) (min:%lu,max:%lu) \n",m_limit,(ulong)m_size_bytes,(ulong)m_seed,m_min_value,m_max_value);
 }
 
 void StreamVmInstructionFlowRandLimit::sanity_check(uint32_t ins_id,StreamVm *lp){
@@ -195,21 +196,29 @@ uint8_t  StreamVmInstructionFlowRandLimit::bss_init_value(uint8_t *p){
     case 1:
         u.lpv8=(RandMemBss8 *)p;
         u.lpv8->m_seed=m_seed;
+        u.lpv8->m_cnt=0;
+        u.lpv8->m_val=0;
         res=sizeof(RandMemBss8);
         break;
     case 2:
         u.lpv16=(RandMemBss16 *)p;
         u.lpv16->m_seed=m_seed;
+        u.lpv16->m_cnt=0;
+        u.lpv16->m_val=0;
         res=sizeof(RandMemBss16);
         break;
     case 4:
         u.lpv32=(RandMemBss32 *)p;
         u.lpv32->m_seed=m_seed;
+        u.lpv32->m_cnt=0;
+        u.lpv32->m_val=0;
         res=sizeof(RandMemBss32);
         break;
     case 8:
         u.lpv64=(RandMemBss64 *)p;
         u.lpv64->m_seed=m_seed;
+        u.lpv64->m_cnt=0;
+        u.lpv64->m_val=0;
         res=sizeof(RandMemBss64);
         break;
     default:
@@ -671,6 +680,8 @@ void StreamVm::build_program(){
                 fv8.m_flow_offset = get_var_offset(lpMan->m_var_name);
                 fv8.m_limit     = (uint8_t)lpMan->m_limit;
                 fv8.m_seed      = (uint32_t)lpMan->m_seed;
+                fv8.m_min_val = (uint8_t)lpMan->m_min_value;
+                fv8.m_max_val = (uint8_t)lpMan->m_max_value;
                 m_instructions.add_command(&fv8,sizeof(fv8));
             }
 
@@ -680,6 +691,9 @@ void StreamVm::build_program(){
                 fv16.m_flow_offset = get_var_offset(lpMan->m_var_name);
                 fv16.m_limit     = (uint16_t)lpMan->m_limit;
                 fv16.m_seed      = (uint32_t)lpMan->m_seed;
+                fv16.m_min_val   = (uint16_t)lpMan->m_min_value;
+                fv16.m_max_val   = (uint16_t)lpMan->m_max_value;
+
                 m_instructions.add_command(&fv16,sizeof(fv16));
             }
 
@@ -689,6 +703,9 @@ void StreamVm::build_program(){
                 fv32.m_flow_offset = get_var_offset(lpMan->m_var_name);
                 fv32.m_limit     = (uint32_t)lpMan->m_limit;
                 fv32.m_seed      = (uint32_t)lpMan->m_seed;
+                fv32.m_min_val   = (uint32_t)lpMan->m_min_value;
+                fv32.m_max_val   = (uint32_t)lpMan->m_max_value;
+
                 m_instructions.add_command(&fv32,sizeof(fv32));
             }
 
@@ -698,6 +715,8 @@ void StreamVm::build_program(){
                 fv64.m_flow_offset = get_var_offset(lpMan->m_var_name);
                 fv64.m_limit     = lpMan->m_limit;
                 fv64.m_seed      = (uint32_t)lpMan->m_seed;
+                fv64.m_min_val   = lpMan->m_min_value;
+                fv64.m_max_val   = lpMan->m_max_value;
                 m_instructions.add_command(&fv64,sizeof(fv64));
             }
         }
@@ -1578,19 +1597,19 @@ void StreamDPOpPktSizeChange::dump(FILE *fd,std::string opt){
 
 
 void StreamDPOpFlowRandLimit8::dump(FILE *fd,std::string opt){
-    fprintf(fd," %10s, flow_offset: %lu  limit :%lu seed:%x \n",  opt.c_str(),(ulong)m_flow_offset,(ulong)m_limit,m_seed);
+    fprintf(fd," %10s, flow_offset: %lu  limit :%lu seed:%x (%x-%x) \n",  opt.c_str(),(ulong)m_flow_offset,(ulong)m_limit,m_seed,m_min_val,m_max_val);
 }
 
 void StreamDPOpFlowRandLimit16::dump(FILE *fd,std::string opt){
-    fprintf(fd," %10s, flow_offset: %lu  limit :%lu seed:%x \n",  opt.c_str(),(ulong)m_flow_offset,(ulong)m_limit,m_seed);
+    fprintf(fd," %10s, flow_offset: %lu  limit :%lu seed:%x (%x-%x) \n",  opt.c_str(),(ulong)m_flow_offset,(ulong)m_limit,m_seed,m_min_val,m_max_val);
 }
 
 void StreamDPOpFlowRandLimit32::dump(FILE *fd,std::string opt){
-    fprintf(fd," %10s, flow_offset: %lu  limit :%lu seed:%x \n",  opt.c_str(),(ulong)m_flow_offset,(ulong)m_limit,m_seed);
+    fprintf(fd," %10s, flow_offset: %lu  limit :%lu seed:%x (%x-%x) \n",  opt.c_str(),(ulong)m_flow_offset,(ulong)m_limit,m_seed,m_min_val,m_max_val);
 }
 
 void StreamDPOpFlowRandLimit64::dump(FILE *fd,std::string opt){
-    fprintf(fd," %10s, flow_offset: %lu  limit :%lu seed:%x \n",  opt.c_str(),(ulong)m_flow_offset,(ulong)m_limit,m_seed);
+    fprintf(fd," %10s, flow_offset: %lu  limit :%lu seed:%x  \n",  opt.c_str(),(ulong)m_flow_offset,(ulong)m_limit,m_seed);
 }
 
 
diff --git a/src/stateless/cp/trex_stream_vm.h b/src/stateless/cp/trex_stream_vm.h
index 6a83c5ea..5e3665c6 100644
--- a/src/stateless/cp/trex_stream_vm.h
+++ b/src/stateless/cp/trex_stream_vm.h
@@ -106,7 +106,10 @@ struct StreamDPOpFlowRandLimit8 {
     uint8_t m_op;
     uint8_t m_flow_offset;
     uint8_t m_limit;
+    uint8_t m_min_val;
+    uint8_t m_max_val;
     uint32_t m_seed;
+
 public:
     void dump(FILE *fd,std::string opt);
     inline void run(uint8_t * flow_var) {
@@ -115,7 +118,7 @@ public:
             p->m_seed = m_seed;
             p->m_cnt=0;
         }
-        uint32_t val = vm_rand16(&p->m_seed);
+        uint32_t val = m_min_val + (vm_rand16(&p->m_seed)  % (int)(m_max_val - m_min_val + 1));
         p->m_val= (uint8_t)(val);
         p->m_cnt++;
     }
@@ -125,6 +128,9 @@ struct StreamDPOpFlowRandLimit16 {
     uint8_t m_op;
     uint8_t m_flow_offset;
     uint16_t m_limit;
+    uint16_t m_min_val;
+    uint16_t m_max_val;
+
     uint32_t m_seed;
 public:
     void dump(FILE *fd,std::string opt);
@@ -134,7 +140,7 @@ public:
             p->m_seed = m_seed;
             p->m_cnt=0;
         }
-        uint32_t val = vm_rand16(&p->m_seed);
+        uint32_t val = m_min_val + (vm_rand16(&p->m_seed)  % (int)(m_max_val - m_min_val + 1)); 
         p->m_val= (uint16_t)(val);
         p->m_cnt++;
     }
@@ -145,6 +151,9 @@ struct StreamDPOpFlowRandLimit32 {
     uint8_t m_op;
     uint8_t m_flow_offset;
     uint32_t m_limit;
+    uint32_t m_min_val;
+    uint32_t m_max_val;
+
     uint32_t m_seed;
 public:
     void dump(FILE *fd,std::string opt);
@@ -154,7 +163,7 @@ public:
             p->m_seed = m_seed;
             p->m_cnt=0;
         }
-        uint32_t val = vm_rand32(&p->m_seed);
+        uint32_t val = m_min_val + (vm_rand32(&p->m_seed)  % ((uint64_t)m_max_val - m_min_val + 1)); 
         p->m_val= val;
         p->m_cnt++;
     }
@@ -164,6 +173,9 @@ struct StreamDPOpFlowRandLimit64 {
     uint8_t m_op;
     uint8_t m_flow_offset;
     uint64_t m_limit;
+    uint64_t m_min_val;
+    uint64_t m_max_val;
+
     uint32_t m_seed;
 public:
     void dump(FILE *fd,std::string opt);
@@ -173,7 +185,13 @@ public:
             p->m_seed = m_seed;
             p->m_cnt=0;
         }
-        uint64_t val = vm_rand64(&p->m_seed);
+        uint64_t val;
+        if ((m_max_val - m_min_val) == UINT64_MAX) {
+            val = vm_rand64(&p->m_seed);
+        } else {
+            val = m_min_val + ( vm_rand64(&p->m_seed)  % ( (uint64_t)m_max_val - m_min_val + 1) );
+        }
+        
         p->m_val= val;
         p->m_cnt++;
     }
@@ -1170,12 +1188,16 @@ public:
     StreamVmInstructionFlowRandLimit(const std::string &var_name,
                                      uint8_t  size,
                                      uint64_t limit,
+                                     uint64_t min_value,
+                                     uint64_t max_value,
                                      int       seed
                                      ) : StreamVmInstructionVar(var_name) {
 
         m_size_bytes = size;
         m_seed       = seed;
         m_limit      = limit;
+        m_min_value  = min_value;
+        m_max_value  = max_value;
     }
 
     virtual void Dump(FILE *fd);
@@ -1188,6 +1210,8 @@ public:
         return new StreamVmInstructionFlowRandLimit(m_var_name,
                                                     m_size_bytes,
                                                     m_limit,
+                                                    m_min_value,
+                                                    m_max_value,
                                                     m_seed);
     }
 
@@ -1197,6 +1221,9 @@ private:
 public:
 
     uint64_t       m_limit;
+    uint64_t       m_min_value;
+    uint64_t       m_max_value;
+
     int            m_seed;
     uint8_t        m_size_bytes;
 };