From e9d71e162ed6ae90ffa48ed5120f0b98fb5418b7 Mon Sep 17 00:00:00 2001
From: KimJihwan <eric967712@ajou.ac.kr>
Date: Fri, 15 Jun 2018 23:41:46 +0900
Subject: [PATCH] final

---
 Makefile  |   0
 README.md |   0
 alloc.c   | 162 +++++++++++++++++++++++++++++
 alloc.h   |  23 +++++
 input.txt |   4 +
 main      | Bin 0 -> 24424 bytes
 main.c    | 145 +++++++++++++++++++++++++-
 temp.c    | 303 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 8 files changed, 634 insertions(+), 3 deletions(-)
 mode change 100644 => 100755 Makefile
 mode change 100644 => 100755 README.md
 mode change 100644 => 100755 alloc.c
 mode change 100644 => 100755 alloc.h
 create mode 100644 input.txt
 create mode 100755 main
 mode change 100644 => 100755 main.c
 create mode 100644 temp.c

diff --git a/Makefile b/Makefile
old mode 100644
new mode 100755
diff --git a/README.md b/README.md
old mode 100644
new mode 100755
diff --git a/alloc.c b/alloc.c
old mode 100644
new mode 100755
index 931b9fd..02527ff
--- a/alloc.c
+++ b/alloc.c
@@ -1 +1,163 @@
 #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
diff --git a/alloc.h b/alloc.h
old mode 100644
new mode 100755
index 3245f55..36a5233
--- a/alloc.h
+++ b/alloc.h
@@ -1,8 +1,31 @@
 #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
diff --git a/input.txt b/input.txt
new file mode 100644
index 0000000..8a55a18
--- /dev/null
+++ b/input.txt
@@ -0,0 +1,4 @@
+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
diff --git a/main b/main
new file mode 100755
index 0000000000000000000000000000000000000000..dad82d849c7cb88106be86de548bf4b7ede12089
GIT binary patch
literal 24424
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
DUqec}

literal 0
HcmV?d00001

diff --git a/main.c b/main.c
old mode 100644
new mode 100755
index b5fba06..29d2636
--- a/main.c
+++ b/main.c
@@ -1,6 +1,145 @@
 #include "alloc.h"
+#include<unistd.h>
+#include <string.h>
 
-int main()
-{
-  return 0;
+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"))
+		{
+			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
diff --git a/temp.c b/temp.c
new file mode 100644
index 0000000..b33968b
--- /dev/null
+++ b/temp.c
@@ -0,0 +1,303 @@
+#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
-- 
GitLab