Simplified the trace messages

src/bitmap/bitmap_free.c

@@ -71,17 +71,6 @@ void bitmap_free(bitmap_rb_t *raw_block, void *ptr) {
         }
     }
 
-#ifndef REQUEST_SIZE_INFO
-    TRACE_1("dmmlib - free - free'ing %zu bytes from bitmap raw block %p\n",
-            cells_used * raw_block->bytes_per_cell, (void *)raw_block);
-#else /* REQUEST_SIZE_INFO */
-    TRACE_1("dmmlib - free - free'ing %zu bytes from bitmap raw block %p, "
-            "out of which %zu were used by the application\n",
-            cells_used * raw_block->bytes_per_cell,
-            (void *)raw_block,
-            chunk_header->requested_size);
-#endif /* REQUEST_SIZE_INFO */
-
 #ifdef WITH_ALLOCATOR_STATS
             update_stats(&systemallocator.dmm_stats,
                     FREE,

src/bitmap/bitmap_malloc.c

@@ -122,14 +122,7 @@ void * bitmap_malloc(bitmap_rb_t *raw_block, size_t req_size) {
 
             ret = (void *)((char *)chunk_address + CHUNK_HDR_SIZE);
 
-            // 5. Trace support
-
-            TRACE_1("dmmlib - malloc - allocated %zu bytes"
-                    " at bitmap raw block %p\n",
-                    cells * raw_block->bytes_per_cell,
-                    (void *)raw_block);
-
-            // 6. Statistics support
+            // 5. Statistics support
 #ifdef WITH_ALLOCATOR_STATS
             update_stats(&systemallocator.dmm_stats,
                     MALLOC,

src/debug.c

@@ -41,13 +41,13 @@ void get_raw_blocks(allocator_t *allocator) {
 
     while(current_raw_block) {
         counter++;
-        TRACE_1("dmmlib - Raw block at %p of size %zu\n",
+        TRACE_3("dmmlib - Raw block at %p of size %zu\n",
                 (void *)current_raw_block,
                 current_raw_block->size);
         current_raw_block = current_raw_block->next_raw_block;
     }
 
-    TRACE_1("dmmlib - there are %d raw blocks\n", counter);
+    TRACE_3("dmmlib - there are %d raw blocks\n", counter);
 
 }
 

src/free.c

@@ -53,6 +53,8 @@ void free(void *ptr) {
         return;
     }
 
+    TRACE_1("dmmlib - f %p\n", ptr);
+
     found = false;
 
     current_raw_block = systemallocator.raw_block_head;
@@ -95,8 +97,6 @@ void free(void *ptr) {
 
         current_raw_block = (raw_block_header_t *)((char *)ptr -
                 sizeof(raw_block_header_t));
-        TRACE_1("dmmlib - free - free'ing %zu bytes from raw block %p\n",
-                current_raw_block->size, (void *)current_raw_block);
 
 #ifdef WITH_ALLOCATOR_STATS
         update_stats(&systemallocator.dmm_stats,

src/freelist/freelist_free.c

@@ -44,17 +44,6 @@ void freelist_free(freelist_rb_t *raw_block, void *ptr) {
 
     block_header_t *block = get_header(ptr);
 
-#ifndef REQUEST_SIZE_INFO
-    TRACE_1("dmmlib - free - free'ing %zu bytes from freelist raw block %p\n",
-            get_size(block), (void *)raw_block);
-#else /* REQUEST_SIZE_INFO */
-    TRACE_1("dmmlib - free - free'ing %zu bytes from freelist raw block %p, out of "
-            "which %zu were used by the application\n",
-            get_size(block),
-            (void *)raw_block,
-            get_requested_size(block));
-#endif /* REQUEST_SIZE_INFO */
-
     // Memory stats get updated here in case the space gets coalesced with its
     // free neighbors.
 

src/malloc.c

@@ -59,7 +59,6 @@ void * malloc(size_t size) {
         return NULL;
     }
     
-    TRACE_1("dmmlib - malloc - request %zu bytes\n", size);
 
     /* Try to find a raw block available for allocation */
 
@@ -109,9 +108,6 @@ void * malloc(size_t size) {
             ptr = (void *)create_raw_block(size +
                     sizeof(raw_block_header_t), BIGBLOCK);
             if(ptr != NULL) {
-                TRACE_1("dmmlib - malloc - allocated a whole raw block of %zu"
-                        " bytes at %p\n", size + sizeof(raw_block_header_t),
-                        (void *)ptr);
 
 #ifdef WITH_ALLOCATOR_STATS
                 update_stats(&systemallocator.dmm_stats,
@@ -124,42 +120,45 @@ void * malloc(size_t size) {
 
                 ptr = (void *)((char *)ptr + sizeof(raw_block_header_t));
             }
-            return ptr;
-        }
+
+        } else {
 
 #ifdef HAVE_LOCKS
-        pthread_mutex_lock(&systemallocator.creation_mutex);
+            pthread_mutex_lock(&systemallocator.creation_mutex);
 #endif /* HAVE_LOCKS */
-        new_raw_block = create_raw_block((size_t) SYS_ALLOC_SIZE,
+            new_raw_block = create_raw_block((size_t) SYS_ALLOC_SIZE,
 #ifdef FL_RB_ONLY
-                FREELIST
+                    FREELIST
 #endif /* FL_RB_ONLY */
 #ifdef BITMAP_RB_ONLY
-                BITMAP
+                    BITMAP
 #endif /* BITMAP_RB_ONLY */
-                );
-        if(new_raw_block != NULL) {
-            new_raw_block->next_raw_block = systemallocator.raw_block_head;
-            systemallocator.raw_block_head = new_raw_block;
+                    );
+            if(new_raw_block != NULL) {
+                new_raw_block->next_raw_block = systemallocator.raw_block_head;
+                systemallocator.raw_block_head = new_raw_block;
 #ifdef HAVE_LOCKS
-            pthread_mutex_unlock(&systemallocator.creation_mutex);
-            pthread_mutex_lock(&new_raw_block->mutex);
+                pthread_mutex_unlock(&systemallocator.creation_mutex);
+                pthread_mutex_lock(&new_raw_block->mutex);
 #endif /* HAVE_LOCKS */
 
-            encapsulated_rb =
+                encapsulated_rb =
 #ifdef BITMAP_RB_ONLY
-                (bitmap_rb_t *)
+                    (bitmap_rb_t *)
 #endif /* BITMAP_RB_ONLY */
 #ifdef FL_RB_ONLY
-                (freelist_rb_t *)
+                    (freelist_rb_t *)
 #endif /* FL_RB_ONLY */
-                ((char *)new_raw_block + sizeof(raw_block_header_t));
-            ptr = dmmlib_malloc(encapsulated_rb, size);
+                    ((char *)new_raw_block + sizeof(raw_block_header_t));
+                ptr = dmmlib_malloc(encapsulated_rb, size);
 #ifdef HAVE_LOCKS
-            pthread_mutex_unlock(&new_raw_block->mutex);
+                pthread_mutex_unlock(&new_raw_block->mutex);
 #endif /* HAVE_LOCKS */
+            }
         }
     }
+
+    TRACE_1("dmmlib - m %p %zu\n", ptr, size);
     
     return ptr;
 }

src/realloc.c

@@ -47,6 +47,7 @@
 void * realloc(void *ptr, size_t size) {
     raw_block_header_t *current_raw_block;
     bool found;
+    void *return_ptr;
 
     if(ptr == NULL) {
         return malloc(size);
@@ -54,7 +55,8 @@ void * realloc(void *ptr, size_t size) {
 
     if(size == 0) {
         free(ptr);
-        return malloc((size_t) 32); // FIXME 32 <- minimum size
+        return_ptr = malloc((size_t) 32); // FIXME 32 <- minimum size
+        goto done;
     }
 
     current_raw_block = systemallocator.raw_block_head;
@@ -87,7 +89,8 @@ void * realloc(void *ptr, size_t size) {
 #endif /* FL_RB_ONLY */
                 ((char *)current_raw_block + sizeof(raw_block_header_t));
         
-        return dmmlib_realloc(encapsulated_rb, ptr, size);
+        return_ptr = dmmlib_realloc(encapsulated_rb, ptr, size);
+        goto done;
 
     } else { /* This has to be a big block */
 
@@ -113,18 +116,19 @@ void * realloc(void *ptr, size_t size) {
 #ifdef WITH_ALLOCATOR_STATS
             systemallocator.dmm_stats.total_mem_allocated -=
                 remaining_size;
-            TRACE_1("dmmlib - global allocated memory: %zu bytes\n",
+            TRACE_2("dmmlib - global allocated memory: %zu bytes\n",
                     systemallocator.dmm_stats.total_mem_allocated);
 #ifdef REQUEST_SIZE_INFO
             systemallocator.dmm_stats.total_mem_requested -=
                 remaining_size;
-            TRACE_1("dmmlib - global requested memory: %zu bytes\n",
+            TRACE_2("dmmlib - global requested memory: %zu bytes\n",
                     systemallocator.dmm_stats.total_mem_requested);
 #endif /* REQUEST_SIZE_INFO */
             systemallocator.dmm_stats.num_realloc++;
 #endif /* WITH_ALLOCATOR_STATS */
 
-            return ptr;
+            return_ptr = ptr;
+            goto done;
 
         } else {
 
@@ -135,7 +139,8 @@ void * realloc(void *ptr, size_t size) {
 
             if(new_block == NULL) {
 
-                return NULL;
+                return_ptr = NULL;
+                goto done;
 
             } else {
 
@@ -159,8 +164,17 @@ void * realloc(void *ptr, size_t size) {
                 systemallocator.dmm_stats.num_realloc++;
 #endif /* WITH_ALLOCATOR_STATS */
 
-                return (void *)((char *)new_block + sizeof(raw_block_header_t));
+                return_ptr = (void *)((char *)new_block +
+                        sizeof(raw_block_header_t));
+                goto done;
             }
         }
     }
+
+done:
+
+    TRACE_1("dmmlib - r %p %p %zu\n", ptr, return_ptr, size);
+
+    return return_ptr;
+
 }