support more than 255 client/server pools

Signed-off-by: Hanoh Haim <[email protected]>

diff --git a/scripts/exp/rtsp_short3-0.erf b/scripts/exp/rtsp_short3-0.erf
index 1b178df..e69de29 100644 (file)
Binary files a/scripts/exp/rtsp_short3-0.erf and b/scripts/exp/rtsp_short3-0.erf differ

diff --git a/src/bp_sim.cpp b/src/bp_sim.cpp
index d3c8abb..8a8292a 100755 (executable)
--- a/src/bp_sim.cpp
+++ b/src/bp_sim.cpp
@@ -3615,7 +3615,7 @@ FORCE_NO_INLINE void CFlowGenListPerThread::handler_defer_job(CGenNode *p){
 void CFlowGenListPerThread::defer_client_port_free(bool is_tcp,
                                                    uint32_t c_idx,
                                                    uint16_t port,
-                                                   uint8_t c_pool_idx,
+                                                   pool_index_t c_pool_idx,
                                                    CTupleGeneratorSmart * gen){
     /* free is not required in this case */
     if (!gen->IsFreePortRequired(c_pool_idx) ){
@@ -4510,7 +4510,7 @@ uint32_t CFlowGenListPerThread::getDualPortId(){
     return ( ::getDualPortId(m_thread_id) );
 }
 
-double CFlowGenListPerThread::get_longest_flow(uint8_t pool_idx, bool is_client){
+double CFlowGenListPerThread::get_longest_flow(pool_index_t pool_idx, bool is_client){
     int i;
     double longest_flow = 0.0;
     for (i=0;i<(int)m_cap_gen.size(); i++) {
@@ -4545,7 +4545,7 @@ double CFlowGenListPerThread::get_longest_flow(){
     return longest_flow;
 }
 
-double CFlowGenListPerThread::get_total_kcps(uint8_t pool_idx, bool is_client){
+double CFlowGenListPerThread::get_total_kcps(pool_index_t pool_idx, bool is_client){
     int i;
     double total=0.0;
     for (i=0; i<(int)m_cap_gen.size(); i++) {

diff --git a/src/bp_sim.h b/src/bp_sim.h
index bc2eaf0..53ff33e 100755 (executable)
--- a/src/bp_sim.h
+++ b/src/bp_sim.h
@@ -1443,11 +1443,11 @@ struct CFlowYamlInfo {
     uint32_t        m_wlength;
     uint32_t        m_limit;
     uint32_t        m_flowcnt;
+    pool_index_t    m_client_pool_idx;
+    pool_index_t    m_server_pool_idx;
+    uint32_t        m_server_addr;
     uint8_t         m_plugin_id; /* 0 - default , 1 - RTSP160 , 2- RTSP250 */
-    uint8_t         m_client_pool_idx;
-    uint8_t         m_server_pool_idx;
     bool            m_one_app_server;
-    uint32_t        m_server_addr;
     bool            m_one_app_server_was_set;
     bool            m_cap_mode;
     bool            m_cap_mode_was_set;
@@ -1865,8 +1865,8 @@ struct CGenNodeDeferPort  {
 
     uint32_t            m_clients[DEFER_CLIENTS_NUM];
     uint16_t            m_ports[DEFER_CLIENTS_NUM];
-    uint8_t             m_pool_idx[DEFER_CLIENTS_NUM];
-    uint64_t            m_pad4[8];
+    pool_index_t        m_pool_idx[DEFER_CLIENTS_NUM];
+    uint64_t            m_pad4[6];
 
 public:
     void init(void){
@@ -1875,7 +1875,7 @@ public:
     }
 
     /* return true if object is full */
-    bool add_client(uint8_t pool_idx, uint32_t client,
+    bool add_client(pool_index_t pool_idx, uint32_t client,
                    uint16_t port){
         m_clients[m_cnt]=client;
         m_ports[m_cnt]=port;
@@ -3912,10 +3912,10 @@ public:
     uint32_t getDualPortId();
 public :
     double get_total_kcps();
-    double get_total_kcps(uint8_t pool_idx, bool is_client);
+    double get_total_kcps(pool_index_t pool_idx, bool is_client);
     double get_delta_flow_is_sec();
     double get_longest_flow();
-    double get_longest_flow(uint8_t pool_idx, bool is_client);
+    double get_longest_flow(pool_index_t pool_idx, bool is_client);
     void inc_current_template(void);
     int generate_flows_roundrobin(bool *done);
     int reschedule_flow(CGenNode *node);
@@ -4023,7 +4023,7 @@ private:
     void init_from_global();
     void defer_client_port_free(CGenNode *p);
     void defer_client_port_free(bool is_tcp,uint32_t c_ip,uint16_t port,
-                                uint8_t pool_idx, CTupleGeneratorSmart*gen);
+                                pool_index_t pool_idx, CTupleGeneratorSmart*gen);
 
 
     FORCE_NO_INLINE void   handler_defer_job(CGenNode *p);

diff --git a/src/tuple_gen.cpp b/src/tuple_gen.cpp
index 14d51c3..3da47c1 100755 (executable)
--- a/src/tuple_gen.cpp
+++ b/src/tuple_gen.cpp
@@ -323,6 +323,10 @@ bool CTupleGenPoolYaml::is_valid(uint32_t num_threads,bool is_plugins){
     utl_yaml_read_ ## type (node, #field , target); \
     } else { printf("generator definition mising " #field "\n"); } 
 
+#define UTL_YAML_READ_NO_MSG(type, field, target) if (node.FindValue(#field)) { \
+    utl_yaml_read_ ## type (node, #field , target); \
+    } 
+
 IP_DIST_t convert_distribution (const YAML::Node& node) {
     std::string tmp;
     node["distribution"] >> tmp ;
@@ -336,11 +340,11 @@ IP_DIST_t convert_distribution (const YAML::Node& node) {
 }
 
 void read_tuple_para(const YAML::Node& node, CTupleGenPoolYaml & fi) {
-    UTL_YAML_READ(uint32, clients_per_gb, fi.m_number_of_clients_per_gb);
-    UTL_YAML_READ(uint32, min_clients, fi.m_min_clients);
-    UTL_YAML_READ(ip_addr, dual_port_mask, fi.m_dual_interface_mask);
-    UTL_YAML_READ(uint16, tcp_aging, fi.m_tcp_aging_sec);
-    UTL_YAML_READ(uint16, udp_aging, fi.m_udp_aging_sec);
+    UTL_YAML_READ_NO_MSG(uint32, clients_per_gb, fi.m_number_of_clients_per_gb);
+    UTL_YAML_READ_NO_MSG(uint32, min_clients, fi.m_min_clients);
+    UTL_YAML_READ_NO_MSG(ip_addr, dual_port_mask, fi.m_dual_interface_mask);
+    UTL_YAML_READ_NO_MSG(uint16, tcp_aging, fi.m_tcp_aging_sec);
+    UTL_YAML_READ_NO_MSG(uint16, udp_aging, fi.m_udp_aging_sec);
 }
 
 void operator >> (const YAML::Node& node, CTupleGenPoolYaml & fi) {
@@ -416,6 +420,11 @@ void operator >> (const YAML::Node& node, CTupleGenYamlInfo & fi) {
         printf("no client generator pool configured, using default pool\n");
     } 
 
+    if (fi.m_client_pool.size() >= CS_MAX_POOLS) {
+        printf(" ERROR pool_size: %lu is bigger than maximum %lu \n",(ulong)fi.m_client_pool.size(),(ulong)CS_MAX_POOLS);
+        exit(1);
+    }
+
     if (node.FindValue("generator_servers")) {
         const YAML::Node& s_pool_info = node["generator_servers"];
         for (uint16_t idx=0;idx<s_pool_info.size();idx++) {
@@ -429,6 +438,12 @@ void operator >> (const YAML::Node& node, CTupleGenYamlInfo & fi) {
     } else {
         printf("no server generator pool configured, using default pool\n");
     } 
+
+    if (fi.m_server_pool.size() >= CS_MAX_POOLS) {
+        printf(" ERROR pool_size: %lu is bigger than maximum %lu \n",(ulong)fi.m_server_pool.size(),(ulong)CS_MAX_POOLS);
+        exit(1);
+    }
+
 }
 
 bool CTupleGenYamlInfo::is_valid(uint32_t num_threads,bool is_plugins){

diff --git a/src/tuple_gen.h b/src/tuple_gen.h
index 59f9758..55003d3 100755 (executable)
--- a/src/tuple_gen.h
+++ b/src/tuple_gen.h
@@ -41,6 +41,9 @@ limitations under the License.
 
 #include <random>
 
+typedef uint16_t  pool_index_t;
+#define CS_MAX_POOLS UINT16_MAX
+
 class CTupleBase {
 public:
 
@@ -649,17 +652,17 @@ public:
     }
 
     
-    void FreePort(uint8_t pool_idx, uint32_t id, uint16_t port) {
+    void FreePort(pool_index_t pool_idx, uint32_t id, uint16_t port) {
         get_client_pool(pool_idx)->FreePort(id, port);
     }
         
-    bool IsFreePortRequired(uint8_t pool_idx){
+    bool IsFreePortRequired(pool_index_t pool_idx){
         return(get_client_pool(pool_idx)->IsFreePortRequired());
     }
-    uint16_t get_tcp_aging(uint8_t pool_idx) {
+    uint16_t get_tcp_aging(pool_index_t pool_idx) {
         return (get_client_pool(pool_idx)->get_tcp_aging());
     }
-    uint16_t get_udp_aging(uint8_t pool_idx) {
+    uint16_t get_udp_aging(pool_index_t pool_idx) {
         return (get_client_pool(pool_idx)->get_udp_aging());
     }
 
@@ -698,16 +701,16 @@ public:
                          double     active_flows,
                          bool       is_bundling);
 
-    CClientPool* get_client_pool(uint8_t idx) {
+    CClientPool* get_client_pool(pool_index_t idx) {
         return m_client_pool[idx];
     }
-    uint8_t get_client_pool_num() {
+    pool_index_t get_client_pool_num() {
         return m_client_pool.size();
     }
-    uint8_t get_server_pool_num() {
+    pool_index_t get_server_pool_num() {
         return m_server_pool.size();
     }
-    CServerPoolBase* get_server_pool(uint8_t idx) {
+    CServerPoolBase* get_server_pool(pool_index_t idx) {
         return m_server_pool[idx];
     }
 private:
@@ -762,7 +765,9 @@ public:
 
 public:
 
-    bool Create( CTupleGeneratorSmart * gen,uint8_t c_pool,uint8_t s_pool){
+    bool Create( CTupleGeneratorSmart * gen,
+                 pool_index_t c_pool,
+                 pool_index_t s_pool){
         m_gen=gen;
         m_is_single_server=false;
         m_server_ip=0;
@@ -861,11 +866,11 @@ struct CTupleGenYamlInfo {
         
 public:
     bool is_valid(uint32_t num_threads,bool is_plugins);
-    uint8_t get_server_pool_id(std::string name){
+    pool_index_t get_server_pool_id(std::string name){
          if (name=="default") {
              return 0;
          }
-        for (uint8_t i=0;i<m_server_pool.size();i++) {
+        for (pool_index_t i=0;i<m_server_pool.size();i++) {
             if (m_server_pool[i].m_name==name) 
                 return i;
         }
@@ -874,11 +879,11 @@ public:
         return 0;
     }
 
-    uint8_t get_client_pool_id(std::string name){
+    pool_index_t get_client_pool_id(std::string name){
          if (name=="default") {
              return 0;
          }
-        for (uint8_t i=0;i<m_client_pool.size();i++) {
+        for (pool_index_t i=0;i<m_client_pool.size();i++) {
             if (m_client_pool[i].m_name==name) 
                 return i;
         }