X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/08b0207634111339deda63fa368c42be87b6dc13..4e62e76d104a17f0c9aaf9135ac605e9c8c87141:/src/xbt/mmalloc/mmalloc.c

diff --git a/src/xbt/mmalloc/mmalloc.c b/src/xbt/mmalloc/mmalloc.c
index ee9dee9219..ca3b40d788 100644
--- a/src/xbt/mmalloc/mmalloc.c
+++ b/src/xbt/mmalloc/mmalloc.c
@@ -1,6 +1,6 @@
 /* Memory allocator `malloc'. */
 
-/* Copyright (c) 2010-2017. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2010-2019. The SimGrid Team. All rights reserved.          */
 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
@@ -47,7 +47,7 @@ static void *align(struct mdesc *mdp, size_t size)
   return (result);
 }
 
-/** Initialise heapinfo about the heapinfo pages :)
+/** Initialize heapinfo about the heapinfo pages :)
  *
  */
 static void initialize_heapinfo_heapinfo(xbt_mheap_t mdp)
@@ -95,7 +95,11 @@ static void initialize(xbt_mheap_t mdp)
   }
 }
 
-#define update_hook(a,offset) do { if (a) { a = ((char*)a +(offset));} }while(0)
+static inline void update_hook(void **a, size_t offset)
+{
+  if (*a)
+    *a = (char*)*a + offset;
+}
 
 /* Get neatly aligned memory from the low level layers, and register it
  * into the heap info table as necessary. */
@@ -116,7 +120,7 @@ static void *register_morecore(struct mdesc *mdp, size_t size)
     malloc_info* newinfo = (malloc_info*)align(mdp, newsize * sizeof(malloc_info));
     memcpy(newinfo, oldinfo, mdp->heapsize * sizeof(malloc_info));
 
-    /* Initialise the new blockinfo : */
+    /* Initialize the new blockinfo : */
     memset((char*) newinfo + mdp->heapsize * sizeof(malloc_info), 0,
       (newsize - mdp->heapsize)* sizeof(malloc_info));
 
@@ -124,13 +128,13 @@ static void *register_morecore(struct mdesc *mdp, size_t size)
     size_t offset=((char*)newinfo)-((char*)oldinfo);
 
     for (int i = 1 /*first element of heapinfo describes the mdesc area*/; i < mdp->heaplimit; i++) {
-      update_hook(newinfo[i].freehook.next,offset);
-      update_hook(newinfo[i].freehook.prev,offset);
+      update_hook(&newinfo[i].freehook.next, offset);
+      update_hook(&newinfo[i].freehook.prev, offset);
     }
     // also update the starting points of the swag
     for (int i = 0; i < BLOCKLOG; i++) {
-      update_hook(mdp->fraghead[i].head,offset);
-      update_hook(mdp->fraghead[i].tail,offset);
+      update_hook(&mdp->fraghead[i].head, offset);
+      update_hook(&mdp->fraghead[i].tail, offset);
     }
     mdp->heapinfo = newinfo;
 
@@ -152,7 +156,6 @@ static void *register_morecore(struct mdesc *mdp, size_t size)
   mdp->heaplimit = BLOCK((char *) result + size);
   return (result);
 }
-#undef update_hook
 
 /* Allocate memory from the heap.  */
 void *mmalloc(xbt_mheap_t mdp, size_t size) {
@@ -162,7 +165,22 @@ void *mmalloc(xbt_mheap_t mdp, size_t size) {
   }
   return res;
 }
-/* Spliting mmalloc this way is mandated by a trick in mrealloc, that gives
+
+static void mmalloc_mark_used(xbt_mheap_t mdp, size_t block, size_t nblocks, size_t requested_size)
+{
+  for (int it = 0; it < nblocks; it++) {
+    mdp->heapinfo[block + it].type                 = MMALLOC_TYPE_UNFRAGMENTED;
+    mdp->heapinfo[block + it].busy_block.busy_size = 0;
+    mdp->heapinfo[block + it].busy_block.ignore    = 0;
+    mdp->heapinfo[block + it].busy_block.size      = 0;
+  }
+  mdp->heapinfo[block].busy_block.size      = nblocks;
+  mdp->heapinfo[block].busy_block.busy_size = requested_size;
+  mdp->heapstats.chunks_used++;
+  mdp->heapstats.bytes_used += nblocks * BLOCKSIZE;
+}
+
+/* Splitting mmalloc this way is mandated by a trick in mrealloc, that gives
    back the memory of big blocks to the system before reallocating them: we don't
    want to loose the beginning of the area when this happens */
 void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size)
@@ -179,13 +197,9 @@ void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size)
   if (size < SMALLEST_POSSIBLE_MALLOC)
     size = SMALLEST_POSSIBLE_MALLOC;
 
