/*
* place - Place block of asize bytes at start of free block bp
* and split if remainder would be at least minimum block size
*
* given a free block, removes free block from list and updates all relevant pointers
*
*/
static void place(void* bp, size_t asize) {
size_t old_size = GET_SIZE(HDRP(bp));
size_t prev_alloc = GET_PREV_ALLOC(HDRP(bp));
size_t temp_value;
dbg1("[IN ] : place()\n");
/* remove free block from free list */
remove_free_block(bp);
/* check to see if block can be split up */
dbg1("old_size=%ld, asize=%ld, compare=%d\n", old_size, asize, (int) OVERHEAD+2*DSIZE);
if (old_size - asize >= OVERHEAD + 2*DSIZE) {
/* block can be split up */
PUT(HDRP(bp), PACK(asize, prev_alloc | 0x1));
PUT(HDRP(NEXT_BLKP(bp)), PACK( old_size - asize, 0x2 ));
PUT(FTRP(NEXT_BLKP(bp)), PACK( old_size - asize, 0x2 ));
insert_free_block(NEXT_BLKP(bp));
}
else {
/* just use entire block */
PUT(HDRP(bp), PACK(old_size, prev_alloc | 0x1));
temp_value = GET(HDRP(NEXT_BLKP(bp))) | 0x2;
PUT(HDRP(NEXT_BLKP(bp)), temp_value);
}
dbg1("[OUT] : place()\n");
}
/*
* place - Place block of asize bytes at start of free block bp
* and split if remainder would be at least minimum block size
*/
static void place(block_ptr bp, size_t asize)
{
size_t csize = GET_SIZE(HDRP(bp)), delta = csize - asize;
if (delta >= (2 * DSIZE))
{
PUT(HDRP(bp), PACK(asize, 1));
PUT(FTRP(bp), PACK(asize, 1));
SET_ALLOC(bp);
bp = NEXT_BLKP(bp);
PUT(HDRP(bp), PACK(delta, 0));
PUT(FTRP(bp), PACK(delta, 0));
SET_UNALLOC(bp);
reset_block(bp);
insert_free_block(bp, delta);
#ifdef DEBUG
{
printf("Block with size %zu remains a block:\n", asize);
printblock(bp);
}
#endif
}
else
{
PUT(HDRP(bp), PACK(csize, 1));
PUT(FTRP(bp), PACK(csize, 1));
SET_ALLOC(bp);
}
}
/*
* place
*/
static void place(void *bp, size_t asize){
size_t csize = GET_SIZE(HDRP(bp));
if ((csize - asize) >= (2*DSIZE)) {
delete_free_block(bp);
PUT(HDRP(bp), PACK(asize, 1));
PUT(FTRP(bp), PACK(asize, 1));
PUT(NEXT_BLKP(bp), PREV_F_BLKP(bp));
PUT(NEXT_BLKP(bp) + WSIZE, NEXT_F_BLKP(bp));
dbg_printf("place: %d to %d\n",(int)(HDRP(bp)-heap_listp),(int)(FTRP(bp)-heap_listp+WSIZE));
bp = NEXT_BLKP(bp);
PUT(HDRP(bp), PACK(csize - asize, 0));
PUT(FTRP(bp), PACK(csize - asize, 0));
insert_free_block(bp);
}
else{
PUT(HDRP(bp), PACK(csize, 1));
PUT(FTRP(bp), PACK(csize, 1));
delete_free_block(bp);
}
}
void grow_heap(size_t min_size)
{
struct block_header *block;
size_t grow_size;
void *new_space;
grow_size = ((min_size + BRK_SIZE - 1) / BRK_SIZE) * BRK_SIZE;
new_space = sbrk(grow_size);
memset((void*) new_space, UNALLOCED_FILL, grow_size);
block = (struct block_header*) new_space;
block->size = grow_size;
block->magic = FREE_MAGIC;
insert_free_block(block);
total_space_used += grow_size;
}
void __free_internal(void *address)
{
struct block_header *header;
if (address == 0)
return;
assert(allocated_blocks > 0);
header = (struct block_header*) ((unsigned) address - MALLOCED_HEADER_SIZE);
assert(header->magic == MALLOCED_MAGIC)
memset((void*)((unsigned) header + sizeof(struct block_header)), FREE_FILL,
header->size - sizeof(struct block_header));
header->magic = FREE_MAGIC;
allocated_blocks--;
total_allocated -= header->size;
insert_free_block(header);
}
/*
* coalesce
*/
static void *coalesce(void *bp){
size_t prev_alloc = GET_ALLOC(FTRP(PREV_BLKP(bp)));
size_t next_alloc = GET_ALLOC(HDRP(NEXT_BLKP(bp)));
size_t size = GET_SIZE(HDRP(bp));
/*prev and next block are allocated*/
if(prev_alloc && next_alloc){
//insert_free_block(bp);
//return bp;
}
/* next block is free */
else if(prev_alloc && !next_alloc){
delete_free_block(NEXT_BLKP(bp));
size += GET_SIZE(HDRP(NEXT_BLKP(bp)));
PUT(HDRP(bp),PACK(size,0));
PUT(FTRP(bp),PACK(size,0));
//insert_free_block(bp);
}
/* prev block is free */
else if(!prev_alloc && next_alloc){
delete_free_block(PREV_BLKP(bp));
size += GET_SIZE(HDRP(PREV_BLKP(bp)));
PUT(FTRP(bp),PACK(size,0));
PUT(HDRP(PREV_BLKP(bp)), PACK(size,0));
bp = PREV_BLKP(bp);
//insert_free_block(bp);
}
/*prev and next are free*/
else{
delete_free_block(PREV_BLKP(bp));
delete_free_block(NEXT_BLKP(bp));
size += GET_SIZE(HDRP(PREV_BLKP(bp))) + GET_SIZE(FTRP(NEXT_BLKP(bp)));
PUT(HDRP(PREV_BLKP(bp)), PACK(size,0));
PUT(FTRP(NEXT_BLKP(bp)), PACK(size,0));
bp = PREV_BLKP(bp);
//insert_free_block(bp);
}
insert_free_block(bp);
return bp;
}
/*
* free
*/
void free(block_ptr ptr)
{
block_ptr tmp;
size_t size;
if (!ptr || !in_heap(ptr) || !aligned(ptr))
return;
#ifdef DEBUG
{
printf("\nFree request: ptr = %p \033[41;37m[ID:%d]\033[0m\n", ptr, operid++);
printblock(ptr);
}
#endif
size = GET_SIZE(HDRP(ptr));
PUT(HDRP(ptr), PACK(size, 0));
PUT(FTRP(ptr), PACK(size, 0));
SET_UNALLOC(ptr);
reset_block(ptr);
tmp = coalesce(ptr);
insert_free_block(tmp, GET_SIZE(HDRP(tmp)));
}
/*
* coalesce - boundary tag coalescing. return ptr to coalesced block
*
*/
static void* coalesce(void* bp) {
size_t prev_alloc = GET_PREV_ALLOC(HDRP(bp));
size_t next_alloc = GET_ALLOC(HDRP(NEXT_BLKP(bp)));
size_t size = GET_SIZE(HDRP(bp));
dbg1("[IN ] : coalesce()\n");
switch (prev_alloc | next_alloc)
{
case 3:
/* neither of the adjacent blocks are free */
insert_free_block(bp);
dbg1("[OUT] : coalesce() : neither of the adjacent blocks are free.\n");
return bp;
case 2:
/* next block is free */
size += GET_SIZE(HDRP(NEXT_BLKP(bp)));
/* remove next block from free list */
remove_free_block(NEXT_BLKP(bp));
/* update header and footer pointers */
PUT(HDRP(bp), PACK(size, prev_alloc));
PUT(FTRP(bp), PACK(size, prev_alloc));
/* insert new merged block into free list */
insert_free_block(bp);
dbg1("[OUT] : coalesce() : next block is free - merged \n");
return(bp);
case 1:
/* prev block is free */
size += GET_SIZE(HDRP(PREV_BLKP(bp)));
/* remove this block from free list */
remove_free_block(PREV_BLKP(bp));
/* update header and footer pointers */
prev_alloc = GET_PREV_ALLOC(HDRP(PREV_BLKP(bp)));
PUT(FTRP(bp), PACK(size, prev_alloc));
PUT(HDRP(PREV_BLKP(bp)), PACK(size, prev_alloc));
/* insert new merged block into free list */
insert_free_block(PREV_BLKP(bp));
dbg1("[OUT] : coalesce() : previous block is free - merged \n");
return(PREV_BLKP(bp));
default:
/* both previous and next blocks are free */
size += GET_SIZE(HDRP(PREV_BLKP(bp))) + GET_SIZE(FTRP(NEXT_BLKP(bp)));
/* remove next block from free list */
remove_free_block(NEXT_BLKP(bp));
/* remove this block from free list */
remove_free_block(PREV_BLKP(bp));
/* update header and footer pointers */
prev_alloc = GET_PREV_ALLOC(HDRP(PREV_BLKP(bp)));
PUT(HDRP(PREV_BLKP(bp)), PACK(size, prev_alloc));
PUT(FTRP(NEXT_BLKP(bp)), PACK(size, prev_alloc));
/* insert new merged block into free list */
insert_free_block(PREV_BLKP(bp));
dbg1("[OUT] : coalesce() : both previous and next blocks are free - merged \n");
return(PREV_BLKP(bp));
}
}
