diff options
Diffstat (limited to 'src/platform_cfg.cpp')
| -rwxr-xr-x | src/platform_cfg.cpp | 513 |
1 files changed, 513 insertions, 0 deletions
diff --git a/src/platform_cfg.cpp b/src/platform_cfg.cpp new file mode 100755 index 00000000..a8f7997c --- /dev/null +++ b/src/platform_cfg.cpp @@ -0,0 +1,513 @@ +/* + Hanoh Haim + Cisco Systems, Inc. +*/ + +/* +Copyright (c) 2015-2016 Cisco Systems, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#include <fstream> +#include <iostream> +#include <stdlib.h> +#include "common/basic_utils.h" +#include "utl_yaml.h" +#include "platform_cfg.h" +#include "utl_yaml.h" + +void CPlatformMemoryYamlInfo::reset(){ + int i; + i=0; + for (i=0; i<MBUF_ELM_SIZE; i++) { + m_mbuf[i] = CONST_NB_MBUF_2_10G; + } + m_mbuf[MBUF_64] = m_mbuf[MBUF_64]*2; + + m_mbuf[MBUF_2048] = CONST_NB_MBUF_2_10G/2; + + m_mbuf[MBUF_4096] = 128; + m_mbuf[MBUF_9k] = 512; + + + m_mbuf[TRAFFIC_MBUF_64] = m_mbuf[MBUF_64] * 4; + m_mbuf[TRAFFIC_MBUF_128] = m_mbuf[MBUF_128] * 4; + + m_mbuf[TRAFFIC_MBUF_2048] = CONST_NB_MBUF_2_10G * 8; + + m_mbuf[TRAFFIC_MBUF_4096] = 128; + m_mbuf[TRAFFIC_MBUF_9k] = 512; + + + m_mbuf[MBUF_DP_FLOWS] = (1024*1024/2); + m_mbuf[MBUF_GLOBAL_FLOWS] =(10*1024/2); +} + +const std::string names []={ + "MBUF_64", + "MBUF_128", + "MBUF_256", + "MBUF_512", + "MBUF_1024", + "MBUF_2048", + "MBUF_4096", + "MBUF_9K", + + "TRAFFIC_MBUF_64", + "TRAFFIC_MBUF_128", + "TRAFFIC_MBUF_256", + "TRAFFIC_MBUF_512", + "TRAFFIC_MBUF_1024", + "TRAFFIC_MBUF_2048", + "TRAFFIC_MBUF_4096", + "TRAFFIC_MBUF_9K", + + "MBUF_DP_FLOWS", + "MBUF_GLOBAL_FLOWS" + +}; + +const std::string * get_mbuf_names(void){ + return names; +} + +void CPlatformDualIfYamlInfo::Dump(FILE *fd){ + fprintf(fd," socket : %d \n",m_socket); + int i; + fprintf(fd," [ "); + for (i=0; i<m_threads.size(); i++) { + fprintf(fd," %d ",(int)m_threads[i]); + } + fprintf(fd," ] \n"); +} + +void CPlatformCoresYamlInfo::Dump(FILE *fd){ + if ( m_is_exists == false){ + fprintf(fd," no platform info \n"); + return; + } + fprintf(fd," master thread : %d \n", m_master_thread); + fprintf(fd," rx thread : %d \n", m_rx_thread); + int i; + for (i=0; i<m_dual_if.size(); i++) { + printf(" dual_if : %d \n",i); + CPlatformDualIfYamlInfo * lp=&m_dual_if[i]; + lp->Dump(fd); + } +} + +void operator >> (const YAML::Node& node, CPlatformDualIfYamlInfo & plat_info) { + node["socket"] >> plat_info.m_socket; + const YAML::Node& threads = node["threads"]; + /* fill the vector*/ + for(unsigned i=0;i<threads.size();i++) { + uint32_t fi; + const YAML::Node & node = threads; + node[i] >> fi; + plat_info.m_threads.push_back(fi); + } +} + +void operator >> (const YAML::Node& node, CPlatformCoresYamlInfo & plat_info) { + node["master_thread_id"] >> plat_info.m_master_thread; + if (node.FindValue("rx_thread_id")) { + node["rx_thread_id"] >> plat_info.m_rx_thread; + } else { + // Obolete option. + if (node.FindValue("latency_thread_id")) { + node["latency_thread_id"] >> plat_info.m_rx_thread; + } else { + node["rx_thread_id"] >> plat_info.m_rx_thread; // do this to get the error message + } + } + + const YAML::Node& dual_info = node["dual_if"]; + for(unsigned i=0;i<dual_info.size();i++) { + CPlatformDualIfYamlInfo fi; + dual_info[i] >> fi; + plat_info.m_dual_if.push_back(fi); + } +} + +void CPlatformMemoryYamlInfo::Dump(FILE *fd){ + fprintf(fd," memory per 2x10G ports \n"); + const std::string * names =get_mbuf_names(); + + int i=0; + for (i=0; i<MBUF_ELM_SIZE; i++) { + fprintf(fd," %-40s : %lu \n",names[i].c_str(), (ulong)m_mbuf[i]); + } +} + +void CMacYamlInfo::copy_dest(char *p){ + assert(m_dest_base.size() == 6); + int i; + for (i=0; i<m_dest_base.size(); i++) { + p[i]=m_dest_base[i]; + } +} + +void CMacYamlInfo::copy_src(char *p){ + assert(m_src_base.size() == 6); + int i; + for (i=0; i<m_src_base.size(); i++) { + p[i]=m_src_base[i]; + } +} + +uint32_t CMacYamlInfo::get_def_gw() { + return m_def_gw; +} + +uint32_t CMacYamlInfo::get_ip() { + return m_ip; +} + +uint32_t CMacYamlInfo::get_mask() { + return m_mask; +} + +uint32_t CMacYamlInfo::get_vlan() { + return m_vlan; +} + +void CMacYamlInfo::Dump(FILE *fd){ + if (m_dest_base.size() != 6) { + fprintf(fd,"ERROR in dest mac addr \n"); + return; + } + if (m_src_base.size() != 6) { + fprintf(fd,"ERROR in src mac addr \n"); + return; + } + fprintf (fd," src : "); + dump_mac_vector( m_src_base,fd); + fprintf (fd," dest : "); + dump_mac_vector( m_dest_base,fd); + +} + +void operator >> (const YAML::Node& node, CMacYamlInfo & mac_info) { + uint32_t fi; + bool res; + std::string mac_str; + + if (node.FindValue("dest_mac")) { + const YAML::Node& dmac = node["dest_mac"]; + if (dmac.Type() == YAML::NodeType::Sequence) { // [1,2,3,4,5,6] + ASSERT_MSG(dmac.size() == 6, "Array of dest MAC should have 6 elements."); + for(unsigned i=0;i<dmac.size();i++) { + dmac[i] >> fi; + mac_info.m_dest_base.push_back(fi); + } + } + else if (dmac.Type() == YAML::NodeType::Scalar) { // "12:34:56:78:9a:bc" + dmac >> mac_str; + res = mac2vect(mac_str, mac_info.m_dest_base); + ASSERT_MSG(res && mac_info.m_dest_base.size() == 6 + , "String of dest MAC should be in format '12:34:56:78:9a:bc'."); + } + } else { + for(unsigned i = 0; i < 6; i++) { + mac_info.m_dest_base.push_back(0); + } + } + + if (node.FindValue("src_mac")) { + const YAML::Node& smac = node["src_mac"]; + if (smac.Type() == YAML::NodeType::Sequence) { + ASSERT_MSG(smac.size() == 6, "Array of src MAC should have 6 elements."); + for(unsigned i=0;i<smac.size();i++) { + smac[i] >> fi; + mac_info.m_src_base.push_back(fi); + } + } + else if (smac.Type() == YAML::NodeType::Scalar) { + smac >> mac_str; + res = mac2vect(mac_str, mac_info.m_src_base); + ASSERT_MSG(res && mac_info.m_src_base.size() == 6 + , "String of src MAC should be in format '12:34:56:78:9a:bc'."); + } + } else { + for(unsigned i = 0; i < 6; i++) { + mac_info.m_src_base.push_back(0); + } + } + + if (! utl_yaml_read_ip_addr(node, "default_gw", mac_info.m_def_gw)) { + mac_info.m_def_gw = 0; + } + + if (! utl_yaml_read_ip_addr(node, "ip", mac_info.m_ip)) { + mac_info.m_ip = 0; + } + if (! utl_yaml_read_ip_addr(node, "mask", mac_info.m_mask)) { + mac_info.m_mask = 0; + } + if (! utl_yaml_read_uint16(node, "vlan", mac_info.m_vlan)) { + mac_info.m_vlan = 0; + } +} + +void operator >> (const YAML::Node& node, CPlatformMemoryYamlInfo & plat_info) { + if ( node.FindValue("mbuf_64") ){ + node["mbuf_64"] >> plat_info.m_mbuf[MBUF_64]; + } + + if ( node.FindValue("mbuf_128") ){ + node["mbuf_128"] >> plat_info.m_mbuf[MBUF_128]; + } + + if ( node.FindValue("mbuf_256") ){ + node["mbuf_256"] >> plat_info.m_mbuf[MBUF_256]; + } + + if ( node.FindValue("mbuf_512") ){ + node["mbuf_512"] >> plat_info.m_mbuf[MBUF_512]; + } + + if ( node.FindValue("mbuf_1024") ){ + node["mbuf_1024"] >> plat_info.m_mbuf[MBUF_1024]; + } + + if ( node.FindValue("mbuf_2048") ){ + node["mbuf_2048"] >> plat_info.m_mbuf[MBUF_2048]; + } + + if ( node.FindValue("mbuf_4096") ){ + node["mbuf_4096"] >> plat_info.m_mbuf[MBUF_4096]; + } + + if ( node.FindValue("mbuf_9k") ){ + node["mbuf_9k"] >> plat_info.m_mbuf[MBUF_9k]; + } + + + if ( node.FindValue("traffic_mbuf_64") ){ + node["traffic_mbuf_64"] >> plat_info.m_mbuf[TRAFFIC_MBUF_64]; + } + + if ( node.FindValue("traffic_mbuf_128") ){ + node["traffic_mbuf_128"] >> plat_info.m_mbuf[TRAFFIC_MBUF_128]; + } + + if ( node.FindValue("traffic_mbuf_256") ){ + node["traffic_mbuf_256"] >> plat_info.m_mbuf[TRAFFIC_MBUF_256]; + } + + if ( node.FindValue("traffic_mbuf_512") ){ + node["traffic_mbuf_512"] >> plat_info.m_mbuf[TRAFFIC_MBUF_512]; + } + + if ( node.FindValue("traffic_mbuf_1024") ){ + node["traffic_mbuf_1024"] >> plat_info.m_mbuf[TRAFFIC_MBUF_1024]; + } + + if ( node.FindValue("traffic_mbuf_2048") ){ + node["traffic_mbuf_2048"] >> plat_info.m_mbuf[TRAFFIC_MBUF_2048]; + } + + if ( node.FindValue("traffic_mbuf_4096") ){ + node["traffic_mbuf_4096"] >> plat_info.m_mbuf[TRAFFIC_MBUF_4096]; + } + + if ( node.FindValue("traffic_mbuf_9k") ){ + node["traffic_mbuf_9k"] >> plat_info.m_mbuf[TRAFFIC_MBUF_9k]; + } + + + if ( node.FindValue("dp_flows") ){ + node["dp_flows"] >> plat_info.m_mbuf[MBUF_DP_FLOWS]; + } + + if ( node.FindValue("global_flows") ){ + node["global_flows"] >> plat_info.m_mbuf[MBUF_GLOBAL_FLOWS]; + } + +} + +void operator >> (const YAML::Node& node, CPlatformYamlInfo & plat_info) { + if (node.FindValue("interface_mask")) { + printf("WARNING interface_mask in not used any more !\n"); + } + + /* must have interfaces */ + const YAML::Node& interfaces = node["interfaces"]; + for(unsigned i=0;i<interfaces.size();i++) { + std::string fi; + const YAML::Node & node = interfaces; + node[i] >> fi; + plat_info.m_if_list.push_back(fi); + } + + + if ( node.FindValue("port_limit") ){ + node["port_limit"] >> plat_info.m_port_limit; + plat_info.m_port_limit_exist=true; + } + + + plat_info.m_enable_zmq_pub_exist = true; + + if ( node.FindValue("enable_zmq_pub") ){ + node["enable_zmq_pub"] >> plat_info.m_enable_zmq_pub; + plat_info.m_enable_zmq_pub_exist = true; + } + + if ( node.FindValue("zmq_pub_port") ){ + node["zmq_pub_port"] >> plat_info.m_zmq_pub_port; + plat_info.m_enable_zmq_pub_exist = true; + } + + if ( node.FindValue("prefix") ){ + node["prefix"] >> plat_info.m_prefix; + } + + if ( node.FindValue("limit_memory") ){ + node["limit_memory"] >> plat_info.m_limit_memory; + } + + if ( node.FindValue("c") ){ + node["c"] >> plat_info.m_thread_per_dual_if; + } + + if ( node.FindValue("telnet_port") ){ + node["telnet_port"] >> plat_info.m_telnet_port; + plat_info.m_telnet_exist=true; + } + + if ( node.FindValue("zmq_rpc_port") ){ + node["zmq_rpc_port"] >> plat_info.m_zmq_rpc_port; + } + + if ( node.FindValue("port_bandwidth_gb") ){ + node["port_bandwidth_gb"] >> plat_info.m_port_bandwidth_gb; + } + + if ( node.FindValue("memory") ){ + node["memory"] >> plat_info.m_memory; + } + + if ( node.FindValue("platform") ){ + node["platform"] >> plat_info.m_platform; + plat_info.m_platform.m_is_exists=true; + } + + if ( node.FindValue("port_info") ) { + const YAML::Node& mac_info = node["port_info"]; + for(unsigned i=0;i<mac_info.size();i++) { + CMacYamlInfo fi; + const YAML::Node & node =mac_info; + node[i] >> fi; + plat_info.m_mac_info.push_back(fi); + } + plat_info.m_mac_info_exist = true; + } +} + +int CPlatformYamlInfo::load_from_yaml_file(std::string file_name){ + reset(); + m_info_exist =true; + + if ( !utl_is_file_exists(file_name) ){ + printf(" ERROR file %s does not exists \n",file_name.c_str()); + exit(-1); + } + + try { + std::ifstream fin((char *)file_name.c_str()); + YAML::Parser parser(fin); + YAML::Node doc; + + parser.GetNextDocument(doc); + for(unsigned i=0;i<doc.size();i++) { + doc[i] >> *this; + break; + } + } catch ( const std::exception& e ) { + std::cout << e.what() << "\n"; + exit(-1); + } + return (0); +} + +std::string CPlatformYamlInfo::get_use_if_comma_seperated(){ + std::string s=""; + int i; + for (i=0; i<(int)m_if_list.size()-1; i++) { + s+=m_if_list[i]+","; + } + s+=m_if_list[i]; + return (s); +} + +void CPlatformYamlInfo::Dump(FILE *fd){ + if ( m_info_exist ==false ){ + fprintf(fd," file info does not exist \n"); + return; + } + + if (m_port_limit_exist && (m_port_limit != 0xffffffff)) { + fprintf(fd," port limit : %d \n",m_port_limit); + }else{ + fprintf(fd," port limit : not configured \n"); + } + fprintf(fd," port_bandwidth_gb : %lu \n", (ulong)m_port_bandwidth_gb); + + if ( m_if_mask_exist && m_if_mask.size() ) { + fprintf(fd," if_mask : "); + int i; + for (i=0; i<(int)m_if_mask.size(); i++) { + fprintf(fd," %s,",m_if_mask[i].c_str()); + } + fprintf(fd,"\n"); + + }else{ + fprintf(fd," if_mask : None \n"); + } + + if ( m_prefix.length() ){ + fprintf(fd," prefix : %s \n",m_prefix.c_str()); + } + if ( m_limit_memory.length() ){ + fprintf(fd," limit_memory : %s \n",m_limit_memory.c_str()); + } + fprintf(fd," thread_per_dual_if : %d \n",(int)m_thread_per_dual_if); + + fprintf(fd," if : "); + int i; + for (i=0; i<(int)m_if_list.size(); i++) { + fprintf(fd," %s,",m_if_list[i].c_str()); + } + fprintf(fd,"\n"); + + if ( m_enable_zmq_pub_exist ){ + fprintf(fd," enable_zmq_pub : %d \n",m_enable_zmq_pub?1:0); + fprintf(fd," zmq_pub_port : %d \n",m_zmq_pub_port); + } + if ( m_telnet_exist ){ + fprintf(fd," telnet_port : %d \n",m_telnet_port); + + } + fprintf(fd," m_zmq_rpc_port : %d \n",m_zmq_rpc_port); + + if ( m_mac_info_exist ){ + int i; + for (i=0; i<(int)m_mac_info.size(); i++) { + m_mac_info[i].Dump(fd); + } + } + m_memory.Dump(fd); + m_platform.Dump(fd); +} |