自学教程：C++ GET_ALLOC函数代码示例

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;}