refactor: change PQ capacity to exclude 0th elem

runtime/include/priority_queue.h

@@ -64,8 +64,8 @@ priority_queue_append(struct priority_queue *priority_queue, void *new_item)
 
 	int rc;
 
-	if (unlikely(priority_queue->size + 1 > priority_queue->capacity)) panic("PQ overflow");
+	if (unlikely(priority_queue->size > priority_queue->capacity)) panic("PQ overflow");
-	if (unlikely(priority_queue->size + 1 == priority_queue->capacity)) goto err_enospc;
+	if (unlikely(priority_queue->size == priority_queue->capacity)) goto err_enospc;
 	priority_queue->items[++priority_queue->size] = new_item;
 
 	rc = 0;
@@ -271,16 +271,13 @@ priority_queue_initialize(size_t capacity, bool use_lock, priority_queue_get_pri
 	assert(get_priority_fn != NULL);
 
 	/* Add one to capacity because this data structure ignores the element at 0 */
-	size_t one_based_capacity = capacity + 1;
+	struct priority_queue *priority_queue = (struct priority_queue *)calloc(1, sizeof(struct priority_queue)
-
+	                                                                             + sizeof(void *) * (capacity + 1));
-	struct priority_queue *priority_queue = (struct priority_queue *)
-	  calloc(1, sizeof(struct priority_queue) + sizeof(void *) * one_based_capacity);
-
 
 	/* We're assuming a min-heap implementation, so set to larget possible value */
 	priority_queue_update_highest_priority(priority_queue, ULONG_MAX);
 	priority_queue->size            = 0;
-	priority_queue->capacity        = one_based_capacity; // Add one because we skip element 0
+	priority_queue->capacity        = capacity;
 	priority_queue->get_priority_fn = get_priority_fn;
 	priority_queue->use_lock        = use_lock;
 

runtime/src/local_runqueue_minheap.c

@@ -13,6 +13,8 @@
 #include "sandbox_functions.h"
 #include "runtime.h"
 
+#define INITIAL_LOCAL_RUNQUEUE_MINHEAP_CAPACITY 256
+
 thread_local static struct priority_queue *local_runqueue_minheap;
 
 /**
@@ -33,18 +35,19 @@ local_runqueue_minheap_grow(void)
 {
 	assert(local_runqueue_minheap != NULL);
 
-	/* capacity is padded by 1 because idx 0 is padding */
+	if (unlikely(local_runqueue_minheap->capacity == 0)) {
-	if (unlikely(local_runqueue_minheap->capacity == 1)) {
-		debuglog("Growing to 2\n");
 		local_runqueue_minheap->capacity++;
+		debuglog("Growing to 1\n");
 	} else {
-		local_runqueue_minheap->capacity = (local_runqueue_minheap->capacity - 1) * 2 + 1;
+		local_runqueue_minheap->capacity *= 2;
 		debuglog("Growing to %zu\n", local_runqueue_minheap->capacity);
 	}
 
-	local_runqueue_minheap = (struct priority_queue *)
+	/* capacity is padded by 1 because idx 0 is unused */
-	  realloc(local_runqueue_minheap,
+	local_runqueue_minheap = (struct priority_queue *)realloc(local_runqueue_minheap,
-	          sizeof(struct priority_queue) + sizeof(void *) * (local_runqueue_minheap->capacity));
+	                                                          sizeof(struct priority_queue)
+	                                                            + sizeof(void *) * local_runqueue_minheap->capacity
+	                                                            + 1);
 }
 
 /**
@@ -103,7 +106,8 @@ void
 local_runqueue_minheap_initialize()
 {
 	/* Initialize local state */
-	local_runqueue_minheap = priority_queue_initialize(256, false, sandbox_get_priority);
+	local_runqueue_minheap = priority_queue_initialize(INITIAL_LOCAL_RUNQUEUE_MINHEAP_CAPACITY, false,
+	                                                   sandbox_get_priority);
 
 	/* Register Function Pointers for Abstract Scheduling API */
 	struct local_runqueue_config config = { .add_fn      = local_runqueue_minheap_add,