/*
|
* Copyright (C) 2018 Philippe Gerum <rpm@xenomai.org>
|
*
|
* SPDX-License-Identifier: MIT
|
*/
|
#include <xenomai/init.h>
|
#include <xenomai/tunables.h>
|
#include <copperplate/heapobj.h>
|
#include "memcheck/memcheck.h"
|
|
smokey_test_plugin(memory_pshared,
|
MEMCHECK_ARGS,
|
"Check for the pshared allocator sanity.\n"
|
MEMCHECK_HELP_STRINGS
|
);
|
|
#define MIN_HEAP_SIZE 8192
|
#define MAX_HEAP_SIZE (1024 * 1024 * 2)
|
#define RANDOM_ROUNDS 1024
|
|
#define PATTERN_HEAP_SIZE (128*1024)
|
#define PATTERN_ROUNDS 128
|
|
static struct heapobj heap;
|
|
static int do_pshared_init(void *heap, void *mem, size_t arena_size)
|
{
|
/* mem is ignored, pshared uses its own memory. */
|
return heapobj_init(heap, "memcheck", arena_size);
|
}
|
|
static void do_pshared_destroy(void *heap)
|
{
|
heapobj_destroy(heap);
|
}
|
|
static void *do_pshared_alloc(void *heap, size_t size)
|
{
|
return heapobj_alloc(heap, size);
|
}
|
|
static int do_pshared_free(void *heap, void *block)
|
{
|
heapobj_free(heap, block);
|
|
return 0; /* Hope for the best. */
|
}
|
|
static size_t do_pshared_used_size(void *heap)
|
{
|
return heapobj_inquire(heap);
|
}
|
|
static size_t do_pshared_usable_size(void *heap)
|
{
|
return heapobj_get_size(heap);
|
}
|
|
static size_t do_pshared_arena_size(size_t heap_size)
|
{
|
struct heapobj h;
|
size_t overhead;
|
int ret;
|
|
ret = heapobj_init(&h, "memcheck", heap_size);
|
if (ret)
|
return 0;
|
|
overhead = heap_size - heapobj_get_size(&h);
|
heapobj_destroy(&h);
|
|
/*
|
* pshared must have no external overhead, since
|
* heapobj_init() allocates the memory it needs. Make sure
|
* this assumption is correct for any tested size.
|
*/
|
return overhead == 0 ? heap_size : 0;
|
}
|
|
static struct memcheck_descriptor pshared_descriptor = {
|
.name = "pshared",
|
.init = HEAP_INIT_T(do_pshared_init),
|
.destroy = HEAP_DESTROY_T(do_pshared_destroy),
|
.alloc = HEAP_ALLOC_T(do_pshared_alloc),
|
.free = HEAP_FREE_T(do_pshared_free),
|
.get_usable_size = HEAP_USABLE_T(do_pshared_usable_size),
|
.get_used_size = HEAP_USED_T(do_pshared_used_size),
|
.get_arena_size = do_pshared_arena_size,
|
.seq_min_heap_size = MIN_HEAP_SIZE,
|
.seq_max_heap_size = MAX_HEAP_SIZE,
|
.random_rounds = RANDOM_ROUNDS,
|
.pattern_heap_size = PATTERN_HEAP_SIZE,
|
.pattern_rounds = PATTERN_ROUNDS,
|
/* heapobj-pshared has overgead even for ^2 sizes, can't check for ZEROOVRD. */
|
.valid_flags = MEMCHECK_ALL_FLAGS & ~MEMCHECK_ZEROOVRD,
|
.heap = &heap,
|
};
|
|
static int run_memory_pshared(struct smokey_test *t,
|
int argc, char *const argv[])
|
{
|
return memcheck_run(&pshared_descriptor, t, argc, argv);
|
}
|
|
static int memcheck_pshared_tune(void)
|
{
|
/*
|
* We create test pools from the main one: make sure the
|
* latter is large enough.
|
*/
|
set_config_tunable(mem_pool_size, MAX_HEAP_SIZE + 1024 * 1024);
|
|
return 0;
|
}
|
|
static struct setup_descriptor memcheck_pshared_setup = {
|
.name = "memcheck_pshared",
|
.tune = memcheck_pshared_tune,
|
};
|
|
user_setup_call(memcheck_pshared_setup);
|
