AISE/malloc-lab
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Modified helper functions

Browse Source
This commit is contained in:
anna_schlittenhardt
2021-01-24 21:18:50 +01:00
parent b1a5273123
commit 31028203d8
1 changed files with 55 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
mm.c
View File

@@ -133,18 +133,18 @@ static void add_free(void* bp, size_t asize);
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
static void *extend_heap(size_t size) static void *extend_heap(size_t size)
{ {
void *ptr; size_t asize;
size_t asize; // Adjusted size
asize = ALIGN(size); asize = ALIGN(size);
void *ptr;
if ((ptr = mem_sbrk(asize)) == (void *)-1) if ((ptr = mem_sbrk(asize)) == (void *)-1)
return NULL; return NULL;
// Set headers and footer /* Set Header and Footer*/
PUTT(HDRP(ptr), PACK(asize, 0)); PUTT(HDRP(ptr), PACK(asize, 0));
PUTT(FTRP(ptr), PACK(asize, 0)); PUTT(FTRP(ptr), PACK(asize, 0));
PUTT(HDRP(NEXT_BLKP(ptr)), PACK(0, 1)); PUTT(HDRP(NEXT_BLKP(ptr)), PACK(0, 1));
add_free(ptr, asize); add_free(ptr, asize);
return coalesce(ptr); return coalesce(ptr);
@@ -152,77 +152,72 @@ static void *extend_heap(size_t size)
static void add_free(void *ptr, size_t size) { static void add_free(void *ptr, size_t size) {
int list = 0; int list = 0;
void *search_ptr = ptr; void *searching_ptr = ptr;
void *insert_ptr = NULL; void *in_ptr = NULL;
// Select segregated list /* Select List*/
while ((list < LISTSIZE - 1) && (size > 1)) { while ((list < LISTSIZE - 1) && (size > 1)) {
size >>= 1; size >>= 1;
list++; list++;
} }
// Keep size ascending order and search /* Search in size-ascending order*/
search_ptr = seg_list[list]; searching_ptr = seg_list[list];
while ((search_ptr != NULL) && (size > GET_SIZE(HDRP(search_ptr)))) { while ((searching_ptr != NULL) && (size > GET_SIZE(HDRP(searching_ptr)))) {
insert_ptr = search_ptr; in_ptr = searching_ptr;
search_ptr = PRV_BLK(search_ptr); searching_ptr = PRV_BLK(searching_ptr);
} }
// Set predecessor and successor /* Set previous and next*/
if (search_ptr != NULL) { if (searching_ptr != NULL && in_ptr != NULL) {
if (insert_ptr != NULL) { PUT_PTR(NXT_PTR(searching_ptr), ptr);
PUT_PTR(PRV_PTR(ptr), search_ptr); PUT_PTR(NXT_PTR(ptr), in_ptr);
PUT_PTR(NXT_PTR(search_ptr), ptr); PUT_PTR(PRV_PTR(ptr), searching_ptr);
PUT_PTR(NXT_PTR(ptr), insert_ptr); PUT_PTR(PRV_PTR(in_ptr), ptr);
PUT_PTR(PRV_PTR(insert_ptr), ptr); }
} else { else if (searching_ptr != NULL && in_ptr == NULL) {
PUT_PTR(PRV_PTR(ptr), search_ptr); PUT_PTR(PRV_PTR(ptr), searching_ptr);
PUT_PTR(NXT_PTR(search_ptr), ptr); PUT_PTR(NXT_PTR(searching_ptr), ptr);
PUT_PTR(NXT_PTR(ptr), NULL); PUT_PTR(NXT_PTR(ptr), NULL);
seg_list[list] = ptr; seg_list[list] = ptr;
} }
} else { else if(searching_ptr == NULL && in_ptr != NULL) {
if (insert_ptr != NULL) { PUT_PTR(NXT_PTR(ptr), in_ptr);
PUT_PTR(PRV_PTR(ptr), NULL); PUT_PTR(PRV_PTR(ptr), NULL);
PUT_PTR(NXT_PTR(ptr), insert_ptr); PUT_PTR(PRV_PTR(in_ptr), ptr);
PUT_PTR(PRV_PTR(insert_ptr), ptr); }
} else { else {
PUT_PTR(PRV_PTR(ptr), NULL); PUT_PTR(NXT_PTR(ptr), NULL);
PUT_PTR(NXT_PTR(ptr), NULL); PUT_PTR(PRV_PTR(ptr), NULL);
seg_list[list] = ptr; seg_list[list] = ptr;
}
} }
return; return;
} }
static void delete_node(void *ptr) { static void remove_free(void *ptr) {
int list = 0; int list = 0;
size_t size = GET_SIZE(HDRP(ptr)); size_t size = GET_SIZE(HDRP(ptr));
// Select segregated list /* Select List*/
while ((list < LISTSIZE - 1) && (size > 1)) { while ((list < LISTSIZE - 1) && (size > 1)) {
size >>= 1; size >>= 1;
list++; list++;
} }
if (PRV_BLK(ptr) != NULL) { if (PRV_BLK(ptr) != NULL && NXT_BLK(ptr) != NULL) {
if (NXT_BLK(ptr) != NULL) { PUT_PTR(NXT_PTR(PRV_BLK(ptr)), NXT_BLK(ptr));
PUT_PTR(NXT_PTR(PRV_BLK(ptr)), NXT_BLK(ptr)); PUT_PTR(PRV_PTR(NXT_BLK(ptr)), PRV_BLK(ptr));
PUT_PTR(PRV_PTR(NXT_BLK(ptr)), PRV_BLK(ptr)); } else if(PRV_BLK(ptr) != NULL && NXT_BLK(ptr) == NULL) {
} else { PUT_PTR(NXT_PTR(PRV_BLK(ptr)), NULL);
PUT_PTR(NXT_PTR(PRV_BLK(ptr)), NULL); seg_list[list] = PRV_BLK(ptr);
seg_list[list] = PRV_BLK(ptr); }
} else if(PRV_BLK(ptr) == NULL && NXT_BLK(ptr) != NULL) {
PUT_PTR(PRV_PTR(NXT_BLK(ptr)), NULL);
} else { } else {
if (NXT_BLK(ptr) != NULL) { seg_list[list] = NULL;
PUT_PTR(PRV_PTR(NXT_BLK(ptr)), NULL); }
} else {
seg_list[list] = NULL;
}
}
return; return;
} }
@@ -238,22 +233,22 @@ static void *coalesce(void *ptr)
return ptr; return ptr;
} }
else if (prev_alloc && !next_alloc) { // Case 2 else if (prev_alloc && !next_alloc) { // Case 2
delete_node(ptr); remove_free(ptr);
delete_node(NEXT_BLKP(ptr)); remove_free(NEXT_BLKP(ptr));
size += GET_SIZE(HDRP(NEXT_BLKP(ptr))); size += GET_SIZE(HDRP(NEXT_BLKP(ptr)));
PUT(HDRP(ptr), PACK(size, 0)); PUT(HDRP(ptr), PACK(size, 0));
PUT(FTRP(ptr), PACK(size, 0)); PUT(FTRP(ptr), PACK(size, 0));
} else if (!prev_alloc && next_alloc) { // Case 3 } else if (!prev_alloc && next_alloc) { // Case 3
delete_node(ptr); remove_free(ptr);
delete_node(PREV_BLKP(ptr)); remove_free(PREV_BLKP(ptr));
size += GET_SIZE(HDRP(PREV_BLKP(ptr))); size += GET_SIZE(HDRP(PREV_BLKP(ptr)));
PUT(FTRP(ptr), PACK(size, 0)); PUT(FTRP(ptr), PACK(size, 0));
PUT(HDRP(PREV_BLKP(ptr)), PACK(size, 0)); PUT(HDRP(PREV_BLKP(ptr)), PACK(size, 0));
ptr = PREV_BLKP(ptr); ptr = PREV_BLKP(ptr);
} else { // Case 4 } else { // Case 4
delete_node(ptr); remove_free(ptr);
delete_node(PREV_BLKP(ptr)); remove_free(PREV_BLKP(ptr));
delete_node(NEXT_BLKP(ptr)); remove_free(NEXT_BLKP(ptr));
size += GET_SIZE(HDRP(PREV_BLKP(ptr))) + GET_SIZE(HDRP(NEXT_BLKP(ptr))); size += GET_SIZE(HDRP(PREV_BLKP(ptr))) + GET_SIZE(HDRP(NEXT_BLKP(ptr)));
PUT(HDRP(PREV_BLKP(ptr)), PACK(size, 0)); PUT(HDRP(PREV_BLKP(ptr)), PACK(size, 0));
PUT(FTRP(NEXT_BLKP(ptr)), PACK(size, 0)); PUT(FTRP(NEXT_BLKP(ptr)), PACK(size, 0));
@@ -270,7 +265,7 @@ static void *place(void *ptr, size_t asize)
size_t ptr_size = GET_SIZE(HDRP(ptr)); size_t ptr_size = GET_SIZE(HDRP(ptr));
size_t remainder = ptr_size - asize; size_t remainder = ptr_size - asize;
delete_node(ptr); remove_free(ptr);
if (remainder <= DSIZE * 2) { if (remainder <= DSIZE * 2) {