find raw blocks from pointers more efficiently

If raw blocks are aligned to SYS_ALLOC_SIZE, then raw block owners can be found
by simple calculations instead of iterating through lists of raw blocks. In the
case of aligned big blocks, the raw block header is no longer moved, so that the
raw block pointer is found with the new mechanism.

private-include/other.h

@@ -26,6 +26,6 @@
 #define OTHER_H
 #include "dmmlib/raw_block.h"
 
-raw_block_header_t * find_raw_block_owner(struct rb_head_s head, void* ptr);
+raw_block_header_t * find_raw_block_owner(void * ptr);
 
 #endif /* OTHER_H */

src/free.c

@@ -49,10 +49,9 @@ void free(void *ptr) {
     }
 #endif /* PARSE_ENV && WITH_MEM_TRACE */
 
-    owner_raw_block = find_raw_block_owner(systemallocator.rb_head, ptr);
-
-    if(owner_raw_block != NULL) {
-
+    owner_raw_block = find_raw_block_owner(ptr);
+    if( (uintptr_t) owner_raw_block + sizeof(raw_block_header_t) != (uintptr_t) ptr) {
+        /* It is not a big block, so act accordingly. */
         DEFAULT_RB_T *encapsulated_rb = (DEFAULT_RB_T *)
             ((uintptr_t) owner_raw_block + sizeof(raw_block_header_t));
 

src/memalign.c

@@ -104,46 +104,27 @@ void *memalign(size_t alignment, size_t size) {
         }
     } else { /* A big block has to be created */
 
-        memptr = (void *)create_raw_block(size + extra_size +
-                sizeof(raw_block_header_t), BIGBLOCK);
+        memptr = (void *)create_raw_block(size + extra_size, BIGBLOCK);
 
         if(memptr != NULL) {
 
+#ifdef REQUEST_SIZE_INFO
+            raw_block_header_t *bb_header = (raw_block_header_t *)memptr;
+#endif /* REQUEST_SIZE_INFO */
             memptr = (void *)((uintptr_t) memptr + sizeof(raw_block_header_t));
 
             /* Check if alignment is needed */
             if(((uintptr_t) memptr) % alignment != 0) {
                 size_t padding = (- (size_t) memptr) & (alignment - 1);
-                while(padding < sizeof(raw_block_header_t)) {
-                    padding += alignment;
-                }
-
-                /* Sometimes a deadlock is observed unless the old mutex is
-                 * destroyed. */
-                DESTROY_RAW_BLOCK_LOCK(((raw_block_header_t *) memptr));
-
-                /* Copy the raw block's header to the new location */
-                memcpy((void *)((uintptr_t) memptr -
-                            sizeof(raw_block_header_t) + padding),
-                        (void *)((uintptr_t) memptr -
-                            sizeof(raw_block_header_t)),
-                        sizeof(raw_block_header_t)
-                      );
 
                 /* Update *memptr */
                 memptr = (void *)((uintptr_t) memptr + padding);
 
-                /* Update big block's size and requested size */
-                raw_block_header_t *aligned_header =
-                    (raw_block_header_t *)((uintptr_t) memptr -
-                            sizeof(raw_block_header_t));
-                INIT_RAW_BLOCK_LOCK(aligned_header);
-                LOCK_RAW_BLOCK(aligned_header);
-                aligned_header->size -= padding;
 #ifdef REQUEST_SIZE_INFO
+                LOCK_RAW_BLOCK(aligned_header);
                 aligned_header->requested_size = size;
-#endif /* REQUEST_SIZE_INFO */
                 UNLOCK_RAW_BLOCK(aligned_header);
+#endif /* REQUEST_SIZE_INFO */
             }
 
 #ifdef WITH_DEBUG

src/other.c

@@ -23,25 +23,12 @@
  * @brief  Implementation of auxiliary calls.
  */
 
-#include "other.h"
-
+#include <dmmlib/config.h>
 #include <inttypes.h>
+#include "other.h"
 
 /** Finds the raw block owner of a certain pointer */
-raw_block_header_t * find_raw_block_owner(struct rb_head_s head, void* ptr) {
-    raw_block_header_t *current_block, *owner;
-
-    owner = NULL;
-
-    SLIST_FOREACH(current_block, &head, pointers) {
-        if(((uintptr_t) current_block < (uintptr_t) ptr) &&
-                ((uintptr_t) ptr < (uintptr_t) current_block +
-                 current_block->size)
-          ) {
-            owner = current_block;
-            break;
-        }
-    }
-
-    return owner;
+raw_block_header_t * find_raw_block_owner(void* ptr) {
+    return (raw_block_header_t *) ((uintptr_t) ptr &
+            (uintptr_t) ~(SYS_ALLOC_SIZE - 1));
 }

src/raw_block.c

@@ -18,6 +18,7 @@
 #include "dmmlib/raw_block.h"
 
 #include <inttypes.h>
+#include <sys/mman.h>
 
 #include "request_memory.h"
 #ifdef FL_RB_ONLY
@@ -32,6 +33,7 @@
 
 raw_block_header_t *create_raw_block(size_t raw_block_size, rb_type type) {
     raw_block_header_t *ptr;
+    size_t padding;
 #ifdef BITMAP_RB_ONLY
     bitmap_rb_t *bitmap_rb;
     BMAP_EL_TYPE *bitmap_p;
@@ -53,16 +55,25 @@ raw_block_header_t *create_raw_block(size_t raw_block_size, rb_type type) {
 #endif /* PAGESIZE_ALIGN */
     }
 
-    ptr = (raw_block_header_t *) request_memory(raw_block_size);
+    ptr = (raw_block_header_t *) request_memory(raw_block_size +
+            SYS_ALLOC_SIZE - 1);
 
     if(ptr == NULL) {
         return NULL;
     }
 
+    if((uintptr_t) ptr % SYS_ALLOC_SIZE != 0) {
+        padding = (- (uintptr_t) ptr) & (SYS_ALLOC_SIZE - 1);
+        munmap((void *) ptr, padding);
+        ptr = (raw_block_header_t *) ((uintptr_t) ptr + padding);
+    } else {
+        padding = 0;
+    }
+
     INIT_RAW_BLOCK_LOCK(ptr);
     LOCK_RAW_BLOCK(ptr);
 
-    ptr->size = raw_block_size;
+    ptr->size = raw_block_size + SYS_ALLOC_SIZE - 1 - padding;
 
     switch(type) {
 

src/realloc.c

@@ -58,9 +58,10 @@ void * realloc(void *ptr, size_t size) {
         return NULL;
     }
 
-    owner_raw_block = find_raw_block_owner(systemallocator.rb_head, ptr);
+    owner_raw_block = find_raw_block_owner(ptr);
 
-    if(owner_raw_block != NULL) {
+    if( (uintptr_t) owner_raw_block + sizeof(raw_block_header_t) != (uintptr_t) ptr) {
+        /* It is not a big block, so act accordingly. */
 
         DEFAULT_RB_T *encapsulated_rb = (DEFAULT_RB_T *)
             ((uintptr_t) owner_raw_block + sizeof(raw_block_header_t));