/*
* 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);
}
}
static void place(void *bp, size_t asize) {
//dbg_printf("place%p\n",bp);
size_t csize = GET_SIZE(HDRP(bp));
// void *remain_blk;
size_t remain_size=csize-asize;
if ((remain_size) >= 16) {
void *remain_blk;
delete_free_block(bp);
// size_t predoff=get_pred_offset(bp);
// size_t succoff=get_succ_offset(bp);
alloc_block(bp,asize);
remain_blk= NEXT_BLKP(bp);
PUT(HDRP(remain_blk), PACK(remain_size, 0));
PUT(FTRP(remain_blk), PACK(remain_size, 0));
add_free_block(remain_blk,remain_size);
/*size_t re_off=get_offset(remain_blk);
set_succ(remain_blk,succoff);
set_pred(remain_blk,predoff);
// if (predoff){
set_succ(get_addr(predoff),re_off);
// }
// else free_list=remain_blk;
if (succoff){
set_pred(get_addr(succoff),re_off);
}*/
}
else {
delete_free_block(bp);
PUT(HDRP(bp), PACK(csize, 1));
PUT(FTRP(bp), PACK(csize, 1));
}
}
//Coalesce two free blocks into one, add to free list
static void *coalesce(void *bp) //bp is pointer to a free block
{
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){
//fwdPointers(NEXT_BLKP(bp), MINFRAG);
size += GET_SIZE(HDRP(NEXT_BLKP(bp)));
delete_free_block(NEXT_BLKP(bp));
PUT(HDRP(bp), PACK(size, 0));
PUT(FTRP(bp), PACK(size, 0));
}
else if(!prev_alloc && next_alloc){
//fwdPointers(PREV_BLKP(bp), MINFRAG); //if desperate we can leave this in free list
size += GET_SIZE(HDRP(PREV_BLKP(bp)));
delete_free_block(PREV_BLKP(bp));
PUT(FTRP(bp), PACK(size, 0));
PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0));
bp = PREV_BLKP(bp);
}
else if(!prev_alloc && !next_alloc) {
//fwdPointers(PREV_BLKP(bp), MINFRAG);
//fwdPointers(NEXT_BLKP(bp), MINFRAG);
delete_free_block(NEXT_BLKP(bp));
delete_free_block(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));
bp = PREV_BLKP(bp);
}
moveStart(bp);
return bp;
}
//Called by mm_alloc, places
void place (void *bp, size_t asize){
size_t size = GET_SIZE(HDRP(bp));
size_t frag = size - asize;
//internal fragment
if (frag < MINBLKSIZE){
PUT(HDRP(bp), PACK(size, 1));
PUT(FTRP(bp), PACK(size, 1));
delete_free_block(bp); //remove allocated block from free list
// fwdPointers(bp, frag); //Reassigns pointers
}
//external fragment
else{
PUT(HDRP(bp), PACK(asize, 1));
PUT(FTRP(bp), PACK(asize, 1));
//fwdPointers(bp, frag);
delete_free_block(bp);
bp = NEXT_BLKP(bp); //Move pointer to next block
PUT(HDRP(bp), PACK(frag, 0));
PUT(FTRP(bp), PACK(frag, 0));
coalesce(bp);
// moveStart(bp);
}
}
static void place(void *ptr, size_t size)
{
mm_log("placing at %p, size %d\n", ptr, (int)size);
size_t free_size = GET_SIZE(HDRP(ptr));
size_t rem = free_size - size;
if (rem < DSIZE+WSIZE*2)
{
size = free_size;
}
/* Delete from the freelist */
delete_free_block(ptr);
PUT(HDRP(ptr), PACK(size, 1));
PUT(FTRP(ptr), PACK(size, 1));
mm_log("header = (%d,%d)\n", GET_SIZE(HDRP(ptr)), GET_ALLOC(HDRP(ptr)));
mm_log("footer = (%d,%d)\n", GET_SIZE(FTRP(ptr)), GET_ALLOC(FTRP(ptr)));
/* See if we should split */
if (size != free_size)
{
void *split_pt = ptr + size;
init_free_block(split_pt, free_size-size);
}
}
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 */
dbg_printf("no coal%p\n",bp);
add_free_block(bp,size);
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,size);
return bp;
}
/* $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 place(void *bp, size_t asize){
size_t osize=GET_SIZE(bp);
size_t remain_size=osize-asize;
// size_t old_predaddr=pred_blka(bp);
// size_t old_succaddr=succ_blka(bp);
void *remain_block=(char *)bp+asize;
if (remain_size>=16){
delete_free_block(bp);
set_free_block(remain_block,remain_size,0);
add_free_block(remain_block);
}
else{
delete_free_block(bp);
}
alloc_block(bp,asize);
}
/*
* 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;
}
/*
* mm_realloc - Implemented simply in terms of mm_malloc and mm_free
*/
void *mm_realloc(void *ptr, size_t req_size)
{
size_t new_size = adjust_requested_block_size(req_size);
size_t size = GET_SIZE(HDRP(ptr));
mm_log("\nrealloc(%p, %d => %d)\noriginal=%d\n\n", ptr, (int)req_size, (int)new_size, (int)size);
if (new_size < size)
{
mm_log("newsize < original! keep pointer.\n");
size_t remain = size - new_size;
if (remain >= DSIZE+WSIZE*2)
{
PUT(HDRP(ptr), PACK(new_size, 1));
PUT(FTRP(ptr), PACK(new_size, 1));
mm_log("have some leftover (%d), which is enough for a new block.\n",(int)remain);
//split
void *split_pt = ptr + new_size;
init_free_block(split_pt, remain);
}
return ptr;
}
/* Okay, we need to find some new space. See if there are adjacent blocks we can coalesce into */
void *new_ptr;
void *prev_ftr = ptr - DSIZE;
void *next_hdr = ptr + size - WSIZE;
size_t extra_space = 0;
char c_prev = 0;
char c_next = 0;
if (!GET_ALLOC(prev_ftr))
{
extra_space += GET_SIZE(prev_ftr);
c_prev = 1;
}
if (!GET_ALLOC(next_hdr))
{
extra_space += GET_SIZE(next_hdr);
c_next = 1;
}
size_t coalesced_size = extra_space + size;
if (coalesced_size >= new_size)
{
mm_log("prev open = %d; next open = %d. together with %d, we have %d total space.\n",c_prev,c_next,(int)size,(int)coalesced_size);
new_ptr = ptr;
if (c_prev)
{
new_ptr -= GET_SIZE(prev_ftr); //move ptr back to prev block
delete_free_block(new_ptr);
memcpy(new_ptr, ptr, size);
}
if (c_next)
{
delete_free_block(ptr + size);
}
/* We can now see if there's enough room to split another block */
size_t remain = coalesced_size - new_size;
if (remain >= DSIZE+WSIZE*2)
{
PUT(HDRP(new_ptr), PACK(new_size, 1));
PUT(FTRP(new_ptr), PACK(new_size, 1));
mm_log("have some leftover (%d), which is enough for a new block.\n",(int)remain);
//split
void *split_pt = new_ptr + new_size;
init_free_block(split_pt, remain);
}
else
{
PUT(HDRP(new_ptr), PACK(coalesced_size, 1));
PUT(FTRP(new_ptr), PACK(coalesced_size, 1));
}
return new_ptr;
}
mm_log("can't coalesce. have to malloc new & free this thing\n");
/* Can't coalesce. Have to malloc new & free this block :( */
new_ptr = mm_malloc(req_size);
memcpy(new_ptr, ptr, size);
init_free_block(ptr, size);
return new_ptr;
}
static void *init_free_block(void *bp, size_t size)
{
mm_log("\ninit free block %p of size %d\n", bp, (int)size);
void *next = bp + size;
void *prev = bp - GET_SIZE(bp - DSIZE);
int prev_alloc = GET_ALLOC(HDRP(prev));
int next_alloc = GET_ALLOC(HDRP(next));
size_t prev_size = GET_SIZE(HDRP(prev));
size_t next_size = GET_SIZE(HDRP(next));
mm_log("prev = %p (%d,%d); next = %p (%d,%d)\n", prev, (int)prev_size, prev_alloc, next, (int)next_size, next_alloc);
if (prev_alloc && next_alloc) /* Case 1 */
{
PUT(HDRP(bp), PACK(size, 0));
PUT(FTRP_S(bp, size), PACK(size, 0));
append_free_block(bp);
}
else if (prev_alloc && !next_alloc) /* Case 2 */
{
int new_size = size + next_size;
mm_log("coalesce next %p (%d) to make %d\n", next, (int)next_size, (int)new_size);
delete_free_block(next);
append_free_block(bp);
PUT(HDRP(bp), PACK(new_size, 0));
PUT(FTRP_S(bp, new_size), PACK(new_size, 0));
}
else if (!prev_alloc && next_alloc) /* Case 3 */
{
size_t new_size = size + prev_size;
mm_log("coalesce prev %p (%d) to make %d\n", prev, (int)prev_size, (int)new_size);
PUT(HDRP(prev), PACK(new_size, 0)); /* Resize header of prev */
PUT(FTRP_S(prev, new_size), PACK(new_size, 0)); /* Resize footer */
bp = prev;
}
else /* Case 4 */
{
size_t new_size = size + prev_size + next_size;
mm_log("coalesce both prev %p (%d) and next %p (%d) to make %d\n", prev, (int)prev_size, next, (int)next_size, (int)new_size);
/* Delete both prev blocks off the list; then append this new block */
delete_free_block(prev);
delete_free_block(next);
mm_log("deleted %p and %p. tail=%p\n",prev,next,free_tailp);
PUT(HDRP(prev), PACK(new_size, 0));
PUT(FTRP_S(next, next_size), PACK(new_size, 0));
bp = prev;
append_free_block(bp);
}
ASSERT;
return bp;
}
