From 88e8915dfedee5dcef61a922d5f7bbb2aa914208 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9=20Kijewski?= Date: Tue, 20 May 2014 03:17:09 +0200 Subject: [PATCH] Add TLSF (two level segregated fit) PKG MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This is my second take on #669, because I was asked to separate it from #764. This change adds a malloc implementation as a PKG, which uses *TLSF* (two level segregated fit). The patch file removes the 64bit capatibilities, debug functions, and the option to have multiple "control blocks" (a control block holds multiple memory pools). It wraps `malloc()` and friends in `disableIRQ() … restoreIRQ()`. The implemention does not support 16bit platforms, yet, but probably only some constants would need fixing. I limited the maximum size of a memory pool to 2**30 bytes = 1GB. This PKG is not meant to be used by applicitions directly, but by the boards. The board's initialition code needs to call `int tlsf_add_pool(void *mem, size_t bytes)` for every free memory region it has. If the board in using newlib, then this call needs to happen before the first call to `puts`, `printf`, and friends, because newlib allocates the control data IO streams (stdin, stdout, stderr) on the heap. Adding a small (e.g. 1kB) pool before proper board initialization would be a possible solution. Please read the additional information in the website of the implementator, http://tlsf.baisoku.org/: > TLSF (two level segregated fit) is a relatively new memory allocator designed for embedded systems. It boasts constant time O(1) malloc/free response time and a 4-byte block overhead. Though it typically is slightly slower than other allocators such as dlmalloc, it has no worst-case behavior. > The original implementation, which comes alongside the white paper, is distributed under the GNU GPL/LGPL. The code found here is an original implementation, released into the public domain, therefore is not subject to any licensing restrictions. > Features: - O(1) cost for malloc, free, realloc, memalign - Extremely low overhead per allocation (4 bytes) - Low overhead per pool (~3kB) - Low fragmentation - Compiles to only a few kB of code and data > Caveats: - Currently, assumes architecture can make 4-byte aligned accesses - Not designed to be thread safe; the user must provide this > Known Issues: Due to the internal block structure size and the implementation details of tlsf_memalign, there is worst-case behavior when requesting small (<16 byte) blocks aligned to 8-byte boundaries. Overuse of memalign will generally increase fragmentation, but this particular case will leave lots of unusable "holes" in the heap. The solution would be to internally align all blocks to 8 bytes, but this will require significantl changes to the implementation. Contact me if you are interested. --- pkg/tlsf/.gitignore | 1 + pkg/tlsf/Makefile | 41 +++ pkg/tlsf/Makefile.include | 1 + pkg/tlsf/patch.txt | 636 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 679 insertions(+) create mode 100644 pkg/tlsf/.gitignore create mode 100644 pkg/tlsf/Makefile create mode 100644 pkg/tlsf/Makefile.include create mode 100644 pkg/tlsf/patch.txt diff --git a/pkg/tlsf/.gitignore b/pkg/tlsf/.gitignore new file mode 100644 index 000000000000..58a9b88df597 --- /dev/null +++ b/pkg/tlsf/.gitignore @@ -0,0 +1 @@ +/tlsf-*.zip diff --git a/pkg/tlsf/Makefile b/pkg/tlsf/Makefile new file mode 100644 index 000000000000..7ea14d4eaca3 --- /dev/null +++ b/pkg/tlsf/Makefile @@ -0,0 +1,41 @@ +PKG_NAME = tlsf +PKG_VERSION = 3.0 +PKG_FILE = tlsf-$(PKG_VERSION).zip +PKG_URL = http://tlsf.baisoku.org/$(PKG_FILE) + +ifeq (, $(UNZIP)) + ifeq (0, $(shell which unzip 2>&1 > /dev/null ; echo $$?)) + UNZIP := $(shell which unzip) + else + ifeq (0, $(shell which 7z 2>&1 > /dev/null ; echo $$?)) + UNZIP := $(shell which 7z) x + else + $(error "Neither unzip nor 7z is installed.") + endif + endif +endif + +.PHONY: all clean patch reset + +all: $(BINDIR)$(PKG_NAME).a + +$(BINDIR)$(PKG_NAME).a: $(BINDIR)$(PKG_NAME)-src/Makefile + $(AD)make -C $(sl_bitmap[fl] & (~0 << sl); ++ unsigned int sl_map = control.sl_bitmap[fl] & (~0 << sl); +@@ -358 +359 @@ +- const unsigned int fl_map = control->fl_bitmap & (~0 << (fl + 1)); ++ const unsigned int fl_map = control.fl_bitmap & (~0 << (fl + 1)); +@@ -367 +368 @@ +- sl_map = control->sl_bitmap[fl]; ++ sl_map = control.sl_bitmap[fl]; +@@ -374 +375 @@ +- return control->blocks[fl][sl]; ++ return control.blocks[fl][sl]; +@@ -378 +379 @@ +-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) +@@ -388 +389 @@ +- if (control->blocks[fl][sl] == block) ++ if (control.blocks[fl][sl] == block) +@@ -390 +391 @@ +- control->blocks[fl][sl] = next; ++ control.blocks[fl][sl] = next; +@@ -393 +394 @@ +- if (next == &control->block_null) ++ if (next == &control.block_null) +@@ -395 +396 @@ +- control->sl_bitmap[fl] &= ~(1 << sl); ++ control.sl_bitmap[fl] &= ~(1 << sl); +@@ -398 +399 @@ +- if (!control->sl_bitmap[fl]) ++ if (!control.sl_bitmap[fl]) +@@ -400 +401 @@ +- control->fl_bitmap &= ~(1 << fl); ++ control.fl_bitmap &= ~(1 << fl); +@@ -407 +408 @@ +-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) +@@ -409 +410 @@ +- block_header_t* current = control->blocks[fl][sl]; ++ block_header_t* current = control.blocks[fl][sl]; +@@ -413 +414 @@ +- block->prev_free = &control->block_null; ++ block->prev_free = &control.block_null; +@@ -422,3 +423,3 @@ +- control->blocks[fl][sl] = block; +- control->fl_bitmap |= (1 << fl); +- control->sl_bitmap[fl] |= (1 << sl); ++ control.blocks[fl][sl] = block; ++ control.fl_bitmap |= (1 << fl); ++ control.sl_bitmap[fl] |= (1 << sl); +@@ -428 +429 @@ +-static void block_remove(control_t* control, block_header_t* block) ++static void block_remove(block_header_t* block) +@@ -432 +433 @@ +- remove_free_block(control, block, fl, sl); ++ remove_free_block(block, fl, sl); +@@ -436 +437 @@ +-static void block_insert(control_t* control, block_header_t* block) ++static void block_insert(block_header_t* block) +@@ -440 +441 @@ +- insert_free_block(control, block, fl, sl); ++ insert_free_block(block, fl, sl); +@@ -481 +482 @@ +-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 +489 @@ +- block_remove(control, prev); ++ block_remove(prev); +@@ -496 +497 @@ +-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 +505 @@ +- block_remove(control, next); ++ block_remove(next); +@@ -512 +513 @@ +-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 +521 @@ +- block_insert(control, remaining_block); ++ block_insert(remaining_block); +@@ -525 +526 @@ +-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 +535,2 @@ +- 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 +540 @@ +-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 +550 @@ +- block_insert(control, block); ++ block_insert(block); +@@ -555 +556 @@ +-static block_header_t* block_locate_free(control_t* control, size_t size) ++static block_header_t* block_locate_free(size_t size) +@@ -563 +564 @@ +- block = search_suitable_block(control, &fl, &sl); ++ block = search_suitable_block(&fl, &sl); +@@ -569 +570 @@ +- remove_free_block(control, block, fl, sl); ++ remove_free_block(block, fl, sl); +@@ -575 +576 @@ +-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 +581 @@ +- block_trim_free(control, block, size); ++ block_trim_free(block, size); +@@ -587,184 +588 @@ +-/* Clear structure and point all empty lists at the null block. */ +-static void control_construct(control_t* control) +-{ +- int i, j; +- +- control->block_null.next_free = &control->block_null; +- control->block_null.prev_free = &control->block_null; +- +- control->fl_bitmap = 0; +- for (i = 0; i < FL_INDEX_COUNT; ++i) +- { +- control->sl_bitmap[i] = 0; +- for (j = 0; j < SL_INDEX_COUNT; ++j) +- { +- control->blocks[i][j] = &control->block_null; +- } +- } +-} +- +-/* +-** Debugging utilities. +-*/ +- +-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; +-} +- +-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) +- { +- 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; +- } +- } +- } +- +- 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; +- block_header_t* block = +- offset_to_block(pool, -(int)block_header_overhead); +- +- while (block && !block_is_last(block)) +- { +- pool_walker( +- block_to_ptr(block), +- block_size(block), +- !block_is_free(block), +- user); +- block = block_next(block); +- } +-} +- +-size_t tlsf_block_size(void* ptr) +-{ +- size_t size = 0; +- if (ptr) +- { +- const block_header_t* block = block_from_ptr(ptr); +- size = block_size(block); +- } +- return size; +-} +- +-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 +593 @@ +- const size_t pool_overhead = tlsf_pool_overhead(); ++ const size_t pool_overhead = 2 * block_header_overhead; +@@ -787,5 +604,0 @@ +-#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 +@@ -795 +607,0 @@ +-#endif +@@ -808 +620 @@ +- block_insert(tlsf_cast(control_t*, tlsf), block); ++ block_insert(block); +@@ -816,16 +628 @@ +- 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"); +- +- mapping_insert(block_size(block), &fl, &sl); +- remove_free_block(control, block, fl, sl); ++ return 1; +@@ -838,68 +635 @@ +-#if _DEBUG +-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 +- +- if (((tlsfptr_t)mem % ALIGN_SIZE) != 0) +- { +- printf("tlsf_create: Memory must be aligned to %u bytes.\n", +- (unsigned int)ALIGN_SIZE); +- return 0; +- } +- +- control_construct(tlsf_cast(control_t*, 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; +-} +- +-pool_t tlsf_get_pool(tlsf_t tlsf) +-{ +- return tlsf_cast(pool_t, (char*)tlsf + tlsf_size()); +-} +- +-void* tlsf_malloc(tlsf_t tlsf, size_t size) ++void* tlsf_malloc(size_t size) +@@ -907 +636,0 @@ +- control_t* control = tlsf_cast(control_t*, tlsf); +@@ -909,2 +638,2 @@ +- 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 +642 @@ +-void* tlsf_memalign(tlsf_t tlsf, size_t align, size_t size) ++void* tlsf_memalign(size_t align, size_t size) +@@ -915 +643,0 @@ +- control_t* control = tlsf_cast(control_t*, tlsf); +@@ -932 +660 @@ +- block_header_t* block = block_locate_free(control, aligned_size); ++ block_header_t* block = block_locate_free(aligned_size); +@@ -960 +688 @@ +- block = block_trim_free_leading(control, block, gap); ++ block = block_trim_free_leading(block, gap); +@@ -964 +692 @@ +- return block_prepare_used(control, block, adjust); ++ return block_prepare_used(block, adjust); +@@ -967 +695 @@ +-void tlsf_free(tlsf_t tlsf, void* ptr) ++void tlsf_free(void* ptr) +@@ -972 +699,0 @@ +- control_t* control = tlsf_cast(control_t*, tlsf); +@@ -976,3 +703,3 @@ +- 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 +722 @@ +-void* tlsf_realloc(tlsf_t tlsf, void* ptr, size_t size) ++void* tlsf_realloc(void* ptr, size_t size) +@@ -997 +723,0 @@ +- control_t* control = tlsf_cast(control_t*, tlsf); +@@ -1003 +729 @@ +- tlsf_free(tlsf, ptr); ++ tlsf_free(ptr); +@@ -1008 +734 @@ +- p = tlsf_malloc(tlsf, size); ++ p = tlsf_malloc(size); +@@ -1027 +753 @@ +- p = tlsf_malloc(tlsf, size); ++ p = tlsf_malloc(size); +@@ -1032 +758 @@ +- tlsf_free(tlsf, ptr); ++ tlsf_free(ptr); +@@ -1040 +766 @@ +- block_merge_next(control, block); ++ block_merge_next(block); +@@ -1045 +771 @@ +- block_trim_used(control, block, adjust); ++ block_trim_used(block, adjust); +diff -NdaU0 tlsf.h tlsf.h +--- tlsf.h ++++ tlsf.h +@@ -21,15 +20,0 @@ +-#if defined(__cplusplus) +-extern "C" { +-#endif +- +-/* 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; +- +-/* Create/destroy a memory pool. */ +-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); +- +@@ -37,2 +22 @@ +-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,26 +25,4 @@ +-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); +- +-/* 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); +- +-#if defined(__cplusplus) +-}; +-#endif ++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); +diff -NdaU0 Makefile Makefile +--- Makefile ++++ Makefile +@@ -0,0 +1,3 @@ ++MODULE = tlsf ++ ++include $(RIOTBASE)/Makefile.base +diff -NdaU0 tlsf-malloc.c tlsf-malloc.c +--- tlsf-malloc.c ++++ 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 = disableIRQ(); ++ void *result = tlsf_malloc(bytes); ++ restoreIRQ(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 = disableIRQ(); ++ void *result = tlsf_memalign(align, bytes); ++ restoreIRQ(old_state); ++ return result; ++} ++ ++void *TLSF_MALLOC_NAME(realloc)(void *ptr, size_t size) ++{ ++ unsigned old_state = disableIRQ(); ++ void *result = tlsf_realloc(ptr, size); ++ restoreIRQ(old_state); ++ return result; ++} ++ ++void TLSF_MALLOC_NAME(free)(void *ptr) ++{ ++ unsigned old_state = disableIRQ(); ++ tlsf_free(ptr); ++ restoreIRQ(old_state); ++} +diff -NdaU0 tlsf-malloc.h tlsf-malloc.h +--- tlsf-malloc.h ++++ 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