d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

test/stack: remove unneeded memory allocations

Browse Source 
Replace the arguments array by one argument.
All objects in the args array have the same values, so there is no need
to use an array, only one struct is enough.
The args object is a lot smaller, and the allocation can be replaced
with a global variable.
As a consequence of using a single argument, there is no need to use a
loop to launch the test on every core one by one. Replace it with
rte_eal_mp_remote_launch.

The allocation of obj_table isn't needed either, because MAX_BULK is
small. The allocation can instead be replaced with a static array.

Signed-off-by: Steven Lariau <steven.lariau@arm.com>
Reviewed-by: Dharmik Thakkar <dharmik.thakkar@arm.com>
Reviewed-by: Phil Yang <phil.yang@arm.com>
Reviewed-by: Ruifeng Wang <ruifeng.wang@arm.com>
Acked-by: Gage Eads <gage.eads@intel.com>
This commit is contained in:
Steven Lariau 2020-08-12 20:18:44 +01:00 committed by David Marchand
parent dc3cdcd69d
commit e67925af17
1 changed files with 15 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
app/test/test_stack.c
View File

@ -276,19 +276,13 @@ struct test_args {
rte_atomic64_t *sz; rte_atomic64_t *sz;
}; };
static int static struct test_args thread_test_args;
stack_thread_push_pop(void *args)
{
struct test_args *t = args;
void **obj_table;
int i;
obj_table = rte_calloc(NULL, STACK_SIZE, sizeof(void *), 0); static int
if (obj_table == NULL) { stack_thread_push_pop(__rte_unused void *args)
printf("[%s():%u] failed to calloc %zu bytes\n", {
__func__, __LINE__, STACK_SIZE * sizeof(void *)); void *obj_table[MAX_BULK];
return -1; int i;
}
for (i = 0; i < NUM_ITERS_PER_THREAD; i++) { for (i = 0; i < NUM_ITERS_PER_THREAD; i++) {
unsigned int success, num; unsigned int success, num;
@ -297,42 +291,37 @@ stack_thread_push_pop(void *args)
* then push and pop those stack entries. * then push and pop those stack entries.
*/ */
do { do {
uint64_t sz = rte_atomic64_read(t->sz); uint64_t sz = rte_atomic64_read(thread_test_args.sz);
volatile uint64_t *sz_addr; volatile uint64_t *sz_addr;
sz_addr = (volatile uint64_t *)t->sz; sz_addr = (volatile uint64_t *)thread_test_args.sz;
num = RTE_MIN(rte_rand() % MAX_BULK, STACK_SIZE - sz); num = RTE_MIN(rte_rand() % MAX_BULK, STACK_SIZE - sz);
success = rte_atomic64_cmpset(sz_addr, sz, sz + num); success = rte_atomic64_cmpset(sz_addr, sz, sz + num);
} while (success == 0); } while (success == 0);
if (rte_stack_push(t->s, obj_table, num) != num) { if (rte_stack_push(thread_test_args.s, obj_table, num) != num) {
printf("[%s():%u] Failed to push %u pointers\n", printf("[%s():%u] Failed to push %u pointers\n",
__func__, __LINE__, num); __func__, __LINE__, num);
rte_free(obj_table);
return -1; return -1;
} }
if (rte_stack_pop(t->s, obj_table, num) != num) { if (rte_stack_pop(thread_test_args.s, obj_table, num) != num) {
printf("[%s():%u] Failed to pop %u pointers\n", printf("[%s():%u] Failed to pop %u pointers\n",
__func__, __LINE__, num); __func__, __LINE__, num);
rte_free(obj_table);
return -1; return -1;
} }
rte_atomic64_sub(t->sz, num); rte_atomic64_sub(thread_test_args.sz, num);
} }
rte_free(obj_table);
return 0; return 0;
} }
static int static int
test_stack_multithreaded(uint32_t flags) test_stack_multithreaded(uint32_t flags)
{ {
struct test_args *args;
unsigned int lcore_id;
struct rte_stack *s; struct rte_stack *s;
rte_atomic64_t size; rte_atomic64_t size;
@ -344,45 +333,22 @@ test_stack_multithreaded(uint32_t flags)
printf("[%s():%u] Running with %u lcores\n", printf("[%s():%u] Running with %u lcores\n",
__func__, __LINE__, rte_lcore_count()); __func__, __LINE__, rte_lcore_count());
args = rte_malloc(NULL, sizeof(struct test_args) * RTE_MAX_LCORE, 0);
if (args == NULL) {
printf("[%s():%u] failed to malloc %zu bytes\n",
__func__, __LINE__,
sizeof(struct test_args) * RTE_MAX_LCORE);
return -1;
}
s = rte_stack_create("test", STACK_SIZE, rte_socket_id(), flags); s = rte_stack_create("test", STACK_SIZE, rte_socket_id(), flags);
if (s == NULL) { if (s == NULL) {
printf("[%s():%u] Failed to create a stack\n", printf("[%s():%u] Failed to create a stack\n",
__func__, __LINE__); __func__, __LINE__);
rte_free(args);
return -1; return -1;
} }
rte_atomic64_init(&size); rte_atomic64_init(&size);
thread_test_args.s = s;
thread_test_args.sz = &size;
RTE_LCORE_FOREACH_SLAVE(lcore_id) { if (rte_eal_mp_remote_launch(stack_thread_push_pop, NULL, CALL_MASTER))
args[lcore_id].s = s; rte_panic("Failed to launch tests\n");
args[lcore_id].sz = &size;
if (rte_eal_remote_launch(stack_thread_push_pop,
&args[lcore_id], lcore_id))
rte_panic("Failed to launch lcore %d\n", lcore_id);
}
lcore_id = rte_lcore_id();
args[lcore_id].s = s;
args[lcore_id].sz = &size;
stack_thread_push_pop(&args[lcore_id]);
rte_eal_mp_wait_lcore(); rte_eal_mp_wait_lcore();
rte_stack_free(s); rte_stack_free(s);
rte_free(args);
return 0; return 0;
} }