RIOT/pkg/tlsf/patch.txt

diff -NdaU0 tlsf.c tlsf.c
--- tlsf.c
+++ tlsf.c
@@ -25,4 +24,0 @@
-#if defined (TLSF_64BIT)
-	/* All allocation sizes and addresses are aligned to 8 bytes. */
-	ALIGN_SIZE_LOG2 = 3,
-#else
@@ -30,3 +26,2 @@
-	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 @@
-#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 @@
-#endif
@@ -73 +60 @@
-#define tlsf_assert assert
+#define tlsf_assert(X) do { if (0) { (void) (X); } } while (0)
@@ -165,0 +153,14 @@
+static control_t control __attribute__ ((aligned(ALIGN_SIZE))) = {
+	.block_null = {
+		.next_free = &control.block_null,
+		.prev_free = &control.block_null,
+	},
+	.fl_bitmap = 0,
+	.sl_bitmap = {0},
+	.blocks = {
+		[0 ... FL_INDEX_COUNT-1] = {
+			[0 ... SL_INDEX_COUNT-1] = &control.block_null
+		}
+	}
+};
+
@@ -345 +346 @@
-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 +355 @@
-	unsigned int sl_map = control->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 <string.h>
+
+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 <stdbool.h>
+#include <stddef.h>
+
+#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