summaryrefslogtreecommitdiffstats
path: root/src/tuple_gen.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/tuple_gen.cpp')
-rwxr-xr-xsrc/tuple_gen.cpp519
1 files changed, 297 insertions, 222 deletions
diff --git a/src/tuple_gen.cpp b/src/tuple_gen.cpp
index 0faa6b63..2e1099da 100755
--- a/src/tuple_gen.cpp
+++ b/src/tuple_gen.cpp
@@ -1,6 +1,6 @@
/*
- Wenxian Li
+ Wenxian Li
Hanoh Haim
Cisco Systems, Inc.
*/
@@ -21,287 +21,362 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
+
#include "tuple_gen.h"
#include <string.h>
#include "utl_yaml.h"
-
-
-
-/* simple tuple genertion for one low*/
-void CTupleGeneratorSmart::GenerateTuple(CTupleBase & tuple) {
- BP_ASSERT(m_was_init);
- Generate_client_server();
- m_was_generated = true;
- m_result_client_port = GenerateOneClientPort(m_client_ip);
- tuple.setClient(m_result_client_ip);
- tuple.setServer(m_result_server_ip);
- tuple.setClientPort(m_result_client_port);
- tuple.setClientMac(&m_result_client_mac);
-// printf(" alloc %x %d mac:%x,%x\n",m_result_client_ip,m_result_client_port, m_result_client_mac.mac[0], m_result_client_mac.mac[1]);
+void CServerPool::Create(IP_DIST_t dist_value,
+ uint32_t min_ip,
+ uint32_t max_ip,
+ double l_flow,
+ double t_cps) {
+ gen = new CIpPool();
+ gen->set_dist(dist_value);
+ uint32_t total_ip = max_ip - min_ip +1;
+ gen->m_ip_info.resize(total_ip);
+
+ if (total_ip > ((l_flow*t_cps/MAX_PORT))) {
+ for(int idx=0;idx<total_ip;idx++){
+ gen->m_ip_info[idx] = new CServerInfoL();
+ gen->m_ip_info[idx]->set_ip(min_ip+idx);
+ }
+ } else {
+ for(int idx=0;idx<total_ip;idx++){
+ gen->m_ip_info[idx] = new CServerInfo();
+ gen->m_ip_info[idx]->set_ip(min_ip+idx);
+ }
+ }
+ gen->CreateBase();
}
+void CClientPool::Create(IP_DIST_t dist_value,
+ uint32_t min_ip,
+ uint32_t max_ip,
+ double l_flow,
+ double t_cps,
+ CFlowGenList* fl_list,
+ bool has_mac_map,
+ uint16_t tcp_aging,
+ uint16_t udp_aging) {
+ assert(max_ip>=min_ip);
+ set_dist(dist_value);
+ uint32_t total_ip = max_ip - min_ip +1;
+ uint32_t avail_ip = total_ip;
+ if (has_mac_map && (fl_list!=NULL)) {
+ for(int idx=0;idx<total_ip;idx++){
+ mac_addr_align_t *mac_adr = NULL;
+ mac_adr = get_mac_addr_by_ip(fl_list, min_ip+idx);
+ if (mac_adr == NULL) {
+ avail_ip--;
+ }
+ }
+ }
+ if (avail_ip!=0) {
+ m_ip_info.resize(avail_ip);
+ } else {
+ printf("\n Error, empty mac file is configured.\n"
+ "Will ignore the mac file configuration.\n");
+ m_ip_info.resize(total_ip);
+ }
-/*
- * allocate base tuple with n exta ports, used by bundels SIP
- * for example need to allocat 3 ports for this C/S
- */
-void CTupleGeneratorSmart::GenerateTupleEx(CTupleBase & tuple,
- uint8_t extra_ports_no,
- uint16_t * extra_ports) {
- GenerateTuple(tuple) ;
- for (int idx=0;idx<extra_ports_no;idx++) {
- extra_ports[idx] = GenerateOneClientPort(m_client_ip);
+ if (total_ip > ((l_flow*t_cps/MAX_PORT))) {
+ if (has_mac_map) {
+ for(int idx=0;idx<total_ip;idx++){
+ mac_addr_align_t *mac_adr = NULL;
+ mac_adr = get_mac_addr_by_ip(fl_list, min_ip+idx);
+ if (mac_adr != NULL) {
+ m_ip_info[idx] = new CClientInfoL(has_mac_map);
+ m_ip_info[idx]->set_ip(min_ip+idx);
+ m_ip_info[idx]->set_mac(mac_adr);
+ }
+ }
+ } else {
+ for(int idx=0;idx<total_ip;idx++){
+ m_ip_info[idx] = new CClientInfoL(has_mac_map);
+ m_ip_info[idx]->set_ip(min_ip+idx);
+ }
+ }
+ } else {
+ if (has_mac_map) {
+ for(int idx=0;idx<total_ip;idx++){
+ mac_addr_align_t *mac_adr = NULL;
+ mac_adr = get_mac_addr_by_ip(fl_list, min_ip+idx);
+ if (mac_adr != NULL) {
+ m_ip_info[idx] = new CClientInfo(has_mac_map);
+ m_ip_info[idx]->set_ip(min_ip+idx);
+ m_ip_info[idx]->set_mac(mac_adr);
+ }
+ }
+ } else {
+ for(int idx=0;idx<total_ip;idx++){
+ m_ip_info[idx] = new CClientInfo(has_mac_map);
+ m_ip_info[idx]->set_ip(min_ip+idx);
+ }
+ }
+
}
+ m_tcp_aging = tcp_aging;
+ m_udp_aging = udp_aging;
+ CreateBase();
}
-void CTupleGeneratorSmart::Dump(FILE *fd){
- fprintf(fd," id: %x, %x:%x - %x \n client:%x - %x, server:%x-%x\n",m_id,m_result_client_ip,m_result_server_ip,m_result_client_port,m_min_client_ip, m_max_client_ip, m_min_server_ip, m_max_server_ip);
+void delay(int msec);
+
+bool CTupleGeneratorSmart::add_client_pool(IP_DIST_t client_dist,
+ uint32_t min_client,
+ uint32_t max_client,
+ double l_flow,
+ double t_cps,
+ CFlowGenList* fl_list,
+ uint16_t tcp_aging,
+ uint16_t udp_aging){
+ assert(max_client>=min_client);
+ CClientPool* pool = new CClientPool();
+ pool->Create(client_dist, min_client, max_client,
+ l_flow, t_cps, fl_list, has_mac_mapping,
+ tcp_aging, udp_aging);
+
+ m_client_pool.push_back(pool);
+ return(true);
+}
+
+bool CTupleGeneratorSmart::add_server_pool(IP_DIST_t server_dist,
+ uint32_t min_server,
+ uint32_t max_server,
+ double l_flow,
+ double t_cps,
+ bool is_bundling){
+ assert(max_server>=min_server);
+ CServerPoolBase* pool;
+ if (is_bundling)
+ pool = new CServerPool();
+ else
+ pool = new CServerPoolSimple();
+ // we currently only supports mac mapping file for client
+ pool->Create(server_dist, min_server, max_server,
+ l_flow, t_cps);
+ m_server_pool.push_back(pool);
+ return(true);
}
-void delay(int msec);
bool CTupleGeneratorSmart::Create(uint32_t _id,
- uint32_t thread_id,
- IP_DIST_t dist,
- uint32_t min_client,
- uint32_t max_client,
- uint32_t min_server,
- uint32_t max_server,
- double l_flow,
- double t_cps,
- CFlowGenList* fl_list){
-
- m_active_alloc=0;
- if (dist>=cdMAX_DIST) {
- m_client_dist = cdSEQ_DIST;
- } else {
- m_client_dist = dist;
- }
- m_min_client_ip = min_client;
- m_max_client_ip = max_client;
- m_min_server_ip = min_server;
- m_max_server_ip = max_server;
- assert(m_max_client_ip>=m_min_client_ip);
- assert(m_max_server_ip>=m_min_server_ip);
- assert((m_max_client_ip- m_min_client_ip)<50000);
-
- uint32_t total_clients = getTotalClients();
- /*printf("\ntotal_clients:%d, longest_flow:%f sec, total_cps:%f\n",
- total_clients, l_flow, t_cps);*/
- m_client.resize(m_max_client_ip-m_min_client_ip+1);
- if (fl_list == NULL || !is_mac_info_conf(fl_list)) {
- if (total_clients > ((l_flow*t_cps/MAX_PORT))) {
- for (int idx=0;idx<m_client.size();idx++)
- m_client[idx] = new CClientInfoL();
- } else {
- for (int idx=0;idx<m_client.size();idx++)
- m_client[idx] = new CClientInfo();
- }
- } else {
- if (total_clients > ((l_flow*t_cps/MAX_PORT))) {
- for (int idx=0;idx<m_client.size();idx++) {
- m_client[idx] = new CClientInfoL(
- get_mac_addr_by_ip(fl_list, min_client+idx));
- }
- } else {
- for (int idx=0;idx<m_client.size();idx++)
- m_client[idx] = new CClientInfo(
- get_mac_addr_by_ip(fl_list, min_client+idx));
- }
- }
- m_was_generated = false;
+ uint32_t thread_id,
+ bool has_mac)
+{
m_thread_id = thread_id;
-
m_id = _id;
m_was_init=true;
- m_port_allocation_error=0;
+ has_mac_mapping = has_mac;
return(true);
}
void CTupleGeneratorSmart::Delete(){
- m_was_generated = false;
m_was_init=false;
- m_client_dist = cdSEQ_DIST;
+ has_mac_mapping = false;
- for (int idx=0;idx<m_client.size();idx++){
- delete m_client[idx];
+ for (int idx=0;idx<m_client_pool.size();idx++) {
+ m_client_pool[idx]->Delete();
+ delete m_client_pool[idx];
}
- m_client.clear();
-}
+ m_client_pool.clear();
-void CTupleGeneratorSmart::Generate_client_server(){
- if (m_was_generated == false) {
- /*first time */
- m_was_generated = true;
- m_cur_client_ip = m_min_client_ip;
- m_cur_server_ip = m_min_server_ip;
+ for (int idx=0;idx<m_server_pool.size();idx++) {
+ m_server_pool[idx]->Delete();
+ delete m_server_pool[idx];
}
+ m_server_pool.clear();
+}
- uint32_t client_ip;
- int i=0;
- for (;i<100;i++) {
- if (is_client_available(m_cur_client_ip)) {
- break;
- }
- if (m_cur_client_ip >= m_max_client_ip) {
- m_cur_client_ip = m_min_client_ip;
- } else {
- m_cur_client_ip++;
- }
- }
- if (i>=100) {
- printf(" ERROR ! sparse mac-ip files is not supported yet !\n");
- exit(-1);
- }
+void CTupleGenPoolYaml::Dump(FILE *fd){
+ fprintf(fd," dist : %d \n",m_dist);
+ fprintf(fd," IPs : %08x -%08x \n",m_ip_start,m_ip_end);
+ fprintf(fd," clients per gb : %d \n",m_number_of_clients_per_gb);
+ fprintf(fd," min clients : %d \n",m_min_clients);
+ fprintf(fd," tcp aging : %d sec \n",m_tcp_aging_sec);
+ fprintf(fd," udp aging : %d sec \n",m_udp_aging_sec);
+}
- m_client_ip = m_cur_client_ip;
- CClientInfoBase* client = get_client_by_ip(m_client_ip);
- memcpy(&m_result_client_mac,
- client->get_mac_addr(),
- sizeof(mac_addr_align_t));
- m_result_client_ip = m_client_ip;
- m_result_server_ip = m_cur_server_ip ;
-/*
-printf("ip:%x,mac:%x,%x,%x,%x,%x,%x, inused:%x\n",m_client_ip,
- m_result_client_mac.mac[0],
- m_result_client_mac.mac[1],
- m_result_client_mac.mac[2],
- m_result_client_mac.mac[3],
- m_result_client_mac.mac[4],
- m_result_client_mac.mac[5],
- m_result_client_mac.inused);
-*/
- m_cur_client_ip ++;
- m_cur_server_ip ++;
- if (m_cur_client_ip > m_max_client_ip) {
- m_cur_client_ip = m_min_client_ip;
+bool CTupleGenPoolYaml::is_valid(uint32_t num_threads,bool is_plugins){
+ if ( m_ip_start > m_ip_end ){
+ printf(" ERROR The ip_start must be bigger than ip_end \n");
+ return(false);
}
- if (m_cur_server_ip > m_max_server_ip) {
- m_cur_server_ip = m_min_server_ip;
+
+ uint32_t ips= (m_ip_end - m_ip_start +1);
+ if ( ips < num_threads ) {
+ printf(" ERROR The number of ips should be at least number of threads %d \n",num_threads);
+ return (false);
}
-}
-void CTupleGeneratorSmart::return_all_client_ports() {
- for(int idx=0;idx<m_client.size();++idx) {
- m_client.at(idx)->return_all_ports();
+ if (ips > 1000000) {
+ printf(" The number of clients requested is %d maximum supported : %d \n",ips,1000000);
+ return (false);
}
+ return (true);
}
-void CTupleGenYamlInfo::Dump(FILE *fd){
- fprintf(fd," dist : %d \n",m_client_dist);
- fprintf(fd," clients : %08x -%08x \n",m_clients_ip_start,m_clients_ip_end);
- fprintf(fd," servers : %08x -%08x \n",m_servers_ip_start,m_servers_ip_end);
- fprintf(fd," clients per gb : %d \n",m_number_of_clients_per_gb);
- fprintf(fd," min clients : %d \n",m_min_clients);
- fprintf(fd," tcp aging : %d sec \n",m_tcp_aging_sec);
- fprintf(fd," udp aging : %d sec \n",m_udp_aging_sec);
-}
-void operator >> (const YAML::Node& node, CTupleGenYamlInfo & fi) {
- std::string tmp;
+
+void operator >> (const YAML::Node& node, CTupleGenPoolYaml & fi) {
+ std::string tmp;
+ node["name"] >> fi.m_name;
+ node["distribution"] >> tmp ;
+ if (tmp == "random") {
+ fi.m_dist=cdRANDOM_DIST;
+ }else if (tmp == "normal") {
+ fi.m_dist=cdNORMAL_DIST;
+ } else {
+ printf("\ndist,seq\n");
+ fi.m_dist=cdSEQ_DIST;
+ }
+ utl_yaml_read_ip_addr(node,"ip_start",fi.m_ip_start);
+ utl_yaml_read_ip_addr(node,"ip_end",fi.m_ip_end);
try {
- node["distribution"] >> tmp ;
- if (tmp == "seq" ) {
- fi.m_client_dist=cdSEQ_DIST;
- }else{
- if (tmp == "random") {
- fi.m_client_dist=cdRANDOM_DIST;
- }else{
- if (tmp == "normal") {
- fi.m_client_dist=cdNORMAL_DIST;
- }
- }
- }
- }catch ( const std::exception& e ) {
- fi.m_client_dist=cdSEQ_DIST;
+ utl_yaml_read_uint32(node,"clients_per_gb",fi.m_number_of_clients_per_gb);
+ } catch ( const std::exception& e ) {
+ fi.m_number_of_clients_per_gb = 0;
}
- utl_yaml_read_ip_addr(node,"clients_start",fi.m_clients_ip_start);
- utl_yaml_read_ip_addr(node,"clients_end",fi.m_clients_ip_end);
- utl_yaml_read_ip_addr(node,"servers_start",fi.m_servers_ip_start);
- utl_yaml_read_ip_addr(node,"servers_end",fi.m_servers_ip_end);
- utl_yaml_read_uint32(node,"clients_per_gb",fi.m_number_of_clients_per_gb);
- utl_yaml_read_uint32(node,"min_clients",fi.m_min_clients);
- utl_yaml_read_ip_addr(node,"dual_port_mask",fi.m_dual_interface_mask);
- utl_yaml_read_uint16(node,"tcp_aging",fi.m_tcp_aging_sec);
- utl_yaml_read_uint16(node,"udp_aging",fi.m_udp_aging_sec);
-
-}
-
-bool CTupleGenYamlInfo::is_valid(uint32_t num_threads,bool is_plugins){
- if ( m_servers_ip_start > m_servers_ip_end ){
- printf(" ERROR The servers_ip_start must be bigger than servers_ip_end \n");
- return(false);
+ try {
+ utl_yaml_read_uint32(node,"min_clients",fi.m_min_clients);
+ } catch ( const std::exception& e ) {
+ fi.m_min_clients = 0;
}
-
- if ( m_clients_ip_start > m_clients_ip_end ){
- printf(" ERROR The clients_ip_start must be bigger than clients_ip_end \n");
- return(false);
+ try {
+ utl_yaml_read_ip_addr(node,"dual_port_mask",fi.m_dual_interface_mask);
+ } catch ( const std::exception& e ) {
+ fi.m_dual_interface_mask = 0;
}
- uint32_t servers= (m_servers_ip_end - m_servers_ip_start +1);
- if ( servers < num_threads ) {
- printf(" ERROR The number of servers should be at least number of threads %d \n",num_threads);
- return (false);
+ try {
+ utl_yaml_read_uint16(node,"tcp_aging",fi.m_tcp_aging_sec);
+ } catch ( const std::exception& e ) {
+ fi.m_tcp_aging_sec = 0;
}
-
- uint32_t clients= (m_clients_ip_end - m_clients_ip_start +1);
- if ( clients < num_threads ) {
- printf(" ERROR The number of clients should be at least number of threads %d \n",num_threads);
- return (false);
+ try {
+ utl_yaml_read_uint16(node,"udp_aging",fi.m_udp_aging_sec);
+ } catch ( const std::exception& e ) {
+ fi.m_udp_aging_sec = 0;
}
+ try {
+ node["track_ports"] >> fi.m_is_bundling;
+ } catch ( const std::exception& e ) {
+ fi.m_is_bundling = false;
+ }
+}
+void copy_global_pool_para(CTupleGenPoolYaml & src, CTupleGenPoolYaml & dst) {
+ if (src.m_number_of_clients_per_gb == 0)
+ src.m_number_of_clients_per_gb = dst.m_number_of_clients_per_gb;
+ if (src.m_min_clients == 0)
+ src.m_min_clients = dst.m_min_clients;
+ if (src.m_dual_interface_mask == 0)
+ src.m_dual_interface_mask = dst.m_dual_interface_mask;
+ if (src.m_tcp_aging_sec == 0)
+ src.m_tcp_aging_sec = dst.m_tcp_aging_sec;
+ if (src.m_udp_aging_sec == 0)
+ src.m_udp_aging_sec = dst.m_udp_aging_sec;
+}
+void operator >> (const YAML::Node& node, CTupleGenYamlInfo & fi) {
+ std::string tmp;
- /* defect for plugin */
- if (is_plugins) {
- if ( getTotalServers() < getTotalClients() ){
- printf(" Plugin is configured. in that case due to a limitation ( defect trex-54 ) \n");
- printf(" the number of servers should be bigger than number of clients \n");
- return (false);
+ try {
+ CTupleGenPoolYaml c_pool;
+ CTupleGenPoolYaml s_pool;
+ node["distribution"] >> tmp ;
+ if (tmp == "random") {
+ c_pool.m_dist=cdRANDOM_DIST;
+ }else if (tmp == "normal") {
+ c_pool.m_dist=cdNORMAL_DIST;
+ } else {
+ c_pool.m_dist=cdSEQ_DIST;
}
-
- /* update number of servers in a way that it would be exact multiplication */
- uint32_t mul=getTotalServers() / getTotalClients();
- uint32_t new_server_num=mul*getTotalClients();
- m_servers_ip_end = m_servers_ip_start + new_server_num-1 ;
-
- assert(getTotalServers() %getTotalClients() ==0);
+ s_pool.m_dist = c_pool.m_dist;
+ utl_yaml_read_ip_addr(node,"clients_start",c_pool.m_ip_start);
+ utl_yaml_read_ip_addr(node,"clients_end",c_pool.m_ip_end);
+ utl_yaml_read_ip_addr(node,"servers_start",s_pool.m_ip_start);
+ utl_yaml_read_ip_addr(node,"servers_end",s_pool.m_ip_end);
+ utl_yaml_read_uint32(node,"clients_per_gb",c_pool.m_number_of_clients_per_gb);
+ utl_yaml_read_uint32(node,"min_clients",c_pool.m_min_clients);
+ utl_yaml_read_ip_addr(node,"dual_port_mask",c_pool.m_dual_interface_mask);
+ utl_yaml_read_uint16(node,"tcp_aging",c_pool.m_tcp_aging_sec);
+ utl_yaml_read_uint16(node,"udp_aging",c_pool.m_udp_aging_sec);
+ s_pool.m_dual_interface_mask = c_pool.m_dual_interface_mask;
+ fi.m_client_pool.push_back(c_pool);
+ fi.m_server_pool.push_back(s_pool);
+ }catch ( const std::exception& e ) {
+ printf("No default generator defined.\n");
}
+ try{
+ const YAML::Node& c_pool_info = node["generator_clients"];
+ for (uint16_t idx=0;idx<c_pool_info.size();idx++) {
+ CTupleGenPoolYaml pool;
+ try {
+ c_pool_info[idx] >> pool;
+ } catch ( const std::exception& e ) {
+ printf("client pool in YAML is wrong\n");
+ }
+ if (fi.m_client_pool.size()>0) {
+ copy_global_pool_para(pool, fi.m_client_pool[0]);
+ }
+ fi.m_client_pool.push_back(pool);
+ }
+ }catch ( const std::exception& e ) {
+ printf("no client generator pool configured, using default pool\n");
+ }
+ try {
+ const YAML::Node& s_pool_info = node["generator_servers"];
+ for (uint16_t idx=0;idx<s_pool_info.size();idx++) {
+ CTupleGenPoolYaml pool;
+ try {
+ s_pool_info[idx] >> pool;
+ } catch ( const std::exception& e ) {
+ printf("server pool in YAML is wrong\n");
+ }
+ if (fi.m_server_pool.size()>0) {
+ copy_global_pool_para(pool, fi.m_server_pool[0]);
+ }
+ fi.m_server_pool.push_back(pool);
+ }
+ }catch ( const std::exception& e ) {
+ printf("no server generator pool configured, using default pool\n");
+ }
+}
-/* if (clients > 00000) {
- printf(" The number of clients requested is %d maximum supported : %d \n",clients,100000);
- return (false);
+bool CTupleGenYamlInfo::is_valid(uint32_t num_threads,bool is_plugins){
+ for (int i=0;i<m_client_pool.size();i++) {
+ if (m_client_pool[i].is_valid(num_threads, is_plugins)==false)
+ return false;
}
- */ return (true);
+ for (int i=0;i<m_server_pool.size();i++) {
+ if (m_server_pool[i].is_valid(num_threads, is_plugins)==false)
+ return false;
+ }
+ return true;
}
/* split the clients and server by dual_port_id and thread_id ,
clients is splited by threads and dual_port_id
servers is spliteed by dual_port_id */
-void split_clients(uint32_t thread_id,
- uint32_t total_threads,
- uint32_t dual_port_id,
- CTupleGenYamlInfo & fi,
- CClientPortion & portion){
-
- uint32_t clients_chunk = fi.getTotalClients()/total_threads;
- // FIXME need to fix this when fixing the server
- uint32_t servers_chunk = fi.getTotalServers()/total_threads;
-
- assert(clients_chunk>0);
- assert(servers_chunk>0);
+void split_ips(uint32_t thread_id,
+ uint32_t total_threads,
+ uint32_t dual_port_id,
+ CTupleGenPoolYaml& poolinfo,
+ CIpPortion & portion){
- uint32_t dual_if_mask=(dual_port_id*fi.m_dual_interface_mask);
+ uint32_t chunks = poolinfo.getTotalIps()/total_threads;
- portion.m_client_start = fi.m_clients_ip_start + thread_id*clients_chunk + dual_if_mask;
- portion.m_client_end = portion.m_client_start + clients_chunk -1 ;
+ assert(chunks>0);
- portion.m_server_start = fi.m_servers_ip_start + thread_id*servers_chunk +dual_if_mask;
- portion.m_server_end = portion.m_server_start + servers_chunk -1;
+ uint32_t dual_if_mask=(dual_port_id*poolinfo.getDualMask());
+
+ portion.m_ip_start = poolinfo.get_ip_start() + thread_id*chunks + dual_if_mask;
+ portion.m_ip_end = portion.m_ip_start + chunks -1 ;
}