track total_mem_allocated correctly, use proper locks

src/free.c

@@ -83,6 +83,7 @@ void free(void *ptr) {
                 owner_raw_block->requested_size,
 #endif /* REQUEST_SIZE_INFO */
                 owner_raw_block->size);
+        systemallocator.dmm_stats.total_mem_allocated -= owner_raw_block->size;
         UNLOCK_GLOBAL();
 #endif /* WITH_ALLOCATOR_STATS */
 

src/malloc.c

@@ -100,40 +100,41 @@ void * malloc(size_t size) {
                 sizeof(freelist_rb_t)) {
 #endif /* FL_RB_ONLY */
 
-            LOCK_GLOBAL();
             ptr = create_raw_block(size + sizeof(raw_block_header_t),
                         BIGBLOCK);
             if(ptr != NULL) {
 
 #ifdef WITH_DEBUG
+                LOCK_GLOBAL();
+                LOCK_RAW_BLOCK(((raw_block_header_t *)ptr));
                 SLIST_INSERT_HEAD(&systemallocator.bb_head,
                         (raw_block_header_t *) ptr, pointers);
+                UNLOCK_RAW_BLOCK(((raw_block_header_t *)ptr));
+                UNLOCK_GLOBAL();
 #endif /* WITH_DEBUG */
 
 #ifdef WITH_ALLOCATOR_STATS
+                LOCK_GLOBAL();
                 update_stats(&systemallocator.dmm_stats,
                         MALLOC,
 #ifdef REQUEST_SIZE_INFO
                         size,
 #endif /* REQUEST_SIZE_INFO */
                         ((raw_block_header_t *)ptr)->size);
-#endif /* WITH_ALLOCATOR_STATS */
-
                 UNLOCK_GLOBAL();
+#endif /* WITH_ALLOCATOR_STATS */
 
                 ptr = (void *)((uintptr_t) ptr + sizeof(raw_block_header_t));
             }
 
-            UNLOCK_GLOBAL();
-
         } else {
             /* Try to create a new raw block and allocate a memory block from
              * there */
 
-            LOCK_GLOBAL();
             new_raw_block = create_raw_block((size_t) sys_alloc_size,
                     DEFAULT_RB_TYPE);
             if(new_raw_block != NULL) {
+                LOCK_GLOBAL();
                 LOCK_RAW_BLOCK(new_raw_block);
                 SLIST_INSERT_HEAD(&systemallocator.rb_head, new_raw_block, pointers);
                 UNLOCK_GLOBAL();

src/memalign.c

@@ -163,8 +163,10 @@ CheckAlignment:
 
 #ifdef WITH_DEBUG
                 LOCK_GLOBAL();
+                LOCK_RAW_BLOCK(((raw_block_header_t *) *memptr));
                 SLIST_INSERT_HEAD(&systemallocator.bb_head,
                         (raw_block_header_t *) *memptr, pointers);
+                UNLOCK_RAW_BLOCK(((raw_block_header_t *) *memptr));
                 UNLOCK_GLOBAL();
 #endif /* WITH_DEBUG */
 
@@ -199,10 +201,10 @@ CheckAlignment:
                 }
             }
         } else { /* Create a new raw block and use it */
-            LOCK_GLOBAL();
             raw_block = create_raw_block((size_t) SYS_ALLOC_SIZE,
                     DEFAULT_RB_TYPE);
             if(raw_block != NULL) {
+                LOCK_GLOBAL();
                 LOCK_RAW_BLOCK(raw_block);
                 SLIST_INSERT_HEAD(&systemallocator.rb_head, raw_block, pointers);
                 UNLOCK_GLOBAL();

src/realloc.c

@@ -86,6 +86,7 @@ void * realloc(void *ptr, size_t size) {
                         owner_raw_block->size), remaining_size);
 
 #ifdef WITH_ALLOCATOR_STATS
+            LOCK_GLOBAL();
             systemallocator.dmm_stats.total_mem_allocated -=
                 remaining_size;
             TRACE_2("dmmlib - ms all %zu\n",
@@ -97,6 +98,7 @@ void * realloc(void *ptr, size_t size) {
                     systemallocator.dmm_stats.total_mem_requested);
 #endif /* REQUEST_SIZE_INFO */
             systemallocator.dmm_stats.num_realloc++;
+            UNLOCK_GLOBAL();
 #endif /* WITH_ALLOCATOR_STATS */
 
             return_ptr = ptr;
@@ -126,10 +128,14 @@ void * realloc(void *ptr, size_t size) {
 
 #ifdef WITH_DEBUG
                 LOCK_GLOBAL();
+                LOCK_RAW_BLOCK(owner_raw_block);
                 SLIST_REMOVE(&systemallocator.bb_head, owner_raw_block,
                         raw_block_header_s, pointers);
+                UNLOCK_RAW_BLOCK(owner_raw_block);
+                LOCK_RAW_BLOCK(new_block);
                 SLIST_INSERT_HEAD(&systemallocator.bb_head,
                         new_block, pointers);
+                UNLOCK_RAW_BLOCK(new_block);
                 UNLOCK_GLOBAL();
 #endif /* WITH_DEBUG */
 

src/request_memory_mmap_linux.c

@@ -22,12 +22,19 @@
  * \brief  Request additional memory space via mmap() in Linux.
  */
 
+#include "dmm_config.h"
+
 #include "request_memory.h"
 #include <sys/stat.h> /* for open() */
 #include <fcntl.h> /* for open() */
 
 #include <sys/mman.h>
 
+#ifdef WITH_ALLOCATOR_STATS
+#include "dmmlib/dmmlib.h"
+#include "locks.h"
+#endif /* WITH_ALLOCATOR_STATS */
+
 static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */
 
 void *request_memory(size_t size) {	
@@ -44,6 +51,11 @@ void *request_memory(size_t size) {
     if(zone == MAP_FAILED) {
         return NULL;
     } else {
+#ifdef WITH_ALLOCATOR_STATS
+        LOCK_GLOBAL();
+        systemallocator.dmm_stats.total_mem_allocated += size;
+        UNLOCK_GLOBAL();
+#endif /* WITH_ALLOCATOR_STATS */
         return zone;
     }
 }

src/statistics.c

@@ -47,7 +47,6 @@ void update_stats
  size_t mem_alloc
 ) {
     if(event == MALLOC) {
-        dmm_stats->total_mem_allocated += mem_alloc;
 #ifdef REQUEST_SIZE_INFO
         dmm_stats->total_mem_requested += mem_req;
 #endif /* REQUEST_SIZE_INFO */
@@ -56,7 +55,6 @@ void update_stats
     }
 
     if(event == FREE) {
-        dmm_stats->total_mem_allocated -= mem_alloc;
 #ifdef REQUEST_SIZE_INFO
         dmm_stats->total_mem_requested -= mem_req;
 #endif /* REQUEST_SIZE_INFO */