Reorganized the choosing of bitmap raw blocks (WIP)

include/dmmlib/raw_block.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright 2012 Institute of Communication and Computer Systems (ICCS) 
+ *   Copyright Institute of Communication and Computer Systems (ICCS) 
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -47,18 +47,15 @@ typedef enum rb_type_en {
 /** The header structure of every raw block inside a heap. */
 typedef struct raw_block_header_s {
     rb_type type; /**< The type of the raw block. */
-    size_t size; /**< Total available size of the raw block. */
+    size_t size; /**< Total size of the raw block. */
     struct raw_block_header_s *next_raw_block; /**< Pointer to the next raw
                                                  block. */
-#ifdef WITH_RAWBLOCK_STATS
-    dmmstats_t dmm_stats; /**< Statistics of the heap. */
-#endif /* WITH_RAWBLOCK_STATS */
 #ifdef HAVE_LOCKS
-    pthread_mutex_t mutex;/**< Mutex when POSIX Threads are used. */
+    pthread_mutex_t mutex;/**< Mutex. */
 #endif /* HAVE_LOCKS */
 } raw_block_header_t;
 
 /** Create a new raw block. */
-raw_block_header_t *create_new_raw_block(size_t raw_block_size, rb_type type);
+raw_block_header_t *create_raw_block(size_t raw_block_size, rb_type type);
 
 #endif /* RAW_BLOCK_H */

private-include/bitmap/bitmap.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright 2012 Institute of Communication and Computer Systems (ICCS) 
+ *   Copyright Institute of Communication and Computer Systems (ICCS) 
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -25,18 +25,18 @@
 #define BITMAP_H
 #include "dmm_config.h"
 
-#include "dmmlib/raw_block.h"
+#include "bitmap/bitmap_rb.h"
 
 #ifdef BITMAP_RB_ONLY
 #define dmmlib_malloc(raw_block, size) bitmap_malloc(raw_block, size)
 #define dmmlib_free(raw_block, size) bitmap_free(raw_block, size)
 #endif /* BITMAP_RB_ONLY */
 
-void * bitmap_malloc(raw_block_header_t *raw_block, size_t size);
+void * bitmap_malloc(bitmap_rb_t *raw_block, size_t size);
 
-void bitmap_free(raw_block_header_t *raw_block, void *ptr);
+void bitmap_free(bitmap_rb_t *raw_block, void *ptr);
 
-void * bitmap_realloc(raw_block_header_t *raw_block, void * ptr,
+void * bitmap_realloc(bitmap_rb_t *raw_block, void * ptr,
         size_t req_size);
 
 #endif /* BITMAP_H */

private-include/bitmap/bitmap_rb.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright 2012 Institute of Communication and Computer Systems (ICCS) 
+ *   Copyright Institute of Communication and Computer Systems (ICCS) 
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -44,8 +44,6 @@
 typedef struct bitmap_rb_s {
     size_t bytes_per_cell; /**< The raw block's resolution */
     size_t elements; /**< The necessary amount of bitmap elements */
-    /* FIXME - As long as the bitmap arrays are fixed-sized,
-     * this is also fixed */
 } bitmap_rb_t;
 
 /** Chunk header data structure */

src/bitmap/bitmap_free.c

@@ -28,47 +28,37 @@
 
 #include "trace.h"
 
-#ifdef HAVE_LOCKS
-#include <pthread.h>
-#endif /* HAVE_LOCKS */
-
 #ifdef WITH_ALLOCATOR_STATS
 #include "dmmlib/dmmlib.h"
 #endif /* WITH_ALLOCATOR_STATS */
 
 /** Frees the memory block inside of a specific bitmap-organized raw block.
- * @param raw_block The pointer of the raw block.
+ * @param raw_block The pointer of the bitmap raw block.
  * @param ptr       The pointer of the memory block to be freed.
  */
-void bitmap_free(raw_block_header_t *raw_block, void *ptr) {
-    bitmap_rb_t *rb_header;
+void bitmap_free(bitmap_rb_t *raw_block, void *ptr) {
     chunk_header_t *chunk_header;
     size_t cells_used, cell_no; 
     BMAP_EL_TYPE *bmap_p;
 
-    rb_header = (bitmap_rb_t *)((char *)raw_block + sizeof(raw_block_header_t));
     chunk_header = (chunk_header_t *)((char *)ptr - CHUNK_HDR_SIZE);
 
-#ifdef HAVE_LOCKS
-    pthread_mutex_lock(&raw_block->mutex);
-#endif /* HAVE_LOCKS */
-
     cells_used = chunk_header->num_of_cells;
 
 #ifndef REQUEST_SIZE_INFO
     TRACE_1("dmmlib - free - free'ing %zu bytes from bitmap raw block %p\n",
-            cells_used * rb_header->bytes_per_cell, (void *)raw_block);
+            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 * rb_header->bytes_per_cell,
+            cells_used * raw_block->bytes_per_cell,
             (void *)raw_block,
             chunk_header->requested_size);
 #endif /* REQUEST_SIZE_INFO */
 
 #ifdef WITH_ALLOCATOR_STATS
     systemallocator.dmm_stats.total_mem_allocated -= cells_used *
-        rb_header->bytes_per_cell;
+        raw_block->bytes_per_cell;
     TRACE_1("dmmlib - global allocated memory: %zu bytes\n",
             systemallocator.dmm_stats.total_mem_allocated);
 #ifdef REQUEST_SIZE_INFO
@@ -80,26 +70,12 @@ void bitmap_free(raw_block_header_t *raw_block, void *ptr) {
     systemallocator.dmm_stats.num_free++;
 #endif /* WITH_ALLOCATOR_STATS */
 
-#ifdef WITH_RAWBLOCK_STATS
-    raw_block->dmm_stats.total_mem_allocated -= cells_used *
-        rb_header->bytes_per_cell;
-    TRACE_1("dmmlib - total allocated memory: %zu bytes\n",
-            raw_block->dmm_stats.total_mem_allocated);
-#ifdef REQUEST_SIZE_INFO
-    raw_block->dmm_stats.total_mem_requested -= chunk_header->requested_size;
-    TRACE_1("dmmlib - total requested memory: %zu bytes\n",
-            raw_block->dmm_stats.total_mem_requested);
-#endif /* REQUEST_SIZE_INFO */
-    raw_block->dmm_stats.live_objects--;
-    raw_block->dmm_stats.num_free++;
-#endif /* WITH_RAWBLOCK_STATS */
-
     cell_no = ((char *)chunk_header -
-            ((char *)rb_header + sizeof(bitmap_rb_t) + 
-             rb_header->elements * BMAP_EL_SIZE))
-        / rb_header->bytes_per_cell;
+            ((char *)raw_block + sizeof(bitmap_rb_t) + 
+             raw_block->elements * BMAP_EL_SIZE))
+        / raw_block->bytes_per_cell;
 
-    bmap_p = (BMAP_EL_TYPE *)((char *)rb_header + sizeof(bitmap_rb_t));
+    bmap_p = (BMAP_EL_TYPE *)((char *)raw_block + sizeof(bitmap_rb_t));
 
     size_t mask_counter = cells_used;
     size_t mask_start = cell_no % BMAP_EL_SIZE_BITS + 1;
@@ -118,8 +94,4 @@ void bitmap_free(raw_block_header_t *raw_block, void *ptr) {
             mask_counter = 0;
         }
     }
-
-#ifdef HAVE_LOCKS
-    pthread_mutex_unlock(&raw_block->mutex);
-#endif /* HAVE_LOCKS */
 }

src/bitmap/bitmap_malloc.c

@@ -39,64 +39,49 @@
 /**
  * Returns a memory block from a bitmap-organized raw block
  *
- * @param  raw_block The pointer of the raw block.
+ * @param  raw_block The pointer of the bitmap raw block.
  * @param  req_size  The requested memory size.
  * @retval           The address to serve the request.
  * @retval NULL      No available memory space.
  */
-void * bitmap_malloc(raw_block_header_t *raw_block, size_t req_size) { 
-    bitmap_rb_t *rb_header;
+void * bitmap_malloc(bitmap_rb_t *raw_block, size_t req_size) { 
     size_t cells, stop, i, start_pos;
     void *ret;
     chunk_header_t *chunk_address;
     BMAP_EL_TYPE *bmap_p;
-
-    rb_header = (bitmap_rb_t *)((char *)raw_block + sizeof(raw_block_header_t));
-
-    BMAP_EL_TYPE temp1[rb_header->elements], temp2[rb_header->elements];
+    BMAP_EL_TYPE temp1[raw_block->elements], temp2[raw_block->elements];
 
     ret = NULL;
 
     req_size += CHUNK_HDR_SIZE;
 
-    if(req_size >= rb_header->elements * BMAP_EL_SIZE_BITS *
-            rb_header->bytes_per_cell / 2) {
-        // Don't bother searching if you require more than half of this raw
-        // block's cells
-        return NULL;
-    }
-
-    if(req_size % rb_header->bytes_per_cell > 0) {
-        cells = req_size / rb_header->bytes_per_cell + 1;
+    if(req_size % raw_block->bytes_per_cell > 0) {
+        cells = req_size / raw_block->bytes_per_cell + 1;
     } else {
-        cells = req_size / rb_header->bytes_per_cell;
+        cells = req_size / raw_block->bytes_per_cell;
     }
 
     stop = prev_pow2(cells);
 
-#ifdef HAVE_LOCKS
-    pthread_mutex_lock(&raw_block->mutex);
-#endif /* HAVE_LOCKS */
-
-    bmap_p = (BMAP_EL_TYPE *)((char *)rb_header + sizeof(bitmap_rb_t));
+    bmap_p = (BMAP_EL_TYPE *)((char *)raw_block + sizeof(bitmap_rb_t));
 
-    copy_array(temp1, bmap_p, rb_header->elements);
+    copy_array(temp1, bmap_p, raw_block->elements);
 
     // perform bitwise shift & and operations in the BMAP_EL_TYPE arrays
     for(i = 1; i < stop; i <<= 1) {
-        copy_array(temp2, temp1, rb_header->elements);
-        shift_array(temp2, i, rb_header->elements);
-        add_arrays(temp1, temp2, rb_header->elements);
+        copy_array(temp2, temp1, raw_block->elements);
+        shift_array(temp2, i, raw_block->elements);
+        add_arrays(temp1, temp2, raw_block->elements);
     }
     if(stop < cells) {
-        copy_array(temp2, temp1, rb_header->elements);
-        shift_array(temp2, cells - stop, rb_header->elements);
-        add_arrays(temp1, temp2, rb_header->elements);
+        copy_array(temp2, temp1, raw_block->elements);
+        shift_array(temp2, cells - stop, raw_block->elements);
+        add_arrays(temp1, temp2, raw_block->elements);
     }
 
     start_pos = 0;
 
-    for(i = 0; i < rb_header->elements; ++i) {
+    for(i = 0; i < raw_block->elements; ++i) {
 
         // __builtin_ffsl() returns the position of the first 1 starting from 1
         start_pos = (size_t) __builtin_ffsl((long) temp1[i]);
@@ -124,10 +109,10 @@ void * bitmap_malloc(raw_block_header_t *raw_block, size_t req_size) {
 
             // 2. Calculate the pointer to the chunk to be retrieved
 
-            chunk_address = (chunk_header_t *)((char *)rb_header +
+            chunk_address = (chunk_header_t *)((char *)raw_block +
                     sizeof(bitmap_rb_t) +
-                    rb_header->elements * BMAP_EL_SIZE +
-                    cell_no * rb_header->bytes_per_cell);
+                    raw_block->elements * BMAP_EL_SIZE +
+                    cell_no * raw_block->bytes_per_cell);
 
             // 3. Update the chunk header
 
@@ -144,14 +129,14 @@ void * bitmap_malloc(raw_block_header_t *raw_block, size_t req_size) {
 
             TRACE_1("dmmlib - malloc - allocated %zu bytes"
                     " at bitmap raw block %p\n",
-                    cells * rb_header->bytes_per_cell,
+                    cells * raw_block->bytes_per_cell,
                     (void *)raw_block);
 
             // 6. Statistics support
 
 #ifdef WITH_ALLOCATOR_STATS
             systemallocator.dmm_stats.total_mem_allocated +=
-                cells * rb_header->bytes_per_cell;
+                cells * raw_block->bytes_per_cell;
             systemallocator.dmm_stats.live_objects++;
             systemallocator.dmm_stats.num_malloc++;
             TRACE_1("dmmlib - global allocated memory: %zu bytes\n",
@@ -164,28 +149,9 @@ void * bitmap_malloc(raw_block_header_t *raw_block, size_t req_size) {
 #endif /* REQUEST_SIZE_INFO */
 #endif /* WITH_ALLOCATOR_STATS */
 
-#ifdef WITH_RAWBLOCK_STATS
-            raw_block->dmm_stats.total_mem_allocated +=
-                cells * rb_header->bytes_per_cell;
-            raw_block->dmm_stats.live_objects++;
-            raw_block->dmm_stats.num_malloc++;
-            TRACE_1("dmmlib - total allocated memory: %zu bytes\n",
-                    raw_block->dmm_stats.total_mem_allocated);
-#ifdef REQUEST_SIZE_INFO
-            raw_block->dmm_stats.total_mem_requested += req_size -
-                CHUNK_HDR_SIZE;
-            TRACE_1("dmmlib - total requested memory: %zu bytes\n",
-                    raw_block->dmm_stats.total_mem_requested);
-#endif /* REQUEST_SIZE_INFO */
-#endif /* WITH_RAWBLOCK_STATS */
-
             break;
         }
     }
 
-#ifdef HAVE_LOCKS
-    pthread_mutex_unlock(&raw_block->mutex);
-#endif /* HAVE_LOCKS */
-
     return ret;
 } 

src/bitmap/bitmap_realloc.c

@@ -1,5 +1,5 @@
 /*
- *   Copyright 2012 Institute of Communication and Computer Systems (ICCS) 
+ *   Copyright Institute of Communication and Computer Systems (ICCS) 
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -23,32 +23,41 @@
  */
 
 #include "bitmap/bitmap.h"
-#include "bitmap/bitmap_rb.h"
 #include "dmmlib/dmmlib.h"
 
 #include <string.h>
 
+#ifdef HAVE_LOCKS
+#include <pthread.h>
+#endif /* HAVE_LOCKS */
+
 /**
  * Reallocates a memory block from a bitmap-organized raw block
  *
- * @param  raw_block The pointer of the raw block.
+ * @param  raw_block The pointer of the bitmap raw block.
  * @param  ptr       The pointer of the memory block to be re-allocated.
  * @param  req_size  The requested memory size.
  * @retval           The address to serve the request.
  * @retval NULL      No available memory space.
  */
-void * bitmap_realloc(raw_block_header_t *raw_block, void * ptr,
+void * bitmap_realloc(bitmap_rb_t *raw_block, void * ptr,
         size_t req_size) { 
     void *ret;
-    bitmap_rb_t *rb_header;
     chunk_header_t *chunk_header;
 
-    rb_header = (bitmap_rb_t *)((char *)raw_block + sizeof(raw_block_header_t));
     chunk_header = (chunk_header_t *)((char *)ptr - CHUNK_HDR_SIZE);
 
     ret = malloc(req_size);
     ret = memmove(ret, ptr,
-            chunk_header->num_of_cells * rb_header->bytes_per_cell);
+            chunk_header->num_of_cells * raw_block->bytes_per_cell);
+#ifdef HAVE_LOCKS
+    raw_block_header_t *rb;
+    rb = (raw_block_header_t *)((char *)raw_block - sizeof(raw_block_header_t));
+    pthread_mutex_lock(&rb->mutex);
+#endif /* HAVE_LOCKS */
     bitmap_free(raw_block, ptr);
+#ifdef HAVE_LOCKS
+    pthread_mutex_unlock(&rb->mutex);
+#endif /* HAVE_LOCKS */
     return ret;
 }

src/dmmlib.c

@@ -1,5 +1,5 @@
 /*
- *   Copyright 2012 Institute of Communication and Computer Systems (ICCS) 
+ *   Copyright Institute of Communication and Computer Systems (ICCS) 
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -44,8 +44,13 @@
 
 void * malloc(size_t size) {
     raw_block_header_t *raw_block, *new_raw_block;
+#ifdef FL_RB_ONLY
     size_t allocation_size;
+#endif /* FL_RB_ONLY */
     void *ptr;
+#ifdef BITMAP_RB_ONLY
+    bitmap_rb_t *bitmap_rb;
+#endif /* BITMAP_RB_ONLY */
 
     raw_block = systemallocator.raw_block_head;
     ptr = NULL;
@@ -59,7 +64,15 @@ void * malloc(size_t size) {
     /* Try to find a raw block available for allocation */
 
     while(raw_block != NULL) {
-        ptr = dmmlib_malloc(raw_block, size);
+#ifdef HAVE_LOCKS
+        pthread_mutex_lock(&raw_block->mutex);
+#endif /* HAVE_LOCKS */
+        bitmap_rb = (bitmap_rb_t *)((char *)raw_block +
+                sizeof(raw_block_header_t));
+        ptr = dmmlib_malloc(bitmap_rb, size);
+#ifdef HAVE_LOCKS
+        pthread_mutex_unlock(&raw_block->mutex);
+#endif /* HAVE_LOCKS */
         if(ptr != NULL) {
             break;
         }
@@ -71,15 +84,19 @@ void * malloc(size_t size) {
         allocation_size = size + sizeof(raw_block_header_t) +
             sizeof(freelist_rb_t);
 #endif /* FL_RB_ONLY */
-#ifdef BITMAP_RB_ONLY
-        allocation_size = size + sizeof(raw_block_header_t) +
-            sizeof(bitmap_rb_t);
-#endif /* BITMAP_RB_ONLY */
 
-        if(allocation_size < SYS_ALLOC_SIZE / 2) {
-            allocation_size = SYS_ALLOC_SIZE;
-        } else {
-            ptr = (void *)create_new_raw_block(size +
+        /* Check if the request would fit in a new bitmap raw block
+         * FIXME currently the raw block size and resolution are fixed
+         */
+
+        size_t bm_vector_size = BMAP_EL_SIZE *
+            (SYS_ALLOC_SIZE + BMAP_EL_SIZE -
+                sizeof(raw_block_header_t) - sizeof(bitmap_rb_t)) /
+            (BMAP_EL_SIZE + BMAP_EL_SIZE_BITS * BITMAP_RESOLUTION);
+
+        if(2 * size > SYS_ALLOC_SIZE - sizeof(raw_block_header_t) -
+                sizeof(bitmap_rb_t) - bm_vector_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"
@@ -105,19 +122,26 @@ void * malloc(size_t size) {
             return ptr;
         }
 
-
         pthread_mutex_lock(&systemallocator.creation_mutex);
 #ifdef FL_RB_ONLY
-        new_raw_block = create_new_raw_block(allocation_size, FREELIST);
+        new_raw_block = create_raw_block(allocation_size, FREELIST);
 #endif /* FL_RB_ONLY */
 #ifdef BITMAP_RB_ONLY
-        new_raw_block = create_new_raw_block(allocation_size, BITMAP);
+        new_raw_block = create_raw_block((size_t) SYS_ALLOC_SIZE, 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;
             pthread_mutex_unlock(&systemallocator.creation_mutex);
-            ptr = dmmlib_malloc(new_raw_block, size);
+            bitmap_rb = (bitmap_rb_t *)((char *)new_raw_block +
+                    sizeof(raw_block_header_t));
+#ifdef HAVE_LOCKS
+            pthread_mutex_lock(&new_raw_block->mutex);
+#endif /* HAVE_LOCKS */
+            ptr = dmmlib_malloc(bitmap_rb, size);
+#ifdef HAVE_LOCKS
+            pthread_mutex_unlock(&new_raw_block->mutex);
+#endif /* HAVE_LOCKS */
         }
     }
     
@@ -145,7 +169,21 @@ void free(void *ptr) {
     }
 
     if(found == true) {
+#ifdef BITMAP_RB_ONLY
+        bitmap_rb_t *bitmap_rb;
+        bitmap_rb = (bitmap_rb_t *)((char *)current_raw_block +
+                sizeof(raw_block_header_t));
+#ifdef HAVE_LOCKS
+        pthread_mutex_lock(&current_raw_block->mutex);
+#endif /* HAVE_LOCKS */
+        dmmlib_free(bitmap_rb, ptr);
+#ifdef HAVE_LOCKS
+        pthread_mutex_unlock(&current_raw_block->mutex);
+#endif /* HAVE_LOCKS */
+#endif /* BITMAP_RB_ONLY */
+#ifdef FL_RB_ONLY
         dmmlib_free(current_raw_block, ptr);
+#endif /* FL_RB_ONLY */
     } else { // It has to be a BIGBLOCK, just munmap it
         current_raw_block = (raw_block_header_t *)((char *)ptr -
                 sizeof(raw_block_header_t));
@@ -203,7 +241,10 @@ void * realloc(void *ptr, size_t size) {
 
     if(found == true) {
 #ifdef BITMAP_RB_ONLY
-        return bitmap_realloc(current_raw_block, ptr, size);
+        bitmap_rb_t *bitmap_rb;
+        bitmap_rb = (bitmap_rb_t *)((char *)current_raw_block +
+                sizeof(raw_block_header_t));
+        return bitmap_realloc(bitmap_rb, ptr, size);
 #endif /* BITMAP_RB_ONLY */
 #ifdef FL_RB_ONLY
         return freelist_realloc(current_raw_block, ptr, size);

src/raw_block.c

@@ -28,7 +28,7 @@
 #include "bitmap/bitmap_rb.h"
 #endif /* BITMAP_RB_ONLY */
 
-raw_block_header_t *create_new_raw_block(size_t raw_block_size, rb_type type) {
+raw_block_header_t *create_raw_block(size_t raw_block_size, rb_type type) {
     void *ptr;
 #ifdef FL_RB_ONLY
     freelist_rb_t *fl_rb;