Skip to content

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

Update mm1.c

parent b52f8bf7
Hide whitespace changes
Inline Side-by-side
Showing with 74 additions and 173 deletions
mm1.c
View file @ 45bbc0d8
......@@ -151,8 +151,6 @@ void insert_node_in_freelist(free_node_t **head,block_meta_data_t *new_metadata_
free_node_t *temp=*head;
int count=0;
int flag=0;
......@@ -259,29 +257,24 @@ void remove_block_from_free_list(free_node_t **head,free_node_t *del_node)
else
{
//printf("Came here\n");
free_node_t *temp=*head;
while(temp->next_node!=del_node)
{
temp=temp->next_node;
}
free_node_t *prev_node=del_node->prev_node;
free_node_t *next_node=del_node->next_node;
temp->next_node=del_node->next_node;
prev_node->next_node=next_node;
if(del_node->next_node!=NULL)
if(next_node!=NULL)
{
del_node->next_node->prev_node=temp;
next_node->prev_node=prev_node;
}
}
del_node->prev_node=NULL;
del_node->next_node=NULL;
// while (head1)
// {
// block_meta_data_t *trace = (block_meta_data_t *)meta_data_block_addr(head1);
// printf("%d [FREE BLOCK SIZE]\n",trace->block_size);
// head1 = head1->next_node;
// }
}
int get_internal_fragmented_size(block_meta_data_t *block1,block_meta_data_t *block2)
......@@ -296,35 +289,39 @@ int get_internal_fragmented_size(block_meta_data_t *block1,block_meta_data_t *bl
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;
unsigned 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);
size_t extra_size_req=no_of_pages_req*sys_page_size;
void *store_brk = mem_heap_hi();
void *brk= mem_sbrk(extra_size_req);
if(*(int *)brk==-1)
if(store_brk==brk && *(int *)brk == -1)
return NULL;
return brk;
}
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)
void create_new_block_and_insert_into_freelist(block_meta_data_t *meta_data_block,uint32_t final_remain)
{
block_meta_data_t *new_block = (block_meta_data_t *)NEXT_META_BLOCK_BY_SIZE(meta_data_block);
// printf("%d[NEW BLOCK BEFORE SIZE]\n", new_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;
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
if(final_remain < META_DATA_OVERHEAD)
{
meta_data_block->next_block = free_block->next_block;
new_block->block_size = (uint32_t)final_remain;
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;
new_block->free_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;
if(new_block->next_block && new_block->next_block->is_free == MM_TRUE)
merge_free_blocks(new_block, new_block->next_block);
if(new_block->prev_block && new_block->prev_block->is_free == MM_TRUE)
merge_free_blocks(new_block->prev_block,new_block);
insert_node_in_freelist(head,new_block);
}
......@@ -379,11 +376,11 @@ void *mm_malloc(size_t size)
* Try to keep the heap size as small as possible.
*/
//printf("%u [IN MALLOC]\n", size);
if(size <= 0){ // Invalid request size
return NULL;
}
size = ((size+7)/8)*8; //size alligned to 8 bytes
size = ALIGN(size); //size alligned to 8 bytes
block_meta_data_t *free_metadata_block=get_node_from_freelist(head,size);
......@@ -393,8 +390,10 @@ void *mm_malloc(size_t size)
void *brk = allocate_requested_size(size);
if(brk==NULL)
{
//printf("RETURNINH IN HERE\n");
return brk;
}
......@@ -428,13 +427,13 @@ 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=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->block_size= (uint32_t)((char *)(mem_heap_hi()+1)-(char *)brk-size-(2*(uint32_t)ALIGN(sizeof(block_meta_data_t)))-(2*(uint32_t)ALIGN(sizeof(block_end_meta_data_t))));
new_free_meta_block->free_node=init_free_node();
new_free_meta_block->free_node=init_free_node();
new_free_meta_block->prev_block=NULL;
new_free_meta_block->prev_block=NULL;
block_end_meta_data_t *new_end_free_meta_block=end_meta_data_addr(new_free_meta_block);
......@@ -449,7 +448,7 @@ void *mm_malloc(size_t size)
assert(free_metadata_block->is_free==MM_TRUE);
//printf("Free Data block size=%d\n",(int)free_metadata_block->block_size);
remove_block_from_free_list(head,&free_metadata_block->free_node);
uint32_t remaining_size=free_metadata_block->block_size-size;
......@@ -461,7 +460,6 @@ void *mm_malloc(size_t size)
end_meta_data->block_size=size;
remove_block_from_free_list(head,&free_metadata_block->free_node);
//Here we will created new block by splitting previous block
if(ALIGN(sizeof(block_meta_data_t))+ALIGN(sizeof(block_end_meta_data_t))<remaining_size){
......@@ -470,7 +468,6 @@ void *mm_malloc(size_t size)
block_end_meta_data_t *next_end_meta_block=NULL;
// printf("%p %d %u[CHECKING NECT_BLOCK_BY_SIZE]\n",(char *)(free_metadata_block+1), free_metadata_block->block_size , sizeof(block_end_meta_data_t));
next_meta_block=NEXT_META_BLOCK_BY_SIZE(free_metadata_block);
next_meta_block->is_free=MM_TRUE;
......@@ -483,10 +480,8 @@ void *mm_malloc(size_t size)
next_end_meta_block->block_size=next_meta_block->block_size;
insert_node_in_freelist(head,next_meta_block);
mm_bind_blocks_for_allocation(free_metadata_block,next_meta_block);
}
......@@ -503,8 +498,6 @@ void *mm_malloc(size_t size)
void mm_free(void *ptr)
{
/*
* Searches the previously allocated node for memory block with base address ptr.
*
......@@ -515,6 +508,7 @@ void mm_free(void *ptr)
* 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");
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);
......@@ -557,6 +551,8 @@ void mm_free(void *ptr)
{
remove_block_from_free_list(head,&prev_meta_data_block->free_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;
......@@ -566,7 +562,6 @@ void mm_free(void *ptr)
merged_end_meta_data_block->block_size=merged_meta_data_block->block_size;
// printf("%d %d [AFTER MERGINGN FAILING HERE]\n",merged_meta_data_block->block_size);
insert_node_in_freelist(head,merged_meta_data_block);
}
......@@ -586,9 +581,7 @@ void *mm_realloc(void *ptr, size_t size)
* blocks should also be updated.
*/
// mm_free(ptr);
// return mem_sbrk(size);
//printf("[IN REALLOC]\n");
size = ((size+7)/8)*8; //8-byte alignement
// printf("%lu [SIZE AFTER ALIGNMNET]",size);
......@@ -620,9 +613,8 @@ void *mm_realloc(void *ptr, size_t size)
{
block_meta_data_t *new_block = NEXT_META_BLOCK_BY_SIZE(meta_data_block);
remove_block_from_free_list(head, &meta_data_block->next_block->free_node);
// printf("%d %d %d\n", meta_data_block->next_block->block_size , inter_frag , (original_size-size));
new_block->block_size = meta_data_block->next_block->block_size + inter_frag + (original_size - size);
// printf("%d [AFTER REALLOC]\n",new_block->block_size);
meta_data_block->next_block = meta_data_block->next_block->next_block;
new_block->is_free = MM_TRUE;
new_block->free_node= init_free_node();
mm_bind_blocks_for_allocation(meta_data_block, new_block);
......@@ -631,7 +623,6 @@ void *mm_realloc(void *ptr, size_t size)
new_end_meta_data_block->block_size = new_block->block_size;
insert_node_in_freelist(head,new_block);
// printf("%u [NEW FREE BLOCK SIZE ]\n %u [OLD BLOCK SIZE] \n",meta_data_block->next_block->block_size, meta_data_block->block_size);
return (void *)((char *)meta_data_block+ALIGN(sizeof(block_meta_data_t)));
}
......@@ -654,7 +645,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->free_node = init_free_node();
......@@ -680,75 +671,63 @@ void *mm_realloc(void *ptr, size_t size)
if(req_rem_size <= inter_frag)
{
// TODO check sizeof function once
meta_data_block->block_size += req_rem_size;
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;
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_free_list(head,&meta_data_block->prev_block->free_node);
remove_block_from_free_list(head,&meta_data_block->next_block->free_node);
req_rem_size = abs(meta_data_block->prev_block->block_size-size);
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->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))
{
// printf("%p [IN REALLAOC]\n",&meta_data_block->next_block->free_node);
remove_block_from_free_list(head,&meta_data_block->next_block->free_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;
// printf("%d [FINAL REMAINING] %d [ALLTED BLOCK SIZE]\n",final_remain, meta_data_block->block_size);
// printf("%d [SIZE TO REMOVED FROM FREE LIST]\n", meta_data_block->next_block->block_size);
// printf("[REMOVED$$$$$$$$$$$$$$$$$]\n");
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);
}
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->next_block = meta_data_block->next_block->next_block;
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->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)){
// printf("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@2\n");
inter_frag = get_internal_fragmented_size(meta_data_block->prev_block,meta_data_block);
remove_block_from_free_list(head,&meta_data_block->prev_block->free_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->prev_block->block_size = 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);
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);
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_free_list(head,&meta_data_block->prev_block->free_node);
remove_block_from_free_list(head,&meta_data_block->next_block->free_node);
// printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!11111\n");
// printf("%d %d %d %d[]block size]\n",meta_data_block->prev_block->block_size, meta_data_block->block_size , meta_data_block->next_block->block_size, req_rem_size);
req_rem_size = abs(meta_data_block->prev_block->block_size-size);
meta_data_block->prev_block->block_size += req_rem_size;
printf("%d \n", meta_data_block->prev_block->block_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);
// printf("\n%d %d %d[REMAIN SIZE*********************************]\n",meta_data_block->next_block->block_size,meta_data_block->prev_block->block_size,final_remain);
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)));
......@@ -759,81 +738,3 @@ void *mm_realloc(void *ptr, size_t size)
}
}
void traverse_list(free_node_t *root)
{
while(root!=NULL)
{
block_meta_data_t *meta_data=meta_data_block_addr(root);
printf("Block size =%d\n",meta_data->block_size);
root=root->next_node;
}
}
/*
int main(int argc,char *argv[])
{
mm_init();
int *p1=mm_malloc(400);
void *p2=mm_malloc(400);
// int i=0;
// for(i =0;i<6;i++)
// p1[i] = i;
void *p3=mm_malloc(400);
void *p4 = mm_malloc(400);
// block_meta_data_t *meta_data_block=(block_meta_data_t *)((char *)p3-sizeof(block_meta_data_t));
// meta_data_block=(block_meta_data_t *)((char *)p2-sizeof(block_meta_data_t));
p1 = mm_realloc(p1,32);
//void *p5=mm_malloc(60);
// for(int j=0;j<6;j++)
// printf("%d value\n",p1[j]);
//mm_free(p4);
mm_free(p1);
traverse_list(*head);
mm_free(p2);
traverse_list(*head);
mm_free(p4);
mm_free(p3);
//mm_free(p5);
mm_malloc(100);
//mm_malloc(3962);
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