static inline void *find_fit(size_t asize) { void *bp; for (bp = heap_listp; GET_SIZE(HDRP(bp))>0; bp = NEXT_BLKP(bp)) { if (!GET_ALLOC(HDRP(bp)) && (asize <= GET_SIZE(HDRP(bp)))) return bp; } return NULL; }
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)); if(prev_alloc && next_alloc) //101 { add_free(bp); //return bp; } else if(prev_alloc && !next_alloc) //100 { rm_free(NEXT_BLKP(bp)); size += GET_SIZE(HDRP(NEXT_BLKP(bp))); PUT(HDRP(bp), PACK(size, 0)); PUT(FTRP(bp), PACK(size, 0)); add_free(bp); } else if(!prev_alloc && next_alloc) //001 { 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); } else //000 { rm_free(NEXT_BLKP(bp)); size += GET_SIZE(HDRP(NEXT_BLKP(bp))) + GET_SIZE(HDRP(PREV_BLKP(bp))); PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0)); PUT(FTRP(NEXT_BLKP(bp)), PACK(size, 0)); bp = PREV_BLKP(bp); } return bp; }
/* * coalesce - Coalesce adjacent free blocks. Sort the new free block into the * appropriate list. */ static void *coalesce(void *ptr) { size_t prev_alloc = GET_ALLOC(HEAD(PREV(ptr))); size_t next_alloc = GET_ALLOC(HEAD(NEXT(ptr))); size_t size = GET_SIZE(HEAD(ptr)); /* Return if previous and next blocks are allocated */ if (prev_alloc && next_alloc) { return ptr; } /* Do not coalesce with previous block if it is tagged */ if (GET_TAG(HEAD(PREV(ptr)))) prev_alloc = 1; /* Remove old block from list */ delete_node(ptr); /* Detect free blocks and merge, if possible */ if (prev_alloc && !next_alloc) { delete_node(NEXT(ptr)); size += GET_SIZE(HEAD(NEXT(ptr))); PUT(HEAD(ptr), PACK(size, 0)); PUT(FOOT(ptr), PACK(size, 0)); } else if (!prev_alloc && next_alloc) { delete_node(PREV(ptr)); size += GET_SIZE(HEAD(PREV(ptr))); PUT(FOOT(ptr), PACK(size, 0)); PUT(HEAD(PREV(ptr)), PACK(size, 0)); ptr = PREV(ptr); } else { delete_node(PREV(ptr)); delete_node(NEXT(ptr)); size += GET_SIZE(HEAD(PREV(ptr))) + GET_SIZE(HEAD(NEXT(ptr))); PUT(HEAD(PREV(ptr)), PACK(size, 0)); PUT(FOOT(NEXT(ptr)), PACK(size, 0)); ptr = PREV(ptr); } /* Adjust segregated linked lists */ insert_node(ptr, size); return ptr; }
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)); /* if previous and next are allocated do nothing */ if (prev_alloc && next_alloc) { return bp; } /* if next is not allocated */ else if (prev_alloc && !next_alloc) { size += GET_SIZE(HDRP(NEXT_BLKP(bp))); PUT(HDRP(bp), PACK(size, 0)); PUT(FTRP(bp), PACK(size ,0)); /* this node's successor is the next node's */ size_t oldSucc = SCRP(NEXT_BLKP(bp)); PUT(SCRP(bp), oldSucc); return(bp); } else if (!prev_alloc && next_alloc) { size += GET_SIZE(HDRP(PREV_BLKP(bp))); PUT(FTRP(bp), PACK(size, 0)); PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0)); size_t oldSucc = SCRP(PREV_BLKP(bp)); PUT(SCRP(PREV_BLKP(bp)), oldSucc); return(PREV_BLKP(bp)); } else { 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)); return(PREV_BLKP(bp)); } }
static void *coalesce(void *bp) { size_t prev_alloc = GET_ALLOC(FTRP(PREV_BLKP(bp))) || (PREV_BLKP(bp) == bp); size_t next_alloc = GET_ALLOC(HDRP(NEXT_BLKP(bp))); size_t size = GET_SIZE(HDRP(bp)); if (prev_alloc && next_alloc) { // Do nothing } else if (prev_alloc && !next_alloc) { size += GET_SIZE(HDRP(NEXT_BLKP(bp))); remove_block(NEXT_BLKP(bp),GET_SIZE(HDRP(NEXT_BLKP(bp)))); PUT(HDRP(bp), PACK(size, 0)); PUT(FTRP(bp), PACK(size,0)); } else if (!prev_alloc && next_alloc) { size += GET_SIZE(HDRP(PREV_BLKP(bp))); bp = PREV_BLKP(bp); remove_block(bp,GET_SIZE(HDRP(bp))); PUT(HDRP(bp), PACK(size, 0)); PUT(FTRP(bp), PACK(size, 0)); } else { size += GET_SIZE(HDRP(PREV_BLKP(bp))) + GET_SIZE(HDRP(NEXT_BLKP(bp))); void *pbp = PREV_BLKP(bp); remove_block(pbp, GET_SIZE(HDRP(pbp))); void *nbp = NEXT_BLKP(bp); remove_block(nbp, GET_SIZE(HDRP(nbp))); bp = PREV_BLKP(bp); PUT(HDRP(bp), PACK(size, 0)); PUT(FTRP(bp), PACK(size, 0)); } insert_free_list(bp,size); return bp; }
/* * coalesce - Boundary tag coalescing. Return ptr to coalesced block */ static void *coalesce(void *bp){ size_t NEXT_ALLOC = GET_ALLOC( HDRP(NEXT_BLK(bp)) ); size_t PREV_ALLOC = GET_ALLOC( HDRP(PREV_BLK(bp)) ); //size_t PREV_ALLOC = GET_ALLOC( FTRP(PREV_BLK(bp)) ) || PREV_BLK(bp) == bp; size_t size = GET_SIZE(HDRP(bp)); /*return if the previous and next blocks are both allocated */ if (PREV_ALLOC && NEXT_ALLOC) { return bp; } /*Remove old block from list*/ delete_node(bp); if (PREV_ALLOC && !NEXT_ALLOC) { delete_node(NEXT_BLK(bp)); size += GET_SIZE(HDRP(NEXT_BLK(bp))); PUT(HDRP(bp), PACK(size, 0)); PUT(FTRP(bp), PACK(size, 0)); } else if (!PREV_ALLOC && NEXT_ALLOC) { delete_node(PREV_BLK(bp)); size += GET_SIZE(HDRP(PREV_BLK(bp))); PUT(FTRP(bp), PACK(size, 0)); PUT(HDRP(PREV_BLK(bp)), PACK(size, 0)); bp = PREV(bp); } else { delete_node(PREV_BLK(bp)); delete_node(NEXT_BLK(bp)); size += GET_SIZE(HDRP(PREV_BLK(bp))) + GET_SIZE(HDRP(NEXT_BLK(bp))); PUT(HDRP(PREV_BLK(bp)), PACK(size, 0)); PUT(FTRP(NEXT_BLK(bp)), PACK(size, 0)); bp = PREV_BLK(bp); } insert_node(bp, size); return bp; }
static void *coalesce(void *ptr) { size_t prev_alloc = GET_ALLOC(FTRP(PREV_BLKP(ptr))); size_t next_alloc = GET_ALLOC(HDRP(NEXT_BLKP(ptr))); size_t size = GET_SIZE(HDRP(ptr)); if (prev_alloc && next_alloc) { /* Case 1 */ printf("Go into case 1\n"); add_lst(ptr); return ptr; } else if (prev_alloc && !next_alloc) { /* Case 2 */ size += GET_SIZE(HDRP(NEXT_BLKP(ptr))); printf("Go into case 2\n"); remove_lst(NEXT_BLKP(ptr)); PUT(HDRP(ptr), PACK(size, 0)); PUT(FTRP(ptr), PACK(size,0)); add_lst(ptr); } else if (!prev_alloc && next_alloc) { /* Case 3 */ printf("Go into case 3\n"); size += GET_SIZE(HDRP(PREV_BLKP(ptr))); PUT(FTRP(ptr), PACK(size, 0)); PUT(HDRP(PREV_BLKP(ptr)), PACK(size, 0)); ptr = PREV_BLKP(ptr); remove_lst(ptr); add_lst(ptr); } else { /* Case 4 */ printf("Go into case 4\n"); size += GET_SIZE(HDRP(PREV_BLKP(ptr))) + GET_SIZE(FTRP(NEXT_BLKP(ptr))); remove_lst(NEXT_BLKP(ptr)); PUT(HDRP(PREV_BLKP(ptr)), PACK(size, 0)); PUT(FTRP(NEXT_BLKP(ptr)), PACK(size, 0)); ptr = PREV_BLKP(ptr); remove_lst(ptr); add_lst(ptr); } return ptr; }
static void printblock(void *bp) { size_t hsize, halloc, fsize, falloc; checkheap(0); hsize = GET_SIZE(HDRP(bp)); halloc = GET_ALLOC(HDRP(bp)); fsize = GET_SIZE(FTRP(bp)); falloc = GET_ALLOC(FTRP(bp)); if (hsize == 0) { printf("%p: EOL\n", bp); return; } /* printf("%p: header: [%p:%c] footer: [%p:%c]\n", bp, hsize, (halloc ? 'a' : 'f'), fsize, (falloc ? 'a' : 'f')); */ }
static void printblock(void *bp) { size_t hsize, halloc, fsize, falloc; // checkheap(0); hsize = GET_SIZE(HDRP(bp)); halloc = GET_ALLOC(HDRP(bp)); fsize = GET_SIZE(FTRP(bp)); falloc = GET_ALLOC(FTRP(bp)); if (hsize == 0) { dbg_printf("%p: EOL\n", bp); return; } dbg_printf("%p: header: [%u:%c] footer: [%u:%c]\n", bp, (uint32_t) hsize, (halloc ? 'a' : 'f'), (uint32_t)fsize, (falloc ? 'a' : 'f')); }
/* $begin coalesce */ static void *coalesce(void *bp) //bp point to header { void *prev_block=prev_blkp(bp); void *next_block=next_blkp(bp); uint32_t prev_alloc = GET_ALLOC(prev_block); uint32_t next_alloc = GET_ALLOC(next_block); uint32_t size = GET_SIZE(bp); if (prev_alloc && next_alloc) { /* Case 1 */ return bp; } else if (prev_alloc && !next_alloc) { /* Case 2 */ size += GET_SIZE(next_block); delete_free_block(next_block); PUT(bp, PACK(size, 0)); PUT(FTRP1(bp), PACK(size,0)); } else if (!prev_alloc && next_alloc) { /* Case 3 */ size += GET_SIZE(prev_block); delete_free_block(prev_block); PUT(FTRP1(bp), PACK(size, 0)); PUT(prev_block, PACK(size, 0)); bp = prev_block; } else { /* Case 4 */ size += GET_SIZE(prev_block) + GET_SIZE(next_block); delete_free_block(prev_block); delete_free_block(next_block); PUT(prev_block, PACK(size, 0)); PUT(FTRP1(next_block), PACK(size, 0)); bp = prev_block; } add_free_block(bp); return bp; }
static void printblock(void *bp) { size_t hsize, halloc, fsize, falloc; hsize = GET_SIZE(HDRP(bp)); halloc = GET_ALLOC(HDRP(bp)); fsize = GET_SIZE(FTRP(bp)); falloc = GET_ALLOC(FTRP(bp)); if (hsize == 0) { printf("%p: EOL\n", bp); return; } printf("%p: header: [%d:%c] footer: [%d:%c]\n", bp, (int) hsize, (halloc ? 'a' : 'f'), (int) fsize, (falloc ? 'a' : 'f')); }
static void* coalesce(void *bp) //bp point to header { //dbg_printf("coalesce %p\n",bp); void *prev_blk=PREV_BLKP(bp); void *next_blk=NEXT_BLKP(bp); size_t prev_alloc = GET_ALLOC(FTRP(prev_blk)); size_t next_alloc = GET_ALLOC(HDRP(next_blk)); size_t size = GET_SIZE(HDRP(bp)); if (prev_alloc && next_alloc) { /* Case 1 */ add_free_block(bp); return bp; } else if (prev_alloc && !next_alloc) { /* Case 2 */ size += GET_SIZE(HDRP(next_blk)); delete_free_block(next_blk); PUT(HDRP(bp), PACK(size, 0)); PUT(FTRP(bp), PACK(size,0)); } else if (!prev_alloc && next_alloc) { /* Case 3 */ size += GET_SIZE(HDRP(prev_blk)); delete_free_block(prev_blk); PUT(FTRP(bp), PACK(size, 0)); PUT(HDRP(prev_blk), PACK(size, 0)); bp = prev_blk; } else { /* Case 4 */ size += GET_SIZE(HDRP(prev_blk)) + GET_SIZE(FTRP(next_blk)); delete_free_block(prev_blk); delete_free_block(next_blk); PUT(HDRP(prev_blk), PACK(size, 0)); PUT(FTRP(next_blk), PACK(size, 0)); bp = prev_blk; } add_free_block(bp); return bp; }
static void *find_fit(size_t size) { char *bp = heap_listp; while (GET_SIZE(HDRP(bp))) { if (!GET_ALLOC(HDRP(bp)) && GET_SIZE(HDRP(bp)) >= size) { return bp; } bp = NEXT_BLKP(bp); } return NULL; }
void* find_fit(size_t size){ void* temp = heap_ptr; while(*NEXT_BLKP(temp) > 0){ //Keep on going while not footer block if(GET_ALLOC(temp) && (GET_SIZE(temp) > size)) return temp; temp = NEXT_BLKP(temp); } return NULL; //Didn't find a block so returning NULL }
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)); if (prev_alloc && next_alloc) { add_freelist(bp); /* Case:1 Both previous block and next block are allocated*/ return bp; } else if (!prev_alloc && next_alloc) { void *prev = PREV_BLKP(bp); /* Case:2 Previous is free and next block is allocated*/ delete_freelist(prev); size += GET_SIZE(HDRP(PREV_BLKP(bp))); PUT(FTRP(bp), PACK(size, 0)); PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0)); add_freelist(PREV_BLKP(bp)); return (PREV_BLKP(bp)); } else if (prev_alloc && !next_alloc) { void *next = NEXT_BLKP(bp); /* Case:3 Previous is allocated and next block is free */ delete_freelist(next); size += GET_SIZE(HDRP(NEXT_BLKP(bp))); PUT(HDRP(bp), PACK(size, 0)); PUT(FTRP(bp), PACK(size, 0)); add_freelist(bp); return (bp); } else { void *prev = PREV_BLKP(bp); /* Case:4 Both previous and next block are free*/ void *next = NEXT_BLKP(bp); delete_freelist(prev); delete_freelist(next); 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)); add_freelist(PREV_BLKP(bp)); return (PREV_BLKP(bp)); } }
/* * mm_checkheap - Check the heap for consistency */ void mm_checkheap(int verbose) { //printf("************ CHECK BEGIN ***************\n"); char *bp = heap_listp; char *checkAll = heap_listp; int countblocks = -1; if (verbose) { printf("Heap: (%p)\n", heap_listp); } if ((GET_SIZE(HDRP(heap_listp)) != OVERHEAD) || !GET_ALLOC(HDRP(heap_listp))) { printf("Bad prologue header\n"); } checkblock(heap_listp); while(GET(SUCC(bp)) != 0){ if(verbose == 1) printblock(bp); checkblock(bp); //countblocks++; bp = (char*)GET(SUCC(bp)); } if(verbose == 1) printblock(bp); for (checkAll = heap_listp; GET_SIZE(HDRP(checkAll)) > 0; checkAll = NEXT_BLKP(checkAll)) { if(!GET_ALLOC(HDRP(checkAll)) && !block_in_free_list(checkAll)){ printf("Block is marked free but not in free list\n"); } checkblock(checkAll); countblocks++; } //printf("Number of free blocks: %d\n", freeblockcount); //printf("Total number of blocks: %d\n", countblocks); if ((GET_SIZE(HDRP(checkAll)) != 0) || !(GET_ALLOC(HDRP(checkAll)))) { printf("Bad epilogue header\n"); } //printf("****************** CHECK END ********************\n"); }
/** * checkblock - check the current block for consistency * @param bp Block to be checked */ static void checkblock(void *bp) { /** * Checks- * 1) Check for alignment * 2) Check for Header and Footer Match * 3) Check for the block to be in heap * 4) Check coalescing- no previous/next free blocks if current is free. */ /*Check Block for alignment*/ if ((size_t)bp % 8) { printf("ERROR: %p is not doubleword aligned\n", bp); } /*Check Block Header matching Footer*/ if (GET(HDRP(bp)) != GET(FTRP(bp))) { printf("ERROR: header does not match footer\n"); dbg_printf("**Debug Info \n"); dbg_printf("Heap_listp = %p \n", heap_listp ); dbg_printf("Block %p \n", bp ); } /* Check for if the block is in the heap */ if( !in_heap(bp)) { printf("ERROR: %p is not in heap \n", bp); } /** * Concept : As all the blocks are iteratively checked, just checking * next block for coalescing will suffice next/previous block * checks. */ /* Check Coalescing with Next Block */ if( GET_ALLOC(HDRP(bp)) ==0 && NEXT_BLKP(bp)!=NULL && GET_ALLOC(HDRP(NEXT_BLKP(bp))) ==0 ) { printf("ERROR: %p is not coalesced with next block\n", bp); print_all(); exit(1); } }
/********************************************************** * coalesce * Covers the 4 cases discussed in the text: * - both neighbours are allocated * - the next block is available for coalescing * - the previous block is available for coalescing * - both neighbours are available for coalescing **********************************************************/ void *coalesce(void *bp) { logg(4, "============ coalesce() starts =============="); logg(1, "coalesce() called with bp: %p; Previous block: %p header: %zx; Next block: %p header: %zx", bp, PREV_BLKP(bp), GET(HDRP(PREV_BLKP(bp))), NEXT_BLKP(bp), GET(HDRP(NEXT_BLKP(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)); if (prev_alloc && next_alloc) { /* Case 1 */ logg(2, "Case 1: Both prev and next blocks are allocated. NO coalescing."); } else if (prev_alloc && !next_alloc) { /* Case 2 */ logg(2, "Case2: Next block is free."); size += GET_SIZE(HDRP(NEXT_BLKP(bp))); remove_free_block(NEXT_BLKP(bp)); PUT(HDRP(bp), PACK(size, 0)); PUT(FTRP(bp), PACK(size, 0)); } else if (!prev_alloc && next_alloc) { /* Case 3 */ logg(2, "Case3: Prev block is free."); size += GET_SIZE(HDRP(PREV_BLKP(bp))); remove_free_block(PREV_BLKP(bp)); bp = PREV_BLKP(bp); // move bp one block ahead PUT(HDRP(bp), PACK(size, 0)); PUT(FTRP(bp), PACK(size, 0)); } else { /* Case 4 */ logg(2, "Case4: Both blocks are free."); size += GET_SIZE(HDRP(PREV_BLKP(bp))) + GET_SIZE(HDRP(NEXT_BLKP(bp))) ; remove_free_block(NEXT_BLKP(bp)); remove_free_block(PREV_BLKP(bp)); bp = PREV_BLKP(bp); PUT(HDRP(bp), PACK(size,0)); PUT(FTRP(bp), PACK(size,0)); } // Add the bp block to the beginning of free list of corresponding size. add_free_block(bp); logg(4, "============ coalesce() ends =============="); return bp; }
/* * coalesce - boundary tag coalescing. * This function joins adjecent free blocks together by * finding the size (newsize) of the new (bigger) free block, removing the * free block(s) from the free list, and changing the header * and footer information to the newly coalesced free block * (size = newsize, allocated = 0) * Then, we add the new free block to the front of the free list. * * This function takes a block pointer to the newly freed block (around which * we must coalesce) and returns the block pointer to the coalesced free * block. * Return ptr to coalesced block */ static void *coalesce(void *bp) { size_t prev_alloc; prev_alloc = GET_ALLOC(FTRP(PREV_BLKP(bp))) || PREV_BLKP(bp) == bp; size_t next_alloc = GET_ALLOC(HDRP(NEXT_BLKP(bp))); size_t size = GET_SIZE(HDRP(bp)); /* Case 1, extend the block leftward */ if (prev_alloc && !next_alloc) { size += GET_SIZE(HDRP(NEXT_BLKP(bp))); removeBlock(NEXT_BLKP(bp)); PUT(HDRP(bp), PACK(size, 0)); PUT(FTRP(bp), PACK(size, 0)); } /* Case 2, extend the block rightward */ else if (!prev_alloc && next_alloc) { size += GET_SIZE(HDRP(PREV_BLKP(bp))); bp = PREV_BLKP(bp); removeBlock(bp); PUT(HDRP(bp), PACK(size, 0)); PUT(FTRP(bp), PACK(size, 0)); } /* Case 3, extend the block in both directions */ else if (!prev_alloc && !next_alloc) { size += GET_SIZE(HDRP(PREV_BLKP(bp))) + GET_SIZE(HDRP(NEXT_BLKP(bp))); removeBlock(PREV_BLKP(bp)); removeBlock(NEXT_BLKP(bp)); bp = PREV_BLKP(bp); PUT(HDRP(bp), PACK(size, 0)); PUT(FTRP(bp), PACK(size, 0)); } insertAtFront(bp); return bp; }
/* * mm_checkheap - Checks the invariants of the heap * This function checks the invariants of the heap such as header-footer match, * absence of contiguous blocks of free memory and confirmation that the * block pointers are within the heaps boundaries. */ void mm_checkheap(int verbose) { void *bp = heap_listp; //Points to the first block in the heap verbose = verbose; /* If first block's header's size or allocation bit is wrong, * the prologue header is incorrect. */ if ((GET_SIZE(HDRP(heap_listp)) != MINBLOCKSIZE) || !GET_ALLOC(HDRP(heap_listp))) printf("Bad prologue header\n"); checkblock(bp); for (bp = heap_listp; GET_SIZE(HDRP(bp)) > 0; bp = NEXT_BLKP(bp)) { if (verbose) printblock(bp); if(GET_SIZE(HDRP(bp)) == 0) printf("Error: block has zero size\n"); checkblock(bp); /* Checking to see if free block in the free list */ if(!GET_ALLOC(HDRP(bp))) checkInFreeList(bp); } /* If last block's header's size or allocation bit is wrong, * the epilogue's header is wrong. We also check the specific location * of the epilogue header with respect to the last byte of the heap. * mem_heap_hi() and bp(at this point) both point to the same word, * but mem_heap_hi() points to the last byte and hence we must add 3 to * the address of the header of bp to check this condition. */ if (GET_SIZE(HDRP(bp)) != 0 || (GET_ALLOC(HDRP(bp)) != 1) || (HDRP(bp) + WSIZE - 1) != mem_heap_hi()) printf("Bad epilogue header\n"); for(bp = free_listp; GET_ALLOC(HDRP(bp)) == 0; bp = NEXT_FREE(bp)) checkFreeNodes(bp); }
static void *find_fit(size_t asize) { /* First fit search */ void *ptr; for (ptr = heap_listp; GET_SIZE(HDRP(ptr)) > 0; ptr = NEXT_BLKP(ptr)) { if (!GET_ALLOC(HDRP(ptr)) && (asize <= GET_SIZE(HDRP(ptr)))) { return ptr; } } return NULL; /* No fit */ }
/********************************************************** * This function checks the next block to see * if it is the epilog block **********************************************************/ int isNextEiplog(void * bp) { void * next = NEXT_BLKP(bp); if(next == NULL) return 0; if(GET_SIZE(HDRP(next))==0 && GET_ALLOC(HDRP(next)) == 0x1) return 1; else return 0; }
static void *find_fit(size_t asize) { /*first-fit search of the implicit free list */ void *bp; for (bp = heap_listp; GET_SIZE(HDRP(bp)) > 0; bp = NEXT_BLKP(bp)) { if (!GET_ALLOC(HDRP(bp)) && (asize <= GET_SIZE(HDRP(bp)))) { return bp; } } return NULL; /* No fit */ }
/* * mm_realloc - Implemented simply in terms of mm_malloc and mm_free */ void *mm_realloc(void *ptr, size_t size) { size_t oldsize = GET_SIZE(HDRP(ptr)); size_t asize; void *newptr; if(ptr == NULL) return mm_malloc(size); else if(size == 0) { mm_free(ptr); return NULL; } if(size <= DSIZE) asize = 2 * DSIZE; else asize = DSIZE * ((size + (DSIZE) + (DSIZE - 1)) / DSIZE); if(asize <= oldsize) { //ptr = replace(ptr, asize); return ptr; } else //next block { size_t next_alloc = GET_ALLOC(HDRP(NEXT_BLKP(ptr))); size_t next_size = GET_SIZE(HDRP(NEXT_BLKP(ptr))); if(!next_alloc && (oldsize + next_size) >= asize) { rm_free(NEXT_BLKP(ptr)); PUT(HDRP(ptr), PACK(oldsize + next_size, 1)); PUT(FTRP(ptr), PACK(oldsize + next_size, 1)); return ptr; } /*else if(next_size == 0) { if(extend_heap(CHUNKSIZE / WSIZE) == NULL) return 0; next_size = GET_SIZE(HDRP(NEXT_BLKP(ptr))); rm_free(NEXT_BLKP(ptr)); PUT(HDRP(ptr), PACK(oldsize + next_size, 1)); PUT(FTRP(ptr), PACK(oldsize + next_size, 1)); return replace(ptr, asize); }*/ else { newptr = mm_malloc(size); memcpy(newptr, ptr, oldsize); mm_free(ptr); return newptr; } } }
/* * Requires: * "bp" is the address of a block. * * Effects: * Print the block "bp". */ static void printblock(void *bp) { bool halloc, falloc; size_t hsize, fsize; checkheap(false); hsize = GET_SIZE(HDRP(bp)); halloc = GET_ALLOC(HDRP(bp)); fsize = GET_SIZE(FTRP(bp)); falloc = GET_ALLOC(FTRP(bp)); if (hsize == 0) { printf("%p: end of heap\n", bp); return; } printf("%p: header: [%zu:%c] footer: [%zu:%c]\n", bp, hsize, (halloc ? 'a' : 'f'), fsize, (falloc ? 'a' : 'f')); }
/* * Requires: * None. * * Effects: * Find a fit for a block with "asize" bytes. Returns that block's address * or NULL if no suitable block was found. */ static void * find_fit(size_t asize) { void *bp; for (bp = free_listp; GET_ALLOC(HDRP(bp)) == 0; bp = *GETNEXT(bp)) { if (asize <= GET_SIZE(HDRP(bp))) return bp; } return NULL; }
static void* find_fit(size_t asize) { void* bp; /* first fit search */ for(bp = heap_listp; GET_SIZE(HDRP(bp)) > 0; bp = NEXT_BLKP(bp)) { if(!GET_ALLOC(HDRP(bp)) && (asize <= GET_SIZE(HDRP(bp)))) { return bp; } } return NULL; /* no fit */ }
/* prints a single block */ void print_block(void* bp) { #if DEBUG >= 3 //printf("print_block\n"); #endif //int allocated = GET_ALLOC(HDRP(bp)); //int size = GET_SIZE(HDRP(bp)); printf("%p | allocated: %1lu | size %6u | %6u words | %p\n ", bp, GET_ALLOC(HDRP(bp)), GET_SIZE(HDRP(bp)),GET_SIZE(FTRP(bp)),FTRP(bp)); }
static void *find_fit(size_t asize){ void *bp; bp = endfree; /*first fit search*/ while (bp != NULL) { if (!GET_ALLOC(HDRP(bp)) && (asize <= GET_SIZE(HDRP(bp)))) return bp; bp = PREV(bp); } return NULL; }
static void *find_fit(size_t asize){ void *bp; for (bp = free_listp; GET_ALLOC(HDRP(bp)) == 0; bp = GET_NEXT_FREE(bp) ){ if (asize <= (size_t)GET_SIZE(HDRP(bp)) ) { return bp; } } return NULL; }