Implement MOVEABLE_CORE and MOVEABLE_SWAP compile time options

diff --git a/core.h b/core.h
index 026b07e..b9f5d07 100644 (file)
--- a/core.h
+++ b/core.h
@@ -3,6 +3,17 @@
 
 #include "pool.h"
 
+#define MOVEABLE_CORE 1
+
+#ifdef MOVEABLE_CORE
+#define core_alloc(item, size) pool_alloc_moveable(&core_head, item, size)
+#define core_realloc(item, size) pool_realloc_moveable(&core_head, item, size)
+#else
+#define core_alloc(item, size) pool_alloc(&core_head, item, size)
+#define core_realloc(item, size) pool_realloc(&core_head, item, size)
+#endif
+#define core_free(item) pool_free(&core_head, item)
+
 extern struct pool_head core_head;
 extern int *core_mem;
 

diff --git a/n.sh b/n.sh
index 2f9173a..0807437 100755 (executable)
--- a/n.sh
+++ b/n.sh
@@ -3,8 +3,8 @@
 echo "generate test script"
 ./pool_test_gen 64 240 256 16 >pool_test.txt
 
-echo "run non-moveable test"
+echo "run test script, non-moveable"
 ./pool_test_run 64 256 16 <pool_test.txt
 
-echo "run moveable test"
+echo "run test script, moveable"
 ./pool_test_run 64 256 16 1 <pool_test.txt

diff --git a/o.sh b/o.sh
index dde4b61..9555aed 100755 (executable)
--- a/o.sh
+++ b/o.sh
@@ -8,5 +8,5 @@ echo "generate test script"
 # non preallocated core, non preallocated swap:
 ./process_test_gen 16 240 65536 32 >process_test.txt
 
-echo "run test"
+echo "run test script"
 ./process_test_run 16 64 0 192 0 16 <process_test.txt

diff --git a/process.c b/process.c
index 1cebdc3..cc1315b 100644 (file)
--- a/process.c
+++ b/process.c
@@ -227,9 +227,7 @@ static void do_swap_out(int swap_out) {
       // increase swap allocation
       victim_swap_size += size;
 #ifndef PREALLOCATE_SWAP
-      rassert(
-        pool_realloc_moveable(&swap_head, &victim_swap_item, victim_swap_size)
-      );
+      rassert(swap_realloc(&victim_swap_item, victim_swap_size));
 #endif
       goto loop_entry;
     }
