munmap only on large

Author: mirsella

include/malloc.h

@@ -17,7 +17,6 @@
 
 #define MMAP_SHIFT(mmap) ((void *)mmap + sizeof(t_mmap))
 #define ALLOC_SHIFT(alloc) ((void *)alloc + sizeof(t_alloc))
-#define TESTNULL(mmap) ((mmap == NULL || mmap == (void *)1) ? 1 : 0)
 
 #define ALIGNMENT 16 // 8 on 32 bits, 16 on 64 bits
 #define TINY_MMAP_SIZE (4 * getpagesize())
@@ -27,7 +26,7 @@
 // 4*4096 - 100*(1024+32) = 25472 free space
 #define SMALL_ALLOC_SIZE (1024)
 
-typedef enum e_type { ANCHOR, TINY, SMALL, LARGE } t_type;
+typedef enum e_type { TINY, SMALL, LARGE } t_type;
 
 typedef struct s_alloc t_alloc; // declare it here to use it in s_mmap
 typedef struct s_mmap {
@@ -58,7 +57,7 @@ void *_malloc(size_t size);
 void *malloc(size_t size);
 
 // free.c
-void _free(void *mmap);
+void _free(void *ptr);
 void free(void *ptr);
 
 // realloc.c

src/alloc.c

@@ -3,9 +3,7 @@
 // alternative method to find alloc even if the ptr is in the middle of the
 // alloc
 t_alloc *find_alloc_ptr(void *ptr) {
-  if (TESTNULL(g_mmap))
-    return NULL;
-  for (t_mmap *mmap = g_mmap; !TESTNULL(mmap); mmap = mmap->next) {
+  for (t_mmap *mmap = g_mmap; mmap; mmap = mmap->next) {
     if (ptr < (void *)mmap || ptr > MMAP_SHIFT(mmap) + mmap->size)
       continue;
     for (t_alloc *alloc = mmap->alloc; alloc; alloc = alloc->next) {
@@ -60,9 +58,9 @@ t_alloc *new_alloc(t_mmap *mmap, void *ptr, size_t size) {
 }
 
 t_alloc *find_alloc(size_t size) {
-  if (TESTNULL(g_mmap))
+  if (!g_mmap)
     return NULL;
-  for (t_mmap *mmap = g_mmap; !TESTNULL(mmap); mmap = mmap->next) {
+  for (t_mmap *mmap = g_mmap; mmap; mmap = mmap->next) {
     if (mmap->type != get_mmap_type(size))
       continue;
 

src/free.c

@@ -1,9 +1,8 @@
 #include "../include/malloc.h"
 #include <stddef.h>
-#include <unistd.h>
 
 void _free(void *ptr) {
-  if (!ptr || TESTNULL(g_mmap))
+  if (!ptr | !g_mmap)
     return;
   /* t_alloc *alloc = ptr - sizeof(t_alloc); */
   t_alloc *alloc = find_alloc_ptr(ptr);
@@ -22,9 +21,7 @@ void _free(void *ptr) {
     alloc->parent->alloc = alloc->next;
 
   // in case it's the only alloc in a t_mmap, free the mmap
-  if (alloc->parent->type != LARGE)
-    return;
-  if (!alloc->next && !alloc->prev) {
+  if (!alloc->next && !alloc->prev && alloc->parent->type == LARGE) {
     t_mmap *map = alloc->parent;
     if (map->prev)
       map->prev->next = map->next;
@@ -33,12 +30,13 @@ void _free(void *ptr) {
     // FIX: this cause page reclaims to skyrocket
     if (map == g_mmap)
       g_mmap = map->next;
-
     munmap(map, map->size + sizeof(t_mmap));
   }
 }
 
 void free(void *ptr) {
+  (void)ptr;
+  /* return; */
   if (LOGGING) {
     ft_dprintf(tmpfd(), "free(%p)\n", ptr);
     /* flog("free(): ", (size_t)ptr); */

src/global_init.c

@@ -1,7 +1,6 @@
 #include "../include/malloc.h"
 #include <string.h>
 
-/* t_mmap g_mmap = {NULL, NULL, ANCHOR, 0, NULL}; */
 t_mmap *g_mmap = NULL;
 
 pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;

src/malloc.c

@@ -1,12 +1,10 @@
 #include "../include/malloc.h"
-#include <unistd.h>
 
 void *_malloc(size_t size) {
   t_alloc *res = find_alloc(size);
   if (res)
     return ALLOC_SHIFT(res);
-  if (!new_mmap(size))
-    return NULL;
+  new_mmap(size);
   res = find_alloc(size);
   return ALLOC_SHIFT(res);
 }

src/mmap.c

@@ -17,21 +17,21 @@ t_type get_mmap_type(size_t size) {
 }
 
 t_mmap *new_mmap(size_t size) {
-  void *ptr = mmap(NULL, get_mmap_size(size) + sizeof(t_mmap),
-                   PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-  if (!ptr) {
+  t_mmap *map =
+      mmap(NULL, get_mmap_size(size) + sizeof(t_mmap), PROT_READ | PROT_WRITE,
+           MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  if (!map) {
     errno = ENOMEM;
     return NULL;
   }
-  t_mmap *map = ptr;
   map->type = get_mmap_type(size);
   map->size = get_mmap_size(size);
   map->next = NULL;
   map->prev = NULL;
   map->alloc = NULL;
-  if (TESTNULL(g_mmap))
+  if (!g_mmap)
     return g_mmap = map;
-  for (t_mmap *tmp = g_mmap; !TESTNULL(tmp); tmp = tmp->next) {
+  for (t_mmap *tmp = g_mmap; tmp; tmp = tmp->next) {
     if (map < tmp) {
       map->prev = tmp->prev;
       map->next = tmp;

src/show_alloc_mem.c

@@ -11,13 +11,13 @@ char *get_type_string(t_type type) {
 
 void show_alloc_mem() {
   lock_mutex();
-  if (TESTNULL(g_mmap)) {
+  if (!g_mmap) {
     ft_putstr("show_alloc_mem(): No memory allocated\n");
     unlock_mutex();
     return;
   }
   size_t total = 0;
-  for (t_mmap *mmap = g_mmap; !TESTNULL(mmap); mmap = mmap->next) {
+  for (t_mmap *mmap = g_mmap; mmap; mmap = mmap->next) {
     ft_printf("%s : %p\n", get_type_string(mmap->type), mmap);
     for (t_alloc *alloc = mmap->alloc; alloc; alloc = alloc->next) {
       if (!alloc)
@@ -70,13 +70,13 @@ void hexdump(void *ptr, size_t size) {
 
 void show_alloc_mem_asciidump() {
   lock_mutex();
-  if (TESTNULL(g_mmap)) {
+  if (!g_mmap) {
     ft_putstr("show_alloc_mem_ex(): No memory allocated\n");
     unlock_mutex();
     return;
   }
   size_t total = 0;
-  for (t_mmap *mmap = g_mmap; !TESTNULL(mmap); mmap = mmap->next) {
+  for (t_mmap *mmap = g_mmap; mmap; mmap = mmap->next) {
     ft_printf("%s : %p\n", get_type_string(mmap->type), mmap);
     for (t_alloc *alloc = mmap->alloc; alloc; alloc = alloc->next) {
       if (!alloc)
@@ -99,13 +99,13 @@ void show_alloc_mem_asciidump() {
 
 void show_alloc_mem_hexdump() {
   lock_mutex();
-  if (TESTNULL(g_mmap)) {
+  if (!g_mmap) {
     ft_putstr("show_alloc_mem_ex(): No memory allocated\n");
     unlock_mutex();
     return;
   }
   size_t total = 0;
-  for (t_mmap *mmap = g_mmap; !TESTNULL(mmap); mmap = mmap->next) {
+  for (t_mmap *mmap = g_mmap; mmap; mmap = mmap->next) {
     ft_printf("%s : %p\n", get_type_string(mmap->type), mmap);
     for (t_alloc *alloc = mmap->alloc; alloc; alloc = alloc->next) {
       if (!alloc)

test2

@@ -4,6 +4,7 @@
 
 void print(char *s) { write(1, s, strlen(s)); }
 
+void test(void *p);
 int main(void) {
   int i;
   char *addr;

test2.c

@@ -4,31 +4,38 @@
 
 #define M (1024 * 1024)
 
-void print(char *s) { write(1, s, strlen(s)); }
+void print(char *s)
+{
+    write(1, s, strlen(s));
+}
 
-int main() {
-  char *addr1;
-  char *addr2;
-  char *addr3;
+int     main()
+{
+    char *addr1;
+    char *addr2;
+    char *addr3;
 
-  addr1 = (char *)malloc(16 * M);
-  if (addr1 == NULL) {
-    print("Failed to allocate memory\n");
-    exit(1);
-  }
-  strcpy(addr1, "Hello world!\n");
-  print(addr1);
-  addr2 = (char *)malloc(16 * M);
-  if (addr2 == NULL) {
-    print("Failed to allocate memory\n");
-    exit(1);
-  }
-  addr3 = (char *)realloc(addr1, 128 * M);
-  if (addr3 == NULL) {
-    print("Failed to reallocate memory\n");
-    exit(1);
-  }
-  addr3[127 * M] = 42;
-  print(addr3);
-  return (0);
+    addr1 = (char*)malloc(16*M);
+    if (addr1 == NULL)
+    {
+        print("Failed to allocate memory\n");
+        exit(1);
+    }
+    strcpy(addr1, "Hello world!\n");
+    print(addr1);
+    addr2 = (char*)malloc(16*M);
+    if (addr2 == NULL)
+    {
+        print("Failed to allocate memory\n");
+        exit(1);
+    }
+    addr3 = (char*)realloc(addr1, 128*M);
+    if (addr3 == NULL)
+    {
+        print("Failed to reallocate memory\n");
+        exit(1);
+    }
+    addr3[127*M] = 42;
+    print(addr3);
+    return (0);
 }