/*
 * Copyright (C) 2018 Philippe Gerum <rpm@xenomai.org>
 *
 * SPDX-License-Identifier: MIT
 */
#include <tlsf/tlsf.h>
#include <stdlib.h>
#include <pthread.h>
#include "memcheck/memcheck.h"

smokey_test_plugin(memory_tlsf,
		   MEMCHECK_ARGS,
		   "Check for the TLSF 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 memcheck_descriptor tlsf_descriptor;

static pthread_mutex_t tlsf_lock = PTHREAD_MUTEX_INITIALIZER;

static size_t overhead;

static size_t test_pool_size; /* TLSF does not save this information. */

static int do_tlsf_init(void *dummy, void *mem, size_t pool_size)
{
	tlsf_descriptor.heap = mem;
	return init_memory_pool(pool_size, mem) == -1L ? -ENOMEM : 0;
}

static void do_tlsf_destroy(void *pool)
{
	destroy_memory_pool(pool);
}

static void *do_tlsf_alloc(void *pool, size_t size)
{
	void *p;

	pthread_mutex_lock(&tlsf_lock);
	p = malloc_ex(size, pool);
	pthread_mutex_unlock(&tlsf_lock);

	return p;
}

static int do_tlsf_free(void *pool, void *block)
{
	pthread_mutex_lock(&tlsf_lock);
	free_ex(block, pool);
	pthread_mutex_unlock(&tlsf_lock);

	return 0;	/* Yeah, well... */
}

static size_t do_tlsf_used_size(void *pool)
{
	/* Do not count the overhead memory for the TLSF header. */
	return get_used_size(pool) - overhead;
}

static size_t do_tlsf_usable_size(void *pool)
{
	return test_pool_size;
}

static size_t do_tlsf_arena_size(size_t pool_size)
{
	size_t available_size;
	void *pool;

	/*
	 * The area size is the total amount of memory some allocator
	 * may need for managing a heap, including its metadata. We
	 * need to figure out how much memory overhead TLSF has for a
	 * given pool size, which we add to the ideal pool_size for
	 * determining the arena size.
	 */
	test_pool_size = pool_size;
	pool = __STD(malloc(pool_size));
	available_size = init_memory_pool(pool_size, pool);
	if (available_size == (size_t)-1) {
		__STD(free(pool));
		return 0;
	}

	destroy_memory_pool(pool);
	overhead = pool_size - available_size;
	__STD(free(pool));

	return pool_size + overhead;
}

static struct memcheck_descriptor tlsf_descriptor = {
	.name = "tlsf",
	.init = HEAP_INIT_T(do_tlsf_init),
	.destroy = HEAP_DESTROY_T(do_tlsf_destroy),
	.alloc = HEAP_ALLOC_T(do_tlsf_alloc),
	.free = HEAP_FREE_T(do_tlsf_free),
	.get_usable_size = HEAP_USABLE_T(do_tlsf_usable_size),
	.get_used_size = HEAP_USED_T(do_tlsf_used_size),
	.get_arena_size = do_tlsf_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,
	/* TLSF always has overhead, can't check for ZEROOVRD. */
	.valid_flags = MEMCHECK_ALL_FLAGS & ~MEMCHECK_ZEROOVRD,
};

static int run_memory_tlsf(struct smokey_test *t,
			   int argc, char *const argv[])
{
	return memcheck_run(&tlsf_descriptor, t, argc, argv);
}