Dynamic size of the bitmap vector according to the raw block size and the resolution

private-include/bitmap/bitmap_other.h

@@ -28,11 +28,11 @@
 
 #include "bitmap/bitmap_rb.h"
 
-void copy_array(BMAP_EL_TYPE *dest, BMAP_EL_TYPE *src);
+void copy_array(BMAP_EL_TYPE *dest, BMAP_EL_TYPE *src, size_t elements);
 
-void shift_array(BMAP_EL_TYPE *array, size_t n);
+void shift_array(BMAP_EL_TYPE *array, size_t n, size_t elements);
 
-void add_arrays(BMAP_EL_TYPE *array1, BMAP_EL_TYPE *array2);
+void add_arrays(BMAP_EL_TYPE *array1, BMAP_EL_TYPE *array2, size_t elements);
 
 size_t prev_pow2(size_t n);
 

private-include/bitmap/bitmap_rb.h

@@ -31,17 +31,22 @@
 
 /** The data type of the bitmap array element */
 #define BMAP_EL_TYPE uint64_t
+/** The size of bitmap array element */
+#define BMAP_EL_SIZE sizeof(BMAP_EL_TYPE)
 /** The size of bitmap array element in bits */
-#define BMAP_EL_SIZE_BITS (sizeof(BMAP_EL_TYPE) * 8)
-/** The number of bitmap array elements */
-#define BMAP_INDEX_NUM 20
+#define BMAP_EL_SIZE_BITS (BMAP_EL_SIZE * 8)
+/** Bitmap's initial value */
+#define BMAP_EL_INIT_VAL ~((BMAP_EL_TYPE) 0))
+/** How many bytes per cell should be used */
+#define BITMAP_RESOLUTION 256
 
 /** Bitmap-organized raw block header data structure */
 typedef struct bitmap_rb_s {
-    BMAP_EL_TYPE bmap_array[BMAP_INDEX_NUM]; /**< The bitmap vector */
     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 */
+    BMAP_EL_TYPE bmap; /**< The bitmap vector */
 } bitmap_rb_t;
 
 /** Chunk header data structure */
@@ -50,4 +55,7 @@ typedef struct chunk_header_s {
     size_t requested_size; /**< The requested size. */
 } chunk_header_t;
 
+/** The size of the chunk header in bitmap-organised raw blocks */
+#define CHUNK_HDR_SIZE sizeof(chunk_header_t)
+
 #endif /* BITMAP_RB_H */

src/bitmap/bitmap_free.c

