void mm_free(void *bp)
{
size_t size;
int prev_alloc = GET_ALLOC_PREV(HDRP(bp));
size = GET_SIZE(HDRP(bp));
PUT(HDRP(bp), PACK(size, prev_alloc));
PUT(FTRP(bp), PACK(size, prev_alloc));
char *next_block = NEXT_BLKP(bp);
int next_alloc = GET_ALLOC(HDRP(next_block));
size = GET_SIZE(HDRP(next_block));
PUT(HDRP(next_block), PACK(size, next_alloc));
if (!next_alloc)
PUT(FTRP(next_block), PACK(size, next_alloc));
coalesce(bp);
}
/* $begin mmextendheap */
static void *extend_heap(size_t words)
{
char *bp;
size_t size;
/* Allocate an even number of words to maintain alignment */
size = (words % 2) ? (words+1) * WSIZE : words * WSIZE; //line:vm:mm:beginextend
if ((long)(bp = mem_sbrk(size)) == -1)
return NULL; //line:vm:mm:endextend
/* Initialize free block header/footer and the epilogue header */
PUT(HDRP(bp), PACK(size, 0)); /* Free block header */ //line:vm:mm:freeblockhdr
PUT(FTRP(bp), PACK(size, 0)); /* Free block footer */ //line:vm:mm:freeblockftr
PUT(HDRP(NEXT_BLKP(bp)), PACK(0, 1)); /* New epilogue header */ //line:vm:mm:newepihdr
/* Coalesce if the previous block was free */
return coalesce(bp); //line:vm:mm:returnblock
}
//Extend the heap in case when the heap size is not sufficient to hold the block
static void* extend_heap(size_t words){
char *bp;
size_t size;
size = (words % 2) ? (words + 1) * WSIZE : words * WSIZE;
size = MAX(size,OVERHEAD);
if((int)(bp = mem_sbrk(size)) == -1){
return NULL;
}
PUT(HDRP(bp), PACK(size, 0));
PUT(FTRP(bp), PACK(size, 0));
PUT(HDRP(NEXT_BLKP(bp)), PACK(0, 1));
return coalesce(bp);
}
/*
* coalesce - Boundary tag coalescing. Return ptr to coalesced block
*/
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) {
return bp;
}
else if (prev_alloc && !next_alloc) {
delete_node(bp);
delete_node(NEXT_BLKP(bp)); /* Case 2 */
size += GET_SIZE(HDRP(NEXT_BLKP(bp)));
PUT(HDRP(bp), PACK(size, 0));
PUT(FTRP(bp), PACK(size,0));
}
else if (!prev_alloc && next_alloc) { /* Case 3 */
delete_node(bp);
delete_node(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);
}
else {
delete_node(bp);
delete_node(PREV_BLKP(bp));
delete_node(NEXT_BLKP(bp));
/* Case 4 */
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);
}
#ifdef NEXT_FIT
/* Make sure the rover isn't pointing into the free block */
/* that we just coalesced */
if ((rover > (char *)bp) && (rover < NEXT_BLKP(bp)))
rover = bp;
#endif
insert_node(bp, size);
return bp;
}
/*
* extend_heap - Extend heap with free block and return its block pointer
*/
static void *extend_heap(size_t words)
{
void *bp;
size_t size;
/* Allocate an even number of words to maintain alignment */
size = (words % 2) ? (words+1) * WSIZE : words * WSIZE;
if ((bp = mem_sbrk(size)) == (void *) -1)
return NULL;
/* Initialize free block header/footer and the epilogue header */
PUT(HDRP(bp), PACK(size, 0)); /* free block header */
PUT(FTRP(bp), PACK(size, 0)); /* free block footer */
PUT(HDRP(NEXT_BLKP(bp)), PACK(0, 1)); /* new epilogue header */
/* Coalesce if the previous block was free */
return coalesce(bp);
}
//
// extend_heap - Extend heap with free block and return its block pointer
//
static void *extend_heap(size_t words)
{
char *bp;
size_t size;
// Allocate an even number of words to maintain alignment
size = (words % 2) ? (words+1) * WSIZE : words * WSIZE;
if ((long)(bp = mem_sbrk(size)) == -1)
return NULL;
// Initilalize free block header/footer and the epilogue header
PUT(HDRP(bp), PACK(size, 0)); // Free block header
PUT(FTRP(bp), PACK(size, 0)); // Free block footer
PUT(HDRP(NEXT_BLKP(bp)), PACK(0,1)); // New epilogue header
// Coalesce if the previous block was free
return coalesce(bp);
}
/**********************************************************
* 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
* The coalesce has four conditions based on
* the neighbours around it
* basically if there is a free neighbour,
* we need to modify the header and footer
* of the left most neightbour to coalesce the new size.
* But as well, since we need to remove the coalesced free
* block from the free list and re add the new larger block
* onto the free list.
**********************************************************/
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 (bp == NULL)
return NULL;
if (prev_alloc && next_alloc) { /* Case 1 */
insertFifoFreeBlock(bp); // Insert onto free list
return bp;
}
else if (prev_alloc && !next_alloc) { /* Case 2 */
size += GET_SIZE(HDRP(NEXT_BLKP(bp)));
delete_from_free (NEXT_BLKP(bp)); // Remove the right block from the free list
PUT(HDRP(bp), PACK(size, 0));
PUT(FTRP(bp), PACK(size, 0));
insertFifoFreeBlock(bp); // Insert onto free list
return (bp);
}
else if (!prev_alloc && next_alloc) { /* Case 3 */
size += GET_SIZE(HDRP(PREV_BLKP(bp)));
delete_from_free (PREV_BLKP(bp)); // Remove the left block from the free list
PUT(FTRP(bp), PACK(size, 0));
PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0));
bp = PREV_BLKP(bp);
insertFifoFreeBlock(bp); // Insert onto free list
return (bp);
}
else { /* Case 4 */
size += GET_SIZE(HDRP(PREV_BLKP(bp))) +
GET_SIZE(FTRP(NEXT_BLKP(bp))) ;
delete_from_free (PREV_BLKP(bp)); // Remove the left block from the free list
delete_from_free (NEXT_BLKP(bp)); // Remove the right block from the free list
PUT(HDRP(PREV_BLKP(bp)), PACK(size,0));
PUT(FTRP(NEXT_BLKP(bp)), PACK(size,0));
bp = PREV_BLKP(bp);
insertFifoFreeBlock(bp); // Insert onto free list
return (bp);
}
}
/**********************************************************
* 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)
{
//printf("IN COALESCE\n");
//printf("coalescing block ptr %p\n",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));
//printf("sizeof size_t %08p\n",sizeof(size_t));
if (prev_alloc && next_alloc) { /* Case 1 */
//printf("case 1\n");
add_to_free_list(bp); //add to the free list
//print_ptr(bp);
return bp;
}
else if (prev_alloc && !next_alloc) { /* Case 2 */
//printf("case 2\n");
size += GET_SIZE(HDRP(NEXT_BLKP(bp)));
remove_free_block(NEXT_BLKP(bp)); //remove the free block from the free list
PUT(HDRP(bp), PACK(size, 0));
PUT(FTRP(bp), PACK(size, 0));
add_to_free_list(bp);
return (bp);
}
else if (!prev_alloc && next_alloc) { /* Case 3 */
//printf("case 3\n");
size += GET_SIZE(HDRP(PREV_BLKP(bp)));
remove_free_block(PREV_BLKP(bp));
PUT(FTRP(bp), PACK(size, 0));
PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0));
add_to_free_list(PREV_BLKP(bp));
//print_ptr(PREV_BLKP(bp));
//print_ptr(bp);
return (PREV_BLKP(bp));
}
else { /* Case 4 */
//printf("case 4\n");
size += GET_SIZE(HDRP(PREV_BLKP(bp)))+GET_SIZE(FTRP(NEXT_BLKP(bp)));
remove_free_block(PREV_BLKP(bp));
remove_free_block(NEXT_BLKP(bp));
PUT(HDRP(PREV_BLKP(bp)), PACK(size,0));
PUT(FTRP(NEXT_BLKP(bp)), PACK(size,0));
add_to_free_list(PREV_BLKP(bp));
//print_ptr(bp);
return (PREV_BLKP(bp));
}
}
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){
return bp;
}
else if (prev_alloc && !next_alloc){
offlist(NEXT_BLKP(bp));
size += GET_SIZE(HDRP(NEXT_BLKP(bp)));
PUT(SUC(NEXT_BLKP(bp)), GET(SUC(bp)));
PUT(HDRP(bp),PACK(size,0));
PUT(FTRP(bp),PACK(size,0));
}
else if (!prev_alloc && next_alloc){
offlist(bp);
size += GET_SIZE(HDRP(PREV_BLKP(bp)));
PUT(SUC(bp), GET(SUC(PREV_BLKP(bp))));
PUT(FTRP(bp),PACK(size,0));
PUT(HDRP(PREV_BLKP(bp)),PACK(size,0));
bp = PREV_BLKP(bp);
}
else {
offlist(bp);
offlist(NEXT_BLKP(bp));
size += GET_SIZE(HDRP(PREV_BLKP(bp))) + GET_SIZE(FTRP(NEXT_BLKP(bp)));
PUT(SUC(NEXT_BLKP(bp)), GET(SUC(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;
}
/* used in realloc */
static void *replace(void *bp, size_t asize)
{
size_t csize = GET_SIZE(HDRP(bp));
if((csize - asize) >= (2 * DSIZE))
{
//contain old block data
PUT(HDRP(bp), PACK(asize, 1));
PUT(FTRP(bp), PACK(asize, 1));
void *p = NEXT_BLKP(bp);
PUT(HDRP(p), PACK((csize - asize), 0));
PUT(FTRP(p), PACK((csize - asize), 0));
add_free(p);
return bp;
}
else return bp; //no action
}
static void place(void *bp, size_t asize)
{
size_t csize = GET_SIZE(HDRP(bp));
if((csize - asize) >= (3*DSIZE))
{
PUT(HDRP(bp), PACK(asize, 1));
PUT(FTRP(bp), PACK(asize , 1));
bp = NEXT_BLKP(bp);
PUT(HDRP(bp), PACK(csize-asize, 0));
PUT(FTRP(bp), PACK(csize-asize, 0));
add_to_group(bp);
}
else
{
PUT(HDRP(bp), PACK(csize, 1));
PUT(FTRP(bp), PACK(csize, 1));
}
}
/*my helper functions*/
static void *extend_heap(size_t words)
{
void *bp;
size_t size;
/* Allocate an even number of words to maintain alignment. */
size = (words % 2) ? (words + 1) * WSIZE : words * WSIZE;
if ((bp = mem_sbrk(size)) == (void *)-1)
{
return (NULL);
}
/* Initialize free block header/footer and the epilogue header. */
PUT(HDRP(bp), PACK(size, 0)); /* Free block header */
PUT(NEXT(bp), 0); /*next address is null*/
PUT(PREV(bp), 0); /*prev address is null*/
PUT(FTRP(bp), PACK(size, 0)); /* Free block footer */
PUT(HDRP(NEXT_BLKP(bp)), PACK(0, 1)); /* New epilogue header */
/* Coalesce if the previous block was free. */
return (coalesce(bp));
}
//将空闲位标志为分配位
static void place(void *bp, size_t asize)
{
size_t csize=GET_SIZE(HDRP(bp));
//如果一个块儿不够
if((csize-asize) >= (2*DSIZE)){
PUT(HDRP(bp), PACK(asize, 1));
PUT(FTRP(bp), PACK(asize, 1));
bp=NEXT_BLKP(bp);
//占用下一个块儿一些空间
PUT( HDRP(bp), PACK(csize-asize, 0) );
PUT( FTRP(bp), PACK(csize-asize, 0) );
}else{
PUT(HDRP(bp), PACK(csize, 1));
PUT(FTRP(bp), PACK(csize, 1));
}
}
/* Decides whether we can split the block, and if so performs the split
by computing leftover block space, deleting shortened allocated block,
and then labeling split free block and coalescing.
Otherwise, just resets size and allocation tags of block and deletes
it from free list. */
static void place(void *bp, size_t asize) {
size_t csize = GET_SIZE(HDRP(bp));
if ((csize - asize) >= MIN_BLOCK_SIZE) {
PUT(HDRP(bp), PACK(asize, 1));
PUT(FTRP(bp), PACK(asize, 1));
deleteBlk(bp);
bp = NEXT_BLKP(bp);
PUT(HDRP(bp), PACK(csize-asize, 0));
PUT(FTRP(bp), PACK(csize-asize, 0));
coalesce(bp);
}
/* Not enoough room to split, simple allocation and free list deletion */
else {
PUT(HDRP(bp), PACK(csize, 1));
PUT(FTRP(bp), PACK(csize, 1));
deleteBlk(bp);
}
}
/* Extends the heap by asking for more space, and reassigning pointers
accordingly. */
static void *extend_heap(size_t words) {
char *bp;
size_t size;
size = (words % 2) ? (words+1) * WSIZE : words * WSIZE;
if (size < MIN_BLOCK_SIZE) {
size = MIN_BLOCK_SIZE;
}
if ((long)(bp = mem_sbrk(size)) == -1)
return NULL;
/* Initialize free block header/footer and the epilogue header */
PUT(HDRP(bp), PACK(size, 0)); /* Free block header */
PUT(FTRP(bp), PACK(size, 0)); /* Free block footer */
PUT(HDRP(NEXT_BLKP(bp)), PACK(0, 1));
return coalesce(bp);
}
static void *extend_heap(size_t words)
{
char *ptr;
size_t size;
/* Allocate an even number of words to maintain alignment */
size = (words % 2) ? (words+1) * SWORD : words * SWORD;
if ((long)(ptr = mem_sbrk(size)) == -1)
return NULL;
/* Initialize free block header/footer and the epilogue header */
PUT(HDRP(ptr), PACK(size, 0)); /* Free block header */
PUT(FTRP(ptr), PACK(size, 0)); /* Free block footer */
PUT(HDRP(NEXT_BLKP(ptr)), PACK(0, 1)); /* New epilogue header */
/* Coalesce if the previous block was free */
printf("Before coalesce\n");
return coalesce(ptr);
}
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;
}
void place(void *bp, size_t asize)
/* $end mmplace-proto */
{
size_t csize = GET_SIZE(HDRP(bp));
int k=in_heap(bp);
printf("some %d useless\n",k);
if ((csize - asize) >= (2*DSIZE)) {
PUT(HDRP(bp), PACK(asize, 1));
PUT(FTRP(bp), PACK(asize, 1));
bp = NEXT_BLKP(bp);
PUT(HDRP(bp), PACK(csize-asize, 0));
PUT(FTRP(bp), PACK(csize-asize, 0));
}
else {
PUT(HDRP(bp), PACK(csize, 1));
PUT(FTRP(bp), PACK(csize, 1));
}
}
static void place(void *bp, size_t size){
size_t totalsize = GET_SIZE(HDRP(bp));
if((totalsize - size) >= OVERHEAD){
PUT(HDRP(bp), PACK(size, 1));
PUT(FTRP(bp), PACK(size, 1));
mm_remove(bp);
bp = NEXT_BLKP(bp);
PUT(HDRP(bp), PACK(totalsize - size, 0));
PUT(FTRP(bp), PACK(totalsize - size, 0));
coalesce(bp);
}
else{
PUT(HDRP(bp), PACK(totalsize, 1));
PUT(FTRP(bp), PACK(totalsize, 1));
mm_remove(bp);
}
}
/*
* coalesce
* coalesce consecutive free blocks
* use hdr and ftr to do constant time coalesce
*/
void *coalesce(void *bp){
size_t prev_alloc = GET(FTRP(PREV_BLKP(bp))) & 0x1;
size_t next_alloc = GET_ALLOC(NEXT_BLKP(bp));
if(prev_alloc && next_alloc){
/* prev/next blocks are not free */
}else if(prev_alloc && !next_alloc){
/* next block is free */
coalesce_next(bp);
}else if(!prev_alloc && next_alloc){
/* prev block is free */
bp = PREV_BLKP(bp);
coalesce_next(bp);
}else{
coalesce_next(bp);
bp = PREV_BLKP(bp);
coalesce_next(bp);
}
return bp;
}
/**********************************************************
* extend_heap
* Extend the heap by "words" words, maintaining alignment
* requirements of course. Free the former epilogue block
* and reallocate its new header
**********************************************************/
void *extend_heap(size_t words) {
char *bp;
size_t size;
/* Allocate an even number of words to maintain alignments */
size = (words % 2) ? (words + 1) * WSIZE : words * WSIZE;
if ((bp = mem_sbrk(size)) == (void *) - 1)
return NULL;
/* Initialize free block header/footer and the epilogue header */
PUT(HDRP(bp), PACK(size, 0)); // free block header
PUT(FTRP(bp), PACK(size, 0)); // free block footer
PUT(HDRP(NEXT_BLKP(bp)), PACK(0, 1)); // new epilogue header
// we do not coalesce at the end for better binary malloc case
return 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");
}
/**********************************************************
* coalesce (Immediate Coalescing)
* 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
* based on these cases, we removed the coalesced blocks and
* re-insert into the free lists
**********************************************************/
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) { /* Case 1 */
//add to free list
insertToFreeList(bp);
return bp;
} else if (prev_alloc && !next_alloc) { /* Case 2 */
//remove that one from free list
removeFromFreeList(NEXT_BLKP(bp));
size += GET_SIZE(HDRP(NEXT_BLKP(bp)));
PUT(HDRP(bp), PACK(size, 0));
PUT(FTRP(bp), PACK(size, 0));
//add the new block to free list
insertToFreeList(bp);
return (bp);
} else if (!prev_alloc && next_alloc) { /* Case 3 */
//remove that one from free list
removeFromFreeList(PREV_BLKP(bp));
size += GET_SIZE(HDRP(PREV_BLKP(bp)));
PUT(FTRP(bp), PACK(size, 0));
PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0));
//add the new block to free list
insertToFreeList(PREV_BLKP(bp));
return (PREV_BLKP(bp));
} else { /* Case 4 */
//remove that one from free list
removeFromFreeList(NEXT_BLKP(bp));
removeFromFreeList(PREV_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));
//add the new block to free list
insertToFreeList(PREV_BLKP(bp));
return (PREV_BLKP(bp));
}
}
/*
* Requires:
* words: the number of words to increase the heap by
* next: next pointer at the end of the linked list, to be set to the
header of the new block
* Effects:
* Extend the heap with a free block and return that block's address.
*/
static void *
extend_heap(size_t words)
{
size_t size;
void *bp;
/* Allocate an even number of words to maintain alignment. */
size = (words % 2) ? (words + 1) * WSIZE : words * WSIZE;
if ((bp = mem_sbrk(size)) == (void *)-1)
return (NULL);
printf("Before extended block is added to the free list\n");
checkheap(1);
/* Initialize the new node pointers, next precedes previous */
/* The previous point points to the header of the previous block*/
/*PUT(bp, NULL);
PUT(bp + WSIZE, HDRP(next));*/
/* Initialize free block header/footer and the epilogue header. */
PUT(HDRP(bp), PACK(size, 0)); /* Free block header */
PUT(FTRP(bp), PACK(size, 0)); /* Free block footer */
PUT(HDRP(NEXT_BLKP(bp)), PACK(0, 1)); /* New epilogue header */
/* If list start is NULL, initialize the start to the pointer to the
* added block
*/
if (list_start == NULL) {
list_start = (struct node *)bp;
list_start->next = list_start;
list_start->previous = list_start;
}
printf("For isolation\n");
add_to_front(bp);
printf("After extended block is added to the free list\n");
checkheap(1);
printf("Entering coalesce from extend_heap\n");
/* Coalesce if the previous block was free. */
return (coalesce(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);
}
/**********************************************************
* extend_heap
* Extend the heap by "words" words, maintaining alignment
* requirements of course. Free the former epilogue block
* and reallocate its new header
**********************************************************/
void *extend_heap(size_t words) {
intptr_t *bp;
size_t size;
/* Allocate an even number of words to maintain alignments */
size = (words % 2) ? (words + 1) * WSIZE : words * WSIZE;
if ((bp = mem_sbrk(size)) == (void *) -1)
return NULL;
/* Initialize free block header/footer and the epilogue header */
PUT(HDRP(bp), PACK(size, 0)); // free block header
PUT(FTRP(bp), PACK(size, 0)); // free block footer
PUT(HDRP(NEXT_BLKP(bp)), PACK(0, 1)); // new epilogue header
/* Coalesce if the previous block was free */
// Trade-off between util and thru
// bp = coalesce(bp);
return bp;
}
/**
* 将请求块放置在空闲块的起始位置，当剩余部分大于等于最小块的大小时进行分割操作
*
* @param bp 指向free list中一个size大于asize字节的block
*/
static void place(void *bp, size_t asize)
{
size_t bsize = GET_SIZE(HDRP(bp));
size_t diff_size = bsize - asize;
if (diff_size >= MIN_BLK) {
/* 请求块防止在空闲块的起始位置 */
PUT(HDRP(bp), PACK(asize, 1));
PUT(FTRP(bp), PACK(asize, 1)); /* 此处FTRP的GET_SIZE取到的是上面的asize */
/* 多余的部分进行分割 */
bp = NEXT_BLKP(bp);
PUT(HDRP(bp), PACK(diff_size, 0));
PUT(FTRP(bp), PACK(diff_size, 0));
} else {
PUT(HDRP(bp), PACK(bsize, 1));
PUT(FTRP(bp), PACK(bsize, 1));
}
}
static void *extend_heap(size_t words) {
char *bp;
size_t size;
/* Allocate an even number of words to maintain alignment */
size = (words % 2) ? (words + 1) * WSIZE : words * WSIZE;
/* call for more memory space */
if ((bp = mem_sbrk(size)) == (void *)-1)
return (NULL);
/* Initialize free block header/footer and the epilogue header */
SET_HDRP(bp, PACK(size, 0)); /* free block header */
SET_FTRP(bp, PACK(size, 0)); /* free block footer */
SET_HDRP(NEXT_BLKP(bp), PACK(0, 1)); /* new epilogue header */
/* coalesce bp with next and previous blocks */
return coalesce(bp);
}
/*
* Requires:
* "bp" is the address of a free block that is at least "asize" bytes.
*
* Effects:
* Place a block of "asize" bytes at the start of the free block "bp" and
* split that block if the remainder would be at least the minimum block
* size.
*/
static void
place(void *bp, size_t asize)
{
size_t csize = GET_SIZE(HDRP(bp));
if ((csize - asize) >= (MINBLOCKSIZE)) {
PUT(HDRP(bp), PACK(asize, 1));
PUT(FTRP(bp), PACK(asize, 1));
removeBlockFromList(bp);
bp = NEXT_BLKP(bp);
PUT(HDRP(bp), PACK(csize - asize, 0));
PUT(FTRP(bp), PACK(csize - asize, 0));
coalesce(bp);
} else {
PUT(HDRP(bp), PACK(csize, 1));
PUT(FTRP(bp), PACK(csize, 1));
removeBlockFromList(bp);
}
}
static void place(void *bp, size_t asize)
{
size_t csize = GET_SIZE(HDRP(bp));
if ((csize - asize) >= (2 * DSIZE))
{
LLrem(bp);
PUT(HDRP(bp), PACK(asize, 1));
PUT(FTRP(bp), PACK(asize, 1));
bp = NEXT_BLKP(bp);
PUT(HDRP(bp), PACK(csize - asize, 0));
PUT(FTRP(bp), PACK(csize - asize, 0));
coalesce(bp);
}
else
{
LLrem(bp);
PUT(HDRP(bp), PACK(csize, 1));
PUT(FTRP(bp), PACK(csize, 1));
}
}