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