Add fast path for growing realloc()

When realloc() needs a larger size, we can check if the next block is
free and adjacent. If the combined size of the current and next block
is sufficient, merge them into a single block and split it to the
desired size.

This fast path avoids allocating a new block and copying data, and
selective coalescing is triggered only when fragmentation exceeds the
threshold, improving performance for growing realloc() calls.

Author: visitorckw

lib/malloc.c

@@ -288,6 +288,23 @@ void *realloc(void *ptr, uint32_t size)
         return (void *) (old_block + 1);
     }
 
+    /* fast path for growing */
+    if (old_block->next && !IS_USED(old_block->next) &&
+        GET_SIZE(old_block) + sizeof(memblock_t) + GET_SIZE(old_block->next) >=
+            size) {
+        old_block->size = GET_SIZE(old_block) + sizeof(memblock_t) +
+                          GET_SIZE(old_block->next);
+        old_block->next = old_block->next->next;
+        free_blocks_count--;
+        split_block(old_block, size);
+        /* Trigger coalescing only when fragmentation is high */
+        if (free_blocks_count > COALESCE_THRESHOLD)
+            selective_coalesce();
+        CRITICAL_LEAVE();
+        return (void *) (old_block + 1);
+    }
+
+
     void *new_buf = malloc(size);
     if (new_buf) {
         memcpy(new_buf, ptr, min(old_size, size));