@@ -40,10 +40,10 @@ void bitmap_free(raw_block_header_t *raw_block, void *ptr) {
     bitmap_rb_t *rb_header;
     chunk_header_t *chunk_header;
     size_t cells_used, cell_no, bmap_index, start_pos;
-    BMAP_EL_TYPE mask1, mask2;
+    BMAP_EL_TYPE mask1, mask2, *bmap_p;
 
     rb_header = (bitmap_rb_t *)((char *)raw_block + sizeof(raw_block_header_t));
-    chunk_header = (chunk_header_t *)((char *)ptr - sizeof(chunk_header_t));
+    chunk_header = (chunk_header_t *)((char *)ptr - CHUNK_HDR_SIZE);
 
 #ifdef HAVE_LOCKS
     pthread_mutex_lock(&raw_block->mutex);
@@ -68,6 +68,8 @@ void bitmap_free(raw_block_header_t *raw_block, void *ptr) {
     bmap_index = cell_no / BMAP_EL_SIZE_BITS;
     start_pos = cell_no % BMAP_EL_SIZE_BITS;
 
+    bmap_p = &rb_header->bmap;
+
     // If the sum of the starting position and the cells that are used is more
     // than the available bits of one bitmap array element, then we have to
     // modify the next element as well.
@@ -78,9 +80,9 @@ void bitmap_free(raw_block_header_t *raw_block, void *ptr) {
         mask2 = make_bit_mask((size_t) 1,
                 start_pos + cells_used - BMAP_EL_SIZE_BITS);
 
-        rb_header->bmap_array[bmap_index + 1] |= mask2;
+        bmap_p[bmap_index + 1] |= mask2;
     }
-    rb_header->bmap_array[bmap_index] |= mask1;
+    bmap_p[bmap_index] |= mask1;
 
 #ifdef HAVE_LOCKS
     pthread_mutex_unlock(&raw_block->mutex);

src/bitmap/bitmap_malloc.c

@@ -44,15 +44,16 @@ void * bitmap_malloc(raw_block_header_t *raw_block, size_t req_size) {
     bitmap_rb_t *rb_header;
     size_t cells, stop, i, found;
     void *ret;
-    BMAP_EL_TYPE temp1[BMAP_INDEX_NUM], temp2[BMAP_INDEX_NUM];
-    BMAP_EL_TYPE mask1, mask2;
     chunk_header_t *chunk_address;
+    BMAP_EL_TYPE mask1, mask2, *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];
+
     ret = NULL;
 
-    req_size += sizeof(chunk_header_t);
+    req_size += CHUNK_HDR_SIZE;
 
     if(req_size % rb_header->bytes_per_cell > 0) {
         cells = req_size / rb_header->bytes_per_cell + 1;
@@ -66,23 +67,24 @@ void * bitmap_malloc(raw_block_header_t *raw_block, size_t req_size) {
     pthread_mutex_lock(&raw_block->mutex);
 #endif /* HAVE_LOCKS */
 
-    copy_array(temp1, rb_header->bmap_array);
+    copy_array(temp1, &rb_header->bmap, rb_header->elements);
 
     // perform bitwise shift & and operations in the BMAP_EL_TYPE arrays
     for(i = 1; i < stop; i <<= 1) {
-        copy_array(temp2, temp1);
-        shift_array(temp2, i);
-        add_arrays(temp1, temp2);
+        copy_array(temp2, temp1, rb_header->elements);
+        shift_array(temp2, i, rb_header->elements);
+        add_arrays(temp1, temp2, rb_header->elements);
     }
     if(stop < cells) {
-        copy_array(temp2, temp1);
-        shift_array(temp2, cells - stop);
-        add_arrays(temp1, temp2);
+        copy_array(temp2, temp1, rb_header->elements);
+        shift_array(temp2, cells - stop, rb_header->elements);
+        add_arrays(temp1, temp2, rb_header->elements);
     }
 
     found = 0;
 
-    for(i = 0; i < BMAP_INDEX_NUM; ++i) {
+    bmap_p = &rb_header->bmap;
+    for(i = 0; i < rb_header->elements; ++i) {
         found = __builtin_ffsl(temp1[i]);
         if(found) {
             // Check if one or two elements have to be modified
@@ -92,26 +94,27 @@ void * bitmap_malloc(raw_block_header_t *raw_block, size_t req_size) {
                 mask1 = ~make_bit_mask(found, BMAP_EL_SIZE_BITS - found + 1);
                 mask2 = ~make_bit_mask((size_t) 1,
                         cells - (BMAP_EL_SIZE_BITS - found) - 1);
-                rb_header->bmap_array[i + 1] &= mask2;
+                bmap_p[i + 1] &= mask2;
             }
-                rb_header->bmap_array[i] &= mask1;
+            bmap_p[i] &= mask1;
 
             // Calculate the pointer to the chunk to be retrieved
             chunk_address = (chunk_header_t *)((char *)rb_header +
                     sizeof(bitmap_rb_t) +
+                    rb_header->elements * BMAP_EL_SIZE +
                     (i * BMAP_EL_SIZE_BITS + found - 1) *
                     rb_header->bytes_per_cell);
             chunk_address->num_of_cells = cells;
 #ifdef REQUEST_SIZE_INFO
-            chunk_address->requested_size = req_size - sizeof(chunk_header_t);
+            chunk_address->requested_size = req_size - CHUNK_HDR_SIZE;
 #endif /* REQUEST_SIZE_INFO */
 
-            ret = (void *)((char *)chunk_address + sizeof(chunk_header_t));
+            ret = (void *)((char *)chunk_address + CHUNK_HDR_SIZE);
 
             TRACE_1("dmmlib - malloc - allocated %zu bytes for a memory request"
                     " of %zu bytes at bitmap raw block %p...\n",
                     cells * rb_header->bytes_per_cell,
-                    req_size - sizeof(chunk_header_t),
+                    req_size - CHUNK_HDR_SIZE,
                     (void *)raw_block);
 
             break;

src/bitmap/bitmap_other.c

@@ -18,7 +18,7 @@
 /**
  * @file   bitmap_other.c
  * @author Ilias Pliotas, Ioannis Koutras
- * @date   September, 2012
+ * @date   September 2012
  * @brief  Helping functions for bitmap-organized raw blocks
  */
 
@@ -28,9 +28,10 @@
  *
  * @param dest The destination bitmap array.
  * @param src  The source bitmap array.
+ * @param elements The number of elements
  */
-void copy_array(BMAP_EL_TYPE *dest, BMAP_EL_TYPE *src) {
-    for(int i = 0; i < BMAP_INDEX_NUM; i++) {
+void copy_array(BMAP_EL_TYPE *dest, BMAP_EL_TYPE *src, size_t elements) {
+    for(size_t i = 0; i < elements; ++i) {
         dest[i] = src[i];
     }
 }
@@ -39,17 +40,18 @@ void copy_array(BMAP_EL_TYPE *dest, BMAP_EL_TYPE *src) {
  *
  * @param array The array to be shifted right
  * @param n The number of bits to be shifted
+ * @param elements The number of elements
  */
-void shift_array(BMAP_EL_TYPE *array, size_t n) {
+void shift_array(BMAP_EL_TYPE *array, size_t n, size_t elements) {
     int i;
     BMAP_EL_TYPE mask1, mask2, guard_mask;
 
     // Move element-wise at first
     while(n >= BMAP_EL_SIZE_BITS) {
-        for(i = 1; i < BMAP_INDEX_NUM; i++) {
+        for(i = 1; i < (int) elements; i++) {
             array[i - 1] = array[i];
         }
-        array[BMAP_INDEX_NUM - 1] = 0;
+        array[elements - 1] = 0;
         n -= BMAP_EL_SIZE_BITS;
     }
 
@@ -57,7 +59,7 @@ void shift_array(BMAP_EL_TYPE *array, size_t n) {
     if(n > 0) {
         mask1 = (BMAP_EL_TYPE) 0;
         guard_mask = ((BMAP_EL_TYPE) 1 << n) - 1;
-        for(i = BMAP_INDEX_NUM - 1; i >= 0; --i) {
+        for(i = (int) elements - 1; i >= 0; --i) {
             mask2 = array[i] & guard_mask;
             array[i] >>= n;
             array[i] |= mask1 << (BMAP_EL_SIZE_BITS - n);
@@ -69,8 +71,8 @@ void shift_array(BMAP_EL_TYPE *array, size_t n) {
 /** Perform bitwsie add on every element of a BMAP_EL_TYPE arrays; store the
  *  result on the first array
  */
-void add_arrays(BMAP_EL_TYPE *array1, BMAP_EL_TYPE *array2) {
-    for(int i = 0; i < BMAP_INDEX_NUM; i++) {
+void add_arrays(BMAP_EL_TYPE *array1, BMAP_EL_TYPE *array2, size_t elements) {
+    for(size_t i = 0; i < elements; i++) {
         array1[i] &= array2[i];
     }
 }

src/dmmlib.c

@@ -65,7 +65,7 @@ void * malloc(size_t size) {
 #endif /* BITMAP_RB_ONLY */
 
         if(allocation_size < SYS_ALLOC_SIZE / 2) {
-            allocation_size = SYS_ALLOC_SIZE / 2;
+            allocation_size = SYS_ALLOC_SIZE;
         } else {
             return (void *)create_new_raw_block(allocation_size, BIGBLOCK);
         }

src/raw_block.c

@@ -35,6 +35,7 @@ raw_block_header_t *create_new_raw_block(size_t raw_block_size, rb_type type) {
 #endif /* FL_RB_ONLY */
 #ifdef BITMAP_RB_ONLY
     bitmap_rb_t *bitmap_rb;
+    BMAP_EL_TYPE *bitmap_p;
 #endif /* BITMAP_RB_ONLY */
 
     ptr = request_memory(raw_block_size);
@@ -62,12 +63,18 @@ raw_block_header_t *create_new_raw_block(size_t raw_block_size, rb_type type) {
         case BITMAP:
             bitmap_rb = (bitmap_rb_t *)((char *)ptr +
                     sizeof(raw_block_header_t));
-            bitmap_rb->bytes_per_cell = (raw_block_size -
-                    sizeof(raw_block_header_t) - sizeof(bitmap_rb_t)) /
-                (BMAP_INDEX_NUM * BMAP_EL_SIZE_BITS);
-            for(int i = 0; i < BMAP_INDEX_NUM; i++) {
-                bitmap_rb->bmap_array[i] = 0xFFFFFFFFFFFFFFFF;
-                // This is due to the data type of the element (64-bit)
+            bitmap_rb->bytes_per_cell = BITMAP_RESOLUTION;
+
+            bitmap_rb->elements =
+                (raw_block_size + BMAP_EL_SIZE - 
+                 sizeof(raw_block_header_t) - sizeof(bitmap_rb_t)) /
+                (BMAP_EL_SIZE + BMAP_EL_SIZE_BITS * bitmap_rb->bytes_per_cell);
+
+            bitmap_p = &bitmap_rb->bmap;
+            for(size_t i = 0; i < bitmap_rb->elements; ++i) {
+                /* *bitmap_p = BMAP_EL_INIT_VAL; */
+                *bitmap_p = ~((BMAP_EL_TYPE) 0);
+                bitmap_p++;
             }
             break;
 #endif /* BITMAP_RB_ONLY */