/* this is really a sanity check */
static int
test_macros(int __rte_unused unused_parm)
{
#define SMALLER 0x1000U
#define BIGGER 0x2000U
#define PTR_DIFF BIGGER - SMALLER
#define FAIL_MACRO(x)\
{printf(#x "() test failed!\n");\
return -1;}
uintptr_t unused = 0;
RTE_SET_USED(unused);
if ((uintptr_t)RTE_PTR_ADD(SMALLER, PTR_DIFF) != BIGGER)
FAIL_MACRO(RTE_PTR_ADD);
if ((uintptr_t)RTE_PTR_SUB(BIGGER, PTR_DIFF) != SMALLER)
FAIL_MACRO(RTE_PTR_SUB);
if (RTE_PTR_DIFF(BIGGER, SMALLER) != PTR_DIFF)
FAIL_MACRO(RTE_PTR_DIFF);
if (RTE_MAX(SMALLER, BIGGER) != BIGGER)
FAIL_MACRO(RTE_MAX);
if (RTE_MIN(SMALLER, BIGGER) != SMALLER)
FAIL_MACRO(RTE_MIN);
if (strncmp(RTE_STR(test), "test", sizeof("test")))
FAIL_MACRO(RTE_STR);
return 0;
}
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;
}
