Skip to content

M
MallocProject
Commit 04d718ae authored by Vadapalli K Chaitanya's avatar Vadapalli K Chaitanya
Browse files
Options

Update mm2.c

parent 9694c78f
Show whitespace changes
Inline Side-by-side
Showing with 560 additions and 112 deletions
mm2.c
View file @ 04d718ae
......@@ -16,7 +16,6 @@
#include <string.h>
#include<stddef.h>
#include<stdint.h>
#include "mm.h"
#include "memlib.h"
......@@ -26,15 +25,15 @@
********************************************************/
team_t team = {
/* Team name */
"segmentation_fault",
"team name",
/* First member's full name */
"member 1",
/* First member's email address */
"member_1@cse.iitb.ac.in",
/* Second member's full name (leave blank if none) */
"shivaji chirumamilla",
"member 2",
/* Second member's email address (leave blank if none) */
"shivaji@cse.iitb.ac.in"
"member_2@cse.iitb.ac.in"
};
typedef struct tree_node_
......@@ -73,6 +72,7 @@ uint32_t block_size;
} block_end_meta_data_t;
int c=0;
#define NEXT_META_BLOCK_BY_SIZE(block_meta_data_ptr) \
(block_meta_data_t *)((char *)(block_meta_data_ptr)+ALIGN(sizeof(block_meta_data_t)) \
......@@ -86,10 +86,6 @@ uint32_t block_size;
if(free_meta_block->next_block) \
free_meta_block->next_block->prev_block=free_meta_block
#define offsetof(struct_name,field_name) \
(unsigned int)&((struct_name *)0)->field_name
#define meta_data_block_addr(free_node_addr) \
(block_meta_data_t *) ((char *)(free_node_addr)-offsetof(block_meta_data_t,tree_node))
......@@ -147,6 +143,9 @@ void *init_mem_sbrk_break = NULL;
tree_node_t **root=NULL;
void LL_rotate(tree_node_t *parent,tree_node_t *node)
{
......@@ -188,6 +187,11 @@ void LL_rotate(tree_node_t *parent,tree_node_t *node)
parent->parent_node=temp;
parent->left_node=temp_right;
if(temp_right!=NULL)
{
temp_right->parent_node=parent;
}
}
......@@ -204,6 +208,7 @@ void LR_Rotate(tree_node_t *parent,tree_node_t *node)
tree_node_t *node_right=node->right_node;
if(p_parent==NULL)
{
*root=node;
......@@ -231,17 +236,29 @@ void LR_Rotate(tree_node_t *parent,tree_node_t *node)
node->left_node=temp;
temp->parent_node=node;
parent->left_node=node_right;
if(node_right!=NULL)
{
node_right->parent_node=parent;
}
temp->right_node=node_left;
if(node_left!=NULL)
{
node_left->parent_node=temp;
}
}
void RR_Rotate(tree_node_t *parent,tree_node_t *node)
{
printf("Came to RR\n");
printf("Came to RR1\n");
tree_node_t *p_parent=parent->parent_node;
tree_node_t *temp=parent->right_node;
tree_node_t *temp_left=temp->left_node;
if(p_parent==NULL)
{
*root=temp;
......@@ -249,14 +266,13 @@ void RR_Rotate(tree_node_t *parent,tree_node_t *node)
}
else
{
temp->parent_node=p_parent;
block_meta_data_t *p_parent_meta_data=meta_data_block_addr(p_parent);
block_meta_data_t *temp_meta_data=meta_data_block_addr(temp);
if(temp_meta_data->block_size<=p_parent_meta_data->block_size)
if(temp_meta_data->block_size<=p_parent_meta_data->block_size&&p_parent->left_node==NULL)
{
p_parent->left_node=temp;
}
......@@ -264,11 +280,20 @@ void RR_Rotate(tree_node_t *parent,tree_node_t *node)
{
p_parent->right_node=temp;
}
}
temp->left_node=parent;
parent->parent_node=temp;
parent->right_node=temp_left;
if(temp_left!=NULL)
{
temp_left->parent_node=parent;
}
}
......@@ -277,7 +302,7 @@ void RL_Rotate(tree_node_t *parent,tree_node_t *node)
printf("Came to RL\n");
tree_node_t *p_parent=parent->parent_node;
tree_node_t *temp=parent->right_node;
tree_node_t *temp_right=temp->right_node;
//tree_node_t *temp_right=temp->right_node;
tree_node_t *node_left=node->left_node;
tree_node_t *node_right=node->right_node;
......@@ -294,7 +319,7 @@ void RL_Rotate(tree_node_t *parent,tree_node_t *node)
block_meta_data_t *node_meta_data=meta_data_block_addr(node);
if(node_meta_data->block_size<=p_parent_meta_data->block_size)
if(node_meta_data->block_size<=p_parent_meta_data->block_size&&p_parent->left_node==NULL)
{
p_parent->left_node=node;
}
......@@ -310,91 +335,230 @@ void RL_Rotate(tree_node_t *parent,tree_node_t *node)
node->right_node=temp;
temp->parent_node=node;
parent->right_node=node_right;
if(node_right!=NULL)
{
node_right->parent_node=parent;
}
temp->left_node=node_left;
if(node_left!=NULL)
{
node_left->parent_node=temp;
}
}
void rotate(tree_node_t *parent,tree_node_t *node)
int getHeight(tree_node_t *node)
{
block_meta_data_t *parent_meta_data=meta_data_block_addr(parent);
if(node==NULL)
{
return 0;
}
int left_height=getHeight(node->left_node);
int right_height=getHeight(node->right_node);
block_meta_data_t *node_meta_data=meta_data_block_addr(node);
if(parent_meta_data->block_size<node_meta_data->block_size)
return 1+(left_height>=right_height?left_height:right_height);
}
int get_balance(tree_node_t *node)
{
if(node!=NULL)
{
tree_node_t *temp=parent->right_node;
block_meta_data_t *temp_meta_data=meta_data_block_addr(temp);
int left_height=getHeight(node->left_node);
int right_height=getHeight(node->right_node);
if(temp_meta_data->block_size<node_meta_data->block_size)
return (left_height-right_height);
}
return 0;
}
void printLevelOrder(tree_node_t* head)
{
if(c==122)
{
RR_Rotate(parent,node);
printf("Came to level order\n");
}
else
int h = getHeight(head);
if(c==122)
{
RL_Rotate(parent,node);
printf("Came to level order\n");
}
int i;
for (i=1; i<=h; i++)
{
printGivenLevel(head, i);
printf("\n");
}
}
else
void remove_cycles(tree_node_t *head)
{
int h = getHeight(head);
int i;
for (i=1; i<=h; i++)
{
remove_cycles_by_level(head,i);
}
}
tree_node_t *temp=parent->left_node;
block_meta_data_t *temp_meta_data=meta_data_block_addr(temp);
void remove_cycles_1(tree_node_t *head)
{
if(head==NULL)
{
return;
}
if(head->left_node==head)
{
head->left_node=NULL;
}
if(temp_meta_data->block_size<node_meta_data->block_size)
if(head->right_node==head)
{
inorderTraversal(*root);
LR_Rotate(parent,node);
head->right_node=NULL;
}
remove_cycles_1(head->left_node);
remove_cycles_1(head->right_node);
}
int find_node_in_tree(tree_node_t *head,tree_node_t *node)
{
if(head==node)
{
return 1;
}
else
{
LL_rotate(parent,node);
int b1=0;
int b2=0;
if(head->left_node!=NULL)
{
b1=find_node_in_tree(head->left_node,node);
}
if(head->right_node!=NULL)
{
b2=find_node_in_tree(head->right_node,node);
}
return (b1||b2);
}
}
int getHeight(tree_node_t *node)
void remove_cycles_by_level(tree_node_t* head,int level)
{
if(node==NULL)
if (head == NULL)
{
return 0;
return;
}
if(level==1)
{
//block_meta_data_t *meta_data=meta_data_block_addr(head);
//block_meta_data_t *parent_meta_data=meta_data_block_addr(parent);
if(head->left_node==head)
{
head->left_node=NULL;
}
if(head->right_node==head)
{
head->right_node=NULL;
}
}
else if(level>1)
{
remove_cycles_by_level(head->left_node,level-1);
remove_cycles_by_level(head->right_node,level-1);
}
int left_height=getHeight(node->left_node);
int right_height=getHeight(node->right_node);
return 1+(left_height>=right_height?left_height:right_height);
}
int get_balance(tree_node_t *node)
void set_mappings(tree_node_t *head)
{
if(node!=NULL)
int h = getHeight(head);
int i;
for (i=1; i<=h; i++)
{
set_parent_child_mappings(head, head->parent_node,i);
}
inorderTraversal(*root);
}
int left_height=getHeight(node->left_node);
void set_parent_child_mappings(tree_node_t* head,tree_node_t *parent,int level)
{
int right_height=getHeight(node->right_node);
if (head == NULL)
{
return;
}
return (left_height-right_height);
if(level==1)
{
block_meta_data_t *meta_data=meta_data_block_addr(head);
block_meta_data_t *parent_meta_data=meta_data_block_addr(parent);
head->parent_node=parent;
}
return 0;
else if(level>1)
{
set_parent_child_mappings(head->left_node,head,level-1);
set_parent_child_mappings(head->right_node,head,level-1);
}
}
void printGivenLevel(tree_node_t* head, int level)
{
if (head == NULL)
{
return;
}
if (level == 1)
{
block_meta_data_t *meta_data=meta_data_block_addr(head);
printf("%d ", meta_data->block_size);
}
else if (level > 1)
{
printGivenLevel(head->left_node, level-1);
printGivenLevel(head->right_node, level-1);
}
}
void inorderTraversal(tree_node_t *node)
{
if(node!=NULL)
{
inorderTraversal(node->left_node);
block_meta_data_t *meta_data_block=meta_data_block_addr(node);
printf("Block size=%d\n",(int)meta_data_block->block_size);
inorderTraversal(node->left_node);
inorderTraversal(node->right_node);
}
......@@ -406,6 +570,8 @@ void inorderTraversal(tree_node_t *node)
void insert_node_in_freelist(tree_node_t **root,block_meta_data_t *new_metadata_block)
{
printf("Inserting block of size %d into free list\n",new_metadata_block->block_size);
tree_node_t *tree_root=*root;
if(tree_root==NULL)
......@@ -422,8 +588,10 @@ void insert_node_in_freelist(tree_node_t **root,block_meta_data_t *new_metadata_
block_meta_data_t *meta_data=meta_data_block_addr(temp);
if(new_metadata_block->block_size<=meta_data->block_size)
{
if(temp->left_node==NULL)
{
new_metadata_block->tree_node.parent_node=temp;
temp->left_node=&(new_metadata_block->tree_node);
temp=temp->left_node;
......@@ -438,6 +606,7 @@ void insert_node_in_freelist(tree_node_t **root,block_meta_data_t *new_metadata_
else if(new_metadata_block->block_size>meta_data->block_size)
{
if(temp->right_node==NULL)
{
new_metadata_block->tree_node.parent_node=temp;
......@@ -447,6 +616,7 @@ void insert_node_in_freelist(tree_node_t **root,block_meta_data_t *new_metadata_
}
else
{
//printf("It's comming here chaitanya\n");
temp=temp->right_node;
}
}
......@@ -454,19 +624,119 @@ void insert_node_in_freelist(tree_node_t **root,block_meta_data_t *new_metadata_
tree_node_t *parent=temp->parent_node;
while(parent)
{
int b=get_balance(parent);
if(b>=2||b<=-2)
{
rotate(parent,temp);
if(b<-1)
{
if(parent->right_node->right_node!=NULL)
{
if(parent->right_node->left_node!=NULL)
{
if(getHeight(parent->right_node->left_node)>getHeight(parent->right_node->right_node))
{
printf("Before rotating\n");
printLevelOrder(*root);
RL_Rotate(parent,parent->right_node->left_node);
printf("After rotating\n");
printLevelOrder(*root);
}
parent=parent->parent_node;
else
{
printf("Before rotating\n");
printLevelOrder(*root);
RR_Rotate(parent,parent->right_node->right_node);
printf("After rotating\n");
printLevelOrder(*root);
}
}
else
{
printf("Before rotating\n");
printLevelOrder(*root);
RR_Rotate(parent,parent->right_node->right_node);
printf("After rotating\n");
printLevelOrder(*root);
}
}
else
{
printf("Before rotating\n");
printLevelOrder(*root);
RL_Rotate(parent,parent->right_node->left_node);
printf("After rotating\n");
printLevelOrder(*root);
}
}
else if(b>1)
{
if(parent->left_node->left_node!=NULL)
{
if(parent->left_node->right_node!=NULL)
{
if(getHeight(parent->left_node->right_node)>getHeight(parent->left_node->left_node))
{
printf("Before rotating\n");
printLevelOrder(*root);
LR_Rotate(parent,parent->left_node->right_node);
printf("After rotating\n");
printLevelOrder(*root);
}
else
{
printf("Before rotating\n");
printLevelOrder(*root);
LL_rotate(parent,parent->left_node->left_node);
printf("After rotating\n");
printLevelOrder(*root);
}
}
else
{
printf("Before rotating\n");
printLevelOrder(*root);
LL_rotate(parent,parent->left_node->left_node);
printf("After rotating\n");
printLevelOrder(*root);
}
}
else
{
printf("Before rotating\n");
printLevelOrder(*root);
LR_Rotate(parent,parent->left_node->right_node);
printf("After rotating\n");
printLevelOrder(*root);
}
}
}
parent=parent->parent_node;
}
}
}
......@@ -486,14 +756,13 @@ block_meta_data_t *get_node_from_tree(tree_node_t **root,uint32_t reqsize)
return meta_data;
}
tree_node_t *get_min_node(tree_node_t *root)
tree_node_t *get_min_node(tree_node_t *root_node)
{
tree_node_t *temp=root;
tree_node_t *temp=root_node;
while(temp->left_node!=NULL)
{
temp=temp->left_node;
}
......@@ -511,6 +780,7 @@ void remove_block_from_tree(tree_node_t **root,tree_node_t *del_node)
block_meta_data_t *del_meta_data=meta_data_block_addr(del_node);
if(del_node->left_node==NULL||del_node->right_node==NULL)
{
......@@ -519,8 +789,10 @@ void remove_block_from_tree(tree_node_t **root,tree_node_t *del_node)
//Deleting a leaf node
if(temp==NULL)
{
if(parent_node==NULL)
{
printf("Parent node is null\n");
*root=NULL;
return;
}
......@@ -539,6 +811,7 @@ void remove_block_from_tree(tree_node_t **root,tree_node_t *del_node)
else
{
if(del_node->left_node!=NULL)
{
del_node->left_node->parent_node=parent_node;
......@@ -552,11 +825,15 @@ void remove_block_from_tree(tree_node_t **root,tree_node_t *del_node)
}
else if(parent_meta_data->block_size<del_meta_data->block_size)
{
block_meta_data_t *left_meta_data=meta_data_block_addr(del_node->left_node);
printf("Left Node Size=%d\n",left_meta_data->block_size);
parent_node->right_node=del_node->left_node;
}
else
{
parent_node->left_node=del_node->left_node;
}
}
......@@ -587,16 +864,52 @@ void remove_block_from_tree(tree_node_t **root,tree_node_t *del_node)
while(parent_node)
{
int b=get_balance(parent_node);
if(b<-1)
{
if(parent_node->right_node->right_node!=NULL)
{
if(parent_node->right_node->left_node!=NULL)
{
if(getHeight(parent_node->right_node->left_node)>getHeight(parent_node->right_node->right_node))
{
printf("Before rotating\n");
printLevelOrder(*root);
RL_Rotate(parent_node,parent_node->right_node->left_node);
printf("After rotating\n");
printLevelOrder(*root);
}
else
{
printf("Before rotating\n");
printLevelOrder(*root);
RR_Rotate(parent_node,parent_node->right_node->right_node);
printf("After rotating\n");
printLevelOrder(*root);
}
}
else
{
printf("Before rotating\n");
printLevelOrder(*root);
RR_Rotate(parent_node,parent_node->right_node->right_node);
printf("After rotating\n");
printLevelOrder(*root);
}
}
else
{
printf("Before rotating\n");
printLevelOrder(*root);
RL_Rotate(parent_node,parent_node->right_node->left_node);
printf("After rotating\n");
printLevelOrder(*root);
}
}
......@@ -604,25 +917,127 @@ void remove_block_from_tree(tree_node_t **root,tree_node_t *del_node)
{
if(parent_node->left_node->left_node!=NULL)
{
if(parent_node->left_node->right_node!=NULL)
{
if(getHeight(parent_node->left_node->right_node)>getHeight(parent_node->left_node->left_node))
{
printf("Before rotating\n");
printLevelOrder(*root);
LR_Rotate(parent_node,parent_node->left_node->right_node);
printf("After rotating\n");
printLevelOrder(*root);
}
else
{
printf("Before rotating\n");
printLevelOrder(*root);
LL_rotate(parent_node,parent_node->left_node->left_node);
printf("After rotating\n");
printLevelOrder(*root);
}
}
else
{
printf("Before rotating\n");
printLevelOrder(*root);
LL_rotate(parent_node,parent_node->left_node->left_node);
printf("After rotating\n");
printLevelOrder(*root);
}
}
else
{
printf("Before rotating\n");
printLevelOrder(*root);
LR_Rotate(parent_node,parent_node->left_node->right_node);
printf("After rotating\n");
printLevelOrder(*root);
}
}
parent_node=parent_node->parent_node;
}
}
//Deleting node having two children
else
{
/*
printf("Tree traversal of delete node\n");
if(c==122)
{
int k=find_node_in_tree(*root,(*root)->right_node);
if(k==1)
{
printf("Del node is in the tree\n");
}
else
{
printf("Del node is not in the tree\n");
}
//printLevelOrder(del_node);
printf("Delete node address=%p\n",(void *)del_node);
block_meta_data_t *t1=meta_data_block_addr(del_node);
printf("Delete meta data size=%d\n",(int)t1->block_size);
printf("Delete left node address=%p\n",(void *)del_node->left_node);
block_meta_data_t *t2=meta_data_block_addr(del_node->left_node);
printf("Delete left node meta data size=%d\n",(int)t2->block_size);
printf("Delete left left node address=%p\n",(void *)del_node->left_node->left_node);
printf("Delete left right node address=%p\n",(void *)del_node->left_node->right_node);
printf("Delete left parent node address=%p\n",(void *)del_node->left_node->parent_node);
printf("Delete right node address=%p\n",(void *)del_node->right_node);
printf("Delete right left node address=%p\n",(void *)del_node->right_node->left_node);
printf("Delete right right node address=%p\n",(void *)del_node->right_node->right_node);
exit(0);
}
*/
//printf("Parent node pointer=%p\n",(void *)del_node->left_node->parent_node);
tree_node_t *min_right_node=get_min_node(del_node->right_node);
if(min_right_node->parent_node==NULL)
{
set_mappings(del_node);
}
remove_block_from_tree(root,min_right_node);
/*
printf("Tree traversal after right node removed\n");
printLevelOrder(*root);*/
tree_node_t *parent_node_1=del_node->parent_node;
block_meta_data_t *parent_meta_data_1=meta_data_block_addr(parent_node_1);
......@@ -690,20 +1105,18 @@ void merge_free_blocks(block_meta_data_t *first,block_meta_data_t *second)
}
void create_new_block_and_insert_into_freelist(block_meta_data_t *meta_data_block,uint32_t final_remain)
void create_new_block_and_insert_into_freelist(block_meta_data_t *meta_data_block,block_meta_data_t *free_block,uint32_t final_remain,int c)
{
block_end_meta_data_t *end_meta_data_block = (block_end_meta_data_t *)end_meta_data_addr(meta_data_block);
end_meta_data_block->block_size = meta_data_block->block_size;
block_meta_data_t *new_block = (block_meta_data_t *)NEXT_META_BLOCK_BY_SIZE(meta_data_block);
if(meta_data_block->is_free == MM_TRUE)
meta_data_block->is_free = MM_FALSE;
if(final_remain < META_DATA_OVERHEAD)
{
if(meta_data_block->next_block)
meta_data_block->next_block->prev_block = meta_data_block;
return;
}
block_meta_data_t *new_block = (block_meta_data_t *)NEXT_META_BLOCK_BY_SIZE(meta_data_block);
new_block->block_size = final_remain-META_DATA_OVERHEAD;
if(c == 0)
meta_data_block->next_block = free_block->next_block->next_block;
else
meta_data_block->next_block = free_block->next_block;
new_block->block_size = (uint32_t)final_remain;
new_block->tree_node = init_free_node();
new_block->is_free = MM_TRUE;
mm_bind_blocks_for_allocation(meta_data_block, new_block);
......@@ -721,11 +1134,10 @@ void create_new_block_and_insert_into_freelist(block_meta_data_t *meta_data_bloc
void *allocate_requested_size(size_t size)
{
size_t sys_page_size=mem_pagesize();
int no_of_pages_req=((size+2*ALIGN(sizeof(block_end_meta_data_t))+2*ALIGN(sizeof(block_meta_data_t))+sys_page_size-1)/sys_page_size);
int no_of_pages_req=((size+ALIGN(sizeof(block_end_meta_data_t))+ALIGN(sizeof(block_meta_data_t))+sys_page_size-1)/sys_page_size);
size_t extra_size_req=(int)no_of_pages_req*sys_page_size;
void *store_brk = mem_heap_hi();
void *brk= mem_sbrk(extra_size_req);
if(store_brk==brk && *(int *)brk == -1)
if(*(int *)brk==-1)
return NULL;
return brk;
}
......@@ -781,6 +1193,8 @@ void *mm_malloc(size_t size)
* If no appropriate free block is available then the increase the heap size using 'mem_sbrk(size)'.
* Try to keep the heap size as small as possible.
*/
printf("[IN MALLOC]\n");
if(size <= 0){ // Invalid request size
return NULL;
......@@ -845,13 +1259,21 @@ void *mm_malloc(size_t size)
mm_bind_blocks_for_allocation(next_meta_data_block,new_free_meta_block);
printf("Tree after malloc\n");
printLevelOrder(*root);
return (void *)((char *)next_meta_data_block+ALIGN(sizeof(block_meta_data_t)));
}
assert(free_metadata_block->is_free==MM_TRUE);
printf("Free Data block size=%d\n",(int)free_metadata_block->block_size);
remove_block_from_tree(root,&free_metadata_block->tree_node);
uint32_t remaining_size=free_metadata_block->block_size-size;
free_metadata_block->is_free=MM_FALSE;
......@@ -886,8 +1308,13 @@ void *mm_malloc(size_t size)
mm_bind_blocks_for_allocation(free_metadata_block,next_meta_block);
}
printf("Tree after malloc\n");
printLevelOrder(*root);
//printf("Inorder Traversal of free list=\n");
//inorderTraversal(*root);
return (void *)((char *)free_metadata_block+ALIGN(sizeof(block_meta_data_t)));
//mem_sbrk() is wrapper function for the sbrk() system call.
......@@ -907,8 +1334,12 @@ void mm_free(void *ptr)
* It should also keep track of all the free memory blocks.
* If the freed block is at the end of the heap then you can also decrease the heap size
* using 'mem_sbrk(-size)'.
*/
printf("[IN FREE]\n");
c++;
printf("[IN FREE] %d\n",c);
block_meta_data_t *meta_data_block=(block_meta_data_t *)((char *)ptr-ALIGN(sizeof(block_meta_data_t)));
assert(meta_data_block->is_free==MM_FALSE);
......@@ -939,9 +1370,26 @@ void mm_free(void *ptr)
if(next_meta_data_block!=NULL&&next_meta_data_block->is_free==MM_TRUE)
{
/*
if(c==88)
{
printf("Next block is free and its size is %d\n",(int)next_meta_data_block->block_size);
printf("Meta data block size=%d\n",(int)meta_data_block->block_size);
}
*/
remove_block_from_tree(root,&next_meta_data_block->tree_node);
/*
if(c==88)
{
printf("Block removed from tree\n");
printf("Tree Traversal after it got removed\n");
printLevelOrder(*root);
}
*/
merge_free_blocks(meta_data_block,next_meta_data_block);
merged_meta_data_block=meta_data_block;
......@@ -952,8 +1400,6 @@ void mm_free(void *ptr)
{
remove_block_from_tree(root,&prev_meta_data_block->tree_node);
prev_meta_data_block->block_size += get_internal_fragmented_size(prev_meta_data_block,meta_data_block);
merge_free_blocks(prev_meta_data_block,meta_data_block);
merged_meta_data_block=prev_meta_data_block;
......@@ -995,7 +1441,7 @@ void *mm_realloc(void *ptr, size_t size)
block_meta_data_t *meta_data_block=(block_meta_data_t *)((char *)ptr-ALIGN(sizeof(block_meta_data_t)));
if(size == meta_data_block->block_size)
return (void *)(meta_data_block+1);
return (void *)((char *)meta_data_block+ALIGN(sizeof(block_meta_data_t)));
if(size < meta_data_block->block_size)
......@@ -1018,7 +1464,9 @@ void *mm_realloc(void *ptr, size_t size)
block_end_meta_data_t *new_end_meta_data_block = (block_end_meta_data_t *)end_meta_data_addr(new_block);
new_end_meta_data_block->block_size = new_block->block_size;
insert_node_in_freelist(root,new_block);
return (void *)((char *)meta_data_block+ALIGN(sizeof(block_meta_data_t)));
}
else
{
......@@ -1039,7 +1487,7 @@ void *mm_realloc(void *ptr, size_t size)
block_end_meta_data_t *end_meta_data_block = (block_end_meta_data_t *)end_meta_data_addr(meta_data_block);
end_meta_data_block->block_size = meta_data_block->block_size;
if((original_size- size + inter_frag + fragmented_size) >= META_DATA_OVERHEAD)
if((original_size- size + inter_frag + fragmented_size) > META_DATA_OVERHEAD)
{
block_meta_data_t *new_block = (block_meta_data_t *)NEXT_META_BLOCK_BY_SIZE(meta_data_block);
new_block->tree_node = init_free_node();
......@@ -1072,27 +1520,6 @@ void *mm_realloc(void *ptr, size_t size)
return (void *)((char *)meta_data_block+ALIGN(sizeof(block_meta_data_t))); // Not handling adding remaining free part to free list because it is small in size to handle even headers, so skkipping.
}
if(meta_data_block->next_block && meta_data_block->next_block->is_free==MM_TRUE && meta_data_block->prev_block && meta_data_block->prev_block->is_free ==MM_TRUE && \
req_rem_size <= TOTAL_COMBINED_SIZE_OF_BLOCKS(meta_data_block)+inter_frag)
{
remove_block_from_tree(root,&meta_data_block->prev_block->tree_node);
remove_block_from_tree(root,&meta_data_block->next_block->tree_node);
req_rem_size -= inter_frag;
inter_frag = get_internal_fragmented_size(meta_data_block->prev_block,meta_data_block);
req_rem_size -= inter_frag;
uint32_t final_remain = abs(meta_data_block->next_block->block_size+meta_data_block->prev_block->block_size+2*ALIGN(sizeof(block_end_meta_data_t)) \
+2*ALIGN(sizeof(block_meta_data_t)) - req_rem_size);
meta_data_block->prev_block->block_size = size;
meta_data_block = meta_data_block->prev_block;
block_meta_data_t *store_head = meta_data_block->next_block;
meta_data_block->next_block = meta_data_block->next_block->next_block->next_block;
meta_data_block->is_free = MM_FALSE;
memcpy((char *)(meta_data_block)+ALIGN(sizeof(block_meta_data_t)), (char *)(store_head)+ALIGN(sizeof(block_meta_data_t)),store_head->block_size);
create_new_block_and_insert_into_freelist(meta_data_block,final_remain);
return (void *)((char *)meta_data_block+ALIGN(sizeof(block_meta_data_t)));
}
if(meta_data_block->next_block && meta_data_block->next_block->is_free == MM_TRUE && \
req_rem_size <= (TOTAL_COMBINE_SIZE_OF_BLOCKS(meta_data_block->next_block)+inter_frag))
{
......@@ -1100,28 +1527,49 @@ void *mm_realloc(void *ptr, size_t size)
req_rem_size -= inter_frag;
uint32_t final_remain = TOTAL_COMBINE_SIZE_OF_BLOCKS(meta_data_block->next_block) - req_rem_size;
meta_data_block->block_size = size;
block_meta_data_t *store_head = meta_data_block->next_block;
meta_data_block->next_block = meta_data_block->next_block->next_block;
create_new_block_and_insert_into_freelist(meta_data_block,final_remain);
// block_end_meta_data_t *end_meta_data_block = (block_end_meta_data_t *)end_meta_data_addr(meta_data_block);
// end_meta_data_block->block_size = meta_data_block->block_size;
create_new_block_and_insert_into_freelist(meta_data_block,meta_data_block->next_block,final_remain,1);
return (void *)((char *)meta_data_block+ALIGN(sizeof(block_meta_data_t)));
}
if(meta_data_block->prev_block && meta_data_block->prev_block->is_free == MM_TRUE && \
req_rem_size <= (TOTAL_COMBINE_SIZE_OF_BLOCKS(meta_data_block->prev_block)+inter_frag)){
inter_frag = get_internal_fragmented_size(meta_data_block->prev_block,meta_data_block);
remove_block_from_tree(root,&meta_data_block->prev_block->tree_node);
req_rem_size -= inter_frag;
meta_data_block->prev_block->block_size = size;
uint32_t final_remain = abs(TOTAL_COMBINE_SIZE_OF_BLOCKS(meta_data_block->prev_block) - req_rem_size);
memcpy((char *)(meta_data_block->prev_block)+ALIGN(sizeof(block_meta_data_t)), (char *)(meta_data_block)+ALIGN(sizeof(block_meta_data_t)),meta_data_block->block_size);
block_end_meta_data_t *end_meta_data_block = (block_end_meta_data_t *)end_meta_data_addr(meta_data_block);
// end_meta_data_block->block_size = meta_data_block->block_size;
// meta_data_block = meta_data_block->prev_block;
create_new_block_and_insert_into_freelist(meta_data_block,meta_data_block->next_block,final_remain,1);
return (void *)((char *)meta_data_block+ALIGN(sizeof(block_meta_data_t)));
}
if(meta_data_block->next_block && meta_data_block->next_block->is_free==MM_TRUE && meta_data_block->prev_block && meta_data_block->prev_block->is_free==MM_TRUE && \
req_rem_size <= TOTAL_COMBINED_SIZE_OF_BLOCKS(meta_data_block)+inter_frag)
{
remove_block_from_tree(root,&meta_data_block->prev_block->tree_node);
remove_block_from_tree(root,&meta_data_block->next_block->tree_node);
req_rem_size -= inter_frag;
meta_data_block->prev_block->block_size = size;
uint32_t final_remain = abs(meta_data_block->next_block->block_size+meta_data_block->prev_block->block_size+(uint32_t)ALIGN(sizeof(block_end_meta_data_t)) \
+(uint32_t)ALIGN(sizeof(block_meta_data_t)) - req_rem_size);
memcpy((char *)(meta_data_block->prev_block)+ALIGN(sizeof(block_meta_data_t)), (char *)(meta_data_block)+ALIGN(sizeof(block_meta_data_t)),meta_data_block->block_size);
// block_end_meta_data_t *end_meta_data_block = (block_end_meta_data_t *)end_meta_data_addr(meta_data_block);
// end_meta_data_block->block_size = meta_data_block->block_size;
meta_data_block = meta_data_block->prev_block;
meta_data_block->is_free = MM_FALSE;
block_meta_data_t *store_head = meta_data_block->next_block;
meta_data_block->next_block = meta_data_block->next_block->next_block;
memcpy((char *)(meta_data_block)+ALIGN(sizeof(block_meta_data_t)), (char *)(store_head)+ALIGN(sizeof(block_meta_data_t)),store_head->block_size);
create_new_block_and_insert_into_freelist(meta_data_block,final_remain);
create_new_block_and_insert_into_freelist(meta_data_block,meta_data_block->next_block,final_remain,0);
return (void *)((char *)meta_data_block+ALIGN(sizeof(block_meta_data_t)));
}
void *ptr = mm_malloc(size);
block_meta_data_t *new_meta_data_block = (block_meta_data_t *)((char *)ptr-ALIGN(sizeof(block_meta_data_t)));
uint32_t amount_to_be_copied = meta_data_block->block_size;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment