5 changed files with 290 additions and 170 deletions
Unified View
Diff Options
-
+1 -1Makefile
-
+172 -0ya_block.c
-
+101 -0ya_block.h
-
+15 -168yamalloc.c
-
+1 -1yamalloc.h
+ 1
- 1
Makefile
View File
+ 172
- 0
ya_block.c
View File
| @ -0,0 +1,172 @@ | |||||
| /* | |||||
| * Yet Another Malloc | |||||
| * ya_block.c | |||||
| * Defines operations on blocks and boundary tags | |||||
| */ | |||||
| /*----------*/ | |||||
| /* Includes */ | |||||
| /*----------*/ | |||||
| #include "ya_block.h" | |||||
| #include "ya_debug.h" | |||||
| /*---------*/ | |||||
| /* Globals */ | |||||
| /*---------*/ | |||||
| intptr_t *heap_start = NULL; // with space for 2 words before | |||||
| intptr_t *heap_end = NULL; // first block outside heap | |||||
| /*----------------------*/ | |||||
| /* Function definitions */ | |||||
| /*----------------------*/ | |||||
| #ifdef YA_DEBUG | |||||
| void block_print_range(intptr_t *start, intptr_t *end) { | |||||
| intptr_t *block; | |||||
| intptr_t block_size; | |||||
| for (block = start; block < end; block += block_size) { | |||||
| block_size = YA_SZ_BLK(block); | |||||
| printf("Block at %p size = %ld alloc = %d\n", | |||||
| block, block_size, YA_IS_ALLOC_BLK(block)); | |||||
| } | |||||
| } | |||||
| #endif | |||||
| /* Initializes the block's boundary tags. */ | |||||
| void block_init(intptr_t *block, intptr_t size) { | |||||
| block[-1] = size; | |||||
| block[size - 2] = size; | |||||
| } | |||||
| /* Sets the allocated bit in the block's boundary tags. */ | |||||
| void block_alloc(intptr_t *block) { | |||||
| intptr_t block_size = YA_SZ_BLK(block); | |||||
| block[-1] |= 1; | |||||
| block[block_size-2] |= 1; | |||||
| } | |||||
| /* Erases the allocated bit in the block's boundary tags. */ | |||||
| void block_free(intptr_t *block) { | |||||
| intptr_t block_size = YA_SZ_BLK(block); | |||||
| block[-1] &= -2; | |||||
| block[block_size-2] &= -2; | |||||
| } | |||||
| /* Returns the size in words of the smallest block that can | |||||
| * store n_bytes bytes. Takes alignment and boundary tags into account */ | |||||
| intptr_t block_fit(size_t n_bytes) { | |||||
| intptr_t n_words = YA_ROUND_DIV(n_bytes, YA_SZ_WORD); // size in words | |||||
| // round to dword and make space for tags | |||||
| intptr_t size = 2 + YA_ROUND(n_words, 2); | |||||
| ya_debug("block_fit: requested = %ld, allocating = %ld * %ld = %ld\n", | |||||
| n_bytes, size, YA_SZ_WORD, size * YA_SZ_WORD); | |||||
| return size; | |||||
| } | |||||
| /* Tries to coalesce a block with its previous neighbor. | |||||
| * Returns a pointer to the coalesced block. */ | |||||
| intptr_t *block_join_prev(intptr_t *block) { | |||||
| intptr_t prev_size = YA_SZ_TAG(block[-2]); | |||||
| intptr_t *prev = block - prev_size; | |||||
| if (prev <= heap_start || YA_IS_ALLOC_BLK(prev)) { | |||||
| return block; | |||||
| } | |||||
| intptr_t block_size = YA_SZ_BLK(block); | |||||
| block_init(prev, prev_size + block_size); | |||||
| ya_debug("block_join_prev: joining %p:%ld and %p:%ld -> %p:%ld\n", | |||||
| block, block_size, prev, prev_size, prev, prev_size + block_size); | |||||
| return prev; | |||||
| } | |||||
| /* Tries to colesce a block with its next neighbor. | |||||
| * Returns the unchanged pointer to the block. */ | |||||
| intptr_t *block_join_next(intptr_t *block) { | |||||
| intptr_t block_size = YA_SZ_BLK(block); | |||||
| intptr_t *next = block + block_size; | |||||
| if (next >= heap_end || YA_IS_ALLOC_BLK(next)) { | |||||
| return block; | |||||
| } | |||||
| intptr_t next_size = YA_SZ_BLK(next); | |||||
| block_init(block, block_size + next_size); | |||||
| ya_debug("block_join_next: joining %p:%ld and %p:%ld -> %p:%ld\n", | |||||
| block, block_size, next, next_size, block, block_size + next_size); | |||||
| return block; | |||||
| } | |||||
| /* Tries to coalesce a block with its previous and next neighbors. | |||||
| * Returns a pointer to the coalesced block. */ | |||||
| intptr_t *block_join(intptr_t *block) { | |||||
| if (block > heap_start) { | |||||
| block = block_join_prev(block); | |||||
| } | |||||
| return block_join_next(block); | |||||
| } | |||||
| /* Split the block [block_size] into [size, block_size - size] if possible | |||||
| * Returns a pointer to the second block or NULL if no split occurred. */ | |||||
| intptr_t *block_split(intptr_t *block, intptr_t size) { | |||||
| intptr_t next_size = YA_SZ_BLK(block) - size; | |||||
| if (next_size < YA_MIN_SZ_BLK) { | |||||
| return NULL; // not enough space to warrant a split | |||||
| } | |||||
| block_init(block, size); | |||||
| block_init(block + size, next_size); | |||||
| return block + size; | |||||
| } | |||||
| /* Try to find a free block at least size words big by walking the boundary | |||||
| * tags. If no block is found the heap is grown adequately. | |||||
| * Returns a pointer to the block or NULL in case of failure. */ | |||||
| intptr_t *block_find(intptr_t size) { | |||||
| intptr_t *block; | |||||
| intptr_t block_size; | |||||
| for (block = heap_start; block < heap_end; block += block_size) { | |||||
| block_size = YA_SZ_BLK(block); | |||||
| if (!YA_IS_ALLOC_BLK(block) && size <= block_size) { | |||||
| return block; | |||||
| } | |||||
| } | |||||
| // could not find block, extend heap | |||||
| return heap_extend(size); | |||||
| } | |||||
| /* Initializes the heap by calling sbrk to allocate some starter memory. | |||||
| * Sets heap_start and heap_end to their appropriate values. | |||||
| * Returns the pointer to the start of the heap or NULL in case of failure. */ | |||||
| intptr_t *heap_init() { | |||||
| intptr_t size_w = YA_SZ_CHUNK / YA_SZ_WORD; | |||||
| void *ptr = sbrk(YA_SZ_WORD * (size_w + 2)); | |||||
| if (ptr == (void*) -1) { | |||||
| heap_start = NULL; | |||||
| heap_end = NULL; | |||||
| return NULL; | |||||
| } | |||||
| heap_start = ptr; // cast to intptr_t * | |||||
| heap_start += 2; // space for the first block[-1] + dword alignment | |||||
| heap_end = heap_start + size_w; | |||||
| block_init(heap_start, size_w); | |||||
| ya_debug("heap_init: start = %p, end = %p, size_w = %ld\n", | |||||
| heap_start, heap_end, size_w); | |||||
| return heap_start; | |||||
| } | |||||
| /* Extends the heap by at least size_w words by calling sbrk. | |||||
| * Returns a pointer to the last (free) block or NULL in case of failure. */ | |||||
| intptr_t *heap_extend(intptr_t size_w) { | |||||
| intptr_t size = YA_ROUND(size_w * YA_SZ_WORD, YA_SZ_CHUNK); | |||||
| size_w = size / YA_SZ_WORD; | |||||
| ya_debug("heap_extend: size_w = %ld\n", size_w); | |||||
| void *ptr = sbrk(size); | |||||
| if (ptr == (void *) - 1) { | |||||
| return NULL; | |||||
| } | |||||
| intptr_t *block = ptr; // == old heap_end | |||||
| heap_end = block + size_w; | |||||
| block_init(block, size_w); | |||||
| ya_debug("heap_extend: old end = %p, new end = %p, size_w = %ld\n", | |||||
| block, heap_end, size_w); | |||||
| ya_print_blocks(); | |||||
| return block_join(ptr); | |||||
| } | |||||
+ 101
- 0
ya_block.h
View File
| @ -0,0 +1,101 @@ | |||||
| /* | |||||
| * Yet Another Malloc | |||||
| * ya_block.h | |||||
| */ | |||||
| #ifndef YA_BLOCK_H | |||||
| #define YA_BLOCK_H | |||||
| /*----------*/ | |||||
| /* Includes */ | |||||
| /*----------*/ | |||||
| #include <stddef.h> // for size_t | |||||
| #include <stdint.h> // for intptr_t | |||||
| /*-----------*/ | |||||
| /* Constants */ | |||||
| /*-----------*/ | |||||
| #define YA_SZ_WORD (sizeof(intptr_t)) // big enough to hold a pointer | |||||
| #define YA_SZ_DWORD (2 * YA_SZ_WORD) // storage is aligned to a dword | |||||
| #define YA_SZ_CHUNK 8192 // request memory 8k by 8k from OS | |||||
| #define YA_MIN_SZ_BLK 4 // smallest block: dword-aligned with two boundary tags | |||||
| /*--------*/ | |||||
| /* Macros */ | |||||
| /*--------*/ | |||||
| #define YA_IS_ALLOC_TAG(tag) ((tag) & 1) | |||||
| #define YA_SZ_TAG(tag) ((tag) & -2) | |||||
| #define YA_IS_ALLOC_BLK(block) YA_IS_ALLOC_TAG((block)[-1]) | |||||
| #define YA_SZ_BLK(block) YA_SZ_TAG((block)[-1]) | |||||
| #define YA_IS_ALLOC_END(b_end) YA_IS_ALLOC_TAG((b_end)[0]) | |||||
| #define YA_SZ_END(b_end) YA_SZ_TAG((b_end)[0]) | |||||
| #define YA_ROUND_DIV(n, m) (((n) + ((m)-1)) / (m)) | |||||
| #define YA_ROUND(n, m) (YA_ROUND_DIV(n,m) * (m)) | |||||
| /*---------*/ | |||||
| /* Globals */ | |||||
| /*---------*/ | |||||
| extern intptr_t *heap_start; // with space for 2 words before | |||||
| extern intptr_t *heap_end ; // first block outside heap | |||||
| /*--------------*/ | |||||
| /* Declarations */ | |||||
| /*--------------*/ | |||||
| /* Initializes the heap by calling sbrk to allocate some starter memory. | |||||
| * Sets heap_start and heap_end to their appropriate values. | |||||
| * Returns the pointer to the start of the heap or NULL in case of failure. */ | |||||
| intptr_t *heap_init(); | |||||
| /* Extends the heap by at least size_w words by calling sbrk. | |||||
| * Returns a pointer to the last (free) block or NULL in case of failure. */ | |||||
| intptr_t *heap_extend(intptr_t size_w); | |||||
| #ifdef YA_DEBUG | |||||
| /* Prints each block in the range from the block at start to the one at end */ | |||||
| void block_print_range(intptr_t *start, intptr_t *end); | |||||
| #endif | |||||
| /* Initializes the block's boundary tags. */ | |||||
| void block_init(intptr_t *block, intptr_t size); | |||||
| /* Sets the allocated bit in the block's boundary tags. */ | |||||
| void block_alloc(intptr_t *block); | |||||
| /* Erases the allocated bit in the block's boundary tags. */ | |||||
| void block_free(intptr_t *block); | |||||
| /* Returns the size in words of the smallest block that can | |||||
| * store n_bytes bytes. Takes alignment and boundary tags into account */ | |||||
| intptr_t block_fit(size_t n_bytes); | |||||
| /* Tries to coalesce a block with its previous neighbor. | |||||
| * Returns a pointer to the coalesced block. */ | |||||
| intptr_t *block_join_prev(intptr_t *block); | |||||
| /* Tries to colesce a block with its next neighbor. | |||||
| * Returns the unchanged pointer to the block. */ | |||||
| intptr_t *block_join_next(intptr_t *block); | |||||
| /* Tries to coalesce a block with its previous and next neighbors. | |||||
| * Returns a pointer to the coalesced block. */ | |||||
| intptr_t *block_join(intptr_t *block); | |||||
| /* Split the block [block_size] into [size, block_size - size] if possible | |||||
| * Returns a pointer to the second block or NULL if no split occurred. */ | |||||
| intptr_t *block_split(intptr_t *block, intptr_t size); | |||||
| /* Try to find a free block at least size words big by walking the boundary | |||||
| * tags. If no block is found the heap is grown adequately. | |||||
| * Returns a pointer to the block or NULL in case of failure. */ | |||||
| intptr_t *block_find(intptr_t size); | |||||
| #endif | |||||