memalign(): improved statistics and fix big block address in the list

include/dmmlib/dmmstats.h

@@ -40,6 +40,9 @@ typedef struct dmmstats_s {
     uint32_t num_malloc; /**< Number of malloc()'s served. */
     uint32_t num_free; /**< Number of free()'s served. */
     uint32_t num_realloc; /**< Number of realloc()'s served. */
+#ifdef WITH_MEMALIGN
+    uint32_t num_memalign; /**< Number of memalign()'s served. */
+#endif /* WITH_MEMALIGN */
 } dmmstats_t;
 
 #ifdef REQUEST_SIZE_INFO

private-include/statistics.h

@@ -49,9 +49,12 @@
 #endif /* REQUEST_SIZE_INFO */
 
 /** DMM event type enumeration */
-typedef enum dmm_event_type_en {
-    MALLOC,
-    FREE
+typedef enum dmm_event_type_en
+    { MALLOC
+    , FREE
+#ifdef WITH_MEMALIGN
+    , MEMALIGN
+#endif /* WITH_MEMALIGN */
 } dmm_event_type;
 
 void update_stats

src/bitmap/malloc.c

@@ -118,13 +118,6 @@ void * bitmap_malloc(bitmap_rb_t *raw_block, size_t req_size) {
 
             ret = (void *)((char *)chunk_address + CHUNK_HDR_SIZE);
 
-            // 5. Statistics support
-#ifdef REQUEST_SIZE_INFO
-            UPDATE_GLOBAL_STATS(MALLOC, req_size - CHUNK_HDR_SIZE);
-#else /* REQUEST_SIZE_INFO */
-            UPDATE_GLOBAL_STATS(MALLOC);
-#endif /* REQUEST_SIZE_INFO */
-
             break;
         }
     }

src/freelist/malloc.c

@@ -110,13 +110,6 @@ void * freelist_malloc(freelist_rb_t *raw_block, size_t size) {
     }
 
     if(ptr != NULL) {
-
-#ifdef REQUEST_SIZE_INFO
-        UPDATE_GLOBAL_STATS(MALLOC, size);
-#else /* REQUEST_SIZE_INFO */
-        UPDATE_GLOBAL_STATS(MALLOC);
-#endif /* REQUEST_SIZE_INFO */
-
         return (void *)((uintptr_t) ptr + HEADER_SIZE);
     } else {
         return NULL;

src/initialize.c

@@ -58,6 +58,9 @@ allocator_t systemallocator =
         , 0
         , 0
         , 0
+#ifdef WITH_MEMALIGN
+        , 0
+#endif /* WITH_MEMALIGN */
         }
 #endif /* WITH_ALLOCATOR_STATS */
 #ifdef PARSE_ENV

src/malloc.c

@@ -114,12 +114,6 @@ void * malloc(size_t size) {
                 UNLOCK_GLOBAL();
 #endif /* WITH_DEBUG */
 
-#ifdef REQUEST_SIZE_INFO
-                UPDATE_GLOBAL_STATS(MALLOC, size);
-#else /* REQUEST_SIZE_INFO */
-                UPDATE_GLOBAL_STATS(MALLOC);
-#endif /* REQUEST_SIZE_INFO */
-
                 ptr = (void *)((uintptr_t) ptr + sizeof(raw_block_header_t));
             }
 
@@ -144,6 +138,14 @@ void * malloc(size_t size) {
     }
 
     MEM_TRACE("dmmlib - m %p %zu\n", ptr, size);
+
+    if(ptr != NULL) {
+#ifdef REQUEST_SIZE_INFO
+        UPDATE_GLOBAL_STATS(MALLOC, size);
+#else /* REQUEST_SIZE_INFO */
+        UPDATE_GLOBAL_STATS(MALLOC);
+#endif /* REQUEST_SIZE_INFO */
+    }
     
     return ptr;
 }

src/memalign.c

