void run_suite(odp_instance_t instance,
run_function run_func1, run_function run_func2)
{
odph_linux_pthread_t sock_pthread1;
odph_linux_pthread_t sock_pthread2;
odp_cpumask_t sock_cpumask;
odph_linux_thr_params_t thr_params;
odp_cpumask_zero(&sock_cpumask);
odp_cpumask_set(&sock_cpumask, core_id);
thr_params.start = suite_thread1;
thr_params.arg = run_func1;
thr_params.thr_type = ODP_THREAD_CONTROL;
thr_params.instance = instance;
odph_linux_pthread_create(&sock_pthread1,
&sock_cpumask,
&thr_params);
thr_params.start = suite_thread2;
thr_params.arg = run_func2;
thr_params.thr_type = ODP_THREAD_CONTROL;
thr_params.instance = instance;
odph_linux_pthread_create(&sock_pthread2,
&sock_cpumask,
&thr_params);
odph_linux_pthread_join(&sock_pthread1, 1);
odph_linux_pthread_join(&sock_pthread2, 1);
}
/*
* Run a single instance of the throughput test. When attempting to determine
* the maximum packet rate this will be invoked multiple times with the only
* difference between runs being the target PPS rate.
*/
static int run_test_single(odp_cpumask_t *thd_mask_tx,
odp_cpumask_t *thd_mask_rx,
test_status_t *status)
{
odph_linux_pthread_t thd_tbl[MAX_WORKERS];
thread_args_t args_tx, args_rx;
uint64_t expected_tx_cnt;
int num_tx_workers, num_rx_workers;
odp_atomic_store_u32(&shutdown, 0);
memset(thd_tbl, 0, sizeof(thd_tbl));
memset(&gbl_args->rx_stats, 0, sizeof(gbl_args->rx_stats));
memset(&gbl_args->tx_stats, 0, sizeof(gbl_args->tx_stats));
expected_tx_cnt = status->pps_curr * gbl_args->args.duration;
/* start receiver threads first */
args_rx.batch_len = gbl_args->args.rx_batch_len;
odph_linux_pthread_create(&thd_tbl[0], thd_mask_rx,
run_thread_rx, &args_rx);
odp_barrier_wait(&gbl_args->rx_barrier);
num_rx_workers = odp_cpumask_count(thd_mask_rx);
/* then start transmitters */
num_tx_workers = odp_cpumask_count(thd_mask_tx);
args_tx.pps = status->pps_curr / num_tx_workers;
args_tx.duration = gbl_args->args.duration;
args_tx.batch_len = gbl_args->args.tx_batch_len;
odph_linux_pthread_create(&thd_tbl[num_rx_workers], thd_mask_tx,
run_thread_tx, &args_tx);
odp_barrier_wait(&gbl_args->tx_barrier);
/* wait for transmitter threads to terminate */
odph_linux_pthread_join(&thd_tbl[num_rx_workers],
num_tx_workers);
/* delay to allow transmitted packets to reach the receivers */
busy_loop_ns(SHUTDOWN_DELAY_NS);
/* indicate to the receivers to exit */
odp_atomic_store_u32(&shutdown, 1);
/* wait for receivers */
odph_linux_pthread_join(&thd_tbl[0], num_rx_workers);
return process_results(expected_tx_cnt, status);
}
/** exit from test thread */
int odp_test_thread_exit(pthrd_arg *arg)
{
/* Wait for other threads to exit */
odph_linux_pthread_join(thread_tbl, arg->numthrds);
return 0;
}
static int end_suite(void)
{
odp_atomic_store_u32(&still_running, 0);
odph_linux_pthread_join(&pp_thread_handle, 1);
return 0;
}
int main(int argc, char *argv[]){
if(argc<2)return 1;
int i,n,cpu;
odp_cpumask_t cpumask;
odp_init_global(NULL, NULL);
odp_init_local(ODP_THREAD_CONTROL);
struct iofix fix;
odp_pool_t pool = open_pool("pktin_pool",1024);
//fix.pktio = open_nic("mytap",pool);
fix.pktio = open_nic(argv[1],pool);
n = odp_cpumask_default_worker(&cpumask, MAX_WORKERS);
odph_linux_pthread_create(thread_tbl, &cpumask,
iot_burst,&fix,ODP_THREAD_WORKER);
odph_linux_pthread_join(thread_tbl, n);
return 0;
}
static void test_tls_errno(void)
{
odp_cpumask_t cpumask;
odph_linux_pthread_t threads;
odp_barrier_t barrier__;
odp_barrier_t *barrier;
CU_ASSERT(1 == odp_cpumask_default_worker(&cpumask, 1));
barrier = &barrier__;
odp_barrier_init(barrier, 2);
CU_ASSERT(1 == ofp_linux_pthread_create(
&threads,
&cpumask,
other_thread,
(void *)barrier,
ODP_THREAD_CONTROL));
/* Initialize this thread's ofp_errno. */
ofp_errno = 0;
/* Test 1 - Test that an assignment to the current thread's ofp_errno
* does not modify the ofp_errno of other_thread.
*/
odp_barrier_wait(barrier);
ofp_errno = OFP_EIO;
odp_barrier_wait(barrier);
CU_ASSERT_EQUAL(ofp_errno, OFP_EIO);
/* Test 2 - Test both threads. */
odp_barrier_wait(barrier);
ofp_errno = OFP_EPERM;
odp_barrier_wait(barrier);
CU_ASSERT_EQUAL(ofp_errno, OFP_EPERM);
odph_linux_pthread_join(&threads, 1);
}
/**
* 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;
}
int main(int argc, char **argv)
{
int ret;
ret = odp_init_global(NULL, NULL);
if(ret < 0)
{
fprintf(stderr, "global init failure!\n");
exit(EXIT_FAILURE);
}
ret = odp_init_local(ODP_THREAD_CONTROL);
if(ret < 0)
{
fprintf(stderr, "local init failure!\n");
exit(EXIT_FAILURE);
}
parse_param(argc, argv);
packet_classifier_init(glb_param.rule_file, glb_param.fib_file);
hash_env_init();
sm_hdl = sm_build(glb_param.pat_file);
hs_tbl = create_hash_table();
odp_pool_t pkt_pool;
pkt_pool = create_pkt_pool("PACKET_POOL",PACKET_POOL_OBJ_SZ,
PACKET_POOL_MAX_ELT_NUM);
if(pkt_pool == ODP_POOL_INVALID)
{
fprintf(stderr, "create packet pool failure!\n");
exit(EXIT_FAILURE);
}
if(init_all_if(pkt_pool) == -1)
{
fprintf(stderr, "init nic faliure!\n");
exit(EXIT_FAILURE);
}
odph_linux_pthread_t thr_tbl[ODP_CONFIG_PKTIO_ENTRIES];
int thr_num;
thr_num = odph_linux_pthread_create(thr_tbl, &glb_param.cpu_mask, thread_fwd_routine, NULL);
if(thr_num != glb_param.nic.num)
{
fprintf(stderr, "some nic thread start failure!\n");
exit(EXIT_FAILURE);
}
odph_linux_pthread_t thr_stat_hdl;
odp_cpumask_t thr_stat_mask;
odp_cpumask_zero(&thr_stat_mask);
odp_cpumask_set(&thr_stat_mask, glb_param.nic.num);
if(odph_linux_pthread_create(&thr_stat_hdl, &thr_stat_mask, thread_stat_routine, NULL) != 1)
{
fprintf(stderr, "stat thread start failure!\n");
exit(EXIT_FAILURE);
}
odph_linux_pthread_join(thr_tbl, thr_num);
odph_linux_pthread_join(&thr_stat_hdl, 1);
int nic_id;
for(nic_id = 0; nic_id < glb_param.nic.num; nic_id++)
{
odp_pktio_close(thr_data.nic_hdl[nic_id]);
}
sm_destroy(sm_hdl);
odph_hash_free(hs_tbl);
odp_pool_destroy(pkt_pool);
odp_term_local();
odp_term_global();
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];
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;
}
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;
}
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;
}
/** 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--;
#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;
}
/**
* Test main function
*/
int main(int argc, char *argv[])
{
odph_linux_pthread_t thread_tbl[MAX_WORKERS];
int num_workers;
odp_queue_t queue;
uint64_t cycles, ns;
odp_queue_param_t param;
odp_pool_param_t params;
odp_timer_pool_param_t tparams;
odp_timer_pool_info_t tpinfo;
odp_cpumask_t cpumask;
char cpumaskstr[ODP_CPUMASK_STR_SIZE];
odp_shm_t shm;
test_globals_t *gbls;
printf("\nODP timer example starts\n");
if (odp_init_global(NULL, NULL)) {
printf("ODP global init failed.\n");
return -1;
}
/* Init this thread. */
if (odp_init_local()) {
printf("ODP local init failed.\n");
return -1;
}
printf("\n");
printf("ODP system info\n");
printf("---------------\n");
printf("ODP API version: %s\n", odp_version_api_str());
printf("CPU model: %s\n", odp_sys_cpu_model_str());
printf("CPU freq (hz): %"PRIu64"\n", odp_sys_cpu_hz());
printf("Cache line size: %i\n", odp_sys_cache_line_size());
printf("Max CPU count: %i\n", odp_cpu_count());
printf("\n");
/* Reserve memory for test_globals_t from shared mem */
shm = odp_shm_reserve("shm_test_globals", sizeof(test_globals_t),
ODP_CACHE_LINE_SIZE, 0);
if (ODP_SHM_INVALID == shm) {
EXAMPLE_ERR("Error: shared mem reserve failed.\n");
return -1;
}
gbls = odp_shm_addr(shm);
if (NULL == gbls) {
EXAMPLE_ERR("Error: shared mem alloc failed.\n");
return -1;
}
memset(gbls, 0, sizeof(test_globals_t));
parse_args(argc, argv, &gbls->args);
memset(thread_tbl, 0, sizeof(thread_tbl));
/* Default to system CPU count unless user specified */
num_workers = MAX_WORKERS;
if (gbls->args.cpu_count)
num_workers = gbls->args.cpu_count;
/*
* By default CPU #0 runs Linux kernel background tasks.
* Start mapping thread from CPU #1
*/
num_workers = odph_linux_cpumask_default(&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);
printf("resolution: %i usec\n", gbls->args.resolution_us);
printf("min timeout: %i usec\n", gbls->args.min_us);
printf("max timeout: %i usec\n", gbls->args.max_us);
printf("period: %i usec\n", gbls->args.period_us);
printf("timeouts: %i\n", gbls->args.tmo_count);
/*
* Create pool for timeouts
*/
params.tmo.num = NUM_TMOS;
params.type = ODP_POOL_TIMEOUT;
gbls->pool = odp_pool_create("msg_pool", ODP_SHM_NULL, ¶ms);
if (gbls->pool == ODP_POOL_INVALID) {
EXAMPLE_ERR("Pool create failed.\n");
return -1;
}
tparams.res_ns = gbls->args.resolution_us*ODP_TIME_USEC;
tparams.min_tmo = gbls->args.min_us*ODP_TIME_USEC;
tparams.max_tmo = gbls->args.max_us*ODP_TIME_USEC;
tparams.num_timers = num_workers; /* One timer per worker */
tparams.priv = 0; /* Shared */
tparams.clk_src = ODP_CLOCK_CPU;
gbls->tp = odp_timer_pool_create("timer_pool", &tparams);
if (gbls->tp == ODP_TIMER_POOL_INVALID) {
EXAMPLE_ERR("Timer pool create failed.\n");
return -1;
}
odp_timer_pool_start();
odp_shm_print_all();
(void)odp_timer_pool_info(gbls->tp, &tpinfo);
printf("Timer pool\n");
printf("----------\n");
printf(" name: %s\n", tpinfo.name);
printf(" resolution: %"PRIu64" ns\n", tpinfo.param.res_ns);
printf(" min tmo: %"PRIu64" ticks\n", tpinfo.param.min_tmo);
printf(" max tmo: %"PRIu64" ticks\n", tpinfo.param.max_tmo);
printf("\n");
/*
* Create a queue for timer test
*/
memset(¶m, 0, sizeof(param));
param.sched.prio = ODP_SCHED_PRIO_DEFAULT;
param.sched.sync = ODP_SCHED_SYNC_NONE;
param.sched.group = ODP_SCHED_GROUP_DEFAULT;
queue = odp_queue_create("timer_queue", ODP_QUEUE_TYPE_SCHED, ¶m);
if (queue == ODP_QUEUE_INVALID) {
EXAMPLE_ERR("Timer queue create failed.\n");
return -1;
}
printf("CPU freq %"PRIu64" Hz\n", odp_sys_cpu_hz());
printf("Cycles vs nanoseconds:\n");
ns = 0;
cycles = odp_time_ns_to_cycles(ns);
printf(" %12"PRIu64" ns -> %12"PRIu64" cycles\n", ns, cycles);
printf(" %12"PRIu64" cycles -> %12"PRIu64" ns\n", cycles,
odp_time_cycles_to_ns(cycles));
for (ns = 1; ns <= 100*ODP_TIME_SEC; ns *= 10) {
cycles = odp_time_ns_to_cycles(ns);
printf(" %12"PRIu64" ns -> %12"PRIu64" cycles\n", ns,
cycles);
printf(" %12"PRIu64" cycles -> %12"PRIu64" ns\n", cycles,
odp_time_cycles_to_ns(cycles));
}
printf("\n");
/* Initialize number of timeouts to receive */
odp_atomic_init_u32(&gbls->remain, gbls->args.tmo_count * num_workers);
/* Barrier to sync test case execution */
odp_barrier_init(&gbls->test_barrier, num_workers);
/* Create and launch worker threads */
odph_linux_pthread_create(thread_tbl, &cpumask,
run_thread, gbls);
/* Wait for worker threads to exit */
odph_linux_pthread_join(thread_tbl, num_workers);
printf("ODP timer test complete\n\n");
return 0;
}
static int ofp_lib_start(void)
{
ofp_init_global_t app_init_params;
odph_linux_pthread_t thread_tbl[32];
int ret_val, num_workers = 1;
odp_cpumask_t cpumask;
char cpumaskstr[64];
if (ofp_init_global_called)
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(NULL, NULL)) {
OFP_ERR("ODP global init failed.");
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(ODP_THREAD_CONTROL) != 0) {
OFP_ERR("ODP local init failed.");
odp_term_global();
return EXIT_FAILURE;
}
/*
* 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) {
OFP_ERR("Error: Too small buffer provided to "
"odp_cpumask_to_str");
odp_term_local();
odp_term_global();
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);
/*
* 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.
*/
memset(&app_init_params, 0, sizeof(app_init_params));
if (ofp_init_global(&app_init_params) != 0) {
OFP_ERR("OFP global init failed.");
ofp_term_global();
odp_term_local();
odp_term_global();
return EXIT_FAILURE;
}
if (ofp_init_local() != 0) {
OFP_ERR("Error: OFP local init failed.");
ofp_term_local();
ofp_term_global();
odp_term_local();
odp_term_global();
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));
ret_val = ofp_linux_pthread_create(thread_tbl,
&cpumask,
default_event_dispatcher,
ofp_eth_vlan_processing,
ODP_THREAD_CONTROL);
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();
return EXIT_FAILURE;
}
ofp_ifconfig();
return EXIT_SUCCESS;
}
/** 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;
}
int ofp_term_global(void)
{
int rc = 0;
uint16_t i;
struct ofp_ifnet *ifnet;
ofp_stop();
/* Terminate CLI thread*/
CHECK_ERROR(ofp_stop_cli_thread(), rc);
#ifdef SP
/* Terminate Netlink thread*/
if (shm->nl_thread_is_running) {
odph_linux_pthread_join(&shm->nl_thread, 1);
shm->nl_thread_is_running = 0;
}
#endif /* SP */
/* Cleanup interfaces: queues and pktios*/
for (i = 0; i < VXLAN_PORTS; i++) {
ifnet = ofp_get_ifnet((uint16_t)i, 0);
if (!ifnet) {
OFP_ERR("Failed to locate interface for port %d", i);
rc = -1;
continue;
}
if (ifnet->if_state == OFP_IFT_STATE_FREE)
continue;
if (ifnet->pktio == ODP_PKTIO_INVALID)
continue;
OFP_INFO("Cleaning device '%s' addr %s", ifnet->if_name,
ofp_print_mac((uint8_t *)ifnet->mac));
CHECK_ERROR(odp_pktio_stop(ifnet->pktio), rc);
#ifdef SP
close(ifnet->fd);
odph_linux_pthread_join(ifnet->rx_tbl, 1);
odph_linux_pthread_join(ifnet->tx_tbl, 1);
ifnet->fd = -1;
#endif /*SP*/
/* Multicasting. */
ofp_igmp_domifdetach(ifnet);
ifnet->ii_inet.ii_igmp = NULL;
if (ifnet->loopq_def != ODP_QUEUE_INVALID) {
if (odp_queue_destroy(ifnet->loopq_def) < 0) {
OFP_ERR("Failed to destroy loop queue for %s",
ifnet->if_name);
rc = -1;
}
ifnet->loopq_def = ODP_QUEUE_INVALID;
}
#ifdef SP
if (ifnet->spq_def != ODP_QUEUE_INVALID) {
cleanup_pkt_queue(ifnet->spq_def);
if (odp_queue_destroy(ifnet->spq_def) < 0) {
OFP_ERR("Failed to destroy slow path "
"queue for %s", ifnet->if_name);
rc = -1;
}
ifnet->spq_def = ODP_QUEUE_INVALID;
}
#endif /*SP*/
ifnet->outq_def = ODP_QUEUE_INVALID;
if (ifnet->pktio != ODP_PKTIO_INVALID) {
if (odp_pktio_close(ifnet->pktio) < 0) {
OFP_ERR("Failed to destroy pktio for %s",
ifnet->if_name);
rc = -1;
}
ifnet->pktio = ODP_PKTIO_INVALID;
}
if (ifnet->inq_def != ODP_QUEUE_INVALID) {
cleanup_pkt_queue(ifnet->inq_def);
if (odp_queue_destroy(ifnet->inq_def) < 0) {
OFP_ERR("Failed to destroy default input "
"queue for %s", ifnet->if_name);
rc = -1;
}
ifnet->inq_def = ODP_QUEUE_INVALID;
}
}
CHECK_ERROR(ofp_clean_vxlan_interface_queue(), rc);
if (ofp_term_post_global(SHM_PACKET_POOL_NAME)) {
OFP_ERR("Failed to cleanup resources\n");
rc = -1;
}
return rc;
}
/** 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;
}
