Optimize deque outer array (#124)

Optimize the array which holds mappings to blocks in deque by shifting
whenever it runs out of memory on one side rather than always allocating
new memory.

Author: bkthomps

src/deque.c

@@ -293,24 +293,39 @@ static size_t deque_get_new_block_count(deque me)
 bk_err deque_push_front(deque me, void *const data)
 {
     if (me->start_index == 0) {
-        const size_t new_block_count = deque_get_new_block_count(me);
-        size_t added_blocks;
-        char **temp;
-        if (new_block_count == 0) {
-            return -BK_ERANGE;
-        }
-        added_blocks = new_block_count - me->block_count;
-        temp = realloc(me->data, new_block_count * sizeof(char *));
-        if (!temp) {
-            return -BK_ENOMEM;
+        const size_t available_end = me->block_count - me->alloc_block_end - 1;
+        if (available_end > BKTHOMPS_DEQUE_INITIAL_BLOCK_COUNT) {
+            const size_t shift_end = available_end / 2;
+            const size_t allocated_blocks =
+                    me->alloc_block_end - me->alloc_block_start + 1;
+            memmove(me->data + me->alloc_block_start + shift_end,
+                    me->data + me->alloc_block_start,
+                    allocated_blocks * sizeof(char *));
+            me->start_index += shift_end * me->block_size;
+            me->end_index += shift_end * me->block_size;
+            me->alloc_block_start += shift_end;
+            me->alloc_block_end += shift_end;
+        } else {
+            const size_t new_block_count = deque_get_new_block_count(me);
+            size_t added_blocks;
+            char **temp;
+            if (new_block_count == 0) {
+                return -BK_ERANGE;
+            }
+            added_blocks = new_block_count - me->block_count;
+            temp = realloc(me->data, new_block_count * sizeof(char *));
+            if (!temp) {
+                return -BK_ENOMEM;
+            }
+            memmove(temp + added_blocks, temp,
+                    me->block_count * sizeof(char *));
+            me->data = temp;
+            me->block_count = new_block_count;
+            me->start_index += added_blocks * me->block_size;
+            me->end_index += added_blocks * me->block_size;
+            me->alloc_block_start += added_blocks;
+            me->alloc_block_end += added_blocks;
         }
-        memmove(temp + added_blocks, temp, me->block_count * sizeof(char *));
-        me->data = temp;
-        me->block_count = new_block_count;
-        me->start_index += added_blocks * me->block_size;
-        me->end_index += added_blocks * me->block_size;
-        me->alloc_block_start += added_blocks;
-        me->alloc_block_end += added_blocks;
     }
     if (me->start_index % me->block_size == 0) {
         const size_t add_block_index = me->start_index / me->block_size - 1;
@@ -357,17 +372,31 @@ bk_err deque_push_front(deque me, void *const data)
 bk_err deque_push_back(deque me, void *const data)
 {
     if (me->end_index == me->block_count * me->block_size) {
-        const size_t new_block_count = deque_get_new_block_count(me);
-        char **temp;
-        if (new_block_count == 0) {
-            return -BK_ERANGE;
-        }
-        temp = realloc(me->data, new_block_count * sizeof(char *));
-        if (!temp) {
-            return -BK_ENOMEM;
+        const size_t available_start = me->alloc_block_start;
+        if (available_start > BKTHOMPS_DEQUE_INITIAL_BLOCK_COUNT) {
+            const size_t shift_start = available_start - available_start / 2;
+            const size_t allocated_blocks =
+                    me->alloc_block_end - me->alloc_block_start + 1;
+            memmove(me->data + me->alloc_block_start / 2,
+                    me->data + me->alloc_block_start,
+                    allocated_blocks * sizeof(char *));
+            me->start_index -= shift_start * me->block_size;
+            me->end_index -= shift_start * me->block_size;
+            me->alloc_block_start -= shift_start;
+            me->alloc_block_end -= shift_start;
+        } else {
+            const size_t new_block_count = deque_get_new_block_count(me);
+            char **temp;
+            if (new_block_count == 0) {
+                return -BK_ERANGE;
+            }
+            temp = realloc(me->data, new_block_count * sizeof(char *));
+            if (!temp) {
+                return -BK_ENOMEM;
+            }
+            me->data = temp;
+            me->block_count = new_block_count;
         }
-        me->data = temp;
-        me->block_count = new_block_count;
     }
     if (me->end_index % me->block_size == 0) {
         const size_t add_block_index = me->end_index / me->block_size;

tst/test_deque.c

@@ -388,7 +388,7 @@ struct pair {
     int cur_cost;
 };
 
-static int test_puzzle(int start_node, int dest_node)
+static int test_puzzle_forwards(int start_node, int dest_node)
 {
     deque q = deque_init(sizeof(struct pair));
     struct pair cur;
@@ -424,6 +424,42 @@ static int test_puzzle(int start_node, int dest_node)
     return -1;
 }
 
+static int test_puzzle_backwards(int start_node, int dest_node)
+{
+    deque q = deque_init(sizeof(struct pair));
+    struct pair cur;
+    cur.cur_node = start_node;
+    cur.cur_cost = 0;
+    assert(deque_is_empty(q));
+    deque_push_back(q, &cur);
+    assert(deque_size(q) == 1);
+    while (!deque_is_empty(q)) {
+        int node;
+        int cost;
+        deque_pop_back(&cur, q);
+        node = cur.cur_node;
+        cost = cur.cur_cost;
+        if (node > 2 * dest_node || node < 1) {
+            continue;
+        }
+        if (node == dest_node) {
+            deque_destroy(q);
+            return cost;
+        }
+        cur.cur_cost = cost + 1;
+        cur.cur_node = node - 1;
+        deque_push_front(q, &cur);
+        assert(cur.cur_cost == cost + 1);
+        assert(cur.cur_node == node - 1);
+        cur.cur_node = 2 * node;
+        deque_push_front(q, &cur);
+        assert(cur.cur_cost == cost + 1);
+        assert(cur.cur_node == 2 * node);
+    }
+    deque_destroy(q);
+    return -1;
+}
+
 struct big_object {
     int n;
     double d;
@@ -624,8 +660,12 @@ void test_deque(void)
     test_clear_out_of_memory();
 #endif
     test_single_full_block();
-    assert(test_puzzle(2, 5) == 4);
-    assert(test_puzzle(2, 10) == 5);
+    assert(test_puzzle_forwards(2, 5) == 4);
+    assert(test_puzzle_forwards(2, 10) == 5);
+    assert(test_puzzle_forwards(100, 1000) == 42);
+    assert(test_puzzle_backwards(2, 5) == 4);
+    assert(test_puzzle_backwards(2, 10) == 5);
+    assert(test_puzzle_backwards(100, 1000) == 42);
     test_big_object();
     for (i = 1; i < 6000; i++) {
         test_add_all(i);