From cf686bde2d6ca9635333958e52980e2e13f3a703 Mon Sep 17 00:00:00 2001 From: Juan Carrano Date: Fri, 20 Apr 2018 11:12:33 +0200 Subject: [PATCH] pkg/tlsf: Refactor the TLSF package and bring back original TLSF api. - Cleanup package makefile. - Download directly from git. - Remove giant patch. - Implement malloc function as a contrib package. - Update ccn example. - Update ps command. --- Makefile.dep | 4 + examples/ccn-lite-relay/Makefile | 3 +- examples/ccn-lite-relay/main.c | 2 +- pkg/tlsf/Makefile | 39 +- pkg/tlsf/Makefile.include | 7 +- pkg/tlsf/Makefile.tlsf | 3 + pkg/tlsf/contrib/Makefile | 3 + pkg/tlsf/contrib/include/tlsf-malloc.h | 78 +++ pkg/tlsf/contrib/tlsf-malloc.c | 129 ++++ pkg/tlsf/doc.txt | 21 + pkg/tlsf/patch.txt | 578 ------------------ ...ining-on-implicit-pointer-conversion.patch | 25 + sys/oneway-malloc/include/malloc.h | 2 + sys/ps/ps.c | 3 +- 14 files changed, 284 insertions(+), 613 deletions(-) create mode 100644 pkg/tlsf/Makefile.tlsf create mode 100644 pkg/tlsf/contrib/Makefile create mode 100644 pkg/tlsf/contrib/include/tlsf-malloc.h create mode 100644 pkg/tlsf/contrib/tlsf-malloc.c delete mode 100644 pkg/tlsf/patch.txt create mode 100644 pkg/tlsf/patches/0001-Fix-warnining-on-implicit-pointer-conversion.patch diff --git a/Makefile.dep b/Makefile.dep index fe4187322357..0895d9992bf9 100644 --- a/Makefile.dep +++ b/Makefile.dep @@ -723,6 +723,10 @@ ifneq (,$(filter rdcli_common,$(USEMODULE))) USEMODULE += luid endif +ifneq (,$(filter tlsf-malloc,$(USEMODULE))) + USEPKG += tlsf +endif + # always select gpio (until explicit dependencies are sorted out) FEATURES_OPTIONAL += periph_gpio diff --git a/examples/ccn-lite-relay/Makefile b/examples/ccn-lite-relay/Makefile index d32e33735676..ccebd6c85574 100644 --- a/examples/ccn-lite-relay/Makefile +++ b/examples/ccn-lite-relay/Makefile @@ -37,8 +37,7 @@ USEMODULE += timex USEMODULE += xtimer USEMODULE += random USEMODULE += prng_xorshift - -USEPKG += tlsf +USEMODULE += tlsf-malloc USEPKG += ccn-lite diff --git a/examples/ccn-lite-relay/main.c b/examples/ccn-lite-relay/main.c index 05b6d6398fbe..a1f4eb11af9b 100644 --- a/examples/ccn-lite-relay/main.c +++ b/examples/ccn-lite-relay/main.c @@ -37,7 +37,7 @@ static uint32_t _tlsf_heap[TLSF_BUFFER]; int main(void) { - tlsf_create_with_pool(_tlsf_heap, sizeof(_tlsf_heap)); + tlsf_add_global_pool(_tlsf_heap, sizeof(_tlsf_heap)); msg_init_queue(_main_msg_queue, MAIN_QUEUE_SIZE); puts("Basic CCN-Lite example"); diff --git a/pkg/tlsf/Makefile b/pkg/tlsf/Makefile index 42c84060815e..8ccdebf81762 100644 --- a/pkg/tlsf/Makefile +++ b/pkg/tlsf/Makefile @@ -1,34 +1,13 @@ -PKG_NAME = tlsf -PKG_VERSION = 3.0 -PKG_FILE = tlsf-$(PKG_VERSION).zip -PKG_URL = http://download.riot-os.org/$(PKG_FILE) -PKG_MD5 = 176965d58af525347e582e1630ea9604 -PKG_LICENSE = PD -PKG_DIR=$(CURDIR) -PKG_BUILDDIR=$(PKGDIRBASE)/$(PKG_NAME) -PKG_SRCDIR=$(PKG_BUILDDIR)/src +PKG_NAME=tlsf +PKG_URL=https://github.com/mattconte/tlsf +PKG_VERSION=a1f743ffac0305408b39e791e0ffb45f6d9bc777 +PKG_LICENSE=BSD -.PHONY: all prepare clean distclean +.PHONY: all -all: $(PKG_SRCDIR)/$(PKG_NAME).a +all: Makefile.tlsf + @cp Makefile.tlsf $(PKG_BUILDDIR)/Makefile + "$(MAKE)" -C $(PKG_BUILDDIR) -prepare: $(PKG_SRCDIR)/Makefile -$(PKG_SRCDIR)/$(PKG_NAME).a: $(PKG_SRCDIR)/Makefile - $(Q)"$(MAKE)" -C $( +#include "tlsf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Add an area of memory to the global allocator pool. + * + * The first time this function is called, it will automatically perform a + * tlsf_create() on the global tlsf_control block. + * + * @warning If this module is used, then this function MUST be called at least + * once, before any allocations take place. + * + * @param mem Pointer to memory area. Should be aligned to 4 bytes. + * @param bytes Size in bytes of the memory area. + * + * @return 0 on success, nonzero on failure. + */ +int tlsf_add_global_pool(void *mem, size_t bytes); + +/** + * Get a pointer to the global tlsf_control block. + * + * Use for debugging purposes only. + */ +tlsf_t *_tlsf_get_global_control(void); + + +#ifdef __cplusplus +} +#endif + +#endif /* TLSF_MALLOC_H */ + +/** + * @} + */ diff --git a/pkg/tlsf/contrib/tlsf-malloc.c b/pkg/tlsf/contrib/tlsf-malloc.c new file mode 100644 index 000000000000..b62f2111bdf1 --- /dev/null +++ b/pkg/tlsf/contrib/tlsf-malloc.c @@ -0,0 +1,129 @@ +/* + * Copyright (C) 2014-2018 Freie Universität Berlin + * + * This file is subject to the terms and conditions of the GNU Lesser + * General Public License v2.1. See the file LICENSE in the top level + * directory for more details. + */ +/** + * @ingroup pkg_tlsf_malloc + * @ingroup pkg + * @ingroup sys + * @{ + * @file + * + * @brief TLSF-based global memory allocator. + * @author René Kijewski + * @author Juan I Carrano + * + */ + +#include +#include + +#include "irq.h" +#include "tlsf.h" +#include "tlsf-malloc.h" + +/** + * Global memory heap (really a collection of pools, or areas) + **/ +static tlsf_t gheap = NULL; + +/* TODO: Add defines for other compilers */ +#ifdef __GNUC__ + +#define ATTR_MALLOC __attribute__((malloc, alloc_size(1))) +#define ATTR_CALLOC __attribute__((malloc, alloc_size(1,2))) +#define ATTR_MALIGN __attribute__((alloc_align(1), alloc_size(2), malloc)) +#define ATTR_REALLOC __attribute__((alloc_size(2))) + +#else /* No GNU C -> no alias attribute */ + +#define ATTR_MALLOC +#define ATTR_CALLOC +#define ATTR_MALIGN +#define ATTR_REALLOC + +#endif /* __GNUC__ */ + +int tlsf_add_global_pool(void *mem, size_t bytes) +{ + if (gheap == NULL) { + gheap = tlsf_create_with_pool(mem, bytes); + return gheap == NULL; + } + else { + return tlsf_add_pool(gheap, mem, bytes) == NULL; + } +} + +tlsf_t *_tlsf_get_global_control(void) +{ + return gheap; +} + +/** + * Allocate a block of size "bytes" + */ +ATTR_MALLOC void *malloc(size_t bytes) +{ + unsigned old_state = irq_disable(); + void *result = tlsf_malloc(gheap, bytes); + + irq_restore(old_state); + return result; +} + +/** + * Allocate and clear a block of size "bytes*count" + */ +ATTR_CALLOC void *calloc(size_t count, size_t bytes) +{ + void *result = malloc(count * bytes); + + if (result) { + memset(result, 0, count * bytes); + } + return result; +} + +/** + * Allocate an aligned memory block. + */ +ATTR_MALIGN void *memalign(size_t align, size_t bytes) +{ + unsigned old_state = irq_disable(); + void *result = tlsf_memalign(gheap, align, bytes); + + irq_restore(old_state); + return result; +} + +/** + * Deallocate and reallocate with a different size. + */ +ATTR_REALLOC void *realloc(void *ptr, size_t size) +{ + unsigned old_state = irq_disable(); + void *result = tlsf_realloc(gheap, ptr, size); + + irq_restore(old_state); + return result; +} + + +/** + * Deallocate a block of data. + */ +void free(void *ptr) +{ + unsigned old_state = irq_disable(); + + tlsf_free(gheap, ptr); + irq_restore(old_state); +} + +/** + * @} + */ diff --git a/pkg/tlsf/doc.txt b/pkg/tlsf/doc.txt index e69de29bb2d1..e660fc99bbbb 100644 --- a/pkg/tlsf/doc.txt +++ b/pkg/tlsf/doc.txt @@ -0,0 +1,21 @@ +/** + * @defgroup pkg_tlsf Two-Level Segregated Fit memory allocator + * @ingroup pkg + * @brief TLSF is a general purpose dynamic memory allocator specifically + * designed to meet real-time requirements: + * @see http://www.gii.upv.es/tlsf/ + * @see https://github.com/mattconte/tlsf + * + * TLSF provides an implementation of malloc/realloc/free/etc with the following + * characteristics: + * + * - O(1) Performance + * - Works on a user supplied block of memory instead of a global heap. + * - Efficient both in terms of memory overhead and processor time. + * - Low fragmentation. + * + * Additionally, a contrib package @see pkg_tlsf_malloc implements a global heap + * allocator with the standard malloc/free functions. + * + * @todo The tlsf code uses printf to report errors. This is not OK. + */ diff --git a/pkg/tlsf/patch.txt b/pkg/tlsf/patch.txt deleted file mode 100644 index 64d4d05b100d..000000000000 --- a/pkg/tlsf/patch.txt +++ /dev/null @@ -1,578 +0,0 @@ -diff --git Makefile Makefile -new file mode 100644 -index 0000000..a51d6c2 ---- /dev/null -+++ Makefile -@@ -0,0 +1,3 @@ -+MODULE = tlsf -+ -+include $(RIOTBASE)/Makefile.base -diff --git tlsf-malloc.c tlsf-malloc.c -new file mode 100644 -index 0000000..cb16af8 ---- /dev/null -+++ tlsf-malloc.c -@@ -0,0 +1,44 @@ -+#include "irq.h" -+#include "tlsf-malloc.h" -+ -+#include -+ -+void *TLSF_MALLOC_NAME(malloc)(size_t bytes) -+{ -+ unsigned old_state = irq_disable(); -+ void *result = tlsf_malloc(bytes); -+ irq_restore(old_state); -+ return result; -+} -+ -+void *TLSF_MALLOC_NAME(calloc)(size_t count, size_t bytes) -+{ -+ void *result = tlsf_malloc(count * bytes); -+ if (result) { -+ memset(result, 0, count * bytes); -+ } -+ return result; -+} -+ -+void *TLSF_MALLOC_NAME(memalign)(size_t align, size_t bytes) -+{ -+ unsigned old_state = irq_disable(); -+ void *result = tlsf_memalign(align, bytes); -+ irq_restore(old_state); -+ return result; -+} -+ -+void *TLSF_MALLOC_NAME(realloc)(void *ptr, size_t size) -+{ -+ unsigned old_state = irq_disable(); -+ void *result = tlsf_realloc(ptr, size); -+ irq_restore(old_state); -+ return result; -+} -+ -+void TLSF_MALLOC_NAME(free)(void *ptr) -+{ -+ unsigned old_state = irq_disable(); -+ tlsf_free(ptr); -+ irq_restore(old_state); -+} -diff --git tlsf-malloc.h tlsf-malloc.h -new file mode 100644 -index 0000000..2d8bb4d ---- /dev/null -+++ tlsf-malloc.h -@@ -0,0 +1,26 @@ -+#ifndef __TLSF_MALLOC_H -+#define __TLSF_MALLOC_H -+ -+#include -+#include -+ -+#include "tlsf.h" -+ -+#ifndef TLSF_MALLOC_PREFIX -+# define TLSF_MALLOC_PREFIX -+#endif -+#define __TLSF_MALLOC_NAME(A, B) A ## B -+#define _TLSF_MALLOC_NAME(A, B) __TLSF_MALLOC_NAME(A, B) -+#define TLSF_MALLOC_NAME(NAME) _TLSF_MALLOC_NAME(TLSF_MALLOC_PREFIX, NAME) -+ -+void *TLSF_MALLOC_NAME(malloc)(size_t bytes); -+ -+void *TLSF_MALLOC_NAME(calloc)(size_t count, size_t bytes); -+ -+void *TLSF_MALLOC_NAME(memalign)(size_t align, size_t bytes); -+ -+void *TLSF_MALLOC_NAME(realloc)(void *ptr, size_t size); -+ -+void TLSF_MALLOC_NAME(free)(void *ptr); -+ -+#endif -diff --git tlsf.c tlsf.c -index 3fb5ebd..99c84b2 100644 ---- tlsf.c -+++ tlsf.c -@@ -25,4 +24,0 @@ enum tlsf_private --#if defined (TLSF_64BIT) -- /* All allocation sizes and addresses are aligned to 8 bytes. */ -- ALIGN_SIZE_LOG2 = 3, --#else -@@ -30,3 +26,2 @@ enum tlsf_private -- ALIGN_SIZE_LOG2 = 2, --#endif -- ALIGN_SIZE = (1 << ALIGN_SIZE_LOG2), -+#define ALIGN_SIZE_LOG2 (2) -+#define ALIGN_SIZE (1 << ALIGN_SIZE_LOG2) -@@ -45,7 +39,0 @@ enum tlsf_private --#if defined (TLSF_64BIT) -- /* -- ** TODO: We can increase this to support larger sizes, at the expense -- ** of more overhead in the TLSF structure. -- */ -- FL_INDEX_MAX = 32, --#else -@@ -53 +40,0 @@ enum tlsf_private --#endif -@@ -73 +60 @@ enum tlsf_private --#define tlsf_assert assert -+#define tlsf_assert(X) do { if (0) { (void) (X); } } while (0) -@@ -147 +134 @@ static const size_t block_start_offset = --static const size_t block_size_min = -+static const size_t block_size_min = -@@ -165,0 +153 @@ typedef struct control_t -+static control_t *control; -@@ -168,0 +157,4 @@ typedef ptrdiff_t tlsfptr_t; -+#ifdef DEVELHELP -+void *default_pool; -+#endif -+ -@@ -345 +337 @@ static void mapping_search(size_t size, int* fli, int* sli) --static block_header_t* search_suitable_block(control_t* control, int* fli, int* sli) -+static block_header_t* search_suitable_block(int* fli, int* sli) -@@ -354 +346 @@ static block_header_t* search_suitable_block(control_t* control, int* fli, int* -- unsigned int sl_map = control->sl_bitmap[fl] & (~0 << sl); -+ unsigned int sl_map = control->sl_bitmap[fl] & (((unsigned int)~0) << sl); -@@ -358 +350 @@ static block_header_t* search_suitable_block(control_t* control, int* fli, int* -- const unsigned int fl_map = control->fl_bitmap & (~0 << (fl + 1)); -+ const unsigned int fl_map = control->fl_bitmap & (((unsigned int)~0) << (fl + 1)); -@@ -378 +370 @@ static block_header_t* search_suitable_block(control_t* control, int* fli, int* --static void remove_free_block(control_t* control, block_header_t* block, int fl, int sl) -+static void remove_free_block(block_header_t* block, int fl, int sl) -@@ -407 +399 @@ static void remove_free_block(control_t* control, block_header_t* block, int fl, --static void insert_free_block(control_t* control, block_header_t* block, int fl, int sl) -+static void insert_free_block(block_header_t* block, int fl, int sl) -@@ -428 +420 @@ static void insert_free_block(control_t* control, block_header_t* block, int fl, --static void block_remove(control_t* control, block_header_t* block) -+static void block_remove(block_header_t* block) -@@ -432 +424 @@ static void block_remove(control_t* control, block_header_t* block) -- remove_free_block(control, block, fl, sl); -+ remove_free_block(block, fl, sl); -@@ -436 +428 @@ static void block_remove(control_t* control, block_header_t* block) --static void block_insert(control_t* control, block_header_t* block) -+static void block_insert(block_header_t* block) -@@ -440 +432 @@ static void block_insert(control_t* control, block_header_t* block) -- insert_free_block(control, block, fl, sl); -+ insert_free_block(block, fl, sl); -@@ -481 +473 @@ static block_header_t* block_absorb(block_header_t* prev, block_header_t* block) --static block_header_t* block_merge_prev(control_t* control, block_header_t* block) -+static block_header_t* block_merge_prev(block_header_t* block) -@@ -488 +480 @@ static block_header_t* block_merge_prev(control_t* control, block_header_t* bloc -- block_remove(control, prev); -+ block_remove(prev); -@@ -496 +488 @@ static block_header_t* block_merge_prev(control_t* control, block_header_t* bloc --static block_header_t* block_merge_next(control_t* control, block_header_t* block) -+static block_header_t* block_merge_next(block_header_t* block) -@@ -504 +496 @@ static block_header_t* block_merge_next(control_t* control, block_header_t* bloc -- block_remove(control, next); -+ block_remove(next); -@@ -512 +504 @@ static block_header_t* block_merge_next(control_t* control, block_header_t* bloc --static void block_trim_free(control_t* control, block_header_t* block, size_t size) -+static void block_trim_free(block_header_t* block, size_t size) -@@ -520 +512 @@ static void block_trim_free(control_t* control, block_header_t* block, size_t si -- block_insert(control, remaining_block); -+ block_insert(remaining_block); -@@ -525 +517 @@ static void block_trim_free(control_t* control, block_header_t* block, size_t si --static void block_trim_used(control_t* control, block_header_t* block, size_t size) -+static void block_trim_used(block_header_t* block, size_t size) -@@ -534,2 +526,2 @@ static void block_trim_used(control_t* control, block_header_t* block, size_t si -- remaining_block = block_merge_next(control, remaining_block); -- block_insert(control, remaining_block); -+ remaining_block = block_merge_next(remaining_block); -+ block_insert(remaining_block); -@@ -539 +531 @@ static void block_trim_used(control_t* control, block_header_t* block, size_t si --static block_header_t* block_trim_free_leading(control_t* control, block_header_t* block, size_t size) -+static block_header_t* block_trim_free_leading(block_header_t* block, size_t size) -@@ -549 +541 @@ static block_header_t* block_trim_free_leading(control_t* control, block_header_ -- block_insert(control, block); -+ block_insert(block); -@@ -555 +547 @@ static block_header_t* block_trim_free_leading(control_t* control, block_header_ --static block_header_t* block_locate_free(control_t* control, size_t size) -+static block_header_t* block_locate_free(size_t size) -@@ -563 +555 @@ static block_header_t* block_locate_free(control_t* control, size_t size) -- block = search_suitable_block(control, &fl, &sl); -+ block = search_suitable_block(&fl, &sl); -@@ -569 +561 @@ static block_header_t* block_locate_free(control_t* control, size_t size) -- remove_free_block(control, block, fl, sl); -+ remove_free_block(block, fl, sl); -@@ -575 +567 @@ static block_header_t* block_locate_free(control_t* control, size_t size) --static void* block_prepare_used(control_t* control, block_header_t* block, size_t size) -+static void* block_prepare_used(block_header_t* block, size_t size) -@@ -580 +572 @@ static void* block_prepare_used(control_t* control, block_header_t* block, size_ -- block_trim_free(control, block, size); -+ block_trim_free(block, size); -@@ -588 +580 @@ static void* block_prepare_used(control_t* control, block_header_t* block, size_ --static void control_construct(control_t* control) -+static void control_construct(void) -@@ -605,0 +598 @@ static void control_construct(control_t* control) -+#ifdef DEVELHELP -@@ -608,0 +602 @@ static void control_construct(control_t* control) -+typedef void (*tlsf_walker)(void* ptr, size_t size, int used); -@@ -610 +604 @@ static void control_construct(control_t* control) --typedef struct integrity_t -+static void default_walker(void* ptr, size_t size, int used) -@@ -612,20 +606,2 @@ typedef struct integrity_t -- int prev_status; -- int status; --} integrity_t; -- --#define tlsf_insist(x) { tlsf_assert(x); if (!(x)) { status--; } } -- --static void integrity_walker(void* ptr, size_t size, int used, void* user) --{ -- block_header_t* block = block_from_ptr(ptr); -- integrity_t* integ = tlsf_cast(integrity_t*, user); -- const int this_prev_status = block_is_prev_free(block) ? 1 : 0; -- const int this_status = block_is_free(block) ? 1 : 0; -- const size_t this_block_size = block_size(block); -- -- int status = 0; -- tlsf_insist(integ->prev_status == this_prev_status && "prev status incorrect"); -- tlsf_insist(size == this_block_size && "block size incorrect"); -- -- integ->prev_status = this_status; -- integ->status += status; -+ printf("\tMemory @ %p is %s, size: %u (block: %p)\n", ptr, used ? "used" : "free", -+ (unsigned int)size, (void*) block_from_ptr(ptr)); -@@ -634 +610 @@ static void integrity_walker(void* ptr, size_t size, int used, void* user) --int tlsf_check(tlsf_t tlsf) -+void tlsf_walk_pool(void *pool) -@@ -636,7 +612 @@ int tlsf_check(tlsf_t tlsf) -- int i, j; -- -- control_t* control = tlsf_cast(control_t*, tlsf); -- int status = 0; -- -- /* Check that the free lists and bitmaps are accurate. */ -- for (i = 0; i < FL_INDEX_COUNT; ++i) -+ if (!pool) -@@ -644,37 +614 @@ int tlsf_check(tlsf_t tlsf) -- for (j = 0; j < SL_INDEX_COUNT; ++j) -- { -- const int fl_map = control->fl_bitmap & (1 << i); -- const int sl_list = control->sl_bitmap[i]; -- const int sl_map = sl_list & (1 << j); -- const block_header_t* block = control->blocks[i][j]; -- -- /* Check that first- and second-level lists agree. */ -- if (!fl_map) -- { -- tlsf_insist(!sl_map && "second-level map must be null"); -- } -- -- if (!sl_map) -- { -- tlsf_insist(block == &control->block_null && "block list must be null"); -- continue; -- } -- -- /* Check that there is at least one free block. */ -- tlsf_insist(sl_list && "no free blocks in second-level map"); -- tlsf_insist(block != &control->block_null && "block should not be null"); -- -- while (block != &control->block_null) -- { -- int fli, sli; -- tlsf_insist(block_is_free(block) && "block should be free"); -- tlsf_insist(!block_is_prev_free(block) && "blocks should have coalesced"); -- tlsf_insist(!block_is_free(block_next(block)) && "blocks should have coalesced"); -- tlsf_insist(block_is_prev_free(block_next(block)) && "block should be free"); -- tlsf_insist(block_size(block) >= block_size_min && "block not minimum size"); -- -- mapping_insert(block_size(block), &fli, &sli); -- tlsf_insist(fli == i && sli == j && "block size indexed in wrong list"); -- block = block->next_free; -- } -- } -+ pool = default_pool; -@@ -682,15 +615,0 @@ int tlsf_check(tlsf_t tlsf) -- -- return status; --} -- --#undef tlsf_insist -- --static void default_walker(void* ptr, size_t size, int used, void* user) --{ -- (void)user; -- printf("\t%p %s size: %x (%p)\n", ptr, used ? "used" : "free", (unsigned int)size, block_from_ptr(ptr)); --} -- --void tlsf_walk_pool(pool_t pool, tlsf_walker walker, void* user) --{ -- tlsf_walker pool_walker = walker ? walker : default_walker; -@@ -702 +621 @@ void tlsf_walk_pool(pool_t pool, tlsf_walker walker, void* user) -- pool_walker( -+ default_walker( -@@ -705,2 +624 @@ void tlsf_walk_pool(pool_t pool, tlsf_walker walker, void* user) -- !block_is_free(block), -- user); -+ !block_is_free(block)); -@@ -720,0 +639 @@ size_t tlsf_block_size(void* ptr) -+#endif -@@ -722,49 +641 @@ size_t tlsf_block_size(void* ptr) --int tlsf_check_pool(pool_t pool) --{ -- /* Check that the blocks are physically correct. */ -- integrity_t integ = { 0, 0 }; -- tlsf_walk_pool(pool, integrity_walker, &integ); -- -- return integ.status; --} -- --/* --** Size of the TLSF structures in a given memory block passed to --** tlsf_create, equal to the size of a control_t --*/ --size_t tlsf_size() --{ -- return sizeof(control_t); --} -- --size_t tlsf_align_size() --{ -- return ALIGN_SIZE; --} -- --size_t tlsf_block_size_min() --{ -- return block_size_min; --} -- --size_t tlsf_block_size_max() --{ -- return block_size_max; --} -- --/* --** Overhead of the TLSF structures in a given memory block passes to --** tlsf_add_pool, equal to the overhead of a free block and the --** sentinel block. --*/ --size_t tlsf_pool_overhead() --{ -- return 2 * block_header_overhead; --} -- --size_t tlsf_alloc_overhead() --{ -- return block_header_overhead; --} -- --pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes) -+int tlsf_add_pool(void* mem, size_t bytes) -@@ -775 +646 @@ pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes) -- const size_t pool_overhead = tlsf_pool_overhead(); -+ const size_t pool_overhead = 2 * block_header_overhead; -@@ -787,6 +658 @@ pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes) --#if defined (TLSF_64BIT) -- printf("tlsf_add_pool: Memory size must be between 0x%x and 0x%x00 bytes.\n", -- (unsigned int)(pool_overhead + block_size_min), -- (unsigned int)((pool_overhead + block_size_max) / 256)); --#else -- printf("tlsf_add_pool: Memory size must be between %u and %u bytes.\n", -+ printf("tlsf_add_pool: Memory size must be between %u and %u bytes.\n", -@@ -795 +660,0 @@ pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes) --#endif -@@ -808 +673 @@ pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes) -- block_insert(tlsf_cast(control_t*, tlsf), block); -+ block_insert(block); -@@ -816,13 +681,3 @@ pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes) -- return mem; --} -- --void tlsf_remove_pool(tlsf_t tlsf, pool_t pool) --{ -- control_t* control = tlsf_cast(control_t*, tlsf); -- block_header_t* block = offset_to_block(pool, -(int)block_header_overhead); -- -- int fl = 0, sl = 0; -- -- tlsf_assert(block_is_free(block) && "block should be free"); -- tlsf_assert(!block_is_free(block_next(block)) && "next block should not be free"); -- tlsf_assert(block_size(block_next(block)) == 0 && "next block size should be zero"); -+#ifdef DEVELHELP -+ default_pool = mem; -+#endif -@@ -830,2 +685 @@ void tlsf_remove_pool(tlsf_t tlsf, pool_t pool) -- mapping_insert(block_size(block), &fl, &sl); -- remove_free_block(control, block, fl, sl); -+ return 1; -@@ -838,2 +692 @@ void tlsf_remove_pool(tlsf_t tlsf, pool_t pool) --#if _DEBUG --int test_ffs_fls() -+void tlsf_create(void* mem) -@@ -841,34 +693,0 @@ int test_ffs_fls() -- /* Verify ffs/fls work properly. */ -- int rv = 0; -- rv += (tlsf_ffs(0) == -1) ? 0 : 0x1; -- rv += (tlsf_fls(0) == -1) ? 0 : 0x2; -- rv += (tlsf_ffs(1) == 0) ? 0 : 0x4; -- rv += (tlsf_fls(1) == 0) ? 0 : 0x8; -- rv += (tlsf_ffs(0x80000000) == 31) ? 0 : 0x10; -- rv += (tlsf_ffs(0x80008000) == 15) ? 0 : 0x20; -- rv += (tlsf_fls(0x80000008) == 31) ? 0 : 0x40; -- rv += (tlsf_fls(0x7FFFFFFF) == 30) ? 0 : 0x80; -- --#if defined (TLSF_64BIT) -- rv += (tlsf_fls_sizet(0x80000000) == 31) ? 0 : 0x100; -- rv += (tlsf_fls_sizet(0x100000000) == 32) ? 0 : 0x200; -- rv += (tlsf_fls_sizet(0xffffffffffffffff) == 63) ? 0 : 0x400; --#endif -- -- if (rv) -- { -- printf("tlsf_create: %x ffs/fls tests failed!\n", rv); -- } -- return rv; --} --#endif -- --tlsf_t tlsf_create(void* mem) --{ --#if _DEBUG -- if (test_ffs_fls()) -- { -- return 0; -- } --#endif -- -@@ -879 +698 @@ tlsf_t tlsf_create(void* mem) -- return 0; -+ return; -@@ -882 +701 @@ tlsf_t tlsf_create(void* mem) -- control_construct(tlsf_cast(control_t*, mem)); -+ control = tlsf_cast(control_t*, mem); -@@ -884,14 +703 @@ tlsf_t tlsf_create(void* mem) -- return tlsf_cast(tlsf_t, mem); --} -- --tlsf_t tlsf_create_with_pool(void* mem, size_t bytes) --{ -- tlsf_t tlsf = tlsf_create(mem); -- tlsf_add_pool(tlsf, (char*)mem + tlsf_size(), bytes - tlsf_size()); -- return tlsf; --} -- --void tlsf_destroy(tlsf_t tlsf) --{ -- /* Nothing to do. */ -- (void)tlsf; -+ control_construct(); -@@ -900 +706 @@ void tlsf_destroy(tlsf_t tlsf) --pool_t tlsf_get_pool(tlsf_t tlsf) -+void tlsf_create_with_pool(void* mem, size_t bytes) -@@ -902 +708,2 @@ pool_t tlsf_get_pool(tlsf_t tlsf) -- return tlsf_cast(pool_t, (char*)tlsf + tlsf_size()); -+ tlsf_create(mem); -+ tlsf_add_pool((char*)mem + sizeof(control_t), bytes - sizeof(control_t)); -@@ -905 +712 @@ pool_t tlsf_get_pool(tlsf_t tlsf) --void* tlsf_malloc(tlsf_t tlsf, size_t size) -+void* tlsf_malloc(size_t size) -@@ -907 +713,0 @@ void* tlsf_malloc(tlsf_t tlsf, size_t size) -- control_t* control = tlsf_cast(control_t*, tlsf); -@@ -909,2 +715,2 @@ void* tlsf_malloc(tlsf_t tlsf, size_t size) -- block_header_t* block = block_locate_free(control, adjust); -- return block_prepare_used(control, block, adjust); -+ block_header_t* block = block_locate_free(adjust); -+ return block_prepare_used(block, adjust); -@@ -913 +719 @@ void* tlsf_malloc(tlsf_t tlsf, size_t size) --void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size) -+void* tlsf_memalign(size_t align, size_t size) -@@ -915 +720,0 @@ void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size) -- control_t* control = tlsf_cast(control_t*, tlsf); -@@ -932 +737 @@ void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size) -- block_header_t* block = block_locate_free(control, aligned_size); -+ block_header_t* block = block_locate_free(aligned_size); -@@ -960 +765 @@ void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size) -- block = block_trim_free_leading(control, block, gap); -+ block = block_trim_free_leading(block, gap); -@@ -964 +769 @@ void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size) -- return block_prepare_used(control, block, adjust); -+ return block_prepare_used(block, adjust); -@@ -967 +772 @@ void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size) --void tlsf_free(tlsf_t tlsf, void* ptr) -+void tlsf_free(void* ptr) -@@ -972 +776,0 @@ void tlsf_free(tlsf_t tlsf, void* ptr) -- control_t* control = tlsf_cast(control_t*, tlsf); -@@ -976,3 +780,3 @@ void tlsf_free(tlsf_t tlsf, void* ptr) -- block = block_merge_prev(control, block); -- block = block_merge_next(control, block); -- block_insert(control, block); -+ block = block_merge_prev(block); -+ block = block_merge_next(block); -+ block_insert(block); -@@ -995 +799 @@ void tlsf_free(tlsf_t tlsf, void* ptr) --void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size) -+void* tlsf_realloc(void* ptr, size_t size) -@@ -997 +800,0 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size) -- control_t* control = tlsf_cast(control_t*, tlsf); -@@ -1003 +806 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size) -- tlsf_free(tlsf, ptr); -+ tlsf_free(ptr); -@@ -1008 +811 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size) -- p = tlsf_malloc(tlsf, size); -+ p = tlsf_malloc(size); -@@ -1027 +830 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size) -- p = tlsf_malloc(tlsf, size); -+ p = tlsf_malloc(size); -@@ -1032 +835 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size) -- tlsf_free(tlsf, ptr); -+ tlsf_free(ptr); -@@ -1040 +843 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size) -- block_merge_next(control, block); -+ block_merge_next(block); -@@ -1045 +848 @@ void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size) -- block_trim_used(control, block, adjust); -+ block_trim_used(block, adjust); -diff --git tlsf.h tlsf.h -index 72496a1..6c945e5 100644 ---- tlsf.h -+++ tlsf.h -@@ -25,5 +24,0 @@ extern "C" { --/* tlsf_t: a TLSF structure. Can contain 1 to N pools. */ --/* pool_t: a block of memory that TLSF can manage. */ --typedef void* tlsf_t; --typedef void* pool_t; -- -@@ -31,4 +26,2 @@ typedef void* pool_t; --tlsf_t tlsf_create(void* mem); --tlsf_t tlsf_create_with_pool(void* mem, size_t bytes); --void tlsf_destroy(tlsf_t tlsf); --pool_t tlsf_get_pool(tlsf_t tlsf); -+void tlsf_create(void* mem); -+void tlsf_create_with_pool(void* mem, size_t bytes); -@@ -37,2 +30 @@ pool_t tlsf_get_pool(tlsf_t tlsf); --pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes); --void tlsf_remove_pool(tlsf_t tlsf, pool_t pool); -+int tlsf_add_pool(void* mem, size_t bytes); -@@ -41,7 +33,4 @@ void tlsf_remove_pool(tlsf_t tlsf, pool_t pool); --void* tlsf_malloc(tlsf_t tlsf, size_t bytes); --void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t bytes); --void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size); --void tlsf_free(tlsf_t tlsf, void* ptr); -- --/* Returns internal block size, not original request size */ --size_t tlsf_block_size(void* ptr); -+void* tlsf_malloc(size_t bytes); -+void* tlsf_memalign(size_t align, size_t bytes); -+void* tlsf_realloc(void* ptr, size_t size); -+void tlsf_free(void* ptr); -@@ -49,14 +38,3 @@ size_t tlsf_block_size(void* ptr); --/* Overheads/limits of internal structures. */ --size_t tlsf_size(); --size_t tlsf_align_size(); --size_t tlsf_block_size_min(); --size_t tlsf_block_size_max(); --size_t tlsf_pool_overhead(); --size_t tlsf_alloc_overhead(); -- --/* Debugging. */ --typedef void (*tlsf_walker)(void* ptr, size_t size, int used, void* user); --void tlsf_walk_pool(pool_t pool, tlsf_walker walker, void* user); --/* Returns nonzero if any internal consistency check fails. */ --int tlsf_check(tlsf_t tlsf); --int tlsf_check_pool(pool_t pool); -+#ifdef DEVELHELP -+void tlsf_walk_pool(void *pool); -+#endif diff --git a/pkg/tlsf/patches/0001-Fix-warnining-on-implicit-pointer-conversion.patch b/pkg/tlsf/patches/0001-Fix-warnining-on-implicit-pointer-conversion.patch new file mode 100644 index 000000000000..a900d96b774b --- /dev/null +++ b/pkg/tlsf/patches/0001-Fix-warnining-on-implicit-pointer-conversion.patch @@ -0,0 +1,25 @@ +From fb4b4cf6d2d0bbac15a973f292b21939f2abc38b Mon Sep 17 00:00:00 2001 +From: Juan Carrano +Date: Mon, 23 Apr 2018 13:55:42 +0200 +Subject: [PATCH] Fix warnining on implicit pointer conversion. + +--- + tlsf.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/tlsf.c b/tlsf.c +index f4fc786..eb1cb9c 100644 +--- a/tlsf.c ++++ b/tlsf.c +@@ -898,7 +898,7 @@ int tlsf_check(tlsf_t tlsf) + static void default_walker(void* ptr, size_t size, int used, void* user) + { + (void)user; +- printf("\t%p %s size: %x (%p)\n", ptr, used ? "used" : "free", (unsigned int)size, block_from_ptr(ptr)); ++ printf("\t%p %s size: %x (%p)\n", ptr, used ? "used" : "free", (unsigned int)size, (void *)block_from_ptr(ptr)); + } + + void tlsf_walk_pool(pool_t pool, tlsf_walker walker, void* user) +-- +2.1.4 + diff --git a/sys/oneway-malloc/include/malloc.h b/sys/oneway-malloc/include/malloc.h index a0844d08e968..657ea27782d4 100644 --- a/sys/oneway-malloc/include/malloc.h +++ b/sys/oneway-malloc/include/malloc.h @@ -20,6 +20,8 @@ * * @note You should prefer statically allocated memory whenever possible. * + * @see pkg_tlsf + * * @{ * @file * diff --git a/sys/ps/ps.c b/sys/ps/ps.c index 586686311936..b8b53c073c23 100644 --- a/sys/ps/ps.c +++ b/sys/ps/ps.c @@ -28,6 +28,7 @@ #ifdef MODULE_TLSF #include "tlsf.h" +#include "tlsf-malloc.h" #endif /* list of states copied from tcb.h */ @@ -146,7 +147,7 @@ void ps(void) overall_stacksz, overall_used); # ifdef MODULE_TLSF puts("\nHeap usage:"); - tlsf_walk_pool(NULL); + tlsf_walk_pool(tlsf_get_pool(_tlsf_get_global_control()), NULL, NULL); # endif #endif }