final

alloc.c

 #include "alloc.h"
+
+size_t align_4_unit(size_t size);
+
+
+void *m_malloc(size_t size){
+
+	size = align_4_unit(size);
+	
+	if(head == NULL){
+		meta* temp;
+		temp = sbrk(sizeof(struct meta_struct)+size);
+		temp->next = NULL;
+		temp->prev = NULL;
+		temp->size = size;
+		temp->free = 0;
+
+		head = temp;
+		tail = temp;
+		return (void*)temp+sizeof(struct meta_struct);
+	}
+
+	meta* ptr = head;
+	meta* ptr_assign;
+
+	if(fit == ALLOC_FIRST_FIT){
+		while(!ptr->free){
+			if(ptr == NULL) break;
+			if(ptr->size>(size+sizeof(struct meta_struct))) break;
+			else ptr = ptr->next;
+		}
+		ptr_assign = ptr;
+	}
+	else if(fit == ALLOC_WORST_FIT){
+		while(ptr){
+			if(ptr->size > size+sizeof(struct meta_struct) && ptr->free == 1){
+				if(ptr_assign == NULL) ptr_assign = ptr;
+				else if(ptr_assign->size < ptr->size) ptr_assign = ptr;
+			}
+			else ptr = ptr->next;
+		}
+	}
+	else if(fit == ALLOC_BEST_FIT){
+		while(ptr){
+			if(ptr->size > size+sizeof(struct meta_struct) && ptr->free == 1){
+				if(ptr_assign == NULL) ptr_assign = ptr;
+				else if(ptr_assign->size > ptr->size) ptr_assign = ptr;
+			}
+			else ptr = ptr->next;
+		}
+	}
+	else {
+		sprintf(stderr,"wrong fit option");
+	}
+	//printf("fit option done\n");
+
+	if(ptr_assign == NULL){
+		meta* temp;
+		temp = sbrk(sizeof(struct meta_struct)+size);
+		temp->next = NULL;
+		temp->prev = tail;
+		temp->size = size;
+
+		tail->next = temp;
+		tail = temp;
+
+		return (void*)temp+sizeof(struct meta_struct);
+	}
+	else{
+		meta* temp = (void*)(ptr_assign->next - (size+sizeof(struct meta_struct)));
+		temp->prev = ptr_assign->prev;
+		temp->prev->next = temp;
+		if(ptr_assign->next) ptr_assign->next->prev = temp;
+		temp->next = ptr_assign->next;
+		temp->size = size;
+		ptr_assign->size = ptr_assign->size - (sizeof(struct meta_struct)+size);
+
+		return temp+sizeof(struct meta_struct);
+
+	}
+
+}
+void m_free (void*ptr){
+	if(ptr == NULL) return;
+	meta* current = ptr;
+	current = (void*)(current - sizeof(struct meta_struct));
+	current->free = 1;
+
+	if(current == tail){
+		if(current == head){
+			brk(head);
+		}
+		else{
+			tail = current->prev;
+			current->prev->next = NULL;
+			brk(current->prev);
+		}
+	}
+	if(current->prev && current->prev->free){
+		current->prev->size += current->size;
+
+		current->prev->next = current->next;
+		if(current->next) current->next->prev = current->prev;
+	}
+	if(current->next && current->next->free){
+		current->size += current->next->size;
+
+		current->next = current->next->next;
+		if(current->next->next) current->next->prev = current;
+	}
+
+
+}
+
+void* m_realloc(void* ptr,size_t size){
+
+	meta *current = ptr;
+	current = (void * )(current - sizeof(struct  meta_struct));
+	if(size < current->size){
+		meta *mark_empty = (void * )current + (sizeof(struct meta_struct) + size);
+		mark_empty->prev = current;
+		mark_empty->next = current->next;
+		mark_empty->size = current->size - size;
+		mark_empty->free = 1;
+
+		current->next = mark_empty;
+		current->next->prev = mark_empty;
+
+		memcpy(current,ptr,(sizeof(struct meta_struct)+size));
+
+		return (void*)(current+sizeof(struct meta_struct));
+
+	}else if(size>current->size){//size>current->size
+
+		if(current == tail){
+			sbrk(size - current->size);
+			current->size = size;
+			return (void*)(current+sizeof(struct meta_struct));
+		}
+		else{
+			if(current->size + current->next->size >= size){
+				current->next = (void*)current +(sizeof(struct meta_struct)+ size);
+				current->next->size = (current->next->size -(size - current->size));
+				current->size = size;
+				current->next->free = 1;
+
+				return (void*)(current+sizeof(struct meta_struct));
+			}
+			else{
+				meta *temp = m_malloc(size);
+				memcpy(temp,current,size+sizeof(struct meta_struct));
+				m_free(ptr);
+				return (void*)(temp+sizeof(struct meta_struct));
+			}
+		}
+	}
+
+}
+
+
+size_t align_4_unit(size_t size){
+	return size+(4-(size%4));
+}
\ No newline at end of file

