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); }
void parse_param(int argc, char **argv) { int ch; while((ch = getopt(argc, argv, "i:r:l:k:")) != -1) { switch(ch) { case 'i': parse_ifs(optarg); //1:1 thread:nic int i; odp_cpumask_zero(&glb_param.cpu_mask); for(i = 0; i < glb_param.nic.num; i++) { odp_cpumask_set(&glb_param.cpu_mask, i); } break; case 'r': memcpy(glb_param.rule_file, optarg, strlen(optarg) + 1); break; case 'l': memcpy(glb_param.fib_file, optarg, strlen(optarg) + 1); break; case 'k': memcpy(glb_param.pat_file, optarg, strlen(optarg) + 1); break; default: usage(); exit(EXIT_FAILURE); } } }
int odp_cpumask_default_worker(odp_cpumask_t *mask, int num) { odp_cpumask_t overlap; int cpu, i; /* * If no user supplied number or it's too large, then attempt * to use all CPUs */ cpu = odp_cpumask_count(&odp_global_data.worker_cpus); if (0 == num || cpu < num) num = cpu; /* build the mask, allocating down from highest numbered CPU */ odp_cpumask_zero(mask); for (cpu = 0, i = CPU_SETSIZE - 1; i >= 0 && cpu < num; --i) { if (odp_cpumask_isset(&odp_global_data.worker_cpus, i)) { odp_cpumask_set(mask, i); cpu++; } } odp_cpumask_and(&overlap, mask, &odp_global_data.control_cpus); if (odp_cpumask_count(&overlap)) ODP_DBG("\n\tWorker CPUs overlap with control CPUs...\n" "\tthis will likely have a performance impact on the worker threads.\n"); return cpu; }
static int setup_txrx_masks(odp_cpumask_t *thd_mask_tx, odp_cpumask_t *thd_mask_rx) { odp_cpumask_t cpumask; int num_workers, num_tx_workers, num_rx_workers; int i, cpu; num_workers = odp_cpumask_default_worker(&cpumask, gbl_args->args.cpu_count); if (num_workers < 2) { LOG_ERR("Need at least two cores\n"); return -1; } if (gbl_args->args.num_tx_workers) { if (gbl_args->args.num_tx_workers > (num_workers - 1)) { LOG_ERR("Invalid TX worker count\n"); return -1; } num_tx_workers = gbl_args->args.num_tx_workers; } else { /* default is to split the available cores evenly into TX and * RX workers, favour TX for odd core count */ num_tx_workers = (num_workers + 1) / 2; } num_rx_workers = odp_cpumask_count(&cpumask) - num_tx_workers; odp_cpumask_zero(thd_mask_tx); odp_cpumask_zero(thd_mask_rx); cpu = odp_cpumask_first(&cpumask); for (i = 0; i < num_workers; ++i) { if (i < num_rx_workers) odp_cpumask_set(thd_mask_rx, cpu); else odp_cpumask_set(thd_mask_tx, cpu); cpu = odp_cpumask_next(&cpumask, cpu); } num_rx_workers = odp_cpumask_count(thd_mask_rx); odp_barrier_init(&gbl_args->rx_barrier, num_rx_workers+1); odp_barrier_init(&gbl_args->tx_barrier, num_tx_workers+1); return 0; }
int odph_linux_process_fork(odph_linux_process_t *proc, int cpu) { odp_cpumask_t mask; odp_cpumask_zero(&mask); odp_cpumask_set(&mask, cpu); return odph_linux_process_fork_n(proc, &mask); }
void ofp_start_sysctl_thread(int core_id) { odph_linux_pthread_t test_linux_pthread; odp_cpumask_t cpumask; odp_cpumask_zero(&cpumask); odp_cpumask_set(&cpumask, core_id); odph_linux_pthread_create(&test_linux_pthread, &cpumask, sysctl, NULL); }
void ofp_start_webserver_thread(int core_id) { odph_linux_pthread_t test_linux_pthread; odp_cpumask_t cpumask; odp_cpumask_zero(&cpumask); odp_cpumask_set(&cpumask, core_id); ofp_linux_pthread_create(&test_linux_pthread, &cpumask, webserver, NULL, ODP_THREAD_WORKER ); }
void ofp_multicast_thread(int core_id) { odph_linux_pthread_t test_linux_pthread; odp_cpumask_t cpumask; odp_cpumask_zero(&cpumask); odp_cpumask_set(&cpumask, core_id); ofp_linux_pthread_create(&test_linux_pthread, &cpumask, mcasttest, NULL, ODP_THREAD_WORKER ); }
static int init_suite(void) { odp_pool_param_t pool_params; ofp_pkt_hook pkt_hook[OFP_HOOK_MAX]; odp_pool_t pool; odph_linux_thr_params_t thr_params; odp_instance_t instance; /* Init ODP before calling anything else */ if (odp_init_global(&instance, NULL, NULL)) { OFP_ERR("Error: ODP global init failed.\n"); return -1; } /* Init this thread */ if (odp_init_local(instance, ODP_THREAD_CONTROL)) { OFP_ERR("Error: ODP local init failed.\n"); return -1; } memset(pkt_hook, 0, sizeof(pkt_hook)); pool_params.pkt.seg_len = SHM_PKT_POOL_BUFFER_SIZE; pool_params.pkt.len = SHM_PKT_POOL_BUFFER_SIZE; pool_params.pkt.num = SHM_PKT_POOL_SIZE / SHM_PKT_POOL_BUFFER_SIZE; pool_params.type = ODP_POOL_PACKET; (void) ofp_init_pre_global(pool_name, &pool_params, pkt_hook, &pool, ARP_AGE_INTERVAL, ARP_ENTRY_TIMEOUT); /* * Start a packet processing thread to service timer events. */ odp_atomic_store_u32(&still_running, 1); odp_cpumask_t cpumask; odp_cpumask_zero(&cpumask); odp_cpumask_set(&cpumask, 0x1); thr_params.start = pp_thread; thr_params.arg = NULL; thr_params.thr_type = ODP_THREAD_WORKER; thr_params.instance = instance; odph_linux_pthread_create(&pp_thread_handle, &cpumask, &thr_params); return 0; }
static int start_performance(int core_id) { odph_linux_pthread_t cli_linux_pthread; odp_cpumask_t cpumask; odp_cpumask_zero(&cpumask); odp_cpumask_set(&cpumask, core_id); return ofp_linux_pthread_create(&cli_linux_pthread, &cpumask, perf_client, NULL, ODP_THREAD_WORKER ); }
static int start_performance(odp_instance_t instance, int core_id) { odph_linux_pthread_t cli_linux_pthread; odp_cpumask_t cpumask; odph_linux_thr_params_t thr_params; odp_cpumask_zero(&cpumask); odp_cpumask_set(&cpumask, core_id); thr_params.start = perf_client; thr_params.arg = NULL; thr_params.thr_type = ODP_THREAD_CONTROL; thr_params.instance = instance; return odph_linux_pthread_create(&cli_linux_pthread, &cpumask, &thr_params); }
void ofp_start_webserver_thread(odp_instance_t instance, int core_id) { static odph_linux_pthread_t test_linux_webserver_pthread; odp_cpumask_t cpumask; odph_linux_thr_params_t thr_params; odp_cpumask_zero(&cpumask); odp_cpumask_set(&cpumask, core_id); thr_params.start = webserver; thr_params.arg = NULL; thr_params.thr_type = ODP_THREAD_CONTROL; thr_params.instance = instance; odph_linux_pthread_create(&test_linux_webserver_pthread, &cpumask, &thr_params); }
int ofp_init_global(ofp_init_global_t *params) { int i; HANDLE_ERROR(ofp_init_pre_global(NULL, NULL, params->pkt_hook, NULL, ARP_AGE_INTERVAL, ARP_ENTRY_TIMEOUT)); /* cpu mask for slow path threads */ odp_cpumask_zero(&cpumask); odp_cpumask_set(&cpumask, params->linux_core_id); OFP_INFO("Slow path threads on core %d", odp_cpumask_first(&cpumask)); HANDLE_ERROR(ofp_set_vxlan_interface_queue()); /* Create interfaces */ for (i = 0; i < params->if_count; ++i) HANDLE_ERROR(ofp_ifnet_create(params->if_names[i], params->burst_recv_mode ? ODP_PKTIN_MODE_RECV : ODP_PKTIN_MODE_SCHED)); #ifdef SP /* Start Netlink server process */ if (!ofp_linux_pthread_create(&shm->nl_thread, &cpumask, START_NL_SERVER, NULL, ODP_THREAD_CONTROL)) { OFP_ERR("Failed to start Netlink thread."); return -1; } shm->nl_thread_is_running = 1; #endif /* SP */ odp_schedule_resume(); return 0; }
int odp_cpumask_default_control(odp_cpumask_t *mask, int num) { odp_cpumask_t overlap; int cpu, i; /* * If no user supplied number then default to one control CPU. */ if (0 == num) { num = 1; } else { /* * If user supplied number is too large, then attempt * to use all installed control CPUs */ cpu = odp_cpumask_count(&odp_global_data.control_cpus); if (cpu < num) num = cpu; } /* build the mask, allocating upwards from lowest numbered CPU */ odp_cpumask_zero(mask); for (cpu = 0, i = 0; i < CPU_SETSIZE && cpu < num; i++) { if (odp_cpumask_isset(&odp_global_data.control_cpus, i)) { odp_cpumask_set(mask, i); cpu++; } } odp_cpumask_and(&overlap, mask, &odp_global_data.worker_cpus); if (odp_cpumask_count(&overlap)) ODP_DBG("\n\tControl CPUs overlap with worker CPUs...\n" "\tthis will likely have a performance impact on the worker threads.\n"); return cpu; }
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; }
/** * 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) { 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; }
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; 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; }
/** 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; }