static void meminfo_display(void) { printf("----------- MEMORY_SEGMENTS -----------\n"); rte_dump_physmem_layout(stdout); printf("--------- END_MEMORY_SEGMENTS ---------\n"); printf("------------ MEMORY_ZONES -------------\n"); rte_memzone_dump(stdout); printf("---------- END_MEMORY_ZONES -----------\n"); printf("------------- TAIL_QUEUES -------------\n"); rte_dump_tailq(stdout); printf("---------- END_TAIL_QUEUES ------------\n"); }
static void spdk_nvmf_startup(spdk_event_t event) { int rc; /* start the rdma poller that will listen on all available ports */ rc = nvmf_acceptor_start(); if (rc < 0) { SPDK_ERRLOG("nvmf_acceptor_start() failed\n"); goto initialize_error; } if (getenv("MEMZONE_DUMP") != NULL) { rte_memzone_dump(stdout); fflush(stdout); } return; initialize_error: spdk_app_stop(rc); }
int main(int argc, char **argv) { int ret; int i; char c_flag[] = "-c1"; char n_flag[] = "-n4"; char mp_flag[] = "--proc-type=secondary"; char *argp[argc + 3]; argp[0] = argv[0]; argp[1] = c_flag; argp[2] = n_flag; argp[3] = mp_flag; for(i = 1; i < argc; i++) { argp[i + 3] = argv[i]; } argc += 3; ret = rte_eal_init(argc, argp); if (ret < 0) rte_panic("Cannot init EAL\n"); printf("----------- MEMORY_SEGMENTS -----------\n"); rte_dump_physmem_layout(stdout); printf("--------- END_MEMORY_SEGMENTS ---------\n"); printf("------------ MEMORY_ZONES -------------\n"); rte_memzone_dump(stdout); printf("---------- END_MEMORY_ZONES -----------\n"); printf("------------- TAIL_QUEUES -------------\n"); rte_dump_tailq(stdout); printf("---------- END_TAIL_QUEUES ------------\n"); return 0; }
static void dpdk_init__(const struct smap *ovs_other_config) { char **argv = NULL, **argv_to_release = NULL; int result; int argc, argc_tmp; bool auto_determine = true; int err = 0; cpu_set_t cpuset; char *sock_dir_subcomponent; if (process_vhost_flags("vhost-sock-dir", xstrdup(ovs_rundir()), NAME_MAX, ovs_other_config, &sock_dir_subcomponent)) { struct stat s; if (!strstr(sock_dir_subcomponent, "..")) { vhost_sock_dir = xasprintf("%s/%s", ovs_rundir(), sock_dir_subcomponent); err = stat(vhost_sock_dir, &s); if (err) { VLOG_ERR("vhost-user sock directory '%s' does not exist.", vhost_sock_dir); } } else { vhost_sock_dir = xstrdup(ovs_rundir()); VLOG_ERR("vhost-user sock directory request '%s/%s' has invalid" "characters '..' - using %s instead.", ovs_rundir(), sock_dir_subcomponent, ovs_rundir()); } free(sock_dir_subcomponent); } else { vhost_sock_dir = sock_dir_subcomponent; } argv = grow_argv(&argv, 0, 1); argc = 1; argv[0] = xstrdup(ovs_get_program_name()); argc_tmp = get_dpdk_args(ovs_other_config, &argv, argc); while (argc_tmp != argc) { if (!strcmp("-c", argv[argc]) || !strcmp("-l", argv[argc])) { auto_determine = false; break; } argc++; } argc = argc_tmp; /** * NOTE: This is an unsophisticated mechanism for determining the DPDK * lcore for the DPDK Master. */ if (auto_determine) { int i; /* Get the main thread affinity */ CPU_ZERO(&cpuset); err = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset); if (!err) { for (i = 0; i < CPU_SETSIZE; i++) { if (CPU_ISSET(i, &cpuset)) { argv = grow_argv(&argv, argc, 2); argv[argc++] = xstrdup("-c"); argv[argc++] = xasprintf("0x%08llX", (1ULL<<i)); i = CPU_SETSIZE; } } } else { VLOG_ERR("Thread getaffinity error %d. Using core 0x1", err); /* User did not set dpdk-lcore-mask and unable to get current * thread affintity - default to core 0x1 */ argv = grow_argv(&argv, argc, 2); argv[argc++] = xstrdup("-c"); argv[argc++] = xasprintf("0x%X", 1); } } argv = grow_argv(&argv, argc, 1); argv[argc] = NULL; optind = 1; if (VLOG_IS_INFO_ENABLED()) { struct ds eal_args; int opt; ds_init(&eal_args); ds_put_cstr(&eal_args, "EAL ARGS:"); for (opt = 0; opt < argc; ++opt) { ds_put_cstr(&eal_args, " "); ds_put_cstr(&eal_args, argv[opt]); } VLOG_INFO("%s", ds_cstr_ro(&eal_args)); ds_destroy(&eal_args); } argv_to_release = grow_argv(&argv_to_release, 0, argc); for (argc_tmp = 0; argc_tmp < argc; ++argc_tmp) { argv_to_release[argc_tmp] = argv[argc_tmp]; } /* Make sure things are initialized ... */ result = rte_eal_init(argc, argv); if (result < 0) { ovs_abort(result, "Cannot init EAL"); } argv_release(argv, argv_to_release, argc); /* Set the main thread affinity back to pre rte_eal_init() value */ if (auto_determine && !err) { err = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset); if (err) { VLOG_ERR("Thread setaffinity error %d", err); } } rte_memzone_dump(stdout); /* We are called from the main thread here */ RTE_PER_LCORE(_lcore_id) = NON_PMD_CORE_ID; #ifdef DPDK_PDUMP VLOG_INFO("DPDK pdump packet capture enabled"); err = rte_pdump_init(ovs_rundir()); if (err) { VLOG_INFO("Error initialising DPDK pdump"); rte_pdump_uninit(); } else { char *server_socket_path; server_socket_path = xasprintf("%s/%s", ovs_rundir(), "pdump_server_socket"); fatal_signal_add_file_to_unlink(server_socket_path); free(server_socket_path); } #endif /* Finally, register the dpdk classes */ netdev_dpdk_register(); }
void spdk_memzone_dump(FILE *f) { rte_memzone_dump(f); }
static int test_memzone_reserve_max_aligned(void) { const struct rte_memzone *mz; const struct rte_config *config; const struct rte_memseg *ms; int memseg_idx = 0; int memzone_idx = 0; uintptr_t addr_offset; size_t len = 0; void* last_addr; size_t maxlen = 0; /* random alignment */ rte_srand((unsigned)rte_rdtsc()); const unsigned align = 1 << ((rte_rand() % 8) + 5); /* from 128 up to 4k alignment */ /* get pointer to global configuration */ config = rte_eal_get_configuration(); ms = rte_eal_get_physmem_layout(); addr_offset = 0; for (memseg_idx = 0; memseg_idx < RTE_MAX_MEMSEG; memseg_idx++){ /* ignore smaller memsegs as they can only get smaller */ if (ms[memseg_idx].len < maxlen) continue; /* align everything */ last_addr = RTE_PTR_ALIGN_CEIL(ms[memseg_idx].addr, RTE_CACHE_LINE_SIZE); len = ms[memseg_idx].len - RTE_PTR_DIFF(last_addr, ms[memseg_idx].addr); len &= ~((size_t) RTE_CACHE_LINE_MASK); /* cycle through all memzones */ for (memzone_idx = 0; memzone_idx < RTE_MAX_MEMZONE; memzone_idx++) { /* stop when reaching last allocated memzone */ if (config->mem_config->memzone[memzone_idx].addr == NULL) break; /* check if the memzone is in our memseg and subtract length */ if ((config->mem_config->memzone[memzone_idx].addr >= ms[memseg_idx].addr) && (config->mem_config->memzone[memzone_idx].addr < (RTE_PTR_ADD(ms[memseg_idx].addr, ms[memseg_idx].len)))) { /* since the zones can now be aligned and occasionally skip * some space, we should calculate the length based on * reported length and start addresses difference. */ len -= (uintptr_t) RTE_PTR_SUB( config->mem_config->memzone[memzone_idx].addr, (uintptr_t) last_addr); len -= config->mem_config->memzone[memzone_idx].len; last_addr = RTE_PTR_ADD(config->mem_config->memzone[memzone_idx].addr, (size_t) config->mem_config->memzone[memzone_idx].len); } } /* make sure we get the alignment offset */ if (len > maxlen) { addr_offset = RTE_PTR_ALIGN_CEIL((uintptr_t) last_addr, align) - (uintptr_t) last_addr; maxlen = len; } } if (maxlen == 0 || maxlen == addr_offset) { printf("There is no space left for biggest %u-aligned memzone!\n", align); return 0; } maxlen -= addr_offset; mz = rte_memzone_reserve_aligned("max_zone_aligned", 0, SOCKET_ID_ANY, 0, align); if (mz == NULL){ printf("Failed to reserve a big chunk of memory\n"); rte_dump_physmem_layout(stdout); rte_memzone_dump(stdout); return -1; } if (mz->len != maxlen) { printf("Memzone reserve with 0 size and alignment %u did not return" " bigest block\n", align); printf("Expected size = %zu, actual size = %zu\n", maxlen, mz->len); rte_dump_physmem_layout(stdout); rte_memzone_dump(stdout); return -1; } return 0; }
static int test_memzone_reserve_max(void) { const struct rte_memzone *mz; const struct rte_config *config; const struct rte_memseg *ms; int memseg_idx = 0; int memzone_idx = 0; size_t len = 0; void* last_addr; size_t maxlen = 0; /* get pointer to global configuration */ config = rte_eal_get_configuration(); ms = rte_eal_get_physmem_layout(); for (memseg_idx = 0; memseg_idx < RTE_MAX_MEMSEG; memseg_idx++){ /* ignore smaller memsegs as they can only get smaller */ if (ms[memseg_idx].len < maxlen) continue; /* align everything */ last_addr = RTE_PTR_ALIGN_CEIL(ms[memseg_idx].addr, RTE_CACHE_LINE_SIZE); len = ms[memseg_idx].len - RTE_PTR_DIFF(last_addr, ms[memseg_idx].addr); len &= ~((size_t) RTE_CACHE_LINE_MASK); /* cycle through all memzones */ for (memzone_idx = 0; memzone_idx < RTE_MAX_MEMZONE; memzone_idx++) { /* stop when reaching last allocated memzone */ if (config->mem_config->memzone[memzone_idx].addr == NULL) break; /* check if the memzone is in our memseg and subtract length */ if ((config->mem_config->memzone[memzone_idx].addr >= ms[memseg_idx].addr) && (config->mem_config->memzone[memzone_idx].addr < (RTE_PTR_ADD(ms[memseg_idx].addr, ms[memseg_idx].len)))) { /* since the zones can now be aligned and occasionally skip * some space, we should calculate the length based on * reported length and start addresses difference. Addresses * are allocated sequentially so we don't need to worry about * them being in the right order. */ len -= RTE_PTR_DIFF( config->mem_config->memzone[memzone_idx].addr, last_addr); len -= config->mem_config->memzone[memzone_idx].len; last_addr = RTE_PTR_ADD(config->mem_config->memzone[memzone_idx].addr, (size_t) config->mem_config->memzone[memzone_idx].len); } } /* we don't need to calculate offset here since length * is always cache-aligned */ if (len > maxlen) maxlen = len; } if (maxlen == 0) { printf("There is no space left!\n"); return 0; } mz = rte_memzone_reserve("max_zone", 0, SOCKET_ID_ANY, 0); if (mz == NULL){ printf("Failed to reserve a big chunk of memory\n"); rte_dump_physmem_layout(stdout); rte_memzone_dump(stdout); return -1; } if (mz->len != maxlen) { printf("Memzone reserve with 0 size did not return bigest block\n"); printf("Expected size = %zu, actual size = %zu\n", maxlen, mz->len); rte_dump_physmem_layout(stdout); rte_memzone_dump(stdout); return -1; } return 0; }
static int test_memzone(void) { const struct rte_memzone *memzone1; const struct rte_memzone *memzone2; const struct rte_memzone *memzone3; const struct rte_memzone *memzone4; const struct rte_memzone *mz; memzone1 = rte_memzone_reserve("testzone1", 100, SOCKET_ID_ANY, 0); memzone2 = rte_memzone_reserve("testzone2", 1000, 0, 0); memzone3 = rte_memzone_reserve("testzone3", 1000, 1, 0); memzone4 = rte_memzone_reserve("testzone4", 1024, SOCKET_ID_ANY, 0); /* memzone3 may be NULL if we don't have NUMA */ if (memzone1 == NULL || memzone2 == NULL || memzone4 == NULL) return -1; rte_memzone_dump(stdout); /* check cache-line alignments */ printf("check alignments and lengths\n"); if ((memzone1->phys_addr & RTE_CACHE_LINE_MASK) != 0) return -1; if ((memzone2->phys_addr & RTE_CACHE_LINE_MASK) != 0) return -1; if (memzone3 != NULL && (memzone3->phys_addr & RTE_CACHE_LINE_MASK) != 0) return -1; if ((memzone1->len & RTE_CACHE_LINE_MASK) != 0 || memzone1->len == 0) return -1; if ((memzone2->len & RTE_CACHE_LINE_MASK) != 0 || memzone2->len == 0) return -1; if (memzone3 != NULL && ((memzone3->len & RTE_CACHE_LINE_MASK) != 0 || memzone3->len == 0)) return -1; if (memzone4->len != 1024) return -1; /* check that zones don't overlap */ printf("check overlapping\n"); if (is_memory_overlap(memzone1->phys_addr, memzone1->len, memzone2->phys_addr, memzone2->len)) return -1; if (memzone3 != NULL && is_memory_overlap(memzone1->phys_addr, memzone1->len, memzone3->phys_addr, memzone3->len)) return -1; if (memzone3 != NULL && is_memory_overlap(memzone2->phys_addr, memzone2->len, memzone3->phys_addr, memzone3->len)) return -1; printf("check socket ID\n"); /* memzone2 must be on socket id 0 and memzone3 on socket 1 */ if (memzone2->socket_id != 0) return -1; if (memzone3 != NULL && memzone3->socket_id != 1) return -1; printf("test zone lookup\n"); mz = rte_memzone_lookup("testzone1"); if (mz != memzone1) return -1; printf("test duplcate zone name\n"); mz = rte_memzone_reserve("testzone1", 100, SOCKET_ID_ANY, 0); if (mz != NULL) return -1; printf("test reserving memzone with bigger size than the maximum\n"); if (test_memzone_reserving_zone_size_bigger_than_the_maximum() < 0) return -1; printf("test reserving memory in smallest segments\n"); if (test_memzone_reserve_memory_in_smallest_segment() < 0) return -1; printf("test reserving memory in segments with smallest offsets\n"); if (test_memzone_reserve_memory_with_smallest_offset() < 0) return -1; printf("test memzone_reserve flags\n"); if (test_memzone_reserve_flags() < 0) return -1; printf("test alignment for memzone_reserve\n"); if (test_memzone_aligned() < 0) return -1; printf("test boundary alignment for memzone_reserve\n"); if (test_memzone_bounded() < 0) return -1; printf("test invalid alignment for memzone_reserve\n"); if (test_memzone_invalid_alignment() < 0) return -1; printf("test reserving amounts of memory equal to segment's length\n"); if (test_memzone_reserve_remainder() < 0) return -1; printf("test reserving the largest size memzone possible\n"); if (test_memzone_reserve_max() < 0) return -1; printf("test reserving the largest size aligned memzone possible\n"); if (test_memzone_reserve_max_aligned() < 0) return -1; return 0; }