static int globalinit(void) { int rv; if (rte_eal_init(sizeof(ealargs)/sizeof(ealargs[0]), /*UNCONST*/(void *)(uintptr_t)ealargs) < 0) OUT("eal init\n"); if ((mbpool = rte_mempool_create("mbuf_pool", NMBUF, MBSIZE, MBALIGN, sizeof(struct rte_pktmbuf_pool_private), rte_pktmbuf_pool_init, NULL, rte_pktmbuf_init, NULL, 0, 0)) == NULL) OUT("mbuf pool\n"); if (PMD_INIT() < 0) OUT("wm driver\n"); if (rte_eal_pci_probe() < 0) OUT("PCI probe\n"); if (rte_eth_dev_count() == 0) OUT("no ports\n"); rv = 0; out: return rv; }
static int globalinit(struct virtif_user *viu) { int rv; if ((rv = rte_eal_init(sizeof(ealargs)/sizeof(ealargs[0]), /*UNCONST*/(void *)(uintptr_t)ealargs)) < 0) OUT("eal init"); if ((mbpool_tx = rte_mempool_create("mbuf_pool_tx", NMBUF_TX, MBSIZE, 0/*MBCACHE*/, sizeof(struct rte_pktmbuf_pool_private), rte_pktmbuf_pool_init, NULL, rte_pktmbuf_init, NULL, 0, 0)) == NULL) { rv = -EINVAL; OUT("mbuf pool tx"); } if ((mbpool_rx = rte_mempool_create("mbuf_pool_rx", NMBUF_RX, MBSIZE, 0/*MBCACHE*/, sizeof(struct rte_pktmbuf_pool_private), rte_pktmbuf_pool_init, NULL, rte_pktmbuf_init, NULL, 0, 0)) == NULL) { rv = -EINVAL; OUT("mbuf pool tx"); } if (rte_eth_dev_count() == 0) { rv = -1; OUT("no ports"); } rv = 0; out: return rv; }
int main(void) { int ret; struct cmdline *cl; int param_num = 8; char *param[] = {"anscli", "-c", "1", "-n", "1", "--no-pci", "--socket-mem=1", "--proc-type=secondary", NULL}; rte_set_log_level(RTE_LOG_ERR); ret = rte_eal_init(param_num, param); if (ret < 0) rte_panic("Cannot init EAL\n"); ret = anscli_ring_init(); if(ret != 0) rte_panic("Cannot init ring\n"); cl = cmdline_stdin_new(ip_main_ctx, "ans> "); if (cl == NULL) rte_panic("Cannot create ans cmdline instance\n"); cmdline_interact(cl); cmdline_stdin_exit(cl); return 0; }
int32_t main(int32_t argc, char **argv) { int32_t ret = -1; ret = rte_eal_init(argc, argv); if(0 > ret) { rte_exit(EXIT_FAILURE, "rte_eal_init failed!\n"); } argc -= ret; argv += ret; ret = udpi_parse_args(argc, argv); if(0 > ret) { udpi_print_usage(argv[0]); rte_exit(EXIT_FAILURE, "invalid user args!\n"); } udpi_init(); rte_eal_mp_remote_launch(udpi_lcore_main_loop, NULL, CALL_MASTER); return 0; }
int MAIN(int argc, char **argv) { uint32_t lcore; int ret; /* Init EAL */ ret = rte_eal_init(argc, argv); if (ret < 0) return -1; argc -= ret; argv += ret; /* Parse application arguments (after the EAL ones) */ ret = app_parse_args(argc, argv); if (ret < 0) { app_print_usage(); return -1; } /* Init */ app_init(); app_print_params(); /* Launch per-lcore init on every lcore */ rte_eal_mp_remote_launch(app_lcore_main_loop, NULL, CALL_MASTER); RTE_LCORE_FOREACH_SLAVE(lcore) { if (rte_eal_wait_lcore(lcore) < 0) { return -1; } } return 0; }
/* * Parse the command line arguments passed to the application. */ int parse_args(int argc, char** argv, app_params* p) { // initialize the environment int ret = rte_eal_init(argc, argv); if (ret < 0) { rte_exit(EXIT_FAILURE, "Failed to initialize EAL: %i\n", ret); } // advance past the environmental settings argc -= ret; argv += ret; // parse arguments to the application ret = parse_app_args(argc, argv, p); if (ret < 0) { rte_exit(EXIT_FAILURE, "\n"); } p->nb_ports = rte_eth_dev_count(); p->nb_rx_workers = p->nb_rx_queue; p->nb_tx_workers = (rte_lcore_count() - 1) - p->nb_rx_workers; // validate the number of workers if(p->nb_tx_workers < p->nb_rx_workers) { rte_exit(EXIT_FAILURE, "Additional lcore(s) required; found=%u, required=%u \n", rte_lcore_count(), (p->nb_rx_queue*2) + 1); } return 0; }
static int globalinit(struct virtif_user *viu) { int rv; if ((rv = rte_eal_init(sizeof(ealargs)/sizeof(ealargs[0]), /*UNCONST*/(void *)(uintptr_t)ealargs)) < 0) OUT("eal init\n"); /* disable mempool cache due to DPDK bug, not thread safe */ if ((mbpool = rte_mempool_create("mbuf_pool", NMBUF, MBSIZE, 0/*MBCACHE*/, sizeof(struct rte_pktmbuf_pool_private), rte_pktmbuf_pool_init, NULL, rte_pktmbuf_init, NULL, 0, 0)) == NULL) { rv = -EINVAL; OUT("mbuf pool\n"); } if ((rv = PMD_INIT()) < 0) OUT("pmd init\n"); if ((rv = rte_eal_pci_probe()) < 0) OUT("PCI probe\n"); if (rte_eth_dev_count() == 0) { rv = -1; OUT("no ports\n"); } rv = 0; out: return rv; }
int main(int argc, char *argv[]) { int ret; signal(SIGINT, signal_handler); /* init EAL */ ret = rte_eal_init(argc, argv); if (ret < 0) rte_exit(EXIT_FAILURE, "Error with EAL initialization\n"); g_vhost_ctrlr = vhost_scsi_ctrlr_construct("vhost.socket"); if (g_vhost_ctrlr == NULL) { fprintf(stderr, "Construct vhost scsi controller failed\n"); return 0; } if (sem_init(&exit_sem, 0, 0) < 0) { fprintf(stderr, "Error init exit_sem\n"); return -1; } rte_vhost_driver_start(dev_pathname); /* loop for exit the application */ while (1) sleep(1); return 0; }
int main(int argc, char **argv) { struct cmdline *cl; int ret; ret = rte_eal_init(argc, argv); if (ret < 0) return -1; rte_timer_subsystem_init(); argc -= ret; argv += ret; prgname = argv[0]; #ifndef RTE_EXEC_ENV_BAREMETAL if ((recursive_call = getenv(RECURSIVE_ENV_VAR)) != NULL) return do_recursive_call(); #endif cl = cmdline_stdin_new(main_ctx, "RTE>>"); if (cl == NULL) { return -1; } cmdline_interact(cl); cmdline_stdin_exit(cl); return 0; }
int main(int argc, char **argv) { int c; int ret; int sp_sc; unsigned socket_io; /* initialize EAL first */ ret = rte_eal_init(argc, argv); argc -= ret; argv += ret; sp_sc = 1; bulk_size = 1; while ((c = getopt(argc, argv, "sm:b:w:")) != -1) { switch (c) { case 's': sp_sc = 1; break; case 'm': sp_sc = 0; nb_producers = atoi(optarg); break; case 'b': bulk_size = atoi(optarg); break; case 'w': work_cycles = atoi(optarg); break; case '?': break; } } setlocale(LC_NUMERIC, ""); socket_io = rte_lcore_to_socket_id(rte_get_master_lcore()); ring = rte_ring_create(ring_name, ring_size, socket_io, RING_F_SP_ENQ | RING_F_SC_DEQ); if (ring == NULL) { rte_panic("Cannot create ring"); } if (sp_sc) { printf("[MASTER] Single Producer/Consumer\n"); printf("[MASTER] Bulk size: %d\n", bulk_size); driver_sp_sc(); } else { printf("[MASTER] Number of Producers/Consumers: %d\n", nb_producers); printf("[MASTER] Bulk size: %d\n", bulk_size); driver_mp_mc(); } rte_eal_mp_wait_lcore(); }
int main(int argc, char **argv) { int rc; /* * By default, the SPDK NVMe driver uses DPDK for huge page-based * memory management and NVMe request buffer pools. Huge pages can * be either 2MB or 1GB in size (instead of 4KB) and are pinned in * memory. Pinned memory is important to ensure DMA operations * never target swapped out memory. * * So first we must initialize DPDK. "-c 0x1" indicates to only use * core 0. */ rc = rte_eal_init(sizeof(ealargs) / sizeof(ealargs[0]), ealargs); if (rc < 0) { fprintf(stderr, "could not initialize dpdk\n"); return 1; } /* * Create the NVMe request buffer pool. This will be used internally * by the SPDK NVMe driver to allocate an spdk_nvme_request data * structure for each I/O request. This is implicitly passed to * the SPDK NVMe driver via an extern declaration in nvme_impl.h. */ request_mempool = rte_mempool_create("nvme_request", 8192, spdk_nvme_request_size(), 128, 0, NULL, NULL, NULL, NULL, SOCKET_ID_ANY, 0); if (request_mempool == NULL) { fprintf(stderr, "could not initialize request mempool\n"); return 1; } printf("Initializing NVMe Controllers\n"); /* * Start the SPDK NVMe enumeration process. probe_cb will be called * for each NVMe controller found, giving our application a choice on * whether to attach to each controller. attach_cb will then be * called for each controller after the SPDK NVMe driver has completed * initializing the controller we chose to attach. */ rc = spdk_nvme_probe(NULL, probe_cb, attach_cb, NULL); if (rc != 0) { fprintf(stderr, "spdk_nvme_probe() failed\n"); cleanup(); return 1; } printf("Initialization complete.\n"); hello_world(); cleanup(); return 0; }
/** * Main init function for the multi-process server app, * calls subfunctions to do each stage of the initialisation. */ int init(int argc, char *argv[]) { int retval; const struct rte_memzone *mz; uint8_t i, total_ports; /* init EAL, parsing EAL args */ retval = rte_eal_init(argc, argv); if (retval < 0) return -1; argc -= retval; argv += retval; /* initialise the nic drivers */ retval = init_drivers(); if (retval != 0) rte_exit(EXIT_FAILURE, "Cannot initialise drivers\n"); /* get total number of ports */ total_ports = rte_eth_dev_count(); /* set up array for port data */ mz = rte_memzone_reserve(MZ_PORT_INFO, sizeof(*ports), rte_socket_id(), NO_FLAGS); if (mz == NULL) rte_exit(EXIT_FAILURE, "Cannot reserve memory zone for port information\n"); memset(mz->addr, 0, sizeof(*ports)); ports = mz->addr; /* parse additional, application arguments */ retval = parse_app_args(total_ports, argc, argv); if (retval != 0) return -1; /* initialise mbuf pools */ retval = init_mbuf_pools(); if (retval != 0) rte_exit(EXIT_FAILURE, "Cannot create needed mbuf pools\n"); /* now initialise the ports we will use */ for (i = 0; i < ports->num_ports; i++) { retval = init_port(ports->id[i]); if (retval != 0) rte_exit(EXIT_FAILURE, "Cannot initialise port %u\n", (unsigned)i); } check_all_ports_link_status(ports->num_ports, (~0x0)); /* initialise the client queues/rings for inter-eu comms */ init_shm_rings(); return 0; }
int main(int argc, char **argv) { struct dev *iter; int rc, i; printf("NVMe Write/Read with End-to-End data protection test\n"); rc = rte_eal_init(sizeof(ealargs) / sizeof(ealargs[0]), (char **)(void *)(uintptr_t)ealargs); if (rc < 0) { fprintf(stderr, "could not initialize dpdk\n"); exit(1); } request_mempool = rte_mempool_create("nvme_request", 8192, spdk_nvme_request_size(), 128, 0, NULL, NULL, NULL, NULL, SOCKET_ID_ANY, 0); if (request_mempool == NULL) { fprintf(stderr, "could not initialize request mempool\n"); exit(1); } if (spdk_nvme_probe(NULL, probe_cb, attach_cb, NULL) != 0) { fprintf(stderr, "nvme_probe() failed\n"); exit(1); } rc = 0; foreach_dev(iter) { #define TEST(x) write_read_e2e_dp_tests(iter, x, #x) if (TEST(dp_with_pract_test) || TEST(dp_without_pract_extended_lba_test) || TEST(dp_without_flags_extended_lba_test) || TEST(dp_without_pract_separate_meta_test) || TEST(dp_without_pract_separate_meta_apptag_test) || TEST(dp_without_flags_separate_meta_test)) { #undef TEST rc = 1; printf("%s: failed End-to-End data protection tests\n", iter->name); } } printf("Cleaning up...\n"); for (i = 0; i < num_devs; i++) { struct dev *dev = &devs[i]; spdk_nvme_detach(dev->ctrlr); } return rc; }
/* Main function */ int main(int argc, char **argv) { int ret; int i; /* Create handler for SIGINT for CTRL + C closing and SIGALRM to print stats*/ signal(SIGINT, sig_handler); signal(SIGALRM, alarm_routine); /* Initialize DPDK enviroment with args, then shift argc and argv to get application parameters */ ret = rte_eal_init(argc, argv); if (ret < 0) FATAL_ERROR("Cannot init EAL\n"); argc -= ret; argv += ret; /* Check if this application can use 1 core*/ ret = rte_lcore_count (); if (ret != 2) FATAL_ERROR("This application needs exactly 2 cores."); /* Parse arguments */ parse_args(argc, argv); if (ret < 0) FATAL_ERROR("Wrong arguments\n"); /* Probe PCI bus for ethernet devices, mandatory only in DPDK < 1.8.0 */ #if RTE_VER_MAJOR == 1 && RTE_VER_MINOR < 8 ret = rte_eal_pci_probe(); if (ret < 0) FATAL_ERROR("Cannot probe PCI\n"); #endif /* Get number of ethernet devices */ nb_sys_ports = rte_eth_dev_count(); if (nb_sys_ports <= 0) FATAL_ERROR("Cannot find ETH devices\n"); /* Create a mempool with per-core cache, initializing every element for be used as mbuf, and allocating on the current NUMA node */ pktmbuf_pool = rte_mempool_create(MEMPOOL_NAME, buffer_size-1, MEMPOOL_ELEM_SZ, MEMPOOL_CACHE_SZ, sizeof(struct rte_pktmbuf_pool_private), rte_pktmbuf_pool_init, NULL, rte_pktmbuf_init, NULL,rte_socket_id(), 0); if (pktmbuf_pool == NULL) FATAL_ERROR("Cannot create cluster_mem_pool. Errno: %d [ENOMEM: %d, ENOSPC: %d, E_RTE_NO_TAILQ: %d, E_RTE_NO_CONFIG: %d, E_RTE_SECONDARY: %d, EINVAL: %d, EEXIST: %d]\n", rte_errno, ENOMEM, ENOSPC, E_RTE_NO_TAILQ, E_RTE_NO_CONFIG, E_RTE_SECONDARY, EINVAL, EEXIST ); /* Create a ring for exchanging packets between cores, and allocating on the current NUMA node */ intermediate_ring = rte_ring_create (RING_NAME, buffer_size, rte_socket_id(), RING_F_SP_ENQ | RING_F_SC_DEQ ); if (intermediate_ring == NULL ) FATAL_ERROR("Cannot create ring"); /* Operations needed for each ethernet device */ for(i=0; i < nb_sys_ports; i++) init_port(i); /* Start consumer and producer routine on 2 different cores: producer launched first... */ ret = rte_eal_mp_remote_launch (main_loop_producer, NULL, SKIP_MASTER); if (ret != 0) FATAL_ERROR("Cannot start consumer thread\n"); /* ... and then loop in consumer */ main_loop_consumer ( NULL ); return 0; }
/* * Application main function - loops through * receiving and processing packets. Never returns */ int main(int argc, char *argv[]) { int retval = 0; uint8_t port = 0; char *port_name; if ((retval = rte_eal_init(argc, argv)) < 0) { RTE_LOG(INFO, APP, "EAL init failed.\n"); return -1; } argc -= retval; argv += retval; if (parse_app_args(argc, argv) < 0) rte_exit(EXIT_FAILURE, "Invalid command-line arguments\n"); memset(kni_list, 0, sizeof(struct rte_kni) * MAX_KNI_PORTS); /* Open KNI or exit */ kni_fd = open("/dev/" KNI_DEVICE, O_RDWR); if (kni_fd < 0) { RTE_LOG(ERR, KNI, "Can not open /dev/%s\n", KNI_DEVICE); return -1; } /* Lookup for vports struct */ if (ovs_vport_lookup_vport_info() == NULL) return -1; /* Initialise the devices for each port*/ for (port = 0; port < ports_n; port++) { port_name = port_names[port]; RTE_LOG(INFO, KNI, "Attaching queues for port '%s'\n", port_name); if (create_kni_device(&kni_list[port], port_name, port) < 0) return -1; } RTE_LOG(INFO, KNI, "\nKNI client handling packets \n"); RTE_LOG(INFO, KNI, "[Press Ctrl-C to quit ...]\n"); for (;;) { for (port = 0; port < ports_n; port++) { /* Sleep to reduce processor load. As long as we respond * before rtnetlink times out we will still be able to ifup * and change mtu */ sleep(1); rte_kni_handle_request(&kni_list[port]); } } return 0; }
int initDpdk(char* progname) { int ret; static char *eal_args[] = {progname, "-c0xf", "-n1", "-m128", "--file-prefix=drone"}; // TODO: read env var DRONE_RTE_EAL_ARGS to override defaults ret = rte_eal_init(sizeof(eal_args)/sizeof(char*), eal_args); if (ret < 0) rte_panic("Cannot init EAL\n"); mbufPool_ = rte_mempool_create("DpktPktMbuf", 16*1024, // # of mbufs 2048, // sz of mbuf 32, // per-lcore cache sz sizeof(struct rte_pktmbuf_pool_private), rte_pktmbuf_pool_init, // pool ctor NULL, // pool ctor arg rte_pktmbuf_init, // mbuf ctor NULL, // mbuf ctor arg SOCKET_ID_ANY, 0 // flags ); if (!mbufPool_) rte_exit(EXIT_FAILURE, "cannot init mbuf pool\n"); if (rte_pmd_init_all() < 0) rte_exit(EXIT_FAILURE, "cannot init pmd\n"); if (rte_eal_pci_probe() < 0) rte_exit(EXIT_FAILURE, "cannot probe PCI\n"); // init lcore information lcoreCount_ = rte_lcore_count(); lcoreFreeMask_ = 0; for (int i = 0; i < lcoreCount_; i++) { if (rte_lcore_is_enabled(i) && (unsigned(i) != rte_get_master_lcore())) lcoreFreeMask_ |= (1 << i); } qDebug("lcore_count = %d, lcore_free_mask = 0x%llx", lcoreCount_, lcoreFreeMask_); // assign a lcore for Rx polling rxLcoreId_ = getFreeLcore(); if (rxLcoreId_ < 0) rte_exit(EXIT_FAILURE, "not enough cores for Rx polling"); stopRxPoll_ = false; return 0; }
int main(int argc, char *argv[]) { int eal_init_ret = rte_eal_init(argc, argv); if (eal_init_ret < 0) { rte_exit(EXIT_FAILURE, "Invalid EAL parameters\n"); } FLAGS_logtostderr = 1; google::InitGoogleLogging(argv[0]); ::testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); }
int main(int argc, char *argv[]) { setlocale(LC_NUMERIC, "en_US.utf-8"); int retval = 0; if ((retval = rte_eal_init(argc, argv)) < 0) return -1; argc -= retval; argv += retval; if(argc < 1) { RTE_LOG(INFO, APP, "usage: -- port\n"); return 0; } char rx_ring_name[RTE_RING_NAMESIZE]; char tx_ring_name[RTE_RING_NAMESIZE]; /* be aware that ring name is in ovs point of view */ sprintf(rx_ring_name, "%s_tx", argv[1]); sprintf(tx_ring_name, "%s_rx", argv[1]); init(tx_ring_name, rx_ring_name); printf("Free count in tx: %d\n", rte_ring_free_count(tx_ring)); signal(SIGALRM, ALARMhandler); alarm(PRINT_INTERVAL); RTE_LOG(INFO, APP, "Finished Process Init.\n"); #ifdef USE_BURST RTE_LOG(INFO, APP, "Burst Enabled.\n"); #else RTE_LOG(INFO, APP, "Burst Disabled.\n"); #endif #if ALLOC_METHOD == ALLOC_OVS RTE_LOG(INFO, APP, "Alloc method is OVS.\n"); #elif ALLOC_METHOD == ALLOC_APP RTE_LOG(INFO, APP, "Alloc method is APP.\n"); #endif send_loop(); RTE_LOG(INFO, APP, "Done\n"); return 0; }
int main(int argc, char **argv) { struct dev *iter; int rc, i; rc = rte_eal_init(sizeof(ealargs) / sizeof(ealargs[0]), (char **)(void *)(uintptr_t)ealargs); if (rc < 0) { fprintf(stderr, "could not initialize dpdk\n"); exit(1); } request_mempool = rte_mempool_create("nvme_request", 8192, spdk_nvme_request_size(), 128, 0, NULL, NULL, NULL, NULL, SOCKET_ID_ANY, 0); if (request_mempool == NULL) { fprintf(stderr, "could not initialize request mempool\n"); exit(1); } if (spdk_nvme_probe(NULL, probe_cb, attach_cb, NULL) != 0) { fprintf(stderr, "spdk_nvme_probe() failed\n"); return 1; } rc = 0; foreach_dev(iter) { struct spdk_nvme_qpair *qpair; qpair = spdk_nvme_ctrlr_alloc_io_qpair(iter->ctrlr, 0); if (!qpair) { fprintf(stderr, "spdk_nvme_ctrlr_alloc_io_qpair() failed\n"); rc = 1; } else { reserve_controller(iter->ctrlr, qpair, iter->pci_dev); } } printf("Cleaning up...\n"); for (i = 0; i < num_devs; i++) { struct dev *dev = &devs[i]; spdk_nvme_detach(dev->ctrlr); } return rc; }
lagopus_result_t lagopus_dataplane_init(int argc, const char *const argv[]) { int ret; size_t argsize; char **copy_argv; int i; argsize = sizeof(char *) * (argc + 1); copy_argv = malloc(argsize); if (copy_argv == NULL) { return LAGOPUS_RESULT_NO_MEMORY; } copy_argv[0] = argv[0]; for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "--")) { memcpy(©_argv[1], &argv[i + 1], sizeof(char *) * (argc - i - 1)); break; } } if (i == argc) { /* "--" is not found in argv */ memcpy(copy_argv, argv, argsize); rawsocket_only_mode = true; } else { argc -= i; optind = 1; /* init EAL */ ret = rte_eal_init(argc, copy_argv); if (ret < 0) { return LAGOPUS_RESULT_INVALID_ARGS; } optind = ret + 1; rawsocket_only_mode = false; } /* parse application arguments (after the EAL ones) */ ret = app_parse_args(argc, copy_argv); free(copy_argv); if (ret < 0) { return LAGOPUS_RESULT_INVALID_ARGS; } if (rawsocket_only_mode != true) { /* Init */ app_init(); app_print_params(); } return LAGOPUS_RESULT_OK; }
void main(int argc, char *argv[]) { /* init EAL, parsing EAL args */ int count = 0; count = rte_eal_init(argc, argv); assert(count >= 0); /* skip the `--` separating EAL params from test params */ count++; run_command(argc - count, argv + count, commands); exit(EXIT_SUCCESS); }
int main(int argc, char **argv) { // eal args int num_args = rte_eal_init(argc, argv); if (num_args < 0) rte_exit(EXIT_FAILURE, "init failed"); argc -= num_args; argv += num_args; // our args: [-s] port1 port2 uint8_t port1, port2; char opt = getopt(argc, argv, "s"); bool simple_tx = opt == 's'; if (simple_tx) { printf("Requesting simple tx path\n"); argc--; argv++; } else { printf("Requesting full-featured tx path\n"); } if (argc != 3) { printf("usage: [-s] port1 port2\n"); return -1; } port1 = atoi(argv[1]); port2 = atoi(argv[2]); printf("Using ports %d and %d\n", port1, port2); if (!config_port(port1, simple_tx)) return -1; if (!config_port(port2, simple_tx)) return -1; struct rte_mempool* pool = make_mempool(); uint64_t sent = 0; uint64_t next_print = rte_get_tsc_hz(); uint64_t last_sent = 0; while (true) { sent += send_pkts(port1, pool); sent += send_pkts(port2, pool); uint64_t time = rte_rdtsc(); if (time >= next_print) { double elapsed = (time - next_print + rte_get_tsc_hz()) / rte_get_tsc_hz(); uint64_t pkts = sent - last_sent; printf("Packet rate: %.2f Mpps\n", (double) pkts / elapsed / 1000000); next_print = time + rte_get_tsc_hz(); last_sent = sent; } } return 0; }
int MAIN(int argc, char **argv) { int ret; ret = rte_eal_init(argc, argv); if (ret < 0) rte_panic("Cannot init EAL\n"); //test_share_hashmap<int>(); test_share_hashmap< int, int >(); return 0; }
/** * Main init function for the multi-process server app, * calls subfunctions to do each stage of the initialisation. */ int init(int argc, char *argv[]) { int retval; uint8_t i, total_ports; /* init EAL, parsing EAL args */ retval = rte_eal_init(argc, argv); if (retval < 0) return -1; argc -= retval; argv += retval; /* get total number of ports */ total_ports = 0; /* parse additional, application arguments */ retval = parse_app_args(total_ports, argc, argv); if (retval != 0) return -1; /* initialise mbuf pools */ retval = init_mbuf_pools(); if (retval != 0) rte_exit(EXIT_FAILURE, "Cannot create needed mbuf pools\n"); init_shm_rings(); if (rte_eal_process_type() == RTE_PROC_PRIMARY) { /* create metadata, output cmdline */ if (rte_ivshmem_metadata_create(IVSHMEN_METADATA_NAME) < 0) rte_exit(EXIT_FAILURE, "Cannot create IVSHMEM metadata\n"); if (rte_ivshmem_metadata_add_mempool(pktmbuf_pool, IVSHMEN_METADATA_NAME)) rte_exit(EXIT_FAILURE, "Cannot add mbuf mempool to IVSHMEM metadata\n"); for (i = 0; i < num_rings; i++) { if (rte_ivshmem_metadata_add_ring(clients[i].rx_q, IVSHMEN_METADATA_NAME) < 0) rte_exit(EXIT_FAILURE, "Cannot add ring client %d to IVSHMEM metadata\n", i); } generate_ivshmem_cmdline(IVSHMEN_METADATA_NAME); } return 0; }
static int u2_init(void) { if (rte_eal_init(sizeof(ealargs) / sizeof(ealargs[0]),ealargs) < 0) { fprintf(stderr, "failed to initialize DPDK EAL!\n"); return 1; } printf("\n========================================\n"); printf( " nvme_lat/u2_lat - ict.ncic.syssw.ufo" ); printf("\n========================================\n"); request_mempool = rte_mempool_create("nvme_request", U2_REQUEST_POOL_SIZE, spdk_nvme_request_size(), U2_REQUEST_CACHE_SIZE, U2_REQUEST_PRIVATE_SIZE, NULL, NULL, NULL, NULL, SOCKET_ID_ANY, 0); if (request_mempool == NULL) { fprintf(stderr, "failed to create request pool!\n"); return 1; } if (spdk_nvme_probe(NULL, probe_cb, attach_cb)) { fprintf(stderr, "failed to probe and attach to NVMe device!\n"); return 1; } if (!u2_ctrlr) { fprintf(stderr, "failed to probe a suitable controller!\n"); return 1; } if (!spdk_nvme_ns_is_active(u2_ns)) { fprintf(stderr, "namespace %d is IN-ACTIVE!\n", u2_ns_id); return 1; } if (u2_ns_size < io_size) { fprintf(stderr, "invalid I/O size %"PRIu32"!\n", io_size); return 1; } if (!u2_qpair) { fprintf(stderr, "failed to allocate queue pair!\n"); return 1; } return 0; }
/* * The main function, which does initialization and calls the per-lcore * functions. */ int main(int argc, char *argv[]) { struct rte_mempool *mbuf_pool; unsigned nb_ports; uint8_t portid; /* Initialize the Environment Abstraction Layer (EAL). */ int ret = rte_eal_init(argc, argv); if (ret < 0) rte_exit(EXIT_FAILURE, "Error with EAL initialization\n"); argc -= ret; argv += ret; /* Check that there is an even number of ports to send/receive on. */ nb_ports = rte_eth_dev_count(); if (nb_ports < 2 || (nb_ports & 1)) rte_exit(EXIT_FAILURE, "Error: number of ports must be even\n"); /* Creates a new mempool in memory to hold the mbufs. */ mbuf_pool = rte_mempool_create("MBUF_POOL", NUM_MBUFS * nb_ports, MBUF_SIZE, MBUF_CACHE_SIZE, sizeof(struct rte_pktmbuf_pool_private), rte_pktmbuf_pool_init, NULL, rte_pktmbuf_init, NULL, rte_socket_id(), 0); if (mbuf_pool == NULL) rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n"); /* Initialize all ports. */ for (portid = 0; portid < nb_ports; portid++) if (port_init(portid, mbuf_pool) != 0) rte_exit(EXIT_FAILURE, "Cannot init port %"PRIu8 "\n", portid); if (rte_lcore_count() > 1) printf("\nWARNING: Too many lcores enabled. Only 1 used.\n"); /* Call lcore_main on the master core only. */ lcore_main(); return 0; }
int main(int argc, char* argv[]) { int ret; struct rte_mempool *mbuf_pool; /* Initialize the Environment Abstraction Layer (EAL). */ ret = rte_eal_init(argc, argv); if (ret < 0) rte_exit(EXIT_FAILURE, "Error with EAL initialization\n"); /* Creates a new mempool in memory to hold the msend_bufs. */ mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL", NUM_MBUFS, MBUF_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id()); if (mbuf_pool == NULL) rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n"); // Create Signal Action for interrupts struct sigaction newSigAction; memset((void *)&newSigAction, 0, sizeof(struct sigaction)); newSigAction.sa_handler = &signal_handler; newSigAction.sa_flags = SA_NODEFER; // Attach signal handlers if (sigaction(SIGINT, &newSigAction, NULL) < 0) { fprintf(stderr, "Error attaching signal handler.\n"); exit(0); } if (sigaction(SIGALRM, &newSigAction, NULL) < 0) { fprintf(stderr, "Error attaching signal handler.\n"); exit(0); } if (sigaction(SIGRTMIN, &newSigAction, NULL) < 0) { fprintf(stderr, "Error attaching signal handler.\n"); exit(0); } sleep(1); setup_sender(mbuf_pool); rte_eal_mp_wait_lcore(); return 0; }
int main(int argc, char **argv) { #ifdef RTE_LIBRTE_CMDLINE struct cmdline *cl; #endif int ret; ret = rte_eal_init(argc, argv); if (ret < 0) return -1; #ifdef RTE_LIBRTE_TIMER rte_timer_subsystem_init(); #endif if (commands_init() < 0) return -1; argv += ret; prgname = argv[0]; #ifndef RTE_EXEC_ENV_BAREMETAL if ((recursive_call = getenv(RECURSIVE_ENV_VAR)) != NULL) return do_recursive_call(); #endif #ifdef RTE_LIBEAL_USE_HPET if (rte_eal_hpet_init(1) < 0) #endif RTE_LOG(INFO, APP, "HPET is not enabled, using TSC as default timer\n"); #ifdef RTE_LIBRTE_CMDLINE cl = cmdline_stdin_new(main_ctx, "RTE>>"); if (cl == NULL) { return -1; } cmdline_interact(cl); cmdline_stdin_exit(cl); #endif return 0; }
int main(int argc, char **argv) { int ret; struct cmdline *cl; ret = rte_eal_init(argc, argv); if (ret < 0) rte_panic("Cannot init EAL\n"); cl = cmdline_stdin_new(main_ctx, "example> "); if (cl == NULL) rte_panic("Cannot create cmdline instance\n"); cmdline_interact(cl); cmdline_stdin_exit(cl); return 0; }
/* Main function, does initialisation and calls the per-lcore functions */ int main(int argc, char *argv[]) { struct rte_mempool *mbuf_pool; uint8_t portid = 0; /* init EAL */ int ret = rte_eal_init(argc, argv); if (ret < 0) rte_exit(EXIT_FAILURE, "Error with EAL initialization\n"); argc -= ret; argv += ret; mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL", NUM_MBUFS, MBUF_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id()); if (mbuf_pool == NULL) rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n"); /* initialize all ports */ if (port_init(portid, mbuf_pool) != 0) rte_exit(EXIT_FAILURE, "Cannot init port %"PRIu8"\n", portid); stats_mapping_setup(portid); fdir_filter_add(portid, FDIR_DROP_ADDR, RTE_ETH_FDIR_REJECT, 0); fdir_filter_add(portid, FDIR_ACCEPT_ADDR, RTE_ETH_FDIR_ACCEPT, 1); ntuple_filter_add(portid, NTUPLE_DROP_ADDR, PKT_DROP_QUEUE); ntuple_filter_add(portid, NTUPLE_ACCEPT_ADDR, PKT_ACCEPT_QUEUE); fdir_get_infos(portid); if (rte_lcore_count() > 1) printf("\nWARNING: Too much enabled lcores - " "App uses only 1 lcore\n"); lcore_stats(); /* call lcore_main on master core only */ //lcore_main(); return 0; }