Massive backlog of changes

src/priorityqueue.c

@@ -1,6 +1,5 @@
 #include "priorityqueue.h"
-#include "allocator.h"
-#include "mmgr.h"
+#include "heap.h"
 #include "types/status.h"
 
 void heapify(struct priority_queue_t *queue, size_t i)
@@ -9,71 +8,68 @@ void heapify(struct priority_queue_t *queue, size_t i)
     {
         return;
     }
-    else if(queue->heap[i * 2 + 1]->priority <= queue->heap[i]->priority
-        && queue->heap[i * 2 + 1]->priority <= queue->heap[i * 2 + 2]->priority)
+    else if(queue->heap[i * 2 + 1].priority <= queue->heap[i].priority
+        && queue->heap[i * 2 + 1].priority <= queue->heap[i * 2 + 2].priority)
     {
-        struct process_t *buffer = queue->heap[i];
+        struct priority_queue_node_t buffer = queue->heap[i];
         queue->heap[i] = queue->heap[i * 2 + 1];
         queue->heap[i * 2 + 1] = buffer;
         heapify(queue, i * 2 + 1);
     }
-    else if(queue->heap[i * 2 + 2]->priority <= queue->heap[i]->priority
-        && queue->heap[i * 2 + 2]->priority <= queue->heap[i * 2 + 1]->priority)
+    else if(queue->heap[i * 2 + 2].priority <= queue->heap[i].priority
+        && queue->heap[i * 2 + 2].priority <= queue->heap[i * 2 + 1].priority)
     {
-        struct process_t *buffer = queue->heap[i];
+        struct priority_queue_node_t buffer = queue->heap[i];
         queue->heap[i] = queue->heap[i * 2 + 2];
         queue->heap[i * 2 + 2] = buffer;
         heapify(queue, i * 2 + 2);
     }
 }
 
-int construct_priority_queue(struct priority_queue_t *queue, struct page_stack_t *page_stack)
+int construct_priority_queue(struct priority_queue_t *queue, int capacity)
 {
-    queue->heap = allocate_from_bottom(page_size);
+    queue->heap = kmalloc(sizeof(struct priority_queue_node_t) * capacity);
     if(queue->heap == NULL)
     {
         return S_OUT_OF_MEMORY;
     }
-    int status = map_page(page_stack, queue->heap, reserve_page(page_stack), PAGE_RW);
-    if(status == S_OK)
-    {
-        queue->capacity = page_size / sizeof(struct process_t*);
-        queue->size = 0;
-    }
-    return status;
+    queue->capacity = capacity;
+    queue->size = 0;
+    return S_OK;
 }
 
-struct process_t *extract_min(struct priority_queue_t *queue)
+void *extract_min(struct priority_queue_t *queue)
 {
     if(queue->size == 0)
         return NULL;
     queue->size--;
-    struct process_t *p = queue->heap[0];
+    void *value = queue->heap[0].value;
     queue->heap[0] = queue->heap[queue->size];
     heapify(queue, 0);
-    return p;
+    return value;
 }
 
-int queue_insert(struct priority_queue_t *queue, struct process_t *process)
+int queue_insert(struct priority_queue_t *queue, void *value, int priority)
 {
     if(queue->size == queue->capacity)
         return S_OUT_OF_MEMORY;
     size_t i = queue->size;
     queue->size++;
-    while(i > 0 && queue->heap[(i - 1) / 2]->priority > process->priority)
+    while(i > 0 && queue->heap[(i - 1) / 2].priority > priority)
     {
         queue->heap[i] = queue->heap[(i - 1) / 2];
         i = (i - 1) / 2;
     }
-    queue->heap[i] = process;
+    queue->heap[i].priority = priority;
+    queue->heap[i].value = value;
     return S_OK;
 }
 
-int queue_remove(struct priority_queue_t *queue, struct process_t *process)
+int queue_remove(struct priority_queue_t *queue, void *value)
 {
     for(size_t i = 0; i < queue->size; i++)
     {
-        if(queue->heap[i] == process)
+        if(queue->heap[i].value == value)
         {
             queue->size--;
             queue->heap[i] = queue->heap[queue->size];