feat: malloc tiny zones working on one zone

inc/malloc.h

@@ -39,6 +39,7 @@ extern pthread_mutex_t g_malloc_mutex;
 extern t_zones g_zones;
 
 void *malloc(size_t size);
+void *ft_malloc(size_t size);
 void free(void *ptr);
 void *realloc(void *ptr, size_t size);
 
@@ -46,8 +47,8 @@ void show_alloc_mem(void);
 void show_alloc_mem_ex(void);
 void show_alloc_sizes(void);
 
-static void init_malloc(void);
 void init_tiny_zones(void);
 void init_small_zones(void);
 
 #endif
+

main.c

@@ -2,9 +2,16 @@
 #include "inc/malloc.h"
 
 int main(void) {
-	int *arr = malloc(42);
+	int *arr = ft_malloc(42);
+	printf ("addr of arr is : %p\n", arr);
 	arr = realloc(arr, 42);
+	int *arr2 = ft_malloc(124);
+	int *arr3 = ft_malloc(1540);
+	printf ("addr of arr is : %p\n", arr);
+	printf ("addr of arr2 is : %p\n", arr2);
+	printf ("addr of arr3 is : %p\n", arr3);
 	free(arr);
 	show_alloc_sizes();
 	return 0;
 }
+

src/init.c

@@ -5,6 +5,7 @@ t_zones g_zones;
 
 void init_tiny_zones(void) {
 	g_zones.tiny_block_max_size = g_zones.pagesize / 2;
+	// TODO protect mmap
 	g_zones.tiny_zones = (t_zone *)mmap(NULL, g_zones.tiny_block_max_size * 128, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 	g_zones.tiny_zones->head = NULL;
 	g_zones.tiny_zones->next = NULL;
@@ -12,6 +13,7 @@ void init_tiny_zones(void) {
 
 void init_small_zones(void) {
 	g_zones.small_block_max_size = g_zones.tiny_block_max_size * 128;
+	// TODO protect mmap
 	g_zones.small_zones = (t_zone *)mmap(NULL, g_zones.small_block_max_size * 128, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 	g_zones.small_zones->head = NULL;
 	g_zones.small_zones->next = NULL;
@@ -24,3 +26,4 @@ static void init_malloc(void) {
 	init_tiny_zones();
 	init_small_zones();
 }
+

src/malloc.c

@@ -1,9 +1,79 @@
 #include "malloc.h"
 
-void *malloc(size_t size) {
+void *malloc_tiny(size_t size) {
-	pthread_mutex_lock(&g_malloc_mutex);
+	// TODO check if zone still has size and expand zone if needed
-	(void)size;
+	t_block **head = &(g_zones.tiny_zones->head);
-	write(1, "42 from malloc\n", 15);
+	if (*head == NULL) {
-	pthread_mutex_unlock(&g_malloc_mutex);
+		// TODO size_t should be replaced by char * for pointer arithmetic
+		size_t addr = ((size_t)g_zones.tiny_zones + sizeof(t_zone));
+		printf("addr %zu\n", addr);
+		if ((addr + sizeof(t_block)) % 16 != 0) {
+			addr += 16 - ((addr + sizeof(t_block)) % 16);
+		}
+		printf("addr %zu\n", addr);
+		*head = (t_block *)addr;
+		printf("addr of g_zones.tiny_zones : %p\n \
+				addr of *head %p\n \
+				sizeof tzone : %zu\n \
+				size of tblock %zu\n",
+				g_zones.tiny_zones,
+				*head,
+				sizeof(t_zone),
+				sizeof(t_block));
+		(*head)->size = size;
+		(*head)->free = 0;
+		(*head)->next = NULL;
+		return (void *)((char *)(*head) + sizeof(t_block));
+	}
+	else {
+		t_block *curr = *head;
+		while (curr->next) {
+			// todo check if free and defrag
+			curr = curr->next;
+		}
+		printf("addr of curr %p\n \
+				curr->size %zu\n", curr, curr->size);
+		// TODO size_t should be replaced by char * for pointer arithmetic
+		size_t addr = (size_t)curr + sizeof(t_block) + curr->size;
+		printf("addr %zu\n", addr);
+		if ((addr + sizeof(t_block)) % 16 != 0) {
+			addr += 16 - ((addr + sizeof(t_block)) % 16);
+		}
+		printf("addr %zu\n", addr);
+		curr->next = (t_block *)addr;
+		curr = curr->next;
+		printf("addr of curr %p\n", curr);
+		curr->size = size;
+		curr->free = 0;
+		curr->next = NULL;
+		return (void *)((char *)curr + sizeof(t_block));
+	}
 	return NULL;
 }
+
+void *malloc_small(size_t size) {
+	(void)size;
+	return NULL;
+}
+
+void *malloc_large(size_t size) {
+	(void)size;
+	return NULL;
+}
+
+void *ft_malloc(size_t size) {
+	pthread_mutex_lock(&g_malloc_mutex);
+	void *ptr = NULL;
+	if (size < g_zones.tiny_block_max_size) {
+		printf("entering malloc_tiny\n");
+		ptr = malloc_tiny(size);
+	} else if (size < g_zones.small_block_max_size) {
+		ptr = malloc_small(size);
+	} else {
+		ptr = malloc_large(size);
+	}
+	write(1, "42 from malloc\n", 15);
+	pthread_mutex_unlock(&g_malloc_mutex);
+	return ptr;
+}
+