@@ -105,9 +105,11 @@ CheckAlignment:
                 get_previous_size_availability(block_header);
 
             if(previous_size_availability == 1) {
+                void *old_ptr = *memptr;
+
                 *memptr = dmmlib_malloc(encapsulated_rb, size + alignment - 1);
 
-                dmmlib_free(encapsulated_rb, *memptr);
+                dmmlib_free(encapsulated_rb, old_ptr);
 
                 if(*memptr != NULL) {
                     goto CheckAlignment;
@@ -160,22 +162,8 @@ CheckAlignment:
                     sizeof(raw_block_header_t), BIGBLOCK);
             if(*memptr != NULL) {
 
-#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 */
-
-#ifdef REQUEST_SIZE_INFO
-                UPDATE_GLOBAL_STATS(MALLOC, size);
-#else /* REQUEST_SIZE_INFO */
-                UPDATE_GLOBAL_STATS(MALLOC);
-#endif /* REQUEST_SIZE_INFO */
-
-                *memptr = (void *)((uintptr_t) *memptr + sizeof(raw_block_header_t));
+                *memptr = (void *)((uintptr_t) *memptr +
+                        sizeof(raw_block_header_t));
 
                 if(((uintptr_t) *memptr) % alignment != 0) {
                     size_t padding = (- (size_t) *memptr) & (alignment - 1);
@@ -188,11 +176,24 @@ CheckAlignment:
                            );
 
                     munmap((void *)((uintptr_t) *memptr
-                                - sizeof(raw_block_header_t)),
+                                - sizeof(raw_block_header_t)
+                                - padding),
                             (size_t) padding);
 
                     *memptr = (void *)((uintptr_t) *memptr + padding);
                 }
+
+#ifdef WITH_DEBUG
+                LOCK_GLOBAL();
+                LOCK_RAW_BLOCK(((raw_block_header_t *) ((uintptr_t) *memptr -
+                                sizeof(raw_block_header_t))));
+                SLIST_INSERT_HEAD(&systemallocator.bb_head,
+                        (raw_block_header_t *) ((uintptr_t) *memptr -
+                            sizeof(raw_block_header_t)), pointers);
+                UNLOCK_RAW_BLOCK(((raw_block_header_t *) *memptr));
+                UNLOCK_GLOBAL();
+#endif /* WITH_DEBUG */
+
             }
         } else { /* Create a new raw block and use it */
             raw_block = create_raw_block((size_t) SYS_ALLOC_SIZE,
@@ -215,9 +216,15 @@ CheckAlignment:
         }
     }
 
-    /* Assert that the returned address is a multiple of alignment */
     if(*memptr != NULL) {
+        /* Assert that the returned address is a multiple of alignment */
         assert((uintptr_t) *memptr % alignment == 0);
+
+#ifdef REQUEST_SIZE_INFO
+        UPDATE_GLOBAL_STATS(MEMALIGN, size);
+#else /* REQUEST_SIZE_INFO */
+        UPDATE_GLOBAL_STATS(MEMALIGN);
+#endif /* REQUEST_SIZE_INFO */
     }
 
     MEM_TRACE("dmmlib - ma %p %zu %zu\n", *memptr, alignment, size);

src/statistics.c

@@ -46,20 +46,32 @@ void update_stats
 #endif /* REQUEST_SIZE_INFO */
     )
 {
-    if(event == MALLOC) {
+    switch(event) {
+        case MALLOC :
 #ifdef REQUEST_SIZE_INFO
-        dmm_stats->total_mem_requested += mem_req;
+            dmm_stats->total_mem_requested += mem_req;
 #endif /* REQUEST_SIZE_INFO */
-        dmm_stats->live_objects++;
-        dmm_stats->num_malloc++;
-    }
-
-    if(event == FREE) {
+            dmm_stats->live_objects++;
+            dmm_stats->num_malloc++;
+            break;
+        case FREE :
+#ifdef REQUEST_SIZE_INFO
+            dmm_stats->total_mem_requested -= mem_req;
+#endif /* REQUEST_SIZE_INFO */
+            dmm_stats->live_objects--;
+            dmm_stats->num_free++;
+            break;
+#ifdef WITH_MEMALIGN
+        case MEMALIGN :
 #ifdef REQUEST_SIZE_INFO
-        dmm_stats->total_mem_requested -= mem_req;
+            dmm_stats->total_mem_requested += mem_req;
 #endif /* REQUEST_SIZE_INFO */
-        dmm_stats->live_objects--;
-        dmm_stats->num_free++;
+            dmm_stats->live_objects++;
+            dmm_stats->num_memalign++;
+            break;
+#endif /* WITH_MEMALIGN */
+        default :
+            break;
     }
 
     STATS_TRACE("dmmlib - ms all %zu\n", dmm_stats->total_mem_allocated);