-  //  printf("(%s) Mallocing %d bytes on %p (default: %p)...",xbt_thread_self_name(),size,mdp,__mmalloc_default_mdp);fflush(stdout);
-
   if (!(mdp->flags & MMALLOC_INITIALIZED))
     initialize(mdp);
 
-  mmalloc_paranoia(mdp);
-
   /* Determine the allocation policy based on the request size.  */
   if (size <= BLOCKSIZE / 2) {
     /* Small allocation to receive a fragment of a block.
@@ -222,8 +236,6 @@ void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size)
       /* Update our metadata about this fragment */
       candidate_info->busy_frag.frag_size[candidate_frag] = requested_size;
       candidate_info->busy_frag.ignore[candidate_frag] = 0;
-      //xbt_backtrace_no_malloc(candidate_info->busy_frag.bt[candidate_frag],XBT_BACKTRACE_SIZE);
-      //xbt_libunwind_backtrace(candidate_info->busy_frag.bt[candidate_frag],XBT_BACKTRACE_SIZE);
 
       /* Update the statistics.  */
       mdp -> heapstats.chunks_used++;
@@ -254,8 +266,6 @@ void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size)
       /* mark the fragment returned as busy */
       mdp->heapinfo[block].busy_frag.frag_size[0] = requested_size;
       mdp->heapinfo[block].busy_frag.ignore[0] = 0;
-      //xbt_backtrace_no_malloc(mdp->heapinfo[block].busy_frag.bt[0],XBT_BACKTRACE_SIZE);
-      //xbt_libunwind_backtrace(mdp->heapinfo[block].busy_frag.bt[0],XBT_BACKTRACE_SIZE);
 
       /* update stats */
       mdp -> heapstats.chunks_free += (BLOCKSIZE >> log) - 1;
@@ -298,18 +308,7 @@ void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size)
         result = register_morecore(mdp, blocks * BLOCKSIZE);
 
         block = BLOCK(result);
-        for (int it = 0; it < blocks; it++) {
-          mdp->heapinfo[block + it].type                 = MMALLOC_TYPE_UNFRAGMENTED;
-          mdp->heapinfo[block + it].busy_block.busy_size = 0;
-          mdp->heapinfo[block + it].busy_block.ignore    = 0;
-          mdp->heapinfo[block + it].busy_block.size      = 0;
-        }
-        mdp->heapinfo[block].busy_block.size = blocks;
-        mdp->heapinfo[block].busy_block.busy_size = requested_size;
-        //mdp->heapinfo[block].busy_block.bt_size=xbt_backtrace_no_malloc(mdp->heapinfo[block].busy_block.bt,XBT_BACKTRACE_SIZE);
-        //mdp->heapinfo[block].busy_block.bt_size = xbt_libunwind_backtrace(mdp->heapinfo[block].busy_block.bt,XBT_BACKTRACE_SIZE);
-        mdp -> heapstats.chunks_used++;
-        mdp -> heapstats.bytes_used += blocks * BLOCKSIZE;
+        mmalloc_mark_used(mdp, block, blocks, requested_size);
 
         return result;
       }
@@ -340,23 +339,10 @@ void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size)
         = mdp->heapindex = mdp->heapinfo[block].free_block.next;
     }
 
-    for (int it = 0; it < blocks; it++) {
-      mdp->heapinfo[block+it].type = MMALLOC_TYPE_UNFRAGMENTED;
-      mdp->heapinfo[block+it].busy_block.busy_size = 0;
-      mdp->heapinfo[block+it].busy_block.ignore = 0;
-      mdp->heapinfo[block+it].busy_block.size = 0;
-    }
-    mdp->heapinfo[block].busy_block.size = blocks;
-    mdp->heapinfo[block].busy_block.busy_size = requested_size;
-    //mdp->heapinfo[block].busy_block.bt_size = xbt_backtrace_no_malloc(mdp->heapinfo[block].busy_block.bt,XBT_BACKTRACE_SIZE);
-    //mdp->heapinfo[block].busy_block.bt_size = xbt_libunwind_backtrace(mdp->heapinfo[block].busy_block.bt,XBT_BACKTRACE_SIZE);
-
-    mdp -> heapstats.chunks_used++;
-    mdp -> heapstats.bytes_used += blocks * BLOCKSIZE;
+    mmalloc_mark_used(mdp, block, blocks, requested_size);
     mdp -> heapstats.bytes_free -= blocks * BLOCKSIZE;
 
   }
-  //printf("(%s) Done mallocing. Result is %p\n",xbt_thread_self_name(),result);fflush(stdout);
 
   return (result);
 }