alloc.h

 #ifndef _ALLOC_H_
 #define _ALLOC_H_
 
+#include <stdint.h>
+#include <sys/types.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define ALLOC_FIRST_FIT 0
+#define ALLOC_BEST_FIT 1
+#define ALLOC_WORST_FIT 2
+
+
 typedef struct meta_struct {
+	struct meta_struct* next;
+	struct meta_struct* prev;
+
+	uint32_t free;
+	uint32_t size;
 
 } meta;
 
+meta* head;
+meta* tail;
+int fit;
+
+int num;
+char type[10];
+
 #endif

input.txt

+3 F
+s Think like a man of action and act like man of thought.
+s Courage is very important. Like a muscle, it is strengthened by use.
+s Life is the art of drawing sufficient conclusions from insufficient premises.
\ No newline at end of file

main.c

 #include "alloc.h"
+#include<unistd.h>
+#include <string.h>
 
-int main()
+int main(int argc,char* argv[]){	
+	int count = 0;
+	int k = 0;
+	FILE* fp = fopen("input.txt","r");
+	char buffer[512];
+	char* token;
+	int length = strlen(buffer);
+
+	fgets(buffer,512,fp);
+	buffer[length-1]='\0';
+	//printf("%s",buffer);
+
+	if(buffer[2] == 'F'){
+		fit = ALLOC_FIRST_FIT;
+	}
+	else if(buffer[2] == 'B'){
+		fit = ALLOC_BEST_FIT;
+	}
+	else if(buffer[2] == 'W'){
+		fit = ALLOC_WORST_FIT;
+	}
+	else{
+		printf("wrong flags\n");
+		printf("%s",buffer);
+		return -1;
+	}
+	void * chunk_list[100];
+	meta * meta_chunk[100];
+	printf("while\n");
+
+	do{
+		fgets(buffer,512,fp);
+	//	printf("%s",buffer);
+		token = strtok(buffer," ");
+		//printf("%s\n",token);
+		if(!strcmp(token,"s")){
+		//	printf("token : %s\n",token);
+			//printf("%s\n",token);
+			token = strtok(NULL,"\n");
+			printf("%s\n",token);
+			chunk_list[count] = m_malloc(strlen(token)+1);
+			strcpy(chunk_list[count],token);
+			count ++;
+			printf("s is done\n");
+
+		}
+		else if(!strcmp(token,"f")){
+	//		token = strtok(NULL,"\n");
+	//		int free = atoi(token);
+	//		m_free(chunk_list[free]);
+	//		k++;
+		}
+		else if(!strcmp(token,"e")){
+	//		token = strtok(NULL,"\n");
+	//		int b = atoi(token);
+	//		chunk_list[count-k] = m_malloc(b);
+	//		chunk_meta[count-k] = (meta *)((char*)chunk_list[count-k]-sizeof(struct meta_struct));
+		}
+		else if (!strcmp(token,"r")){
+
+		}
+	}while(buffer);
+
+
+	/*
+	meta* met[num];
+	void *chunk[num];
+	
+	int n =0;
+	int  i =0;
+	int dup=0;
+
+	for ( ; i < num ; i++ )
+	{
+		fgets(buf,256,fd);
+		tok = strtok(buf," ");
+		
+		if(!strcmp(tok,"s"))
+		{
+			tok = strtok(NULL,"\n");
+			strcpy(data,tok);
+			
+   			
+			chunk[i-dup] = m_malloc(strlen(data)+1);
+			strcpy((char *)chunk[i-dup],data);
+			met[i-dup] = (meta*)((char *)chunk[i-dup]-16);
+//			printf("%d - %d\n",i ,chunk[i]);
+		}
+		else if(!strcmp(tok,"f"))
 		{
-  return 0;
+			tok = strtok(NULL,"\n");
+			int target = atoi(tok);
+//			printf("%d target - %d\n",target,chunk[target]);
+			m_free(chunk[target]);
+			dup++;
 		}
+		else if(!strcmp(tok,"r"))
+		{
+			tok = strtok(NULL," ");
+			int target = atoi(tok);
+			
+			tok = strtok(NULL,"\n");
+			int byte = atoi(tok);
+			
+			m_realloc(chunk[target],(size_t)byte);
+			dup++;
+		
+		}
+		else if(!strcmp(tok,"e"))
+		{
+			
+			tok = strtok(NULL,"\n");
+			int byte = atoi(tok);
+			
+			chunk[i-dup] = m_malloc(byte);
+			
+			met[i-dup] = (meta*)((char *)chunk[i-dup]-16);
+		
+		}
+	}
+		int h=0;
+		while(head)
+		{
+			if((head->free) ==1)
+			{}
+			else{
+			printf("%d %d-%s\n",head->free,head->size,(char *)head+16);
+			
+			}
+			head= head->next;
+		}
+	
+		printf("Finished\n");*/
+	fclose(fp);
+}
+
+/*
+
+
+
+}*/
\ No newline at end of file

