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 @@ ...@@ -16,7 +16,6 @@
#include <string.h> #include <string.h>
#include<stddef.h> #include<stddef.h>
#include<stdint.h> #include<stdint.h>
#include "mm.h" #include "mm.h"
#include "memlib.h" #include "memlib.h"
...@@ -26,15 +25,15 @@ ...@@ -26,15 +25,15 @@
********************************************************/ ********************************************************/
team_t team = { team_t team = {
/* Team name */ /* Team name */
"segmentation_fault", "team name",
/* First member's full name */ /* First member's full name */
"member 1", "member 1",
/* First member's email address */ /* First member's email address */
"member_1@cse.iitb.ac.in", "member_1@cse.iitb.ac.in",
/* Second member's full name (leave blank if none) */ /* Second member's full name (leave blank if none) */
"shivaji chirumamilla", "member 2",
/* Second member's email address (leave blank if none) */ /* Second member's email address (leave blank if none) */
"shivaji@cse.iitb.ac.in" "member_2@cse.iitb.ac.in"
}; };
typedef struct tree_node_ typedef struct tree_node_
...@@ -73,6 +72,7 @@ uint32_t block_size; ...@@ -73,6 +72,7 @@ uint32_t block_size;
} block_end_meta_data_t; } block_end_meta_data_t;
int c=0;
#define NEXT_META_BLOCK_BY_SIZE(block_meta_data_ptr) \ #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)) \ (block_meta_data_t *)((char *)(block_meta_data_ptr)+ALIGN(sizeof(block_meta_data_t)) \
...@@ -86,10 +86,6 @@ uint32_t block_size; ...@@ -86,10 +86,6 @@ uint32_t block_size;
if(free_meta_block->next_block) \ if(free_meta_block->next_block) \
free_meta_block->next_block->prev_block=free_meta_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) \ #define meta_data_block_addr(free_node_addr) \
(block_meta_data_t *) ((char *)(free_node_addr)-offsetof(block_meta_data_t,tree_node)) (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; ...@@ -147,6 +143,9 @@ void *init_mem_sbrk_break = NULL;
tree_node_t **root=NULL; tree_node_t **root=NULL;
void LL_rotate(tree_node_t *parent,tree_node_t *node) 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) ...@@ -188,6 +187,11 @@ void LL_rotate(tree_node_t *parent,tree_node_t *node)
parent->parent_node=temp; parent->parent_node=temp;
parent->left_node=temp_right; 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) ...@@ -204,6 +208,7 @@ void LR_Rotate(tree_node_t *parent,tree_node_t *node)
tree_node_t *node_right=node->right_node; tree_node_t *node_right=node->right_node;
if(p_parent==NULL) if(p_parent==NULL)
{ {
*root=node; *root=node;
...@@ -231,17 +236,29 @@ void LR_Rotate(tree_node_t *parent,tree_node_t *node) ...@@ -231,17 +236,29 @@ void LR_Rotate(tree_node_t *parent,tree_node_t *node)
node->left_node=temp; node->left_node=temp;
temp->parent_node=node; temp->parent_node=node;
parent->left_node=node_right; parent->left_node=node_right;
if(node_right!=NULL)
{
node_right->parent_node=parent;
}
temp->right_node=node_left; 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) 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 *p_parent=parent->parent_node;
tree_node_t *temp=parent->right_node; tree_node_t *temp=parent->right_node;
tree_node_t *temp_left=temp->left_node; tree_node_t *temp_left=temp->left_node;
if(p_parent==NULL) if(p_parent==NULL)
{ {
*root=temp; *root=temp;
...@@ -249,14 +266,13 @@ void RR_Rotate(tree_node_t *parent,tree_node_t *node) ...@@ -249,14 +266,13 @@ void RR_Rotate(tree_node_t *parent,tree_node_t *node)
} }
else else
{ {
temp->parent_node=p_parent; temp->parent_node=p_parent;
block_meta_data_t *p_parent_meta_data=meta_data_block_addr(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); 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; p_parent->left_node=temp;
} }
...@@ -264,11 +280,20 @@ void RR_Rotate(tree_node_t *parent,tree_node_t *node) ...@@ -264,11 +280,20 @@ void RR_Rotate(tree_node_t *parent,tree_node_t *node)
{ {
p_parent->right_node=temp; p_parent->right_node=temp;
} }
}
temp->left_node=parent; temp->left_node=parent;
parent->parent_node=temp; parent->parent_node=temp;
parent->right_node=temp_left; 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) ...@@ -277,7 +302,7 @@ void RL_Rotate(tree_node_t *parent,tree_node_t *node)
printf("Came to RL\n"); printf("Came to RL\n");
tree_node_t *p_parent=parent->parent_node; tree_node_t *p_parent=parent->parent_node;
tree_node_t *temp=parent->right_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_left=node->left_node;
tree_node_t *node_right=node->right_node; tree_node_t *node_right=node->right_node;
...@@ -294,7 +319,7 @@ void RL_Rotate(tree_node_t *parent,tree_node_t *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); 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; p_parent->left_node=node;
} }
...@@ -310,91 +335,230 @@ void RL_Rotate(tree_node_t *parent,tree_node_t *node) ...@@ -310,91 +335,230 @@ void RL_Rotate(tree_node_t *parent,tree_node_t *node)
node->right_node=temp; node->right_node=temp;
temp->parent_node=node; temp->parent_node=node;
parent->right_node=node_right; parent->right_node=node_right;
if(node_right!=NULL)
{
node_right->parent_node=parent;
}
temp->left_node=node_left; 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); head->right_node=NULL;
LR_Rotate(parent,node);
} }
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 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) void inorderTraversal(tree_node_t *node)
{ {
if(node!=NULL) if(node!=NULL)
{ {
inorderTraversal(node->left_node);
block_meta_data_t *meta_data_block=meta_data_block_addr(node); block_meta_data_t *meta_data_block=meta_data_block_addr(node);
printf("Block size=%d\n",(int)meta_data_block->block_size); printf("Block size=%d\n",(int)meta_data_block->block_size);
inorderTraversal(node->left_node);
inorderTraversal(node->right_node); inorderTraversal(node->right_node);
} }
...@@ -406,6 +570,8 @@ void inorderTraversal(tree_node_t *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) 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; tree_node_t *tree_root=*root;
if(tree_root==NULL) if(tree_root==NULL)
...@@ -422,8 +588,10 @@ void insert_node_in_freelist(tree_node_t **root,block_meta_data_t *new_metadata_ ...@@ -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); block_meta_data_t *meta_data=meta_data_block_addr(temp);
if(new_metadata_block->block_size<=meta_data->block_size) if(new_metadata_block->block_size<=meta_data->block_size)
{ {
if(temp->left_node==NULL) if(temp->left_node==NULL)
{ {
new_metadata_block->tree_node.parent_node=temp; new_metadata_block->tree_node.parent_node=temp;
temp->left_node=&(new_metadata_block->tree_node); temp->left_node=&(new_metadata_block->tree_node);
temp=temp->left_node; temp=temp->left_node;
...@@ -438,6 +606,7 @@ void insert_node_in_freelist(tree_node_t **root,block_meta_data_t *new_metadata_ ...@@ -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) else if(new_metadata_block->block_size>meta_data->block_size)
{ {
if(temp->right_node==NULL) if(temp->right_node==NULL)
{ {
new_metadata_block->tree_node.parent_node=temp; 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_ ...@@ -447,6 +616,7 @@ void insert_node_in_freelist(tree_node_t **root,block_meta_data_t *new_metadata_
} }
else else
{ {
//printf("It's comming here chaitanya\n");
temp=temp->right_node; temp=temp->right_node;
} }
} }
...@@ -454,19 +624,119 @@ void insert_node_in_freelist(tree_node_t **root,block_meta_data_t *new_metadata_ ...@@ -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; tree_node_t *parent=temp->parent_node;
while(parent) while(parent)
{ {
int b=get_balance(parent); int b=get_balance(parent);
if(b>=2||b<=-2) 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) ...@@ -486,14 +756,13 @@ block_meta_data_t *get_node_from_tree(tree_node_t **root,uint32_t reqsize)
return meta_data; 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) while(temp->left_node!=NULL)
{ {
temp=temp->left_node; temp=temp->left_node;
} }
...@@ -511,6 +780,7 @@ void remove_block_from_tree(tree_node_t **root,tree_node_t *del_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); block_meta_data_t *del_meta_data=meta_data_block_addr(del_node);
if(del_node->left_node==NULL||del_node->right_node==NULL) 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) ...@@ -519,8 +789,10 @@ void remove_block_from_tree(tree_node_t **root,tree_node_t *del_node)
//Deleting a leaf node //Deleting a leaf node
if(temp==NULL) if(temp==NULL)
{ {
if(parent_node==NULL) if(parent_node==NULL)
{ {
printf("Parent node is null\n");
*root=NULL; *root=NULL;
return; return;
} }
...@@ -539,6 +811,7 @@ void remove_block_from_tree(tree_node_t **root,tree_node_t *del_node) ...@@ -539,6 +811,7 @@ void remove_block_from_tree(tree_node_t **root,tree_node_t *del_node)
else else
{ {
if(del_node->left_node!=NULL) if(del_node->left_node!=NULL)
{ {
del_node->left_node->parent_node=parent_node; 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) ...@@ -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) 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; parent_node->right_node=del_node->left_node;
} }
else else
{ {
parent_node->left_node=del_node->left_node; 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) ...@@ -587,16 +864,52 @@ void remove_block_from_tree(tree_node_t **root,tree_node_t *del_node)
while(parent_node) while(parent_node)
{ {
int b=get_balance(parent_node); int b=get_balance(parent_node);
if(b<-1) if(b<-1)
{ {
if(parent_node->right_node->right_node!=NULL) 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); 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 else
{ {
printf("Before rotating\n");
printLevelOrder(*root);
RL_Rotate(parent_node,parent_node->right_node->left_node); 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) ...@@ -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->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); LL_rotate(parent_node,parent_node->left_node->left_node);
printf("After rotating\n");
printLevelOrder(*root);
}
} }
else 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); LR_Rotate(parent_node,parent_node->left_node->right_node);
printf("After rotating\n");
printLevelOrder(*root);
} }
} }
parent_node=parent_node->parent_node; parent_node=parent_node->parent_node;
} }
} }
//Deleting node having two children //Deleting node having two children
else 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); 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); 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; 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); 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) ...@@ -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); 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; 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) if(meta_data_block->is_free == MM_TRUE)
meta_data_block->is_free = MM_FALSE; meta_data_block->is_free = MM_FALSE;
if(final_remain < META_DATA_OVERHEAD) if(c == 0)
{ meta_data_block->next_block = free_block->next_block->next_block;
if(meta_data_block->next_block) else
meta_data_block->next_block->prev_block = meta_data_block; meta_data_block->next_block = free_block->next_block;
return; new_block->block_size = (uint32_t)final_remain;
}
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;
new_block->tree_node = init_free_node(); new_block->tree_node = init_free_node();
new_block->is_free = MM_TRUE; new_block->is_free = MM_TRUE;
mm_bind_blocks_for_allocation(meta_data_block, new_block); 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 ...@@ -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) void *allocate_requested_size(size_t size)
{ {
size_t sys_page_size=mem_pagesize(); 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; 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); void *brk= mem_sbrk(extra_size_req);
if(store_brk==brk && *(int *)brk == -1) if(*(int *)brk==-1)
return NULL; return NULL;
return brk; return brk;
} }
...@@ -781,6 +1193,8 @@ void *mm_malloc(size_t size) ...@@ -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)'. * 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. * Try to keep the heap size as small as possible.
*/ */
printf("[IN MALLOC]\n"); printf("[IN MALLOC]\n");
if(size <= 0){ // Invalid request size if(size <= 0){ // Invalid request size
return NULL; return NULL;
...@@ -845,13 +1259,21 @@ void *mm_malloc(size_t size) ...@@ -845,13 +1259,21 @@ void *mm_malloc(size_t size)
mm_bind_blocks_for_allocation(next_meta_data_block,new_free_meta_block); 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))); return (void *)((char *)next_meta_data_block+ALIGN(sizeof(block_meta_data_t)));
} }
assert(free_metadata_block->is_free==MM_TRUE); 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); remove_block_from_tree(root,&free_metadata_block->tree_node);
uint32_t remaining_size=free_metadata_block->block_size-size; uint32_t remaining_size=free_metadata_block->block_size-size;
free_metadata_block->is_free=MM_FALSE; free_metadata_block->is_free=MM_FALSE;
...@@ -886,8 +1308,13 @@ void *mm_malloc(size_t size) ...@@ -886,8 +1308,13 @@ void *mm_malloc(size_t size)
mm_bind_blocks_for_allocation(free_metadata_block,next_meta_block); 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))); return (void *)((char *)free_metadata_block+ALIGN(sizeof(block_meta_data_t)));
//mem_sbrk() is wrapper function for the sbrk() system call. //mem_sbrk() is wrapper function for the sbrk() system call.
...@@ -907,8 +1334,12 @@ void mm_free(void *ptr) ...@@ -907,8 +1334,12 @@ void mm_free(void *ptr)
* It should also keep track of all the free memory blocks. * 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 * If the freed block is at the end of the heap then you can also decrease the heap size
* using 'mem_sbrk(-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))); 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); assert(meta_data_block->is_free==MM_FALSE);
...@@ -939,9 +1370,26 @@ void mm_free(void *ptr) ...@@ -939,9 +1370,26 @@ void mm_free(void *ptr)
if(next_meta_data_block!=NULL&&next_meta_data_block->is_free==MM_TRUE) 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); 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); merge_free_blocks(meta_data_block,next_meta_data_block);
merged_meta_data_block=meta_data_block; merged_meta_data_block=meta_data_block;
...@@ -952,8 +1400,6 @@ void mm_free(void *ptr) ...@@ -952,8 +1400,6 @@ void mm_free(void *ptr)
{ {
remove_block_from_tree(root,&prev_meta_data_block->tree_node); 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); merge_free_blocks(prev_meta_data_block,meta_data_block);
merged_meta_data_block=prev_meta_data_block; merged_meta_data_block=prev_meta_data_block;
...@@ -995,7 +1441,7 @@ void *mm_realloc(void *ptr, size_t size) ...@@ -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))); 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) 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) if(size < meta_data_block->block_size)
...@@ -1018,7 +1464,9 @@ void *mm_realloc(void *ptr, size_t 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); 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; new_end_meta_data_block->block_size = new_block->block_size;
insert_node_in_freelist(root,new_block); insert_node_in_freelist(root,new_block);
return (void *)((char *)meta_data_block+ALIGN(sizeof(block_meta_data_t))); return (void *)((char *)meta_data_block+ALIGN(sizeof(block_meta_data_t)));
} }
else else
{ {
...@@ -1039,7 +1487,7 @@ void *mm_realloc(void *ptr, size_t size) ...@@ -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); 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; 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); 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(); new_block->tree_node = init_free_node();
...@@ -1072,27 +1520,6 @@ void *mm_realloc(void *ptr, size_t size) ...@@ -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. 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 && \ 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)) 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) ...@@ -1100,28 +1527,49 @@ void *mm_realloc(void *ptr, size_t size)
req_rem_size -= inter_frag; req_rem_size -= inter_frag;
uint32_t final_remain = TOTAL_COMBINE_SIZE_OF_BLOCKS(meta_data_block->next_block) - req_rem_size; uint32_t final_remain = TOTAL_COMBINE_SIZE_OF_BLOCKS(meta_data_block->next_block) - req_rem_size;
meta_data_block->block_size = size; meta_data_block->block_size = size;
block_meta_data_t *store_head = meta_data_block->next_block; // block_end_meta_data_t *end_meta_data_block = (block_end_meta_data_t *)end_meta_data_addr(meta_data_block);
meta_data_block->next_block = meta_data_block->next_block->next_block; // end_meta_data_block->block_size = meta_data_block->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,1);
return (void *)((char *)meta_data_block+ALIGN(sizeof(block_meta_data_t))); 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 && \ 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)){ 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); remove_block_from_tree(root,&meta_data_block->prev_block->tree_node);
req_rem_size -= inter_frag; 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); 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; 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 = meta_data_block->prev_block;
meta_data_block->is_free = MM_FALSE; create_new_block_and_insert_into_freelist(meta_data_block,meta_data_block->next_block,final_remain,0);
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);
return (void *)((char *)meta_data_block+ALIGN(sizeof(block_meta_data_t))); return (void *)((char *)meta_data_block+ALIGN(sizeof(block_meta_data_t)));
} }
void *ptr = mm_malloc(size); 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))); 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; 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