Skip to content

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

Update mm2.c

parent 8d066862
Hide whitespace changes
Inline Side-by-side
Showing with 232 additions and 51 deletions
mm2.c
View file @ b52f8bf7
......@@ -14,6 +14,8 @@
#include <assert.h>
#include <unistd.h>
#include <string.h>
#include<stddef.h>
#include<stdint.h>
#include "mm.h"
#include "memlib.h"
......@@ -59,6 +61,12 @@ typedef struct block_meta_data_
tree_node_t tree_node;
} block_meta_data_t;
typedef struct printer{
int rollno;
char *name;
struct printer *next;
}printer;
typedef struct block_end_meta_data_
{
uint32_t block_size;
......@@ -67,9 +75,9 @@ uint32_t block_size;
#define NEXT_META_BLOCK_BY_SIZE(block_meta_data_ptr) \
(block_meta_data_t *)((char *)(block_meta_data_ptr+1) \
(block_meta_data_t *)((char *)(block_meta_data_ptr)+ALIGN(sizeof(block_meta_data_t)) \
+ block_meta_data_ptr->block_size \
+sizeof(block_end_meta_data_t))
+ALIGN(sizeof(block_end_meta_data_t)))
#define mm_bind_blocks_for_allocation(allocated_meta_block,free_meta_block) \
free_meta_block->prev_block=allocated_meta_block; \
......@@ -78,21 +86,32 @@ 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))
#define end_meta_data_addr(meta_data_addr) \
(block_end_meta_data_t *)((char *)(meta_data_addr+1) \
(block_end_meta_data_t *)((char *)(meta_data_addr)+ALIGN(sizeof(block_meta_data_t)) \
+meta_data_addr->block_size)
#define start_meta_data_addr(end_meta_data_addr) \
(block_meta_data_t *)((char *)(end_meta_data_addr) \
-end_meta_data_addr->block_size \
-sizeof(block_meta_data_t))
-ALIGN(sizeof(block_meta_data_t)))
#define META_DATA_OVERHEAD \
(uint32_t)(ALIGN(sizeof(block_end_meta_data_t))+ALIGN(sizeof(block_meta_data_t)))
#define TOTAL_COMBINE_SIZE_OF_BLOCKS(base) \
base->block_size \
+ALIGN(sizeof(block_end_meta_data_t)) \
+ALIGN(sizeof(block_meta_data_t))
#define TOTAL_COMBINED_SIZE_OF_BLOCKS(base) \
base->next_block->block_size \
+base->prev_block->block_size \
+2*ALIGN(sizeof(block_end_meta_data_t)) \
+2*ALIGN(sizeof(block_meta_data_t))
/* single word (4) or double word (8) alignment */
......@@ -655,7 +674,7 @@ void merge_free_blocks(block_meta_data_t *first,block_meta_data_t *second)
assert(first->is_free==MM_TRUE&&second->is_free==MM_TRUE);
first->block_size+=sizeof(block_meta_data_t) + second->block_size+sizeof(block_end_meta_data_t);
first->block_size+=ALIGN(sizeof(block_meta_data_t)) + second->block_size+ALIGN(sizeof(block_end_meta_data_t));
first->next_block=second->next_block;
......@@ -667,6 +686,36 @@ 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,block_meta_data_t *free_block,uint32_t final_remain,int c)
{
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(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);
assert(meta_data_block->next_block->block_size == new_block->block_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);
}
void *allocate_requested_size(size_t size)
{
size_t sys_page_size=mem_pagesize();
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 *brk= mem_sbrk(extra_size_req);
if(*(int *)brk==-1)
return NULL;
return brk;
}
int mm_init(void)
......@@ -693,9 +742,9 @@ int mm_init(void)
return -1;
}
root=(tree_node_t **)init_mem_sbrk_break;
block_meta_data_t *metadata=(block_meta_data_t *)(root+1);
block_meta_data_t *metadata=(block_meta_data_t *)((char *)root+ALIGN(sizeof(root)));
metadata->is_free=MM_TRUE;
metadata->block_size=mem_pagesize()-sizeof(block_meta_data_t)-sizeof(block_end_meta_data_t)-sizeof(root);
metadata->block_size=mem_pagesize()-ALIGN(sizeof(block_meta_data_t))-ALIGN(sizeof(block_end_meta_data_t))-ALIGN(sizeof(root));
metadata->tree_node=init_free_node();
metadata->next_block=NULL;
metadata->prev_block=NULL;
......@@ -728,24 +777,19 @@ void *mm_malloc(size_t size)
block_meta_data_t *free_metadata_block=get_node_from_tree(root,size);
//If No free block available then we will request new pages by calling mem_sbrk()
if(free_metadata_block==NULL||free_metadata_block->block_size<(size+sizeof(block_end_meta_data_t)+sizeof(block_meta_data_t)))
if(free_metadata_block==NULL||free_metadata_block->block_size<(size+ALIGN(sizeof(block_end_meta_data_t))+ALIGN(sizeof(block_meta_data_t))))
{
size_t sys_page_size=mem_pagesize();
void *brk = allocate_requested_size(size);
int no_of_pages_req=((size+sizeof(block_end_meta_data_t)+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 *brk= mem_sbrk(extra_size_req);
if(*(int *)brk==-1)
{
return NULL;
}
if(brk==NULL)
{
return NULL;
}
block_end_meta_data_t *prev_end_meta_data=NULL;
prev_end_meta_data=(block_end_meta_data_t *)((char *)brk-sizeof(block_end_meta_data_t));
prev_end_meta_data=(block_end_meta_data_t *)((char *)brk-ALIGN(sizeof(block_end_meta_data_t)));
block_meta_data_t *prev_start_meta_data=NULL;
......@@ -773,7 +817,8 @@ void *mm_malloc(size_t size)
new_free_meta_block->is_free=MM_TRUE;
new_free_meta_block->block_size=(uint32_t)(extra_size_req-size-(2*sizeof(block_meta_data_t))-(2*sizeof(block_end_meta_data_t)));
// new_free_meta_block->block_size=(uint32_t)(extra_size_req-size-(2*sizeof(block_meta_data_t))-(2*sizeof(block_end_meta_data_t)));
new_free_meta_block->block_size= (uint32_t)((char *)mem_heap_hi()-(char *)brk+1-size-(2*(uint32_t)ALIGN(sizeof(block_meta_data_t)))-(2*(uint32_t)ALIGN(sizeof(block_end_meta_data_t))));
new_free_meta_block->tree_node=init_free_node();
......@@ -787,7 +832,7 @@ void *mm_malloc(size_t size)
mm_bind_blocks_for_allocation(next_meta_data_block,new_free_meta_block);
return (void *)(next_meta_data_block+1);
return (void *)((char *)next_meta_data_block+ALIGN(sizeof(block_meta_data_t)));
}
assert(free_metadata_block->is_free==MM_TRUE);
......@@ -807,7 +852,7 @@ void *mm_malloc(size_t size)
remove_block_from_tree(root,&free_metadata_block->tree_node);
//Here we will created new block by splitting previous block
if(sizeof(block_meta_data_t)+sizeof(block_end_meta_data_t)<remaining_size){
if(ALIGN(sizeof(block_meta_data_t))+ALIGN(sizeof(block_end_meta_data_t))<remaining_size){
block_meta_data_t *next_meta_block=NULL;
......@@ -817,7 +862,7 @@ void *mm_malloc(size_t size)
next_meta_block->is_free=MM_TRUE;
next_meta_block->block_size=remaining_size-sizeof(block_meta_data_t)-sizeof(block_end_meta_data_t);
next_meta_block->block_size=remaining_size-ALIGN(sizeof(block_meta_data_t))-ALIGN(sizeof(block_end_meta_data_t));
next_meta_block->tree_node=init_free_node();
......@@ -832,7 +877,7 @@ void *mm_malloc(size_t size)
return (void *)(free_metadata_block+1);
return (void *)((char *)free_metadata_block+ALIGN(sizeof(block_meta_data_t)));
//mem_sbrk() is wrapper function for the sbrk() system call.
//Please use mem_sbrk() instead of sbrk() otherwise the evaluation results
......@@ -853,7 +898,7 @@ void mm_free(void *ptr)
* using 'mem_sbrk(-size)'.
*/
block_meta_data_t *meta_data_block=(block_meta_data_t *)((char *)ptr-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);
......@@ -875,7 +920,7 @@ void mm_free(void *ptr)
//If block being free is upper most block
else
{
int fragmented_size=(int)((char *)mem_heap_hi()+1-((char *)end_meta_data_addr(meta_data_block)+sizeof(block_end_meta_data_t)));
int fragmented_size=(int)((char *)mem_heap_hi()+1-((char *)end_meta_data_addr(meta_data_block)+ALIGN(sizeof(block_end_meta_data_t))));
meta_data_block->block_size+=fragmented_size;
}
......@@ -924,6 +969,8 @@ void *mm_realloc(void *ptr, size_t size)
return NULL;
}
/*
* This function should also copy the content of the previous memory block into the new block.
* You can use 'memcpy()' for this purpose.
......@@ -932,6 +979,150 @@ void *mm_realloc(void *ptr, size_t size)
* blocks should also be updated.
*/
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);
if(size < meta_data_block->block_size)
{
uint32_t original_size = (uint32_t)meta_data_block->block_size;
uint32_t inter_frag = (uint32_t)get_internal_fragmented_size(meta_data_block,meta_data_block->next_block);
meta_data_block->block_size = 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(meta_data_block->next_block && meta_data_block->next_block->is_free==MM_TRUE)
{
block_meta_data_t *new_block = NEXT_META_BLOCK_BY_SIZE(meta_data_block);
remove_block_from_tree(root, &meta_data_block->next_block->tree_node);
new_block->block_size = meta_data_block->next_block->block_size + inter_frag + (original_size - size);
meta_data_block->next_block = meta_data_block->next_block->next_block;
new_block->is_free = MM_TRUE;
new_block->tree_node= init_free_node();
mm_bind_blocks_for_allocation(meta_data_block, 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;
insert_node_in_freelist(root,new_block);
return (void *)((char *)meta_data_block+ALIGN(sizeof(block_meta_data_t)));
}
else
{
uint32_t inter_frag =0;
int fragmented_size=(int)((char *)mem_heap_hi()+1-((char *)end_meta_data_addr(meta_data_block)+ALIGN(sizeof(block_end_meta_data_t))));
if(!meta_data_block->next_block){
if( (fragmented_size+original_size-size) < (ALIGN(sizeof(block_end_meta_data_t))+ALIGN(sizeof(end_meta_data_block))) )
return meta_data_block;
}
else{
uint32_t inter_frag = get_internal_fragmented_size(meta_data_block,meta_data_block->next_block);
if( (inter_frag+original_size-size) < (ALIGN(sizeof(block_end_meta_data_t))+ALIGN(sizeof(end_meta_data_block))) )
return meta_data_block;
fragmented_size = 0;
}
meta_data_block->block_size = 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)
{
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->is_free = MM_TRUE;
new_block->block_size = original_size- size + inter_frag + fragmented_size - META_DATA_OVERHEAD;
mm_bind_blocks_for_allocation(meta_data_block, 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;
insert_node_in_freelist(root,new_block);
}
return (void *)((char *)meta_data_block+ALIGN(sizeof(block_meta_data_t)));
}
}
else
{
uint32_t req_rem_size = size-meta_data_block->block_size;
uint32_t inter_frag = 0;
if(meta_data_block->next_block)
inter_frag = get_internal_fragmented_size(meta_data_block,meta_data_block->next_block);
else
inter_frag = (uint32_t)((char *)mem_heap_hi()+1-((char *)end_meta_data_addr(meta_data_block)+ALIGN(sizeof(block_end_meta_data_t))));
if(req_rem_size <= inter_frag)
{
// TODO check sizeof function once
meta_data_block->block_size += req_rem_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;
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 && \
req_rem_size <= (TOTAL_COMBINE_SIZE_OF_BLOCKS(meta_data_block->next_block)+inter_frag))
{
remove_block_from_tree(root,&meta_data_block->next_block->tree_node);
uint32_t final_remain = TOTAL_COMBINE_SIZE_OF_BLOCKS(meta_data_block->next_block) - req_rem_size;
meta_data_block->block_size += req_rem_size;
req_rem_size -= inter_frag;
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( final_remain > META_DATA_OVERHEAD)
{
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)){
remove_block_from_tree(root,&meta_data_block->prev_block->tree_node);
meta_data_block->prev_block->block_size += req_rem_size;
req_rem_size -= inter_frag;
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;
if( final_remain > META_DATA_OVERHEAD)
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 && meta_data_block->prev_block && meta_data_block->prev_block->is_free && \
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 = abs(meta_data_block->prev_block->block_size-size);
meta_data_block->prev_block->block_size += req_rem_size;
req_rem_size -= inter_frag;
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;
if( final_remain > META_DATA_OVERHEAD)
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;
memcpy((char *)(new_meta_data_block)+ALIGN(sizeof(block_meta_data_t)), (char *)(meta_data_block)+ALIGN(sizeof(block_meta_data_t)),amount_to_be_copied);
mm_free((void *)((char *)meta_data_block+ALIGN(sizeof(block_meta_data_t))));
return (void *)((char *)new_meta_data_block+ALIGN(sizeof(block_meta_data_t)));
}
mm_free(ptr);
return mem_sbrk(size);
......@@ -941,19 +1132,23 @@ int main()
{
mm_init();
void *p1=mm_malloc(40);
void *p2=mm_malloc(40);
void *p3=mm_malloc(60);
void *p4=mm_malloc(100);
void *p5=mm_malloc(20);
void *p6=mm_malloc(90);
void *p7=mm_malloc(3500);
printf("Above Call Executed\n");
mm_free(p2);
mm_free(p4);
mm_free(p6);
mm_free(p1);
mm_free(p3);
mm_free(p5);
// mm_free(p2);
mm_free(p4);
mm_free(p6);
mm_free(p1);
// mm_free(p3);
// mm_free(p5);
// mm_free(p7);
printf("[FINAL INORDER TRAVERSAL]\n");
inorderTraversal(*root);
//mm_free(p2);
//mm_free(p2);
......@@ -961,17 +1156,3 @@ int main()
return 0;
}
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