@@ -260,9 +258,7 @@ static void do_swap_out(int swap_out) {
       // add to swap pool, using dedicated swap item
       victim_swap_size = size;
 #ifndef PREALLOCATE_SWAP
-      rassert(
-        pool_alloc_moveable(&swap_head, &victim_swap_item, victim_swap_size)
-      );
+      rassert(swap_alloc(&victim_swap_item, victim_swap_size));
 #endif
 
     loop_entry:
@@ -286,9 +282,7 @@ static void do_swap_out(int swap_out) {
       if (victim_core_size) {
 #ifndef PREALLOCATE_CORE
         // no, reduce core allocation, using dedicated core item
-        rassert(
-          pool_realloc_moveable(&core_head, &victim_core_item, victim_core_size)
-        );
+        rassert(core_realloc(&victim_core_item, victim_core_size));
 #endif
 
         // as an optimization, skip the calculation of swap_out -= size
@@ -298,7 +292,7 @@ static void do_swap_out(int swap_out) {
  printf("victimized %d\n", (int)(victim - processes));
 #ifndef PREALLOCATE_CORE
       // remove from core pool, using dedicated core item
-      pool_free(&core_head, &victim_core_item);
+      core_free(&victim_core_item);
 #endif
 
 #ifndef PREALLOCATE_SWAP
@@ -324,9 +318,15 @@ bool process_alloc(struct process *process, int size) {
   // must not be already allocated
   assert(process->size == -1);
 
-  // check size, disregarding fragmentation
-  if (process_avail < size)
+  // check size
+  if (
+    process_avail < size
+#if defined(PREALLOCATE_SWAP) && !defined(MOVEABLE_SWAP)
+    || !swap_alloc(&process->swap_item, size)
+#endif
+  )
     return false;
+ printf("%d %d %d\n", process_avail, core_head.avail, swap_head.avail);
 
   // free up as much core as we need to
   swap_out = size - core_head.avail;
@@ -335,14 +335,37 @@ bool process_alloc(struct process *process, int size) {
 #endif
   do_swap_out(swap_out);
 
-  // allocate core, can't fail
+  // allocate core and possible swap
+#ifdef MOVEABLE_CORE
+  rassert(
+    core_alloc(
 #ifdef PREALLOCATE_CORE
-  rassert(pool_alloc_moveable(&core_head, &process->core_item, size));
+      &process->core_item,
 #else
-  rassert(pool_alloc_moveable(&core_head, &process->pool_item, size));
+      &process->pool_item,
 #endif
-#ifdef PREALLOCATE_SWAP
-  rassert(pool_alloc_moveable(&swap_head, &process->swap_item, size));
+      size
+    )
+  );
+#else
+  if (
+    !core_alloc(
+#ifdef PREALLOCATE_CORE
+      &process->core_item,
+#else
+      &process->pool_item,
+#endif
+      size
+    )
+  ) {
+#if defined(PREALLOCATE_SWAP) && !defined(MOVEABLE_SWAP)
+    swap_free(&process->swap_item);
+#endif
+    return false;
+  }
+#endif
+#if defined(PREALLOCATE_SWAP) && defined(MOVEABLE_SWAP)
+  rassert(swap_alloc(&process->swap_item, size));
 #endif
 
   // insert at head of LRU list
@@ -367,10 +390,17 @@ bool process_realloc(struct process *process, int size) {
   // must be fully in core
   assert(process->lru_item.prev != NULL);
 
-  // check size, disregarding fragmentation
+  // check size
   int size_change = size - process->size;
   if (process_avail < size_change)
     return false;
+#if defined(PREALLOCATE_SWAP) && !defined(MOVEABLE_SWAP)
+  swap_free(&process->swap_item);
+  if (!swap_alloc(&process->swap_item, size)) {
+    rassert(swap_alloc(&process->swap_item, process->size));
+    return false;
+  }
+#endif
 
   // free up as much core as we need to
   swap_out = size_change - core_head.avail;
@@ -379,14 +409,40 @@ bool process_realloc(struct process *process, int size) {
 #endif
   do_swap_out(swap_out);
 
-  // reallocate core, can't fail
+  // reallocate core and possible swap
+  // allocate core and possible swap
+#ifdef MOVEABLE_CORE
+  rassert(
+    core_realloc(
 #ifdef PREALLOCATE_CORE
-  rassert(pool_realloc_moveable(&core_head, &process->core_item, size));
+      &process->core_item,
 #else
-  rassert(pool_realloc_moveable(&core_head, &process->pool_item, size));
+      &process->pool_item,
 #endif
-#ifdef PREALLOCATE_SWAP
-  rassert(pool_realloc_moveable(&swap_head, &process->swap_item, size));
+      size
+    )
+  );
+#else
+  if (
+    !core_realloc(
+#ifdef PREALLOCATE_CORE
+      &process->core_item,
+#else
+      &process->pool_item,
+#endif
+      size
+    )
+  ) {
+#if defined(PREALLOCATE_SWAP) && !defined(MOVEABLE_SWAP)
+    swap_free(&process->swap_item);
+    rassert(swap_alloc(&process->swap_item, process->size));
+#endif
+    return false;
+  }
+#endif
+#if defined(PREALLOCATE_SWAP) && defined(MOVEABLE_SWAP)
+  swap_free(&process->swap_item);
+  rassert(swap_alloc(&process->swap_item, size));
 #endif
 
   // track total allocation
@@ -455,9 +511,7 @@ void process_run(struct process *process) {
       // add to core pool, using dedicated core item
       process_core_size = size;
 #ifndef PREALLOCATE_CORE
-      rassert(
-        pool_alloc_moveable(&core_head, &process_core_item, process_core_size)
-      );
+      rassert(core_alloc(&process_core_item, process_core_size));
 #endif
       goto loop_entry_full;
     }
@@ -488,9 +542,7 @@ void process_run(struct process *process) {
     do {
 #ifndef PREALLOCATE_SWAP
       // reduce swap allocation
-      rassert(
-        pool_realloc_moveable(&swap_head, &process_swap_item, process_swap_size)
-      );
+      rassert(swap_realloc(&process_swap_item, process_swap_size));
 
     loop_entry_partial:
 #endif
@@ -508,9 +560,7 @@ void process_run(struct process *process) {
       // increase core allocation
       process_core_size += size;
 #ifndef PREALLOCATE_CORE
-      rassert(
-        pool_realloc_moveable(&core_head, &process_core_item, process_core_size)
-      );
+      rassert(core_realloc(&process_core_item, process_core_size));
 #endif
 
     loop_entry_full:
@@ -539,7 +589,7 @@ void process_run(struct process *process) {
 
 #ifndef PREALLOCATE_SWAP
     // remove from swap pool, using dedicated swap item
-    pool_free(&swap_head, &process_swap_item);
+    swap_free(&process_swap_item);
 #endif
   }
 
@@ -556,10 +606,10 @@ void process_free(struct process *process) {
   assert(process->size != -1);
 
 #ifdef PREALLOCATE_CORE
-  pool_free(&core_head, &process->core_item);
+  core_free(&process->core_item);
 #endif
 #ifdef PREALLOCATE_SWAP
-  pool_free(&swap_head, &process->swap_item);
+  swap_free(&process->swap_item);
 #endif
 
   // see whether fully in core, victim, or fully in swap
@@ -571,7 +621,7 @@ void process_free(struct process *process) {
     process->lru_item.next->prev = process->lru_item.prev;
 
 #ifndef PREALLOCATE_CORE
-    pool_free(&core_head, &process->pool_item);
+    core_free(&process->pool_item);
 #endif
   }
   else if (process == victim) {
@@ -580,19 +630,18 @@ void process_free(struct process *process) {
 #ifdef PREALLOCATE_CORE
     victim_core_size = 0;
 #else
-    pool_free(&core_head, &victim_core_item);
+    core_free(&victim_core_item);
 #endif
 #ifdef PREALLOCATE_SWAP
     victim_swap_size = 0;
 #else
-    pool_free(&swap_head, &victim_swap_item);
+    swap_free(&victim_swap_item);
 #endif
   }
 #ifndef PREALLOCATE_SWAP
-  else {
+  else
     // fully in swap, remove from swap pool
-    pool_free(&swap_head, &process->pool_item);
-  }
+    swap_free(&process->pool_item);
 #endif
 
   // track total allocation

diff --git a/swap.h b/swap.h
index a3d9c7f..e35a26d 100644 (file)
--- a/swap.h
+++ b/swap.h
@@ -3,6 +3,17 @@
 
 #include "pool.h"
 
+#define MOVEABLE_SWAP 1
+
+#ifdef MOVEABLE_SWAP
+#define swap_alloc(item, size) pool_alloc_moveable(&swap_head, item, size)
+#define swap_realloc(item, size) pool_realloc_moveable(&swap_head, item, size)
+#else
+#define swap_alloc(item, size) pool_alloc(&swap_head, item, size)
+#define swap_realloc(item, size) pool_realloc(&swap_head, item, size)
+#endif
+#define swap_free(item) pool_free(&swap_head, item)
+
 extern struct pool_head swap_head;
 extern int *swap_mem;