aboutsummaryrefslogtreecommitdiffstats
path: root/docs/gettingstarted/developers/softwarearchitecture.md
diff options
context:
space:
mode:
authorPaul Atkins <patkins@graphiant.com>2021-01-19 15:22:23 +0000
committerDave Barach <openvpp@barachs.net>2021-02-01 17:20:32 +0000
commit2ac41357bc15dce578f67d53c25f2de357185e71 (patch)
tree9a140bee266b1b695041845f24534e2a17177696 /docs/gettingstarted/developers/softwarearchitecture.md
parent21ed5e8adeca5366073c750572b089f7656f845a (diff)
vppinfra: add defines for bihash add and delete
When calling the bihash_add_del... functions some callers add a comment beside the value to indicate this is the is_add param. Make the code easier to read by adding defines for add and delete that the callers can use instead of having to use 0 or 1. Type: improvement Signed-off-by: Paul Atkins <patkins@graphiant.com> Change-Id: Iab5f7c8e8df12ac62fc7e726ca1798622dcdb42c
Diffstat (limited to 'docs/gettingstarted/developers/softwarearchitecture.md')
0 files changed, 0 insertions, 0 deletions
ef='#n220'>220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 
/*
 Hanoh Haim
 Cisco Systems, Inc.
*/

/*
Copyright (c) 2015-2015 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 "bp_sim.h"
#include "os_time.h"
#include "trex_client_config.h"

#include <unordered_map>
#include <string>

#include <common/arg/SimpleGlob.h>
#include <common/arg/SimpleOpt.h>
#include <stateless/cp/trex_stateless.h>
#include <sim/trex_sim.h>

using namespace std;

// An enum for all the option types
enum { OPT_HELP, OPT_CFG, OPT_NODE_DUMP, OP_STATS,
       OPT_FILE_OUT, OPT_UT, OPT_PCAP, OPT_IPV6, OPT_CLIENT_CFG_FILE,
       OPT_SL, OPT_DP_CORE_COUNT, OPT_DP_CORE_INDEX, OPT_LIMIT,
       OPT_DRY_RUN, OPT_DURATION};



/**
 * type of run 
 * GTEST 
 * Stateful 
 * Stateless 
 */
typedef enum {
    OPT_TYPE_GTEST = 7,
    OPT_TYPE_SF,
    OPT_TYPE_SL
} opt_type_e;


/* these are the argument types:
   SO_NONE --    no argument needed
   SO_REQ_SEP -- single required argument
   SO_MULTI --   multiple arguments needed
*/
static CSimpleOpt::SOption parser_options[] =
{
    { OPT_HELP,               "-?",           SO_NONE    },
    { OPT_HELP,               "-h",           SO_NONE    },
    { OPT_HELP,               "--help",       SO_NONE    },
    { OPT_UT,                 "--ut",         SO_NONE    },
    { OP_STATS,               "-s",           SO_NONE    },
    { OPT_CFG,                "-f",           SO_REQ_SEP },
    { OPT_CLIENT_CFG_FILE,    "--client_cfg", SO_REQ_SEP },
    { OPT_CLIENT_CFG_FILE,    "--client-cfg", SO_REQ_SEP },
    { OPT_FILE_OUT ,          "-o",           SO_REQ_SEP },
    { OPT_NODE_DUMP ,         "-v",           SO_REQ_SEP },
    { OPT_DURATION,           "-d",           SO_REQ_SEP },
    { OPT_PCAP,               "--pcap",       SO_NONE    },
    { OPT_IPV6,               "--ipv6",       SO_NONE    },
    { OPT_SL,                 "--sl",         SO_NONE    },
    { OPT_DP_CORE_COUNT,      "--cores",      SO_REQ_SEP },
    { OPT_DP_CORE_INDEX,      "--core_index", SO_REQ_SEP },
    { OPT_LIMIT,              "--limit",      SO_REQ_SEP },
    { OPT_DRY_RUN,            "--dry",      SO_NONE },

    
    SO_END_OF_OPTIONS
};

static TrexStateless *m_sim_statelss_obj;
static char *g_exe_name;

const char *get_exe_name() {
    return g_exe_name;
}

static int usage(){

    printf(" Usage: bp_sim [OPTION] -f cfg.yaml -o outfile.erf   \n");
    printf(" \n");
    printf(" \n");
    printf(" options:\n");
    printf(" -d  [s]   duration time of simulated traffic in seconds\n");
    printf(" -v  [1-3]   verbose mode  \n");
    printf("      1    show only stats  \n");
    printf("      2    run preview do not write to file  \n");
    printf("      3    run preview write stats file  \n");
    printf("  Note in case of verbose mode you don't need to add the output file \n");
    printf("   \n");
    printf("  Warning : This program can generate huge-files (TB ) watch out! try this only on local drive \n");
    printf(" \n");
    printf(" --pcap  export the file in pcap mode \n");
    printf(" Examples: ");
    printf("  1) preview show csv stats \n");
    printf("  #>bp_sim -f cfg.yaml -v 1 \n");
    printf("  \n ");
    printf("  2) more detail preview preview show csv stats \n");
    printf("  #>bp_sim -f cfg.yaml -v 2 \n");
    printf("  \n ");
    printf("  3) more detail preview plus stats  \n");
    printf("  #>bp_sim -f cfg.yaml -v 3 \n");
    printf("  \n ");
    printf("  4) do the job  ! \n");
    printf("  #>bp_sim -f cfg.yaml -o outfile.erf \n");
    printf("\n");
    printf("\n");
    printf(" Copyright (C) 2015 by hhaim Cisco-System for IL dev-test \n");
    printf(" version : 1.0 beta  \n");
    return (0);
}