temp.c

+#include "alloc.h"
+// 1 meta size is 16   -    point + 1  ==  16 meta size
+// count
+// free - 0  (not free) &  free - 1 (free)
+// return new meta pointer
+void *new_malloc(size_t chunk_size){
+	meta* a;
+	
+	a = sbrk(sizeof(meta)+chunk_size) ;
+	a->next = NULL;
+	a->prev = NULL;
+	a->size = chunk_size;
+	a->free = 0;
+	return a;
+} 
+void *m_malloc(size_t size)
+{
+	meta* ret;
+	meta* save;
+	// new head
+	if(head == NULL)
+	{
+	  head = new_malloc(size);
+	  return (head+1);
+	}
+	// head exist
+	else
+	{
+		save = head;
+	// for reculsive
+	  meta* prev;
+	 int count=0;
+	//first fit
+	if(fit == 0){ 
+	//find split space
+	while( (head && (!(head->free) || head->size < (size+sizeof(meta)))) )
+	{
+		prev = head;
+		head = head->next;
+		count++;
+	}}//first fit
+	//Best fit
+	else if(fit ==1){
+//		printf("Best\n");
+		int offset = 0;
+		int i = 0;
+		int sub = 50000;
+		int cmp = 0;
+		int flag = 0;
+		while(head)
+		{
+		
+			if(head->free && head->size >= (size + sizeof(meta)) )
+			{
+	
+				cmp = head->size - (size + sizeof(meta));
+				if(sub > cmp)
+				{
+					sub = cmp;
+					offset = i;
+					flag =1;
+				}
+			}
+			i++;
+			head =head -> next;
+		}
+		head = save;
+		
+		if(flag == 0)
+		{
+			while(head)
+			{
+				prev = head;
+				head = head->next;
+			}
+		}
+		
+		else{
+		for(i=0;i<offset;i++)
+		{	
+			prev = head;
+			head = head->next;
+		}
+		}
+	
+	}
+	
+	
+	//Worst fit
+	else{
+		
+//		printf("Worst\n");
+		int offset = 0;
+		int i = 0;
+		int sub = 0;
+		int cmp = 0;
+		int flag = 0;
+		while(head)
+		{
+			if(head->free && head -> size >= (size + sizeof(meta)))
+			{
+				cmp = head -> size - (size + sizeof(meta));
+				if(sub < cmp)
+				{
+					sub = cmp;
+					offset = i;
+					flag = 1;
+				}
+			}
+			i++;
+			head = head -> next;
+		}
+		head = save;
+		if(flag == 0){
+		
+			while(head)
+			{
+				prev = head;
+				head = head->next;
+			}
+		}
+		
+		else{
+		for(i=0;i<offset;i++)
+		{
+			prev=head;
+			head = head->next;
+		}
+		}
+	}
+	// if no space
+	if(head==NULL){
+	
+//		printf("if no space\n");
+		
+		meta* new = (sbrk(sizeof(meta) + size));
+		new->next = NULL;
+		new->prev = prev;
+		new->size = size;
+		prev->next = new;
+		new->free = 0;
+		ret = new;
+	}
+	// space exists
+	else{
+	
+//		printf("space exists %d\n",size);
+		meta* new = (meta*)((char *)head->next - (sizeof(meta)+size) );	
+		new-> next = head->next;
+		if(head->next)
+			head->next->prev = new;
+		new->free = 0;
+		new -> prev = head;
+		head->next = new;
+		new -> size = size ;
+		head -> size = head->size - (sizeof(meta)+size);
+		
+		ret = new;
+	}
+	  head = save;
+	}//else
+	return (ret+1) ;
+}
+void m_free(void *ptr)
+{
+	ptr = ptr-16;
+	// NULL
+	if(!ptr)
+	{
+		printf("NULL\n");
+		return;
+	}
+	int flag=0;
+	meta *save = head;
+	while(head)
+	{
+		
+		if(head == ptr)
+		{
+			flag =1 ;
+			break;
+		}
+		
+		head = head->next;
+	}
+	if(flag == 0)
+	{
+		printf("Invalid pointer\n");
+		return;
+	}
+	head = save;
+	meta* a = (meta*)ptr;
+	a->free = 1;
+//	printf("a->prev %d\n",a->prev);
+//printf("123 123\n");
+	if(a->next && a->next->free)
+	{
+		a->size = sizeof(meta) + a->size + a->next->size;
+		a->next = a->next->next;
+		if(a->next)
+		{
+			a->next->prev = a;
+		}
+	}
+//printf("134 134\n");
+	if(ptr==head)
+	{}
+	else if(a->prev->free)
+	{
+		a = a->prev;
+		a->size = sizeof(meta) + a->size + a->next->size;
+		a->next = a->next->next;
+		if(a->next)
+		{
+			a->next->prev = a;
+		}
+	}
+//printf("146 146\n");
+	if((a->next)==NULL)
+	{
+		if(a == head)
+		{
+			sbrk(-(a->size + sizeof(meta)));
+			head = NULL;
+		}
+		else{
+		a->prev->next= NULL;
+		sbrk(- (a->size + sizeof(meta)));
+		}
+	}
+//printf("???\n");
+}
+void * m_realloc(void* ptr,size_t size){
+	
+	char copy[1024];
+	strcpy(copy,ptr);
+	ptr = ptr-16;
+	meta* a = (meta *)ptr;
+	
+	if((a->size == size))
+	{
+		return ptr+16;
+	}
+	if( a->size > size   )
+	{
+		if( a->size - 16 < size   )
+		{
+	
+			return ptr+16;
+		}
+	
+		else
+		{
+		meta* split = (meta *)( (char*)a + sizeof(meta) + size  );
+		split -> size = a->size - sizeof(meta) - size;
+		split -> free = 1;
+		split -> next = a->next;
+		if(split->next)
+		{
+			split->next->prev = split;
+		}
+		split -> prev = a;
+		a->next = split;
+		a->size = size;
+		
+		a+=1;
+		strcpy((void *)a,copy);
+		return a;
+		}
+	}
+	if(!a->next)
+	{
+		sbrk(size - a->size);
+		a->size = size;
+		
+		return a+1;
+	}
+	else{
+		if( (a->next->free ==1) && ( (a->size + a->next->size) >= size  )  )
+		{
+		meta *fusion = (meta *)((char *)a + sizeof(meta) + size  );
+		fusion->free = 1;
+		fusion->size = a->next->size - (size - a->size);
+		fusion->next = a->next->next;
+		if(fusion->next)
+		{
+			fusion->next->prev = fusion;
+		}
+		fusion ->prev = a;
+		a->size = size;
+		a->next = fusion;
+		a+=1;
+		strcpy((void *)a,copy);
+		return a;
+		}
+	}
+	ptr += 16;
+	m_free(ptr);
+	void *r = m_malloc(size);
+	
+	a = (meta *)((char *)r + sizeof(meta));
+	strcpy((void *)a,copy);
+	return a;
\ No newline at end of file