simplify resize api

Author: minad

bench.c

@@ -92,11 +92,11 @@ static void run_alloc_benchmark(size_t loops, size_t blk_min, size_t blk_max,
 }
 
 static size_t max_size;
+static void* mem = 0;
 
-static size_t resize(tlsf* _t, void* _start, size_t old_size, size_t req_size) {
+static void* resize(tlsf* _t, size_t req_size) {
     (void)_t;
-    (void)_start;
-    return req_size > max_size ? old_size : req_size;
+    return req_size <= max_size ? mem : 0;
 }
 
 int main(int argc, char **argv) {
@@ -129,7 +129,8 @@ int main(int argc, char **argv) {
     }
 
     max_size = blk_max * num_blks;
-    tlsf_init(&t, malloc(max_size), resize);
+    mem = malloc(max_size);
+    tlsf_init(&t, resize);
 
     void** blk_array = (void**)calloc(num_blks, sizeof(void*));
     assert(blk_array);

test.c

@@ -16,21 +16,27 @@
 static size_t PAGE;
 static size_t MAX_PAGES;
 static size_t curr_pages = 0;
+static void* start_addr = 0;
 
-static size_t resize(tlsf* t, void* start, size_t old_size, size_t req_size) {
+static void* resize(tlsf* t, size_t req_size) {
     (void)t;
 
+    if (!start_addr)
+        start_addr = mmap(0, MAX_PAGES * PAGE,
+                          PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE,
+                          -1, 0);
+
     size_t req_pages = (req_size + PAGE - 1) / PAGE;
     if (req_pages > MAX_PAGES)
-        return old_size;
+        return 0;
 
     if (req_pages != curr_pages) {
         if (req_pages < curr_pages)
-            madvise((char*)start + PAGE * req_pages, (size_t)(curr_pages - req_pages) * PAGE, MADV_DONTNEED);
+            madvise((char*)start_addr + PAGE * req_pages, (size_t)(curr_pages - req_pages) * PAGE, MADV_DONTNEED);
         curr_pages = req_pages;
     }
 
-    return req_size;
+    return start_addr;
 }
 
 static void random_test(tlsf* t, size_t spacelen, const size_t cap) {
@@ -153,11 +159,8 @@ int main(void) {
     PAGE = (size_t)sysconf(_SC_PAGESIZE);
     MAX_PAGES = 20 * TLSF_MAX_SIZE / PAGE;
 
-    void* p = mmap(0, MAX_PAGES * PAGE,
-                   PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE,
-                   -1, 0);
     tlsf t;
-    tlsf_init(&t, p, resize);
+    tlsf_init(&t, resize);
 
     srand((unsigned int)time(0));
     large_size_test(&t);

tlsf.c

@@ -342,48 +342,43 @@ TLSF_INL void* block_use(tlsf* t, tlsf_block* block, size_t size) {
     return block_payload(block);
 }
 
-TLSF_INL tlsf_block* get_sentinel(tlsf* t) {
-    return to_block(t->size ? (char*)t->start + t->size - 2*BLOCK_OVERHEAD : (char*)t->start - BLOCK_OVERHEAD);
-}
-
-TLSF_INL void check_sentinel(tlsf* t, tlsf_block* block) {
-    (void)t;
+TLSF_INL void check_sentinel(tlsf_block* block) {
     (void)block;
-    TLSF_ASSERT(get_sentinel(t) == block, "not the sentinel");
     TLSF_ASSERT(!block_size(block), "sentinel should be last");
     TLSF_ASSERT(!block_is_free(block), "sentinel block should not be free");
 }
 
 static bool arena_grow(tlsf* t, size_t size) {
-    size_t req_size = (t->size ? t->size + BLOCK_OVERHEAD : 2*BLOCK_OVERHEAD) + size,
-        new_size = t->resize(t, t->start, t->size, req_size);
-    TLSF_ASSERT(new_size == t->size || new_size == req_size, "invalid size after grow");
-    if (new_size == t->size)
+    size_t req_size = (t->size ? t->size + BLOCK_OVERHEAD : 2*BLOCK_OVERHEAD) + size;
+    void* addr = t->resize(t, req_size);
+    if (!addr)
         return false;
-    tlsf_block* block = get_sentinel(t);
+    TLSF_ASSERT((size_t)addr % ALIGN_SIZE == 0, "wrong heap alignment address");
+    tlsf_block* block = to_block(t->size ? (char*)addr + t->size - 2*BLOCK_OVERHEAD : (char*)addr - BLOCK_OVERHEAD);
     if (!t->size)
         block->header = 0;
-    check_sentinel(t, block);
+    check_sentinel(block);
     block->header |= size | BLOCK_BIT_FREE;
     block = block_merge_prev(t, block);
     block_insert(t, block);
     tlsf_block* sentinel = block_link_next(block);
     sentinel->header = BLOCK_BIT_PREV_FREE;
-    t->size = new_size;
-    check_sentinel(t, sentinel);
+    t->size = req_size;
+    check_sentinel(sentinel);
     return true;
 }
 
 static void arena_shrink(tlsf* t, tlsf_block* block) {
-    check_sentinel(t, block_next(block));
-    size_t size = block_size(block),
-        req_size = (char*)block == (char*)t->start - BLOCK_OVERHEAD ? 0 : t->size - size - BLOCK_OVERHEAD;
-    TLSF_ASSERT(t->size >= size, "invalid heap size before shrink");
-    t->size = t->resize(t, t->start, t->size, req_size);
-    TLSF_ASSERT(t->size == req_size, "invalid heap size after shrink");
+    check_sentinel(block_next(block));
+    size_t size = block_size(block);
+    TLSF_ASSERT(t->size + BLOCK_OVERHEAD >= size, "invalid heap size before shrink");
+    t->size = t->size - size - BLOCK_OVERHEAD;
+    if (t->size == BLOCK_OVERHEAD)
+        t->size = 0;
+    t->resize(t, t->size);
     if (t->size) {
         block->header = 0;
-        check_sentinel(t, block);
+        check_sentinel(block);
     }
 }
 
@@ -403,11 +398,9 @@ TLSF_INL tlsf_block* block_find_free(tlsf* t, size_t size) {
     return block;
 }
 
-TLSF_API void tlsf_init(tlsf* t, void* start, tlsf_resize resize) {
+TLSF_API void tlsf_init(tlsf* t, tlsf_resize resize) {
     memset(t, 0, sizeof (tlsf));
-    t->start = start;
     t->resize = resize;
-    TLSF_ASSERT((size_t)t->start % ALIGN_SIZE == 0, "wrong alignment");
 }
 
 TLSF_API void* tlsf_malloc(tlsf* t, size_t size) {

tlsf.h

@@ -13,17 +13,16 @@
 #define TLSF_MAX_SIZE  (((size_t)1 << (_TLSF_FL_MAX - 1)) - sizeof (size_t))
 
 typedef struct tlsf_ tlsf;
-typedef size_t (*tlsf_resize)(tlsf*, void*, size_t, size_t);
+typedef void* (*tlsf_resize)(tlsf*, size_t);
 
 struct tlsf_ {
     uint32_t fl, sl[_TLSF_FL_COUNT];
     struct tlsf_block_* block[_TLSF_FL_COUNT][_TLSF_SL_COUNT];
     tlsf_resize resize;
-    void*       start;
     size_t      size;
 };
 
-TLSF_API void tlsf_init(tlsf*, void*, tlsf_resize);
+TLSF_API void tlsf_init(tlsf*, tlsf_resize);
 TLSF_API void* tlsf_aalloc(tlsf*, size_t, size_t);
 TLSF_API void* tlsf_malloc(tlsf*, size_t);
 TLSF_API void* tlsf_realloc(tlsf*, void*, size_t);