static int parse_options(int argc,
                         char *argv[],
                         CParserOption* po,
                         std::unordered_map<std::string, int> &params) {

     CSimpleOpt args(argc, argv, parser_options);

     int a=0;
     int node_dump=0;
     po->preview.clean();
     po->preview.setFileWrite(true);

     /* by default - type is stateful */
     params["type"] = OPT_TYPE_SF;

     while ( args.Next() ){
        if (args.LastError() == SO_SUCCESS) {
            switch (args.OptionId()) {
            case OPT_UT :
                params["type"] = OPT_TYPE_GTEST;
                return (0);
                break;

            case OPT_HELP: 
                usage();
                return -1;

            case OPT_SL:
                params["type"] = OPT_TYPE_SL;
                break;

            case OPT_CFG:
                po->cfg_file = args.OptionArg();
                break;

            case OPT_CLIENT_CFG_FILE:
                po->client_cfg_file = args.OptionArg();
                break;

            case OPT_FILE_OUT:
                po->out_file = args.OptionArg();
                break;

            case OPT_IPV6:
                po->preview.set_ipv6_mode_enable(true);
                break;

            case OPT_NODE_DUMP:
                a=atoi(args.OptionArg());
                node_dump=1;
                po->preview.setFileWrite(false);
                break;

            case OPT_PCAP:
                po->preview.set_pcap_mode_enable(true);
                break;

            case OPT_DP_CORE_COUNT:
                params["dp_core_count"] = atoi(args.OptionArg());
                break;

            case OPT_DP_CORE_INDEX:
                params["dp_core_index"] = atoi(args.OptionArg());
                break;

            case OPT_LIMIT:
                params["limit"] = atoi(args.OptionArg());
                break;

            case OPT_DURATION:
                sscanf(args.OptionArg(),"%f", &po->m_duration);
                break;

            case OPT_DRY_RUN:
                params["dry"] = 1;
                break;

            default:
                printf("Error: option %s is defined, but not handled.\n\n", args.OptionText());
                return -1;
                break;
            } // End of switch
         }// End of IF
        else {
            usage();
            return -1;
        }
     } // End of while
     

    if ((po->cfg_file =="") ) {
         printf("Invalid combination of parameters you must add -f with configuration file \n");
         usage();
         return -1;
     }

    if ( node_dump ){
        po->preview.setVMode(a);
    }else{
        if  (po->out_file=="" ){
         printf("Invalid combination of parameters you must give output file iwth -o  \n");
         usage();
         return -1;
        }
    }

    /* did the user configure dp core count or dp core index ? */

    if (params.count("dp_core_count") > 0) {
        if (!in_range(params["dp_core_count"], 1, 8)) {
            printf("dp core count must be a value between 1 and 8\n");
            return (-1);
        }
    }

     if (params.count("dp_core_index") > 0) {
        if (!in_range(params["dp_core_index"], 0, params["dp_core_count"] - 1)) {
            printf("dp core index must be a value between 0 and cores - 1\n");
            return (-1);
        }
    }

    return 0;
}

void set_default_mac_addr(){

    int i;
    for (i=0; i<4; i++) {
        memset(CGlobalInfo::m_options.get_dst_src_mac_addr(i),((i+1)<<4),6);
        memset(CGlobalInfo::m_options.get_src_mac_addr(i),((i+1)<<4)+8,6);
    }
}

TrexStateless * get_stateless_obj() {
    return m_sim_statelss_obj;
}

CRxCoreStateless * get_rx_sl_core_obj() {
    return NULL;
}

void set_stateless_obj(TrexStateless *obj) {
    m_sim_statelss_obj = obj;
}

int main(int argc , char * argv[]){
    g_exe_name = argv[0];

    std::unordered_map<std::string, int> params;

    if ( parse_options(argc, argv, &CGlobalInfo::m_options , params) != 0) {
        exit(-1);
    }
    set_default_mac_addr();

    opt_type_e type = (opt_type_e) params["type"];

    switch (type) {
    case OPT_TYPE_GTEST:
        {
            SimGtest test;
            return test.run(argc, argv);
        }

    case OPT_TYPE_SF:
        {
            SimStateful sf;
            CGlobalInfo::m_options.m_run_mode = CParserOption::RUN_MODE_BATCH;
            return sf.run();
        }

    case OPT_TYPE_SL:
        {
            SimStateless &st = SimStateless::get_instance();
            CGlobalInfo::m_options.m_run_mode = CParserOption::RUN_MODE_INTERACTIVE;

            if (params.count("dp_core_count") == 0) {
                params["dp_core_count"] = 1;
            }

            if (params.count("dp_core_index") == 0) {
                params["dp_core_index"] = -1;
            }

            if (params.count("limit") == 0) {
                params["limit"] = 5000;
            }

            if (params.count("dry") == 0) {
                params["dry"] = 0;
            }

            return st.run(CGlobalInfo::m_options.cfg_file,
                          CGlobalInfo::m_options.out_file,
                          2,
                          params["dp_core_count"],
                          params["dp_core_index"],
                          params["limit"],
                          (params["dry"] == 1)
                          );
        }
    }
}