/**
* Prinf usage information
*/
static void usage(char *progname)
{
printf("\n"
"OpenDataPlane L2 forwarding application.\n"
"\n"
"Usage: %s OPTIONS\n"
" E.g. %s -i eth0,eth1,eth2,eth3 -m 0 -t 1\n"
" In the above example,\n"
" eth0 will send pkts to eth1 and vice versa\n"
" eth2 will send pkts to eth3 and vice versa\n"
"\n"
"Mandatory OPTIONS:\n"
" -i, --interface Eth interfaces (comma-separated, no spaces)\n"
" -m, --mode 0: Burst send&receive packets (no queues)\n"
" 1: Send&receive packets through ODP queues.\n"
"\n"
"Optional OPTIONS\n"
" -c, --count <number> CPU count.\n"
" -t, --time <number> Time in seconds to run.\n"
" -a, --accuracy <number> Time in seconds get print statistics\n"
" (default is 1 second).\n"
" -h, --help Display help and exit.\n\n"
" environment variables: ODP_PKTIO_DISABLE_SOCKET_MMAP\n"
" ODP_PKTIO_DISABLE_SOCKET_MMSG\n"
" can be used to advanced pkt I/O selection for linux-generic\n"
"\n", NO_PATH(progname), NO_PATH(progname)
);
}
/**
* Prinf usage information
*/
static void usage(char *progname)
{
printf("\n"
"Usage: %s OPTIONS\n"
" E.g. %s -i eth1,eth2,eth3 -m 0\n"
"\n"
"OpenDataPlane example application.\n"
"\n"
"Mandatory OPTIONS:\n"
" -i, --interface Eth interfaces (comma-separated, no spaces)\n"
" -m, --mode 0: Burst send&receive packets (no queues)\n"
" 1: Send&receive packets through ODP queues.\n"
" -t, --type 1: ODP_PKTIO_TYPE_SOCKET_BASIC\n"
" 2: ODP_PKTIO_TYPE_SOCKET_MMSG\n"
" 3: ODP_PKTIO_TYPE_SOCKET_MMAP\n"
" 4: ODP_PKTIO_TYPE_NETMAP\n"
" Default: 3: ODP_PKTIO_TYPE_SOCKET_MMAP\n"
" -f, --fanout 0: off 1: on (Default 1: on)\n"
"\n"
"Optional OPTIONS\n"
" -c, --count <number> Core count.\n"
" -h, --help Display help and exit.\n"
"\n", NO_PATH(progname), NO_PATH(progname)
);
}
/**
* Prinf usage information
*/
static void usage(char *progname)
{
printf("\n"
"Usage: %s OPTIONS\n"
" E.g. %s -i eth1,eth2,eth3\n"
"\n"
"ODPFastpath application.\n"
"\n"
"Mandatory OPTIONS:\n"
" -i, --interface Eth interfaces (comma-separated, no spaces)\n"
"\n"
"Optional OPTIONS\n"
" -c, --count <number> Core count.\n"
" -h, --help Display help and exit.\n"
"\n", NO_PATH(progname), NO_PATH(progname)
);
}
/**
* Prinf usage information
*/
static void usage(char *progname)
{
printf("\n"
"Usage: %s OPTIONS\n"
" E.g. %s -I eth1 -r\n"
"\n"
"OpenDataPlane example application.\n"
"\n"
" Work mode:\n"
" 1.send udp packets\n"
" odp_generator -I eth0 --srcmac fe:0f:97:c9:e0:44 --dstmac 32:cb:9b:27:2f:1a --srcip 192.168.0.1 --dstip 192.168.0.2 -m u\n"
" 2.receive udp packets\n"
" odp_generator -I eth0 -m r\n"
" 3.work likes ping\n"
" odp_generator -I eth0 --srcmac fe:0f:97:c9:e0:44 --dstmac 32:cb:9b:27:2f:1a --srcip 192.168.0.1 --dstip 192.168.0.2 --cpumask 0xc -m p\n"
"\n"
"Mandatory OPTIONS:\n"
" -I, --interface Eth interfaces (comma-separated, no spaces)\n"
" -a, --srcmac src mac address\n"
" -b, --dstmac dst mac address\n"
" -s, --srcip src ip address\n"
" -d, --dstip dst ip address\n"
" -m, --mode work mode: send udp(u), receive(r), send icmp(p)\n"
"\n"
"Optional OPTIONS\n"
" -h, --help Display help and exit.\n"
" environment variables: ODP_PKTIO_DISABLE_NETMAP\n"
" ODP_PKTIO_DISABLE_SOCKET_MMAP\n"
" ODP_PKTIO_DISABLE_SOCKET_MMSG\n"
" can be used to advanced pkt I/O selection for linux-generic\n"
" -p, --payloadsize payload length of the packets\n"
" -P, --packetsize payload + header length of the packets\n"
" -t, --timeout only for ping mode, wait ICMP reply timeout seconds\n"
" -i, --interval wait interval ms between sending each packet\n"
" default is 1000ms. 0 for flood mode\n"
" -w, --workers specify number of workers need to be assigned to application\n"
" default is to assign all\n"
" -n, --count the number of packets to be send\n"
" -c, --cpumask to set on cores\n"
"\n", NO_PATH(progname), NO_PATH(progname)
);
}
/**
* Prinf usage information
*/
static void usage(char *progname)
{
printf("\n"
"Usage: %s OPTIONS\n"
" E.g. %s -i eth1,eth2,eth3\n"
"\n"
"ODPFastpath application.\n"
"\n"
"Mandatory OPTIONS:\n"
" -i, --interface Eth interfaces (comma-separated, no spaces)\n"
" -l, local address\n"
" -r, remote address\n"
" -s, number of local sockets, at least one(default)\n"
"\n"
"Optional OPTIONS\n"
" -c, --count <number> Core count.\n"
" -h, --help Display help and exit.\n"
"\n", NO_PATH(progname), NO_PATH(progname)
);
}
/**
* Print usage information
*/
static void usage(char *progname)
{
printf("\n"
"OpenDataPlane learning switch example.\n"
"\n"
"Usage: %s OPTIONS\n"
" E.g. %s -i eth0,eth1,eth2,eth3\n"
"\n"
"Mandatory OPTIONS:\n"
" -i, --interface Eth interfaces (comma-separated, no spaces)\n"
" Interface count min 2, max %i\n"
"\n"
"Optional OPTIONS:\n"
" -c, --count <number> CPU count.\n"
" -t, --time <number> Time in seconds to run.\n"
" -a, --accuracy <number> Statistics print interval in seconds\n"
" (default is 10 second).\n"
" -h, --help Display help and exit.\n\n"
"\n", NO_PATH(progname), NO_PATH(progname), MAX_PKTIOS
);
}
/**
* Prinf usage information
*/
static void usage(char *progname)
{
printf("\n"
"OpenDataPlane L2 forwarding application.\n"
"\n"
"Usage: %s OPTIONS\n"
" E.g. %s -i eth0,eth1,eth2,eth3 -m 0 -t 1\n"
" In the above example,\n"
" eth0 will send pkts to eth1 and vice versa\n"
" eth2 will send pkts to eth3 and vice versa\n"
"\n"
"Mandatory OPTIONS:\n"
" -i, --interface Eth interfaces (comma-separated, no spaces)\n"
"\n"
"Optional OPTIONS\n"
" -m, --mode 0: Send&receive packets directly from NIC (default)\n"
" 1: Send&receive packets through scheduler sync none queues\n"
" 2: Send&receive packets through scheduler sync atomic queues\n"
" 3: Send&receive packets through scheduler sync ordered queues\n"
" -c, --count <number> CPU count.\n"
" -t, --time <number> Time in seconds to run.\n"
" -a, --accuracy <number> Time in seconds get print statistics\n"
" (default is 1 second).\n"
" -d, --dst_change 0: Don't change packets' dst eth addresses (default)\n"
" 1: Change packets' dst eth addresses\n"
" -s, --src_change 0: Don't change packets' src eth addresses\n"
" 1: Change packets' src eth addresses (default)\n"
" -e, --error_check 0: Don't check packet errors (default)\n"
" 1: Check packet errors\n"
" -h, --help Display help and exit.\n\n"
" environment variables: ODP_PKTIO_DISABLE_NETMAP\n"
" ODP_PKTIO_DISABLE_SOCKET_MMAP\n"
" ODP_PKTIO_DISABLE_SOCKET_MMSG\n"
" can be used to advanced pkt I/O selection for linux-generic\n"
"\n", NO_PATH(progname), NO_PATH(progname)
);
}
/**
* Prinf usage information
*/
static void usage(char *progname)
{
printf("\n"
"Usage: %s OPTIONS\n"
" E.g. %s -i eth1,eth2,eth3\n"
"\n"
"ODPFastpath application.\n"
"\n"
"Mandatory OPTIONS:\n"
" -i, --interface Eth interfaces (comma-separated, no spaces)\n"
"\n"
"Optional OPTIONS\n"
" -c, --count <number> Core count.\n"
" -r, --root <web root folder> Webserver root folder.\n"
"\tDefault: "DEFAULT_ROOT_DIRECTORY"\n"
" -l, --laddr <IPv4 address> IPv4 address were webserver binds.\n"
"\tDefault: %s\n"
" -p, --lport <port> Port address were webserver binds.\n"
"\tDefault: %d\n"
" -h, --help Display help and exit.\n"
"\n", NO_PATH(progname), NO_PATH(progname),
ofp_print_ip_addr(DEFAULT_BIND_ADDRESS), DEFAULT_BIND_PORT
);
}
/**
* main() Application entry point
*
* This is the main function of the FPM application, it's a minimalistic
* example, see 'usage' function for available arguments and usage.
*
* Using the number of available cores as input, this example sets up
* ODP dispatcher threads executing OFP VLAN processesing and starts
* a CLI function on a managment core.
*
* @param argc int
* @param argv[] char*
* @return int
*
*/
int main(int argc, char *argv[])
{
odph_linux_pthread_t thread_tbl[MAX_WORKERS];
appl_args_t params;
int core_count, num_workers, ret_val;
odp_cpumask_t cpumask;
char cpumaskstr[64];
odph_linux_thr_params_t thr_params;
odp_instance_t instance;
/* Parse and store the application arguments */
if (parse_args(argc, argv, ¶ms) != EXIT_SUCCESS)
return EXIT_FAILURE;
if (ofp_sigactions_set(ofp_sig_func_stop)) {
printf("Error: failed to set signal actions.\n");
return EXIT_FAILURE;
}
/*
* Before any ODP API functions can be called, we must first init the ODP
* globals, e.g. availale accelerators or software implementations for
* shared memory, threads, pool, qeueus, sheduler, pktio, timer, crypto
* and classification.
*/
if (odp_init_global(&instance, NULL, NULL)) {
printf("Error: ODP global init failed.\n");
return EXIT_FAILURE;
}
/*
* When the gloabel ODP level init has been done, we can now issue a
* local init per thread. This must also be done before any other ODP API
* calls may be made. Local inits are made here for shared memory,
* threads, pktio and scheduler.
*/
if (odp_init_local(instance, ODP_THREAD_CONTROL) != 0) {
printf("Error: ODP local init failed.\n");
odp_term_global(instance);
return EXIT_FAILURE;
}
/* Print both system and application information */
print_info(NO_PATH(argv[0]), ¶ms);
/*
* Get the number of cores available to ODP, one run-to-completion thread
* will be created per core.
*/
core_count = odp_cpu_count();
num_workers = core_count;
if (params.core_count)
num_workers = params.core_count;
if (num_workers > MAX_WORKERS)
num_workers = MAX_WORKERS;
/*
* This example assumes that core #0 runs Linux kernel background tasks.
* By default, cores #1 and beyond will be populated with a OFP
* processing thread each.
*/
memset(&app_init_params, 0, sizeof(app_init_params));
app_init_params.linux_core_id = 0;
if (core_count > 1)
num_workers--;
/*
* Initializes cpumask with CPUs available for worker threads.
* Sets up to 'num' CPUs and returns the count actually set.
* Use zero for all available CPUs.
*/
num_workers = odp_cpumask_default_worker(&cpumask, num_workers);
if (odp_cpumask_to_str(&cpumask, cpumaskstr, sizeof(cpumaskstr)) < 0) {
printf("Error: Too small buffer provided to "
"odp_cpumask_to_str\n");
odp_term_local();
odp_term_global(instance);
return EXIT_FAILURE;
}
printf("Num worker threads: %i\n", num_workers);
printf("first CPU: %i\n", odp_cpumask_first(&cpumask));
printf("cpu mask: %s\n", cpumaskstr);
app_init_params.if_count = params.if_count;
app_init_params.if_names = params.if_names;
app_init_params.pkt_hook[OFP_HOOK_LOCAL] = fastpath_local_hook;
/*
* Now that ODP has been initalized, we can initialize OFP. This will
* open a pktio instance for each interface supplied as argument by the
* user.
*
* General configuration will be to pktio and schedluer queues here in
* addition will fast path interface configuration.
*/
if (ofp_init_global(instance, &app_init_params) != 0) {
printf("Error: OFP global init failed.\n");
ofp_term_global();
odp_term_local();
odp_term_global(instance);
return EXIT_FAILURE;
}
if (ofp_init_local() != 0) {
printf("Error: OFP local init failed.\n");
ofp_term_local();
ofp_term_global();
odp_term_local();
odp_term_global(instance);
return EXIT_FAILURE;
}
/*
* Create and launch dataplane dispatcher worker threads to be placed
* according to the cpumask, thread_tbl will be populated with the
* created pthread IDs.
*
* In this case, all threads will run the default_event_dispatcher
* function with ofp_eth_vlan_processing as argument.
*
* If different dispatchers should run, or the same be run with differnt
* input arguments, the cpumask is used to control this.
*/
memset(thread_tbl, 0, sizeof(thread_tbl));
thr_params.start = default_event_dispatcher;
thr_params.arg = ofp_eth_vlan_processing;
thr_params.thr_type = ODP_THREAD_WORKER;
thr_params.instance = instance;
ret_val = odph_linux_pthread_create(thread_tbl,
&cpumask,
&thr_params);
if (ret_val != num_workers) {
OFP_ERR("Error: Failed to create worker threads, "
"expected %d, got %d",
num_workers, ret_val);
ofp_stop_processing();
odph_linux_pthread_join(thread_tbl, num_workers);
ofp_term_local();
ofp_term_global();
odp_term_local();
odp_term_global(instance);
return EXIT_FAILURE;
}
/*
* Now when the ODP dispatcher threads are running, further applications
* can be launched, in this case, we will start the OFP CLI thread on
* the management core, i.e. not competing for cpu cycles with the
* worker threads
*/
if (ofp_start_cli_thread(instance, app_init_params.linux_core_id,
params.conf_file) < 0) {
OFP_ERR("Error: Failed to init CLI thread");
ofp_stop_processing();
odph_linux_pthread_join(thread_tbl, num_workers);
ofp_term_local();
ofp_term_global();
odp_term_local();
odp_term_global(instance);
return EXIT_FAILURE;
}
/*
* If we choose to check performance, a performance monitoring client
* will be started on the management core. Once every second it will
* read the statistics from the workers from a shared memory region.
* Using this has negligible performance impact (<<0.01%).
*/
if (params.perf_stat) {
if (start_performance(instance,
app_init_params.linux_core_id) <= 0) {
OFP_ERR("Error: Failed to init performance monitor");
ofp_stop_processing();
odph_linux_pthread_join(thread_tbl, num_workers);
ofp_term_local();
ofp_term_global();
odp_term_local();
odp_term_global(instance);
return EXIT_FAILURE;
}
}
/*
* Wait here until all worker threads have terminated, then free up all
* resources allocated by odp_init_global().
*/
odph_linux_pthread_join(thread_tbl, num_workers);
if (ofp_term_local() < 0)
printf("Error: ofp_term_local failed\n");
if (ofp_term_global() < 0)
printf("Error: ofp_term_global failed\n");
if (odp_term_local() < 0)
printf("Error: odp_term_local failed\n");
if (odp_term_global(instance) < 0)
printf("Error: odp_term_global failed\n");
printf("FPM End Main()\n");
return EXIT_SUCCESS;
}
/**
* ODP packet example main function
*/
int main(int argc, char * argv[])
{
odph_linux_pthread_t thread_tbl[MAX_WORKERS];
odp_pool_t pool;
int num_workers;
int i;
odp_shm_t shm;
odp_cpumask_t cpumask;
char cpumaskstr[ODP_CPUMASK_STR_SIZE];
odp_pool_param_t params;
odp_timer_pool_param_t tparams;
odp_timer_pool_t tp;
odp_pool_t tmop;
/* Init ODP before calling anything else */
if (odp_init_global(NULL, NULL)) {
EXAMPLE_ERR("Error: ODP global init failed.\n");
exit(EXIT_FAILURE);
}
if (odp_init_local(ODP_THREAD_CONTROL)) {
EXAMPLE_ERR("Error: ODP local init failed.\n");
exit(EXIT_FAILURE);
}
my_sleep(1 + __k1_get_cluster_id() / 4);
/* init counters */
odp_atomic_init_u64(&counters.seq, 0);
odp_atomic_init_u64(&counters.ip, 0);
odp_atomic_init_u64(&counters.udp, 0);
odp_atomic_init_u64(&counters.icmp, 0);
odp_atomic_init_u64(&counters.cnt, 0);
/* Reserve memory for args from shared mem */
shm = odp_shm_reserve("shm_args", sizeof(args_t),
ODP_CACHE_LINE_SIZE, 0);
args = odp_shm_addr(shm);
if (args == NULL) {
EXAMPLE_ERR("Error: shared mem alloc failed.\n");
exit(EXIT_FAILURE);
}
memset(args, 0, sizeof(*args));
/* Parse and store the application arguments */
parse_args(argc, argv, &args->appl);
/* Print both system and application information */
print_info(NO_PATH(argv[0]), &args->appl);
/* Default to system CPU count unless user specified */
num_workers = MAX_WORKERS;
if (args->appl.cpu_count)
num_workers = args->appl.cpu_count;
num_workers = odp_cpumask_default_worker(&cpumask, num_workers);
if (args->appl.mask) {
odp_cpumask_from_str(&cpumask, args->appl.mask);
num_workers = odp_cpumask_count(&cpumask);
}
(void)odp_cpumask_to_str(&cpumask, cpumaskstr, sizeof(cpumaskstr));
printf("num worker threads: %i\n", num_workers);
printf("first CPU: %i\n", odp_cpumask_first(&cpumask));
printf("cpu mask: %s\n", cpumaskstr);
/* ping mode need two workers */
if (args->appl.mode == APPL_MODE_PING) {
if (num_workers < 2) {
EXAMPLE_ERR("Need at least two worker threads\n");
exit(EXIT_FAILURE);
} else {
num_workers = 2;
}
}
/* Create packet pool */
odp_pool_param_init(¶ms);
params.pkt.seg_len = SHM_PKT_POOL_BUF_SIZE;
params.pkt.len = SHM_PKT_POOL_BUF_SIZE;
params.pkt.num = SHM_PKT_POOL_SIZE/SHM_PKT_POOL_BUF_SIZE;
params.type = ODP_POOL_PACKET;
pool = odp_pool_create("packet_pool", ¶ms);
if (pool == ODP_POOL_INVALID) {
EXAMPLE_ERR("Error: packet pool create failed.\n");
exit(EXIT_FAILURE);
}
odp_pool_print(pool);
/* Create timer pool */
tparams.res_ns = 1 * ODP_TIME_MSEC_IN_NS;
tparams.min_tmo = 0;
tparams.max_tmo = 10000 * ODP_TIME_SEC_IN_NS;
tparams.num_timers = num_workers; /* One timer per worker */
tparams.priv = 0; /* Shared */
tparams.clk_src = ODP_CLOCK_CPU;
tp = odp_timer_pool_create("timer_pool", &tparams);
if (tp == ODP_TIMER_POOL_INVALID) {
EXAMPLE_ERR("Timer pool create failed.\n");
exit(EXIT_FAILURE);
}
odp_timer_pool_start();
/* Create timeout pool */
memset(¶ms, 0, sizeof(params));
params.tmo.num = tparams.num_timers; /* One timeout per timer */
params.type = ODP_POOL_TIMEOUT;
tmop = odp_pool_create("timeout_pool", ¶ms);
if (pool == ODP_POOL_INVALID) {
EXAMPLE_ERR("Error: packet pool create failed.\n");
exit(EXIT_FAILURE);
}
for (i = 0; i < args->appl.if_count; ++i)
create_pktio(args->appl.if_names[i], pool);
/* Create and init worker threads */
memset(thread_tbl, 0, sizeof(thread_tbl));
if (args->appl.mode == APPL_MODE_PING) {
odp_cpumask_t cpu_mask;
odp_queue_t tq;
int cpu_first, cpu_next;
odp_cpumask_zero(&cpu_mask);
cpu_first = odp_cpumask_first(&cpumask);
odp_cpumask_set(&cpu_mask, cpu_first);
tq = odp_queue_create("", ODP_QUEUE_TYPE_POLL, NULL);
if (tq == ODP_QUEUE_INVALID)
abort();
args->thread[1].pktio_dev = args->appl.if_names[0];
args->thread[1].pool = pool;
args->thread[1].tp = tp;
args->thread[1].tq = tq;
args->thread[1].tim = odp_timer_alloc(tp, tq, NULL);
if (args->thread[1].tim == ODP_TIMER_INVALID)
abort();
args->thread[1].tmo_ev = odp_timeout_alloc(tmop);
if (args->thread[1].tmo_ev == ODP_TIMEOUT_INVALID)
abort();
args->thread[1].mode = args->appl.mode;
odph_linux_pthread_create(&thread_tbl[1], &cpu_mask,
gen_recv_thread, &args->thread[1],
ODP_THREAD_WORKER);
tq = odp_queue_create("", ODP_QUEUE_TYPE_POLL, NULL);
if (tq == ODP_QUEUE_INVALID)
abort();
args->thread[0].pktio_dev = args->appl.if_names[0];
args->thread[0].pool = pool;
args->thread[0].tp = tp;
args->thread[0].tq = tq;
args->thread[0].tim = odp_timer_alloc(tp, tq, NULL);
if (args->thread[0].tim == ODP_TIMER_INVALID)
abort();
args->thread[0].tmo_ev = odp_timeout_alloc(tmop);
if (args->thread[0].tmo_ev == ODP_TIMEOUT_INVALID)
abort();
args->thread[0].mode = args->appl.mode;
cpu_next = odp_cpumask_next(&cpumask, cpu_first);
odp_cpumask_zero(&cpu_mask);
odp_cpumask_set(&cpu_mask, cpu_next);
odph_linux_pthread_create(&thread_tbl[0], &cpu_mask,
gen_send_thread, &args->thread[0],
ODP_THREAD_WORKER);
} else {
int cpu = odp_cpumask_first(&cpumask);
for (i = 0; i < num_workers; ++i) {
odp_cpumask_t thd_mask;
void *(*thr_run_func) (void *);
int if_idx;
odp_queue_t tq;
if_idx = i % args->appl.if_count;
args->thread[i].pktio_dev = args->appl.if_names[if_idx];
tq = odp_queue_create("", ODP_QUEUE_TYPE_POLL, NULL);
if (tq == ODP_QUEUE_INVALID)
abort();
args->thread[i].pool = pool;
args->thread[i].tp = tp;
args->thread[i].tq = tq;
args->thread[i].tim = odp_timer_alloc(tp, tq, NULL);
if (args->thread[i].tim == ODP_TIMER_INVALID)
abort();
args->thread[i].tmo_ev = odp_timeout_alloc(tmop);
if (args->thread[i].tmo_ev == ODP_TIMEOUT_INVALID)
abort();
args->thread[i].mode = args->appl.mode;
if (args->appl.mode == APPL_MODE_UDP) {
thr_run_func = gen_send_thread;
} else if (args->appl.mode == APPL_MODE_RCV) {
thr_run_func = gen_recv_thread;
} else {
EXAMPLE_ERR("ERR MODE\n");
exit(EXIT_FAILURE);
}
/*
* Create threads one-by-one instead of all-at-once,
* because each thread might get different arguments.
* Calls odp_thread_create(cpu) for each thread
*/
odp_cpumask_zero(&thd_mask);
odp_cpumask_set(&thd_mask, cpu);
odph_linux_pthread_create(&thread_tbl[i],
&thd_mask,
thr_run_func,
&args->thread[i],
ODP_THREAD_WORKER);
cpu = odp_cpumask_next(&cpumask, cpu);
}
}
print_global_stats(num_workers);
/* Master thread waits for other threads to exit */
odph_linux_pthread_join(thread_tbl, num_workers);
free(args->appl.if_names);
free(args->appl.if_str);
printf("Exit\n\n");
return 0;
}
/**
* ODP L2 forwarding main function
*/
int main(int argc, char *argv[])
{
odph_linux_pthread_t thread_tbl[MAX_WORKERS];
odp_pool_t pool;
int i;
int cpu;
int num_workers;
odp_shm_t shm;
odp_cpumask_t cpumask;
char cpumaskstr[ODP_CPUMASK_STR_SIZE];
odph_ethaddr_t new_addr;
odp_pktio_t pktio;
odp_pool_param_t params;
int ret;
stats_t *stats;
/* Init ODP before calling anything else */
if (odp_init_global(NULL, NULL)) {
LOG_ERR("Error: ODP global init failed.\n");
exit(EXIT_FAILURE);
}
/* Init this thread */
if (odp_init_local(ODP_THREAD_CONTROL)) {
LOG_ERR("Error: ODP local init failed.\n");
exit(EXIT_FAILURE);
}
/* Reserve memory for args from shared mem */
shm = odp_shm_reserve("shm_args", sizeof(args_t),
ODP_CACHE_LINE_SIZE, 0);
gbl_args = odp_shm_addr(shm);
if (gbl_args == NULL) {
LOG_ERR("Error: shared mem alloc failed.\n");
exit(EXIT_FAILURE);
}
memset(gbl_args, 0, sizeof(*gbl_args));
/* Parse and store the application arguments */
parse_args(argc, argv, &gbl_args->appl);
/* Print both system and application information */
print_info(NO_PATH(argv[0]), &gbl_args->appl);
/* Default to system CPU count unless user specified */
num_workers = MAX_WORKERS;
if (gbl_args->appl.cpu_count)
num_workers = gbl_args->appl.cpu_count;
/* Get default worker cpumask */
num_workers = odp_cpumask_default_worker(&cpumask, num_workers);
(void)odp_cpumask_to_str(&cpumask, cpumaskstr, sizeof(cpumaskstr));
printf("num worker threads: %i\n", num_workers);
printf("first CPU: %i\n", odp_cpumask_first(&cpumask));
printf("cpu mask: %s\n", cpumaskstr);
if (num_workers < gbl_args->appl.if_count) {
LOG_ERR("Error: CPU count %d less than interface count\n",
num_workers);
exit(EXIT_FAILURE);
}
/* Create packet pool */
odp_pool_param_init(¶ms);
params.pkt.seg_len = SHM_PKT_POOL_BUF_SIZE;
params.pkt.len = SHM_PKT_POOL_BUF_SIZE;
params.pkt.num = SHM_PKT_POOL_SIZE/SHM_PKT_POOL_BUF_SIZE;
params.type = ODP_POOL_PACKET;
pool = odp_pool_create("packet pool", ¶ms);
if (pool == ODP_POOL_INVALID) {
LOG_ERR("Error: packet pool create failed.\n");
exit(EXIT_FAILURE);
}
odp_pool_print(pool);
for (i = 0; i < gbl_args->appl.if_count; ++i) {
pktio = create_pktio(gbl_args->appl.if_names[i], pool);
if (pktio == ODP_PKTIO_INVALID)
exit(EXIT_FAILURE);
gbl_args->pktios[i] = pktio;
/* Save interface ethernet address */
if (odp_pktio_mac_addr(pktio, gbl_args->port_eth_addr[i].addr,
ODPH_ETHADDR_LEN) != ODPH_ETHADDR_LEN) {
LOG_ERR("Error: interface ethernet address unknown\n");
exit(EXIT_FAILURE);
}
/* Save destination eth address */
if (gbl_args->appl.dst_change) {
/* 02:00:00:00:00:XX */
memset(&new_addr, 0, sizeof(odph_ethaddr_t));
new_addr.addr[0] = 0x02;
new_addr.addr[5] = i;
gbl_args->dst_eth_addr[i] = new_addr;
}
/* Save interface destination port */
gbl_args->dst_port[i] = find_dest_port(i);
}
gbl_args->pktios[i] = ODP_PKTIO_INVALID;
memset(thread_tbl, 0, sizeof(thread_tbl));
stats = gbl_args->stats;
odp_barrier_init(&barrier, num_workers + 1);
/* Create worker threads */
cpu = odp_cpumask_first(&cpumask);
for (i = 0; i < num_workers; ++i) {
odp_cpumask_t thd_mask;
void *(*thr_run_func) (void *);
if (gbl_args->appl.mode == DIRECT_RECV)
thr_run_func = pktio_direct_recv_thread;
else /* SCHED_NONE / SCHED_ATOMIC / SCHED_ORDERED */
thr_run_func = pktio_queue_thread;
gbl_args->thread[i].src_idx = i % gbl_args->appl.if_count;
gbl_args->thread[i].stats = &stats[i];
odp_cpumask_zero(&thd_mask);
odp_cpumask_set(&thd_mask, cpu);
odph_linux_pthread_create(&thread_tbl[i], &thd_mask,
thr_run_func,
&gbl_args->thread[i],
ODP_THREAD_WORKER);
cpu = odp_cpumask_next(&cpumask, cpu);
}
/* Start packet receive and transmit */
for (i = 0; i < gbl_args->appl.if_count; ++i) {
pktio = gbl_args->pktios[i];
ret = odp_pktio_start(pktio);
if (ret) {
LOG_ERR("Error: unable to start %s\n",
gbl_args->appl.if_names[i]);
exit(EXIT_FAILURE);
}
}
ret = print_speed_stats(num_workers, stats, gbl_args->appl.time,
gbl_args->appl.accuracy);
exit_threads = 1;
/* Master thread waits for other threads to exit */
odph_linux_pthread_join(thread_tbl, num_workers);
free(gbl_args->appl.if_names);
free(gbl_args->appl.if_str);
printf("Exit\n\n");
return ret;
}
/** main() Application entry point
*
* @param argc int
* @param argv[] char*
* @return int
*
*/
int main(int argc, char *argv[])
{
odph_linux_pthread_t thread_tbl[MAX_WORKERS];
appl_args_t params;
int core_count, num_workers;
odp_cpumask_t cpumask;
char cpumaskstr[64];
/* Parse and store the application arguments */
parse_args(argc, argv, ¶ms);
/* Print both system and application information */
print_info(NO_PATH(argv[0]), ¶ms);
if (odp_init_global(NULL, NULL)) {
OFP_ERR("Error: ODP global init failed.\n");
exit(EXIT_FAILURE);
}
if (odp_init_local(ODP_THREAD_CONTROL)) {
OFP_ERR("Error: ODP local init failed.\n");
exit(EXIT_FAILURE);
}
core_count = odp_cpu_count();
num_workers = core_count;
if (params.core_count)
num_workers = params.core_count;
if (num_workers > MAX_WORKERS)
num_workers = MAX_WORKERS;
if (core_count > 1)
num_workers--;
#if ODP_VERSION < 104
num_workers = odp_cpumask_def_worker(&cpumask, num_workers);
#else
num_workers = odp_cpumask_default_worker(&cpumask, num_workers);
#endif
odp_cpumask_to_str(&cpumask, cpumaskstr, sizeof(cpumaskstr));
printf("Num worker threads: %i\n", num_workers);
printf("first CPU: %i\n", odp_cpumask_first(&cpumask));
printf("cpu mask: %s\n", cpumaskstr);
memset(&app_init_params, 0, sizeof(app_init_params));
app_init_params.linux_core_id = 0;
app_init_params.if_count = params.if_count;
app_init_params.if_names = params.if_names;
if (ofp_init_global(&app_init_params)) {
OFP_ERR("Error: OFP global init failed.\n");
exit(EXIT_FAILURE);
}
if (ofp_init_local()) {
OFP_ERR("Error: OFP local init failed.\n");
exit(EXIT_FAILURE);
}
build_classifier(app_init_params.if_count, app_init_params.if_names);
/* Start CLI */
ofp_start_cli_thread(app_init_params.linux_core_id, params.conf_file);
sleep(1);
memset(thread_tbl, 0, sizeof(thread_tbl));
/* Start dataplane dispatcher worker threads */
odph_linux_pthread_create(thread_tbl,
&cpumask,
default_event_dispatcher,
ofp_udp4_processing);
app_processing();
odph_linux_pthread_join(thread_tbl, num_workers);
printf("End Main()\n");
return 0;
}
int main(int argc, char *argv[])
{
odph_linux_pthread_t thread_tbl[MAX_WORKERS], dispatcher_thread;
appl_args_t params;
int core_count, num_workers;
odp_cpumask_t cpu_mask;
char cpumaskstr[64];
int cpu, first_cpu, i;
struct pktio_thr_arg pktio_thr_args[MAX_WORKERS];
/* Parse and store the application arguments */
parse_args(argc, argv, ¶ms);
/* Print both system and application information */
print_info(NO_PATH(argv[0]), ¶ms);
if (odp_init_global(NULL, NULL)) {
OFP_ERR("Error: ODP global init failed.\n");
exit(EXIT_FAILURE);
}
odp_init_local(ODP_THREAD_CONTROL);
memset(&app_init_params, 0, sizeof(app_init_params));
app_init_params.linux_core_id = 0;
app_init_params.if_count = params.if_count;
app_init_params.if_names = params.if_names;
app_init_params.burst_recv_mode = 1;
ofp_init_global(&app_init_params);
ofp_init_local();
memset(thread_tbl, 0, sizeof(thread_tbl));
memset(pktio_thr_args, 0, sizeof(pktio_thr_args));
core_count = odp_cpu_count();
num_workers = core_count;
if (params.core_count)
num_workers = params.core_count < core_count?
params.core_count: core_count;
first_cpu = 1;
num_workers -= first_cpu;
if (num_workers > MAX_WORKERS)
num_workers = MAX_WORKERS;
if (num_workers < params.if_count) {
OFP_ERR("At least %u fastpath cores required.\n",
params.if_count);
exit(EXIT_FAILURE);
}
printf("Num worker threads: %i\n", num_workers);
printf("first CPU: %i\n", first_cpu);
for (i = 0; i < num_workers; ++i) {
pktio_thr_args[i].pkt_func = ofp_eth_vlan_processing;
pktio_thr_args[i].port = i % params.if_count;
odp_cpumask_zero(&cpu_mask);
cpu = first_cpu + i;
odp_cpumask_set(&cpu_mask, cpu);
odp_cpumask_to_str(&cpu_mask, cpumaskstr, sizeof(cpumaskstr));
OFP_DBG("Starting pktio receive on core: %d port: %d\n",
cpu, pktio_thr_args[i].port);
OFP_DBG("cpu mask: %s\n", cpumaskstr);
ofp_linux_pthread_create(&thread_tbl[i],
&cpu_mask,
pkt_io_recv,
&pktio_thr_args[i],
ODP_THREAD_WORKER
);
}
odp_cpumask_zero(&cpu_mask);
odp_cpumask_set(&cpu_mask, app_init_params.linux_core_id + 1);
ofp_linux_pthread_create(&dispatcher_thread,
&cpu_mask,
event_dispatcher,
NULL,
ODP_THREAD_CONTROL
);
/* Start CLI */
ofp_start_cli_thread(app_init_params.linux_core_id, params.conf_file);
sleep(1);
udp_fwd_cfg(params.sock_count, params.laddr, params.raddr);
odph_linux_pthread_join(thread_tbl, num_workers);
printf("End Main()\n");
return 0;
}
/**
* Init and startup of the Error Handler test application.
*
* @see main() and application_start() for setup and dispatch.
*/
void
test_init(appl_conf_t *const appl_conf)
{
em_eo_t eo;
em_queue_t queue;
em_event_t event;
error_event_t* error;
em_status_t ret;
if(em_core_id() == 0) {
error_shm = env_shared_reserve("ErrorSharedMem", sizeof(error_shm_t));
}
else {
error_shm = env_shared_lookup("ErrorSharedMem");
}
if(error_shm == NULL) {
em_error(EM_ERROR_SET_FATAL(0xec0de), APPL_ESCOPE_INIT, "Error init failed on EM-core: %u\n", em_core_id());
}
/*
* Rest of the initializations only on one EM-core, return on all others.
*/
if(em_core_id() != 0)
{
return;
}
printf("\n**********************************************************************\n"
"EM APPLICATION: '%s' initializing: \n"
" %s: %s() - EM-core:%i \n"
" Application running on %d EM-cores (procs:%d, threads:%d)."
"\n**********************************************************************\n"
"\n"
,
appl_conf->name,
NO_PATH(__FILE__), __func__,
em_core_id(),
em_core_count(),
appl_conf->num_procs,
appl_conf->num_threads);
/*
* Register the application specifig global error handler
* This replaces the EM internal default error hanlder
*/
em_register_error_handler(global_error_handler);
/*
* Create and start EO "A"
*/
eo = em_eo_create("EO A", error_start, NULL, error_stop, NULL, error_receive, &error_shm->eo_error_a);
queue = em_queue_create("queue A", EM_QUEUE_TYPE_ATOMIC, EM_QUEUE_PRIO_NORMAL, EM_QUEUE_GROUP_DEFAULT);
if((ret = em_eo_add_queue(eo, queue)) != EM_OK)
{
em_error(EM_ERROR_SET_FATAL(0xdead), APPL_ESCOPE_INIT,
"EO or queue creation failed (%i). EO: %"PRI_EO", queue: %"PRI_QUEUE"\n",
ret, eo, queue);
}
error_shm->queue_a = queue;
if((ret = em_queue_enable(queue)) != EM_OK)
{
em_error(EM_ERROR_SET_FATAL(0xbeef), APPL_ESCOPE_INIT,
"Queue A enable failed (%i). EO: %"PRI_EO", queue: %"PRI_QUEUE"\n",
ret, eo, queue);
}
/*
* Register an application 'EO A'-specific error handler
*/
em_eo_register_error_handler(eo, eo_specific_error_handler);
em_eo_start(eo, NULL, 0, NULL);
/*
* Create and start EO "B"
*/
eo = em_eo_create("EO B", error_start, NULL, error_stop, NULL, error_receive, &error_shm->eo_error_b);
queue = em_queue_create("queue B", EM_QUEUE_TYPE_ATOMIC, EM_QUEUE_PRIO_NORMAL, EM_QUEUE_GROUP_DEFAULT);
if((ret = em_eo_add_queue(eo, queue)) != EM_OK)
{
em_error(EM_ERROR_SET_FATAL(0xacdc), APPL_ESCOPE_INIT,
"EO or queue creation failed (%i). EO: %"PRI_EO", queue: %"PRI_QUEUE"\n",
ret, eo, queue);
}
error_shm->queue_b = queue;
if((ret = em_queue_enable(queue)) != EM_OK)
{
em_error(EM_ERROR_SET_FATAL(0xabba), APPL_ESCOPE_INIT,
"Queue B enable failed (%i). EO: %"PRI_EO", queue: %"PRI_QUEUE"\n",
ret, eo, queue);
}
/* Note: No 'EO B' specific error handler, use the application specific global error handler instead. */
em_eo_start(eo, NULL, 0, NULL);
/*
* Create and start EO "C"
*/
eo = em_eo_create("EO C", error_start, NULL, error_stop, NULL, error_receive, &error_shm->eo_error_c);
queue = em_queue_create("queue C", EM_QUEUE_TYPE_ATOMIC, EM_QUEUE_PRIO_NORMAL, EM_QUEUE_GROUP_DEFAULT);
if((ret = em_eo_add_queue(eo, queue)) != EM_OK)
{
em_error(EM_ERROR_SET_FATAL(0xf00), APPL_ESCOPE_INIT,
"EO or queue creation failed (%i). EO: %"PRI_EO", queue: %"PRI_QUEUE"\n",
ret, eo, queue);
}
error_shm->queue_c = queue;
if((ret = em_queue_enable(queue)) != EM_OK)
{
em_error(EM_ERROR_SET_FATAL(0xbad), APPL_ESCOPE_INIT,
"Queue C enable failed (%i). EO: %"PRI_EO", queue: %"PRI_QUEUE"\n",
ret, eo, queue);
}
/* Note: No 'EO C' specific error handler, use the application specific global error handler instead. */
em_eo_start(eo, NULL, 0, NULL);
/*
* Send an event to EO A.
* Store EO B's queue as the destination queue for EO A.
*/
event = em_alloc(sizeof(error_event_t), EM_EVENT_TYPE_SW, EM_POOL_DEFAULT);
error = em_event_pointer(event);
error->dest = error_shm->queue_b;
error->seq = 0;
error->fatal = 0;
em_send(event, error_shm->queue_a);
/*
* Send an event to EO C.
* No dest queue stored since the fatal flag is set
*/
event = em_alloc(sizeof(error_event_t), EM_EVENT_TYPE_SW, EM_POOL_DEFAULT);
error = em_event_pointer(event);
error->dest = 0; // don't care, never resent
error->seq = 0;
error->fatal = 1; // generate a fatal error when received
em_send(event, error_shm->queue_c);
}
int main(int argc, char **argv)
{
odph_odpthread_t thread_tbl[MAX_WORKERS];
int i, j;
int cpu;
int num_workers;
odp_shm_t shm;
odp_cpumask_t cpumask;
char cpumaskstr[ODP_CPUMASK_STR_SIZE];
odp_pool_param_t params;
int ret;
stats_t (*stats)[MAX_PKTIOS];
int if_count;
odp_instance_t instance;
odph_odpthread_params_t thr_params;
/* Init ODP before calling anything else */
if (odp_init_global(&instance, NULL, NULL)) {
printf("Error: ODP global init failed.\n");
exit(EXIT_FAILURE);
}
/* Init this thread */
if (odp_init_local(instance, ODP_THREAD_CONTROL)) {
printf("Error: ODP local init failed.\n");
exit(EXIT_FAILURE);
}
/* Reserve memory for args from shared mem */
shm = odp_shm_reserve("shm_args", sizeof(args_t),
ODP_CACHE_LINE_SIZE, 0);
gbl_args = odp_shm_addr(shm);
if (gbl_args == NULL) {
printf("Error: shared mem alloc failed.\n");
exit(EXIT_FAILURE);
}
gbl_args_init(gbl_args);
for (i = 0; (unsigned)i < MAC_TBL_SIZE; i++)
odp_atomic_init_u64(&gbl_args->mac_tbl[i], 0);
/* Parse and store the application arguments */
parse_args(argc, argv, &gbl_args->appl);
/* Print both system and application information */
print_info(NO_PATH(argv[0]), &gbl_args->appl);
/* Default to system CPU count unless user specified */
num_workers = MAX_WORKERS;
if (gbl_args->appl.cpu_count)
num_workers = gbl_args->appl.cpu_count;
/* Get default worker cpumask */
num_workers = odp_cpumask_default_worker(&cpumask, num_workers);
(void)odp_cpumask_to_str(&cpumask, cpumaskstr, sizeof(cpumaskstr));
gbl_args->appl.num_workers = num_workers;
if_count = gbl_args->appl.if_count;
printf("num worker threads: %i\n", num_workers);
printf("first CPU: %i\n", odp_cpumask_first(&cpumask));
printf("cpu mask: %s\n", cpumaskstr);
/* Create packet pool */
odp_pool_param_init(¶ms);
params.pkt.seg_len = SHM_PKT_POOL_BUF_SIZE;
params.pkt.len = SHM_PKT_POOL_BUF_SIZE;
params.pkt.num = SHM_PKT_POOL_SIZE;
params.type = ODP_POOL_PACKET;
gbl_args->pool = odp_pool_create("packet pool", ¶ms);
if (gbl_args->pool == ODP_POOL_INVALID) {
printf("Error: packet pool create failed.\n");
exit(EXIT_FAILURE);
}
odp_pool_print(gbl_args->pool);
bind_workers();
for (i = 0; i < if_count; ++i) {
const char *dev = gbl_args->appl.if_names[i];
int num_rx;
/* An RX queue per assigned worker and a private TX queue for
* each worker */
num_rx = gbl_args->pktios[i].num_rx_thr;
if (create_pktio(dev, i, num_rx, num_workers, gbl_args->pool))
exit(EXIT_FAILURE);
ret = odp_pktio_promisc_mode_set(gbl_args->pktios[i].pktio, 1);
if (ret != 0) {
printf("Error: failed to set port to promiscuous mode.\n");
exit(EXIT_FAILURE);
}
}
gbl_args->pktios[i].pktio = ODP_PKTIO_INVALID;
bind_queues();
print_port_mapping();
memset(thread_tbl, 0, sizeof(thread_tbl));
odp_barrier_init(&barrier, num_workers + 1);
stats = gbl_args->stats;
memset(&thr_params, 0, sizeof(thr_params));
thr_params.thr_type = ODP_THREAD_WORKER;
thr_params.instance = instance;
thr_params.start = run_worker;
/* Create worker threads */
cpu = odp_cpumask_first(&cpumask);
for (i = 0; i < num_workers; ++i) {
odp_cpumask_t thd_mask;
for (j = 0; j < MAX_PKTIOS; j++)
gbl_args->thread[i].stats[j] = &stats[i][j];
thr_params.arg = &gbl_args->thread[i];
odp_cpumask_zero(&thd_mask);
odp_cpumask_set(&thd_mask, cpu);
odph_odpthreads_create(&thread_tbl[i], &thd_mask, &thr_params);
cpu = odp_cpumask_next(&cpumask, cpu);
}
/* Start packet receive and transmit */
for (i = 0; i < if_count; ++i) {
odp_pktio_t pktio;
pktio = gbl_args->pktios[i].pktio;
ret = odp_pktio_start(pktio);
if (ret) {
printf("Error: unable to start %s\n",
gbl_args->appl.if_names[i]);
exit(EXIT_FAILURE);
}
}
ret = print_speed_stats(num_workers, gbl_args->stats,
gbl_args->appl.time, gbl_args->appl.accuracy);
exit_threads = 1;
/* Master thread waits for other threads to exit */
for (i = 0; i < num_workers; ++i)
odph_odpthreads_join(&thread_tbl[i]);
free(gbl_args->appl.if_names);
free(gbl_args->appl.if_str);
if (odp_pool_destroy(gbl_args->pool)) {
printf("Error: pool destroy\n");
exit(EXIT_FAILURE);
}
if (odp_term_local()) {
printf("Error: term local\n");
exit(EXIT_FAILURE);
}
if (odp_term_global(instance)) {
printf("Error: term global\n");
exit(EXIT_FAILURE);
}
printf("Exit: %d\n\n", ret);
return ret;
}
/**
* ODP L2 forwarding main function
*/
int main(int argc, char *argv[])
{
odph_linux_pthread_t thread_tbl[MAX_WORKERS];
odp_pool_t pool;
int i;
int cpu;
int num_workers;
odp_shm_t shm;
odp_cpumask_t cpumask;
char cpumaskstr[ODP_CPUMASK_STR_SIZE];
odp_pool_param_t params;
/* Init ODP before calling anything else */
if (odp_init_global(NULL, NULL)) {
LOG_ERR("Error: ODP global init failed.\n");
exit(EXIT_FAILURE);
}
/* Init this thread */
if (odp_init_local(ODP_THREAD_CONTROL)) {
LOG_ERR("Error: ODP local init failed.\n");
exit(EXIT_FAILURE);
}
/* Reserve memory for args from shared mem */
shm = odp_shm_reserve("shm_args", sizeof(args_t),
ODP_CACHE_LINE_SIZE, 0);
gbl_args = odp_shm_addr(shm);
if (gbl_args == NULL) {
LOG_ERR("Error: shared mem alloc failed.\n");
exit(EXIT_FAILURE);
}
memset(gbl_args, 0, sizeof(*gbl_args));
/* Parse and store the application arguments */
parse_args(argc, argv, &gbl_args->appl);
/* Print both system and application information */
print_info(NO_PATH(argv[0]), &gbl_args->appl);
/* Default to system CPU count unless user specified */
num_workers = MAX_WORKERS;
if (gbl_args->appl.cpu_count)
num_workers = gbl_args->appl.cpu_count;
/* Get default worker cpumask */
num_workers = odp_cpumask_def_worker(&cpumask, num_workers);
(void)odp_cpumask_to_str(&cpumask, cpumaskstr, sizeof(cpumaskstr));
printf("num worker threads: %i\n", num_workers);
printf("first CPU: %i\n", odp_cpumask_first(&cpumask));
printf("cpu mask: %s\n", cpumaskstr);
if (num_workers < gbl_args->appl.if_count) {
LOG_ERR("Error: CPU count %d less than interface count\n",
num_workers);
exit(EXIT_FAILURE);
}
if (gbl_args->appl.if_count % 2 != 0) {
LOG_ERR("Error: interface count %d is odd in fwd appl.\n",
gbl_args->appl.if_count);
exit(EXIT_FAILURE);
}
/* Create packet pool */
memset(¶ms, 0, sizeof(params));
params.pkt.seg_len = SHM_PKT_POOL_BUF_SIZE;
params.pkt.len = SHM_PKT_POOL_BUF_SIZE;
params.pkt.num = SHM_PKT_POOL_SIZE/SHM_PKT_POOL_BUF_SIZE;
params.type = ODP_POOL_PACKET;
pool = odp_pool_create("packet pool", ¶ms);
if (pool == ODP_POOL_INVALID) {
LOG_ERR("Error: packet pool create failed.\n");
exit(EXIT_FAILURE);
}
odp_pool_print(pool);
for (i = 0; i < gbl_args->appl.if_count; ++i) {
gbl_args->pktios[i] = create_pktio(gbl_args->appl.if_names[i],
pool, gbl_args->appl.mode);
if (gbl_args->pktios[i] == ODP_PKTIO_INVALID)
exit(EXIT_FAILURE);
}
gbl_args->pktios[i] = ODP_PKTIO_INVALID;
memset(thread_tbl, 0, sizeof(thread_tbl));
stats_t **stats = calloc(1, sizeof(stats_t) * num_workers);
odp_barrier_init(&barrier, num_workers + 1);
/* Create worker threads */
cpu = odp_cpumask_first(&cpumask);
for (i = 0; i < num_workers; ++i) {
odp_cpumask_t thd_mask;
void *(*thr_run_func) (void *);
if (gbl_args->appl.mode == APPL_MODE_PKT_BURST)
thr_run_func = pktio_ifburst_thread;
else /* APPL_MODE_PKT_QUEUE */
thr_run_func = pktio_queue_thread;
gbl_args->thread[i].src_idx = i % gbl_args->appl.if_count;
gbl_args->thread[i].stats = &stats[i];
odp_cpumask_zero(&thd_mask);
odp_cpumask_set(&thd_mask, cpu);
odph_linux_pthread_create(&thread_tbl[i], &thd_mask,
thr_run_func,
&gbl_args->thread[i]);
cpu = odp_cpumask_next(&cpumask, cpu);
}
print_speed_stats(num_workers, stats, gbl_args->appl.time,
gbl_args->appl.accuracy);
free(stats);
exit_threads = 1;
/* Master thread waits for other threads to exit */
odph_linux_pthread_join(thread_tbl, num_workers);
free(gbl_args->appl.if_names);
free(gbl_args->appl.if_str);
printf("Exit\n\n");
return 0;
}
/**
* ODP packet example main function
*/
int main(int argc, char *argv[])
{
odp_linux_pthread_t thread_tbl[MAX_WORKERS];
odp_buffer_pool_t pool;
int thr_id;
int num_workers;
void *pool_base;
int i;
int first_core;
int core_count;
/* Init ODP before calling anything else */
if (odp_init_global()) {
ODP_ERR("Error: ODP global init failed.\n");
exit(EXIT_FAILURE);
}
/* Reserve memory for args from shared mem */
args = odp_shm_reserve("shm_args", sizeof(args_t), ODP_CACHE_LINE_SIZE);
if (args == NULL) {
ODP_ERR("Error: shared mem alloc failed.\n");
exit(EXIT_FAILURE);
}
memset(args, 0, sizeof(*args));
/* Parse and store the application arguments */
parse_args(argc, argv, &args->appl);
/* Print both system and application information */
print_info(NO_PATH(argv[0]), &args->appl);
core_count = odp_sys_core_count();
num_workers = core_count;
if (args->appl.core_count)
num_workers = args->appl.core_count;
if (num_workers > MAX_WORKERS)
num_workers = MAX_WORKERS;
printf("Num worker threads: %i\n", num_workers);
/*
* By default core #0 runs Linux kernel background tasks.
* Start mapping thread from core #1
*/
first_core = 1;
if (core_count == 1)
first_core = 0;
printf("First core: %i\n\n", first_core);
/* Init this thread */
thr_id = odp_thread_create(0);
odp_init_local(thr_id);
/* Create packet pool */
pool_base = odp_shm_reserve("shm_packet_pool",
SHM_PKT_POOL_SIZE, ODP_CACHE_LINE_SIZE);
if (pool_base == NULL) {
ODP_ERR("Error: packet pool mem alloc failed.\n");
exit(EXIT_FAILURE);
}
pool = odp_buffer_pool_create("packet_pool", pool_base,
SHM_PKT_POOL_SIZE,
SHM_PKT_POOL_BUF_SIZE,
ODP_CACHE_LINE_SIZE,
ODP_BUFFER_TYPE_PACKET);
if (pool == ODP_BUFFER_POOL_INVALID) {
ODP_ERR("Error: packet pool create failed.\n");
exit(EXIT_FAILURE);
}
odp_buffer_pool_print(pool);
/* Create and init worker threads */
memset(thread_tbl, 0, sizeof(thread_tbl));
for (i = 0; i < num_workers; ++i) {
void *(*thr_run_func) (void *);
int core;
int if_idx;
core = (first_core + i) % core_count;
if_idx = i % args->appl.if_count;
args->thread[i].pktio_dev = args->appl.if_names[if_idx];
args->thread[i].pool = pool;
args->thread[i].mode = args->appl.mode;
args->thread[i].type = args->appl.type;
args->thread[i].fanout = args->appl.fanout;
if (args->appl.mode == APPL_MODE_PKT_BURST)
thr_run_func = pktio_ifburst_thread;
else /* APPL_MODE_PKT_QUEUE */
thr_run_func = pktio_queue_thread;
/*
* Create threads one-by-one instead of all-at-once,
* because each thread might get different arguments.
* Calls odp_thread_create(cpu) for each thread
*/
odp_linux_pthread_create(thread_tbl, 1, core, thr_run_func,
&args->thread[i]);
}
/* Master thread waits for other threads to exit */
odp_linux_pthread_join(thread_tbl, num_workers);
printf("Exit\n\n");
return 0;
}
int main(int argc, char *argv[])
{
odph_linux_pthread_t thread_tbl[MAX_WORKERS];
appl_args_t params;
int core_count, num_workers;
odp_cpumask_t cpumask;
char cpumaskstr[64];
odph_linux_thr_params_t thr_params;
odp_instance_t instance;
struct rlimit rlp;
getrlimit(RLIMIT_CORE, &rlp);
printf("RLIMIT_CORE: %ld/%ld\n", rlp.rlim_cur, rlp.rlim_max);
rlp.rlim_cur = 200000000;
printf("Setting to max: %d\n", setrlimit(RLIMIT_CORE, &rlp));
/* Parse and store the application arguments */
parse_args(argc, argv, ¶ms);
if (odp_init_global(&instance, NULL, NULL)) {
OFP_ERR("Error: ODP global init failed.\n");
exit(EXIT_FAILURE);
}
if (odp_init_local(instance, ODP_THREAD_CONTROL)) {
OFP_ERR("Error: ODP local init failed.\n");
exit(EXIT_FAILURE);
}
/* Print both system and application information */
print_info(NO_PATH(argv[0]), ¶ms);
core_count = odp_cpu_count();
num_workers = core_count;
if (params.core_count)
num_workers = params.core_count;
if (num_workers > MAX_WORKERS)
num_workers = MAX_WORKERS;
/*
* By default core #0 runs Linux kernel background tasks.
* Start mapping thread from core #1
*/
memset(&app_init_params, 0, sizeof(app_init_params));
app_init_params.linux_core_id = 0;
if (core_count > 1)
num_workers--;
num_workers = odp_cpumask_default_worker(&cpumask, num_workers);
odp_cpumask_to_str(&cpumask, cpumaskstr, sizeof(cpumaskstr));
printf("Num worker threads: %i\n", num_workers);
printf("first CPU: %i\n", odp_cpumask_first(&cpumask));
printf("cpu mask: %s\n", cpumaskstr);
app_init_params.if_count = params.if_count;
app_init_params.if_names = params.if_names;
app_init_params.pkt_hook[OFP_HOOK_LOCAL] = fastpath_local_hook;
if (ofp_init_global(instance, &app_init_params)) {
OFP_ERR("Error: OFP global init failed.\n");
exit(EXIT_FAILURE);
}
memset(thread_tbl, 0, sizeof(thread_tbl));
/* Start dataplane dispatcher worker threads */
thr_params.start = default_event_dispatcher;
thr_params.arg = ofp_eth_vlan_processing;
thr_params.thr_type = ODP_THREAD_WORKER;
thr_params.instance = instance;
odph_linux_pthread_create(thread_tbl,
&cpumask,
&thr_params);
/* other app code here.*/
/* Start CLI */
ofp_start_cli_thread(instance, app_init_params.linux_core_id,
params.conf_file);
sleep(2);
/* webserver */
if (setup_webserver(params.root_dir, params.laddr, params.lport)) {
OFP_ERR("Error: Failed to setup webserver.\n");
exit(EXIT_FAILURE);
}
odph_linux_pthread_join(thread_tbl, num_workers);
printf("End Main()\n");
return 0;
}
/** main() Application entry point
*
* @param argc int
* @param argv[] char*
* @return int
*
*/
int main(int argc, char *argv[])
{
odph_linux_pthread_t thread_tbl[MAX_WORKERS], dispatcher_thread;
appl_args_t params;
int core_count, num_workers;
odp_cpumask_t cpu_mask;
int first_cpu, i;
struct pktio_thr_arg pktio_thr_args[MAX_WORKERS];
odp_pktio_param_t pktio_param;
odp_pktin_queue_param_t pktin_param;
odp_pktout_queue_param_t pktout_param;
odp_pktio_t pktio;
int port, queue_id;
odph_linux_thr_params_t thr_params;
odp_instance_t instance;
struct pktin_table_s {
int num_in_queue;
odp_pktin_queue_t in_queue[OFP_PKTIN_QUEUE_MAX];
} pktin_table[OFP_FP_INTERFACE_MAX];
/* Parse and store the application arguments */
parse_args(argc, argv, ¶ms);
if (params.if_count > OFP_FP_INTERFACE_MAX) {
printf("Error: Invalid number of interfaces: maximum %d\n",
OFP_FP_INTERFACE_MAX);
exit(EXIT_FAILURE);
}
if (odp_init_global(&instance, NULL, NULL)) {
OFP_ERR("Error: ODP global init failed.\n");
exit(EXIT_FAILURE);
}
if (odp_init_local(instance, ODP_THREAD_CONTROL)) {
OFP_ERR("Error: ODP local init failed.\n");
exit(EXIT_FAILURE);
}
/* Print both system and application information */
print_info(NO_PATH(argv[0]), ¶ms);
core_count = odp_cpu_count();
num_workers = core_count;
if (params.core_count && params.core_count < core_count)
num_workers = params.core_count;
if (num_workers > MAX_WORKERS)
num_workers = MAX_WORKERS;
/*
* By default core #0 runs Linux kernel background tasks.
* Start mapping thread from core #1
*/
if (num_workers > 1) {
num_workers--;
first_cpu = 1;
} else {
OFP_ERR("Burst mode requires multiple cores.\n");
exit(EXIT_FAILURE);
}
if (num_workers < params.if_count) {
OFP_ERR("At least %u fastpath cores required.\n",
params.if_count);
exit(EXIT_FAILURE);
}
printf("Num worker threads: %i\n", num_workers);
printf("first CPU: %i\n", first_cpu);
memset(&app_init_params, 0, sizeof(app_init_params));
app_init_params.linux_core_id = 0;
if (ofp_init_global(instance, &app_init_params)) {
OFP_ERR("Error: OFP global init failed.\n");
exit(EXIT_FAILURE);
}
if (ofp_init_local()) {
OFP_ERR("Error: OFP local init failed.\n");
exit(EXIT_FAILURE);
}
odp_pktio_param_init(&pktio_param);
pktio_param.in_mode = ODP_PKTIN_MODE_DIRECT;
pktio_param.out_mode = ODP_PKTOUT_MODE_DIRECT;
odp_pktin_queue_param_init(&pktin_param);
pktin_param.op_mode = ODP_PKTIO_OP_MT;
pktin_param.hash_enable = 0;
pktin_param.hash_proto.all_bits = 0;
pktin_param.num_queues = 1;
odp_pktout_queue_param_init(&pktout_param);
pktout_param.num_queues = 1;
pktout_param.op_mode = ODP_PKTIO_OP_MT;
for (i = 0; i < params.if_count; i++) {
if (ofp_ifnet_create(instance, params.if_names[i],
&pktio_param,
&pktin_param,
&pktout_param) < 0) {
OFP_ERR("Failed to init interface %s",
params.if_names[i]);
exit(EXIT_FAILURE);
}
pktio = odp_pktio_lookup(params.if_names[i]);
if (pktio == ODP_PKTIO_INVALID) {
OFP_ERR("Failed locate pktio %s",
params.if_names[i]);
exit(EXIT_FAILURE);
}
pktin_table[i].num_in_queue = odp_pktin_queue(pktio,
pktin_table[i].in_queue, OFP_PKTIN_QUEUE_MAX);
if (pktin_table[i].num_in_queue < 0) {
OFP_ERR("Failed get input queues for %s",
params.if_names[i]);
exit(EXIT_FAILURE);
}
}
memset(thread_tbl, 0, sizeof(thread_tbl));
memset(pktio_thr_args, 0, sizeof(pktio_thr_args));
for (i = 0; i < num_workers; ++i) {
pktio_thr_args[i].pkt_func = ofp_eth_vlan_processing;
port = i % params.if_count;
queue_id = (i / params.if_count) %
pktin_table[port].num_in_queue;
pktio_thr_args[i].pktin = pktin_table[port].in_queue[queue_id];
odp_cpumask_zero(&cpu_mask);
odp_cpumask_set(&cpu_mask, first_cpu + i);
thr_params.start = pkt_io_recv;
thr_params.arg = &pktio_thr_args[i];
thr_params.thr_type = ODP_THREAD_WORKER;
thr_params.instance = instance;
odph_linux_pthread_create(&thread_tbl[i],
&cpu_mask,
&thr_params);
}
odp_cpumask_zero(&cpu_mask);
odp_cpumask_set(&cpu_mask, app_init_params.linux_core_id);
thr_params.start = event_dispatcher;
thr_params.arg = NULL;
thr_params.thr_type = ODP_THREAD_WORKER;
thr_params.instance = instance;
odph_linux_pthread_create(&dispatcher_thread,
&cpu_mask,
&thr_params);
/* Start CLI */
ofp_start_cli_thread(instance, app_init_params.linux_core_id,
params.conf_file);
odph_linux_pthread_join(thread_tbl, num_workers);
printf("End Main()\n");
return 0;
}
/** main() Application entry point
*
* @param argc int
* @param argv[] char*
* @return int
*
*/
int main(int argc, char *argv[])
{
odph_linux_pthread_t thread_tbl[MAX_WORKERS];
appl_args_t params;
int core_count, num_workers;
odp_cpumask_t cpumask;
char cpumaskstr[64];
/* Parse and store the application arguments */
parse_args(argc, argv, ¶ms);
/* Print both system and application information */
print_info(NO_PATH(argv[0]), ¶ms);
if (odp_init_global(NULL, NULL)) {
OFP_ERR("Error: ODP global init failed.\n");
exit(EXIT_FAILURE);
}
if (odp_init_local(ODP_THREAD_CONTROL)) {
OFP_ERR("Error: ODP local init failed.\n");
exit(EXIT_FAILURE);
}
core_count = odp_cpu_count();
num_workers = core_count;
if (params.core_count)
num_workers = params.core_count;
if (num_workers > MAX_WORKERS)
num_workers = MAX_WORKERS;
if (core_count > 1)
num_workers--;
num_workers = odp_cpumask_default_worker(&cpumask, num_workers);
odp_cpumask_to_str(&cpumask, cpumaskstr, sizeof(cpumaskstr));
printf("Num worker threads: %i\n", num_workers);
printf("first CPU: %i\n", odp_cpumask_first(&cpumask));
printf("cpu mask: %s\n", cpumaskstr);
memset(&app_init_params, 0, sizeof(app_init_params));
app_init_params.linux_core_id = 0;
app_init_params.if_count = params.if_count;
app_init_params.if_names = params.if_names;
if (ofp_init_global(&app_init_params)) {
OFP_ERR("Error: OFP global init failed.\n");
exit(EXIT_FAILURE);
}
memset(thread_tbl, 0, sizeof(thread_tbl));
/* Start dataplane dispatcher worker threads */
ofp_linux_pthread_create(thread_tbl,
&cpumask,
default_event_dispatcher,
ofp_eth_vlan_processing,
ODP_THREAD_CONTROL
);
/* other app code here.*/
/* Start CLI */
ofp_start_cli_thread(app_init_params.linux_core_id, params.conf_file);
sleep(5);
ofp_loglevel = OFP_LOG_INFO;
config_suite_framework(app_init_params.linux_core_id);
OFP_INFO("\n\nSuite: IPv4 UDP socket: create and close.\n\n");
if (!init_suite(NULL))
run_suite(create_close_udp, create_close_udp_noproto);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv4 TCP socket: create and close.\n\n");
if (!init_suite(NULL))
run_suite(create_close_tcp, create_close_tcp_noproto);
end_suite();
OFP_INFO("Test ended.\n");
#ifdef INET6
OFP_INFO("\n\nSuite: IPv6 UDP socket: create and close.\n\n");
if (!init_suite(NULL))
run_suite(create_close_udp6, create_close_udp6_noproto);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv6 TCP socket: create and close.\n\n");
if (!init_suite(NULL))
run_suite(create_close_tcp6, create_close_tcp6_noproto);
end_suite();
OFP_INFO("Test ended.\n");
#endif /* INET6 */
OFP_INFO("\n\nSuite: IPv4 UDP socket: bind.\n\n");
if (!init_suite(init_udp_create_socket))
run_suite(bind_ip4_local_ip, bind_ip4_any);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv4 TCP socket: bind.\n\n");
if (!init_suite(init_tcp_create_socket))
run_suite(bind_ip4_local_ip, bind_ip4_any);
end_suite();
OFP_INFO("Test ended.\n");
#ifdef INET6
OFP_INFO("\n\nSuite: IPv6 UDP socket: bind.\n\n");
if (!init_suite(init_udp6_create_socket))
run_suite(bind_ip6_local_ip, bind_ip6_any);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv6 TCP socket: bind.\n\n");
if (!init_suite(init_tcp6_create_socket))
run_suite(bind_ip6_local_ip, bind_ip6_any);
end_suite();
OFP_INFO("Test ended.\n");
#endif /* INET6 */
OFP_INFO("\n\nSuite: IPv4 UDP socket: shutdown.\n\n");
if (!init_suite(init_udp_create_socket))
run_suite(shutdown_socket, shutdown_socket);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv4 TCP socket: shutdown (no connection).\n\n");
if (!init_suite(init_tcp_create_socket))
run_suite(shutdown_socket, shutdown_socket);
end_suite();
OFP_INFO("Test ended.\n");
#ifdef INET6
OFP_INFO("\n\nSuite: IPv6 UDP socket: shutdown.\n\n");
if (!init_suite(init_udp6_create_socket))
run_suite(shutdown_socket, shutdown_socket);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv6 TCP socket: shutdown (no connection).\n\n");
if (!init_suite(init_tcp6_create_socket))
run_suite(shutdown_socket, shutdown_socket);
end_suite();
OFP_INFO("Test ended.\n");
#endif /* INET6 */
OFP_INFO("\n\nSuite: IPv4 UDP socket: connect.\n\n");
if (!init_suite(init_udp_create_socket))
run_suite(connect_udp4, connect_bind_udp4);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv4 UDP socket: connect + shutdown.\n\n");
if (!init_suite(init_udp_create_socket))
run_suite(connect_shutdown_udp4, connect_shutdown_bind_udp4);
end_suite();
OFP_INFO("Test ended.\n");
#ifdef INET6
OFP_INFO("\n\nSuite: IPv6 UDP socket: connect.\n\n");
if (!init_suite(init_udp6_create_socket))
run_suite(connect_udp6, connect_bind_udp6);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv6 UDP socket: connect + shutdown.\n\n");
if (!init_suite(init_udp6_create_socket))
run_suite(connect_shutdown_udp6, connect_shutdown_bind_udp6);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv6 UDP socket: connect + shutdown + any.\n\n");
if (!init_suite(init_udp6_create_socket))
run_suite(connect_shutdown_udp6_any,
connect_shutdown_bind_udp6_any);
end_suite();
OFP_INFO("Test ended.\n");
#endif /* INET6 */
OFP_INFO("\n\nSuite: IPv4 UDP socket BIND local address: send + sendto\n\n");
if (!init_suite(init_udp_bind_local_ip))
run_suite(send_ip4_udp_local_ip, sendto_ip4_udp_local_ip);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv4 UDP socket bind any address: send + sendto\n\n");
if (!init_suite(init_udp_bind_any))
run_suite(send_ip4_udp_any, sendto_ip4_udp_any);
end_suite();
OFP_INFO("Test ended.\n");
#ifdef INET6
OFP_INFO("\n\nSuite: IPv6 UDP socket BIND local address: send + sendto\n\n");
if (!init_suite(init_udp6_bind_local_ip))
run_suite(send_ip6_udp_local_ip, sendto_ip6_udp_local_ip);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv6 UDP socket bind any address: send + sendto\n\n");
if (!init_suite(init_udp6_bind_any))
run_suite(send_ip6_udp_any, sendto_ip6_udp_any);
end_suite();
OFP_INFO("Test ended.\n");
#endif /* INET6 */
OFP_INFO("\n\nSuite: IPv4 UDP bind local IP: sendto + recv.\n\n");
if (!init_suite(init_udp_local_ip))
run_suite(send_udp_local_ip, recv_udp);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv4 UDP bind local IP: sendto + recvfrom.\n\n");
if (!init_suite(init_udp_bind_local_ip))
run_suite(send_udp_local_ip, recvfrom_udp);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv4 UDP bind any address: sendto + recv.\n\n");
if (!init_suite(init_udp_any))
run_suite(send_udp_any, recv_udp);
end_suite();
OFP_INFO("\n\nSuite: IPv4 UDP bind any address: sendto + recvfrom.\n\n");
if (!init_suite(init_udp_bind_any))
run_suite(send_udp_any, recvfrom_udp);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv4 UDP bind any address: sendto + recvfrom(NULL addr).\n\n");
if (!init_suite(init_udp_bind_any))
run_suite(send_udp_any, recvfrom_udp_null_addr);
end_suite();
OFP_INFO("Test ended.\n");
#ifdef INET6
OFP_INFO("\n\nSuite: IPv6 UDP bind local IP: sendto + recv.\n\n");
if (!init_suite(init_udp6_bind_local_ip))
run_suite(send_udp6_local_ip, recv_udp);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv6 UDP bind local IP: sendto + recvfrom.\n\n");
if (!init_suite(init_udp6_bind_local_ip))
run_suite(send_udp6_local_ip, recvfrom_udp6);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv6 UDP bind any IP: sendto + recv.\n\n");
if (!init_suite(init_udp6_bind_any))
run_suite(send_udp6_any, recv_udp);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv6 UDP bind any IP: sendto + recvfrom.\n\n");
if (!init_suite(init_udp6_bind_any))
run_suite(send_udp6_any, recvfrom_udp6);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv6 UDP bind any IP: sendto + recvfrom(NULL addr).\n\n");
if (!init_suite(init_udp6_bind_any))
run_suite(send_udp6_any, recvfrom_udp_null_addr);
end_suite();
OFP_INFO("Test ended.\n");
#endif /*INET6*/
OFP_INFO("\n\nSuite: IPv4 TCP socket local IP: listen.\n\n");
if (!init_suite(init_tcp_bind_local_ip))
run_suite(listen_tcp, listen_tcp);
end_suite();
OFP_INFO("Test ended.\n");
#ifdef INET6
OFP_INFO("\n\nSuite: IPv6 TCP socket local IP: listen.\n\n");
if (!init_suite(init_tcp6_bind_local_ip))
run_suite(listen_tcp, listen_tcp);
end_suite();
OFP_INFO("Test ended.\n");
#endif /*INET6*/
OFP_INFO("\n\nSuite: IPv4 TCP socket local IP: connect + accept.\n\n");
if (!init_suite(init_tcp_bind_listen_local_ip))
run_suite(connect_tcp4_local_ip, accept_tcp4);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv4 TCP socket any IP: connect + accept.\n\n");
if (!init_suite(init_tcp_bind_listen_any))
run_suite(connect_tcp4_any, accept_tcp4);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv4 TCP socket local IP: connect + accept null address.\n\n");
if (!init_suite(init_tcp_bind_listen_local_ip))
run_suite(connect_tcp4_local_ip, accept_tcp4_null_addr);
end_suite();
OFP_INFO("Test ended.\n");
#ifdef INET6
OFP_INFO("\n\nSuite: IPv6 TCP socket local IP: connect + accept.\n\n");
if (!init_suite(init_tcp6_bind_listen_local_ip))
run_suite(connect_tcp6_local_ip, accept_tcp6);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv6 TCP socket any IP: connect + accept.\n\n");
if (!init_suite(init_tcp6_bind_listen_any))
run_suite(connect_tcp6_any, accept_tcp6);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv6 TCP socket local IP: connect + accept null address.\n\n");
if (!init_suite(init_tcp6_bind_listen_local_ip))
run_suite(connect_tcp6_local_ip, accept_tcp6_null_addr);
end_suite();
OFP_INFO("Test ended.\n");
#endif /*INET6*/
OFP_INFO("\n\nSuite: IPv4 TCP socket local IP: send + recv.\n\n");
if (!init_suite(init_tcp_bind_listen_local_ip))
run_suite(send_tcp4_local_ip, receive_tcp);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv4 TCP socket any IP: send + recv.\n\n");
if (!init_suite(init_tcp_bind_listen_any))
run_suite(send_tcp4_any, receive_tcp);
end_suite();
OFP_INFO("Test ended.\n");
#ifdef INET6
OFP_INFO("\n\nSuite: IPv6 TCP socket local IP: send + recv.\n\n");
if (!init_suite(init_tcp6_bind_listen_local_ip))
run_suite(send_tcp6_local_ip, receive_tcp);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv6 TCP socket any IP: send + recv.\n\n");
if (!init_suite(init_tcp6_bind_listen_any))
run_suite(send_tcp6_any, receive_tcp);
end_suite();
OFP_INFO("Test ended.\n");
#endif /*INET6*/
OFP_INFO("\n\nSuite: IPv4 UDP bind local IP: select + recv.\n\n");
if (!init_suite(init_udp_bind_local_ip))
run_suite(send_udp_local_ip, select_recv_udp);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv4 TCP bind local IP: select + accept + recv.\n\n");
if (!init_suite(init_tcp_bind_listen_local_ip))
run_suite(send_tcp4_local_ip, select_recv_tcp);
end_suite();
OFP_INFO("Test ended.\n");
#ifdef INET6
OFP_INFO("\n\nSuite: IPv6 UDP bind local IP: select + recv.\n\n");
if (!init_suite(init_udp6_bind_local_ip))
run_suite(send_udp6_local_ip, select_recv_udp);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv6 TCP bind local IP: select + accept + recv.\n\n");
if (!init_suite(init_tcp6_bind_listen_local_ip))
run_suite(send_tcp6_local_ip, select_recv_tcp);
end_suite();
OFP_INFO("Test ended.\n");
#endif /*INET6*/
OFP_INFO("\n\nSuite: IPv4 UDP bindlocal IP: select + recv x2.\n\n");
if (!init_suite(init_udp_bind_local_ip))
run_suite(send_udp_local_ip, select_recv_udp_2);
end_suite();
OFP_INFO("Test ended.\n");
OFP_INFO("\n\nSuite: IPv4 UDP bind local IP: socket_sigevent rcv.\n\n");
if (!init_suite(init_udp_bind_local_ip))
run_suite(recv_send_udp_local_ip, socket_sigevent_udp4);
end_suite();
OFP_INFO("Test ended.\n");
#ifdef INET6
OFP_INFO("\n\nSuite: IPv6 UDP bind local IP: socket_sigevent rcv.\n\n");
if (!init_suite(init_udp6_bind_local_ip))
run_suite(recv_send_udp6_local_ip, socket_sigevent_udp6);
end_suite();
OFP_INFO("Test ended.\n");
#endif /*INET6*/
OFP_INFO("\n\nSuite: IPv4 TCP bind local IP: socket_sigevent rcv.\n\n");
if (!init_suite(init_tcp_bind_listen_local_ip))
run_suite(connect_recv_send_tcp_local_ip, socket_sigevent_tcp_rcv);
end_suite();
OFP_INFO("Test ended.\n");
#ifdef INET6
OFP_INFO("\n\nSuite: IPv6 TCP bind local IP: socket_sigevent rcv.\n\n");
if (!init_suite(init_tcp6_bind_listen_local_ip))
run_suite(connect_recv_send_tcp6_local_ip, socket_sigevent_tcp_rcv);
end_suite();
OFP_INFO("Test ended.\n");
#endif /*INET6*/
OFP_INFO("\n\nSuite: IPv4 TCP bind local IP: socket_sigevent accept.\n\n");
if (!init_suite(init_tcp_bind_listen_local_ip))
run_suite(connect_tcp_delayed_local_ip, socket_sigevent_tcp_accept);
end_suite();
OFP_INFO("Test ended.\n");
#ifdef INET6
OFP_INFO("\n\nSuite: IPv6 TCP bind local IP: socket_sigevent accept.\n\n");
if (!init_suite(init_tcp6_bind_listen_local_ip))
run_suite(connect_tcp6_delayed_local_ip,
socket_sigevent_tcp_accept);
end_suite();
OFP_INFO("Test ended.\n");
#endif /*INET6*/
odph_linux_pthread_join(thread_tbl, num_workers);
printf("End Main()\n");
return 0;
}
/** main() Application entry point
*
* @param argc int
* @param argv[] char*
* @return int
*
*/
int main(int argc, char *argv[])
{
odph_linux_pthread_t thread_tbl[MAX_WORKERS];
appl_args_t params;
int core_count, num_workers;
odp_cpumask_t cpumask;
char cpumaskstr[64];
/* Parse and store the application arguments */
parse_args(argc, argv, ¶ms);
/* Print both system and application information */
print_info(NO_PATH(argv[0]), ¶ms);
if (odp_init_global(NULL, NULL)) {
OFP_ERR("Error: ODP global init failed.\n");
exit(EXIT_FAILURE);
}
if (odp_init_local(ODP_THREAD_CONTROL)) {
OFP_ERR("Error: ODP local init failed.\n");
exit(EXIT_FAILURE);
}
core_count = odp_cpu_count();
num_workers = core_count;
if (params.core_count)
num_workers = params.core_count;
if (num_workers > MAX_WORKERS)
num_workers = MAX_WORKERS;
/*
* By default core #0 runs Linux kernel background tasks.
* Start mapping thread from core #1
*/
memset(&app_init_params, 0, sizeof(app_init_params));
app_init_params.linux_core_id = 0;
if (core_count > 1)
num_workers--;
num_workers = odp_cpumask_default_worker(&cpumask, num_workers);
odp_cpumask_to_str(&cpumask, cpumaskstr, sizeof(cpumaskstr));
printf("Num worker threads: %i\n", num_workers);
printf("first CPU: %i\n", odp_cpumask_first(&cpumask));
printf("cpu mask: %s\n", cpumaskstr);
app_init_params.if_count = params.if_count;
app_init_params.if_names = params.if_names;
app_init_params.pkt_hook[OFP_HOOK_LOCAL] = fastpath_local_hook;
if (ofp_init_global(&app_init_params)) {
OFP_ERR("Error: OFP global init failed.\n");
exit(EXIT_FAILURE);
}
memset(thread_tbl, 0, sizeof(thread_tbl));
/* Start dataplane dispatcher worker threads */
ofp_linux_pthread_create(thread_tbl,
&cpumask,
default_event_dispatcher,
ofp_eth_vlan_processing,
ODP_THREAD_CONTROL
);
/* other app code here.*/
/* Start CLI */
ofp_start_cli_thread(app_init_params.linux_core_id, params.conf_file);
/* sysctl test thread */
ofp_start_sysctl_thread(app_init_params.linux_core_id);
odph_linux_pthread_join(thread_tbl, num_workers);
printf("End Main()\n");
return 0;
}
/** main() Application entry point
*
* @param argc int
* @param argv[] char*
* @return int
*
*/
int main(int argc, char *argv[])
{
odph_odpthread_t thread_tbl[MAX_WORKERS];
appl_args_t params;
int core_count, num_workers;
odp_cpumask_t cpumask;
char cpumaskstr[64];
odph_odpthread_params_t thr_params;
odp_instance_t instance;
/* Parse and store the application arguments */
parse_args(argc, argv, ¶ms);
if (params.if_count > OFP_FP_INTERFACE_MAX) {
printf("Error: Invalid number of interfaces: maximum %d\n",
OFP_FP_INTERFACE_MAX);
exit(EXIT_FAILURE);
}
if (odp_init_global(&instance, NULL, NULL)) {
OFP_ERR("Error: ODP global init failed.\n");
exit(EXIT_FAILURE);
}
if (odp_init_local(instance, ODP_THREAD_CONTROL)) {
OFP_ERR("Error: ODP local init failed.\n");
exit(EXIT_FAILURE);
}
/* Print both system and application information */
print_info(NO_PATH(argv[0]), ¶ms);
core_count = odp_cpu_count();
num_workers = core_count;
if (params.core_count && params.core_count < core_count)
num_workers = params.core_count;
if (num_workers > MAX_WORKERS)
num_workers = MAX_WORKERS;
if (core_count > 1)
num_workers--;
num_workers = odp_cpumask_default_worker(&cpumask, num_workers);
odp_cpumask_to_str(&cpumask, cpumaskstr, sizeof(cpumaskstr));
printf("Num worker threads: %i\n", num_workers);
printf("first CPU: %i\n", odp_cpumask_first(&cpumask));
printf("cpu mask: %s\n", cpumaskstr);
ofp_init_global_param(&app_init_params);
app_init_params.if_count = params.if_count;
app_init_params.if_names = params.if_names;
if (ofp_init_global(instance, &app_init_params)) {
OFP_ERR("Error: OFP global init failed.\n");
exit(EXIT_FAILURE);
}
if (ofp_init_local()) {
OFP_ERR("Error: OFP local init failed.\n");
exit(EXIT_FAILURE);
}
build_classifier(app_init_params.if_count, app_init_params.if_names);
/* Start CLI */
ofp_start_cli_thread(instance, app_init_params.linux_core_id, params.cli_file);
sleep(1);
memset(thread_tbl, 0, sizeof(thread_tbl));
/* Start dataplane dispatcher worker threads */
thr_params.start = default_event_dispatcher;
thr_params.arg = ofp_udp4_processing;
thr_params.thr_type = ODP_THREAD_WORKER;
thr_params.instance = instance;
odph_odpthreads_create(thread_tbl,
&cpumask,
&thr_params);
app_processing();
odph_odpthreads_join(thread_tbl);
printf("End Main()\n");
return 0;
}
/** main() Application entry point
*
* @param argc int
* @param argv[] char*
* @return int
*
*/
int main(int argc, char *argv[])
{
odph_linux_pthread_t thread_tbl[MAX_WORKERS], dispatcher_thread;
appl_args_t params;
int core_count, num_workers;
odp_cpumask_t cpu_mask;
char cpumaskstr[64];
int cpu, first_cpu, i;
struct pktio_thr_arg pktio_thr_args[MAX_WORKERS];
/* Parse and store the application arguments */
parse_args(argc, argv, ¶ms);
/* Print both system and application information */
print_info(NO_PATH(argv[0]), ¶ms);
if (odp_init_global(NULL, NULL)) {
OFP_ERR("Error: ODP global init failed.\n");
exit(EXIT_FAILURE);
}
if (odp_init_local(ODP_THREAD_CONTROL)) {
OFP_ERR("Error: ODP local init failed.\n");
exit(EXIT_FAILURE);
}
memset(thread_tbl, 0, sizeof(thread_tbl));
memset(pktio_thr_args, 0, sizeof(pktio_thr_args));
core_count = odp_cpu_count();
num_workers = core_count;
first_cpu = 1;
if (params.core_count)
num_workers = params.core_count;
if (num_workers > MAX_WORKERS)
num_workers = MAX_WORKERS;
/*
* By default core #0 runs Linux kernel background tasks.
* Start mapping thread from core #1
*/
memset(&app_init_params, 0, sizeof(app_init_params));
app_init_params.linux_core_id = 0;
if (core_count <= 1) {
OFP_ERR("Burst mode requires multiple cores.\n");
exit(EXIT_FAILURE);
}
num_workers--;
printf("Num worker threads: %i\n", num_workers);
printf("first CPU: %i\n", first_cpu);
app_init_params.if_count = params.if_count;
app_init_params.if_names = params.if_names;
app_init_params.pkt_hook[OFP_HOOK_LOCAL] = fastpath_local_hook;
app_init_params.burst_recv_mode = 1;
if (ofp_init_global(&app_init_params)) {
OFP_ERR("Error: OFP global init failed.\n");
exit(EXIT_FAILURE);
}
if (num_workers < params.if_count) {
OFP_ERR("At least %u fastpath cores required.\n",
params.if_count);
exit(EXIT_FAILURE);
}
for (i = 0; i < num_workers; ++i) {
pktio_thr_args[i].pkt_func = ofp_eth_vlan_processing;
pktio_thr_args[i].port = i % params.if_count;
odp_cpumask_zero(&cpu_mask);
cpu = first_cpu + i;
odp_cpumask_set(&cpu_mask, cpu);
odp_cpumask_to_str(&cpu_mask, cpumaskstr, sizeof(cpumaskstr));
OFP_DBG("Starting pktio receive on core: %d port: %d\n",
cpu, pktio_thr_args[i].port);
OFP_DBG("cpu mask: %s\n", cpumaskstr);
ofp_linux_pthread_create(&thread_tbl[i],
&cpu_mask,
pkt_io_recv,
&pktio_thr_args[i],
ODP_THREAD_WORKER
);
}
odp_cpumask_zero(&cpu_mask);
odp_cpumask_set(&cpu_mask, app_init_params.linux_core_id);
ofp_linux_pthread_create(&dispatcher_thread,
&cpu_mask,
event_dispatcher,
NULL,
ODP_THREAD_CONTROL
);
/* other app code here.*/
/* Start CLI */
ofp_start_cli_thread(app_init_params.linux_core_id, params.conf_file);
odph_linux_pthread_join(thread_tbl, num_workers);
printf("End Main()\n");
return 0;
}
