Replace core_item and swap_item in the process structure with just pool_item

diff --git a/process.c b/process.c
index a7bd73f..120e598 100644 (file)
--- a/process.c
+++ b/process.c
@@ -36,21 +36,9 @@ static void check_invariants() {
   }
   for (int i = 0; i < n_processes; ++i)
     if (processes[i].size != -1) {
-      if (processes[i].lru_item.prev) {
-        assert(processes + i != victim);
-        assert(processes[i].lru_item.prev->next == &processes[i].lru_item);
-        assert(processes[i].lru_item.next->prev == &processes[i].lru_item);
-        assert(processes[i].core_item.prev);
-        assert(processes[i].swap_item.prev == NULL);
-        assert(
-          processes[i].size ==
-            processes[i].core_item.limit -
-            processes[i].core_item.base
-        );
-      }
-      else if (processes + i == victim) {
-        assert(processes[i].core_item.prev == NULL);
-        assert(processes[i].swap_item.prev == NULL);
+      if (processes + i == victim) {
+        assert(processes[i].lru_item.prev == NULL);
+        assert(processes[i].pool_item.prev == NULL);
         assert(
           processes[i].size ==
             victim_core_item.limit -
@@ -60,12 +48,14 @@ static void check_invariants() {
         );
       }
       else {
-        assert(processes[i].core_item.prev == NULL);
-        assert(processes[i].swap_item.prev);
+        if (processes[i].lru_item.prev) {
+          assert(processes[i].lru_item.prev->next == &processes[i].lru_item);
+          assert(processes[i].lru_item.next->prev == &processes[i].lru_item);
+        }
         assert(
           processes[i].size ==
-            processes[i].swap_item.limit -
-            processes[i].swap_item.base
+            processes[i].pool_item.limit -
+            processes[i].pool_item.base
         );
       }
       avail -= processes[i].size;
@@ -111,7 +101,7 @@ static void do_swap_out(int swap_out) {
       victim_core_item.prev = NULL;
 
       // move dedicated to per-process swap item
-      pool_move_item(&victim_swap_item, &victim->swap_item);
+      pool_move_item(&victim_swap_item, &victim->pool_item);
       victim_swap_item.prev = NULL; 
 
     no_victim:
@@ -126,13 +116,11 @@ static void do_swap_out(int swap_out) {
       victim->lru_item.prev = NULL; // indicates not runnable
 
       // move per-process to dedicated core item
-      pool_move_item(&victim->core_item, &victim_core_item);
-      victim->core_item.prev = NULL; 
+      pool_move_item(&victim->pool_item, &victim_core_item);
+      victim->pool_item.prev = NULL; 
 
       // add to swap pool, using dedicated swap item
       rassert(pool_alloc_moveable(&swap_head, &victim_swap_item, 0));
- assert(victim_core_item.prev && victim_core_item.next);
- assert(victim_swap_item.prev && victim_swap_item.next);
     }
 
     // calculate amount to swap
@@ -164,8 +152,6 @@ static void do_swap_out(int swap_out) {
         victim_core_item.limit - victim_core_item.base - size
       )
     );
- assert(victim_core_item.prev && victim_core_item.next);
- assert(victim_swap_item.prev && victim_swap_item.next);
   }
 }
 
@@ -185,10 +171,7 @@ bool process_alloc(struct process *process, int size) {
   do_swap_out(swap_out);
 
   // allocate core, can't fail
-  rassert(pool_alloc_moveable(&core_head, &process->core_item, size));
-
-  // not allowed to be in swap
-  process->swap_item.prev = NULL;
+  rassert(pool_alloc_moveable(&core_head, &process->pool_item, size));
 
   // insert at head of LRU list
   process->lru_item.prev = &lru_head;
@@ -223,7 +206,7 @@ bool process_realloc(struct process *process, int size) {
   do_swap_out(swap_out);
 
   // reallocate core, can't fail
-  rassert(pool_realloc_moveable(&core_head, &process->core_item, size));
+  rassert(pool_realloc_moveable(&core_head, &process->pool_item, size));
   process->size = size;
 
   // track total allocation
@@ -265,8 +248,8 @@ void process_run(struct process *process) {
     }
     else {
       // fully in swap, take over only the per-process swap item
-      pool_move_item(&process->swap_item, &process_swap_item);
-      process->swap_item.prev = NULL;
+      pool_move_item(&process->pool_item, &process_swap_item);
+      process->pool_item.prev = NULL;
 
       rassert(pool_alloc_moveable(&core_head, &process_core_item, 0));
     }
@@ -315,7 +298,7 @@ void process_run(struct process *process) {
     }
 
     // move dedicated to per-process core item
-    pool_move_item(&process_core_item, &process->core_item);
+    pool_move_item(&process_core_item, &process->pool_item);
     //process_core_item.prev = NULL; 
 
     // remove from swap pool, using dedicated swap item
@@ -343,8 +326,8 @@ void process_free(struct process *process) {
     process->lru_item.prev->next = process->lru_item.next;
     process->lru_item.next->prev = process->lru_item.prev;
 
-    pool_free(&core_head, &process->core_item);
-    process->core_item.prev = NULL;
+    pool_free(&core_head, &process->pool_item);
+    process->pool_item.prev = NULL;
   }
   else if (process == victim) {
     // victim, free the dedicated pool items
@@ -358,8 +341,8 @@ void process_free(struct process *process) {
   }
   else {
     // fully in swap, remove from swap pool
-    pool_free(&swap_head, &process->swap_item);
-    process->swap_item.prev = NULL;
+    pool_free(&swap_head, &process->pool_item);
+    process->pool_item.prev = NULL;
   }
 
   // track total allocation

diff --git a/process.h b/process.h
index 3a74cda..3e5a58b 100644 (file)
--- a/process.h
+++ b/process.h
@@ -10,8 +10,7 @@ struct lru_item {
 
 extern struct process {
   struct lru_item lru_item; // must be first
-  struct pool_item core_item;
-  struct pool_item swap_item;
+  struct pool_item pool_item;
   int size; // brk level
 } *processes;
 int n_processes;

diff --git a/process_test_run.c b/process_test_run.c
index 5b342ab..d224016 100644 (file)
--- a/process_test_run.c
+++ b/process_test_run.c
@@ -60,9 +60,9 @@ int main(int argc, char **argv) {
           processes[process].size = -1;
         }
         else {
-          int base = processes[process].core_item.base;
+          int base = processes[process].pool_item.base;
  printf("new core [%d,%d)\n", base, base + size);
- rassert(processes[process].core_item.limit == base + size); 
+ rassert(processes[process].pool_item.limit == base + size); 
           for (int i = 0; i < size; ++i) {
             rassert(core_mem[base + i] == 0xaaaaaaaa);
             long long hash = process * 17 + i * 29;
@@ -89,7 +89,7 @@ int main(int argc, char **argv) {
           success
         );
       else {
- printf("old core [%d,%d)\n", processes[process].core_item.base, processes[process].core_item.limit);
+ printf("old core [%d,%d)\n", processes[process].pool_item.base, processes[process].pool_item.limit);
         int actual_old_size = processes[process].size;
         rassert(actual_old_size <= old_size);
         bool result = process_realloc(processes + process, size);
@@ -110,9 +110,9 @@ int main(int argc, char **argv) {
             rassert(process_realloc(processes + process, actual_old_size));
           }
           else {
-            int base = processes[process].core_item.base;
+            int base = processes[process].pool_item.base;
  printf("new core [%d,%d)\n", base, base + size);
- rassert(processes[process].core_item.limit == base + size); 
+ rassert(processes[process].pool_item.limit == base + size); 
             for (int i = actual_old_size; i < size; ++i) {
               rassert(core_mem[base + i] == 0xaaaaaaaa);
               long long hash = process * 17 + i * 29;
@@ -155,8 +155,7 @@ int main(int argc, char **argv) {
         );
       else {
         bool is_victim = processes + process == victim;
-        bool in_core = processes[process].core_item.prev != NULL;
-        bool in_swap = processes[process].swap_item.prev != NULL;
+        bool in_core = processes[process].lru_item.prev != NULL;
         int actual_old_size = processes[process].size;
         rassert(actual_old_size <= old_size);
         process_free(processes + process);
@@ -167,10 +166,10 @@ int main(int argc, char **argv) {
           old_size,
           actual_old_size
         );
-        int core_base = is_victim ? victim_core_item.base : in_core ? processes[process].core_item.base : -1;
-        int core_size = is_victim ? victim_core_item.limit - core_base : in_core ? processes[process].core_item.limit - core_base : 0;
-        int swap_limit = is_victim ? victim_swap_item.limit : in_swap ? processes[process].swap_item.limit : 0;
-        int swap_size = is_victim ? swap_limit - victim_swap_item.base : in_swap ? swap_limit - processes[process].swap_item.base : 0;
+        int core_base = is_victim ? victim_core_item.base : in_core ? processes[process].pool_item.base : -1;
+        int core_size = is_victim ? victim_core_item.limit - core_base : in_core ? processes[process].pool_item.limit - core_base : 0;
+        int swap_limit = is_victim ? victim_swap_item.limit : !in_core ? processes[process].pool_item.limit : 0;
+        int swap_size = is_victim ? swap_limit - victim_swap_item.base : !in_core ? swap_limit - processes[process].pool_item.base : 0;
         rassert(core_size + swap_size == actual_old_size);
         int swap_base = ~swap_limit;
  printf("old core [%d,%d) swap [%d,%d)\n", core_base, core_base + core_size, swap_base, swap_base + swap_size);
@@ -200,12 +199,11 @@ done:
       printf("process %d: not allocated\n", i);
     else {
       bool is_victim = processes + i == victim;
-      bool in_core = processes[i].core_item.prev != NULL;
-      int core_base = is_victim ? victim_core_item.base : in_core ? processes[i].core_item.base : -1;
-      int core_size = is_victim ? victim_core_item.limit - core_base : in_core ? processes[i].core_item.limit - core_base : 0;
-      bool in_swap = processes[i].swap_item.prev != NULL;
-      int swap_limit = is_victim ? victim_swap_item.limit : in_swap ? processes[i].swap_item.limit : 0;
-      int swap_size = is_victim ? swap_limit - victim_swap_item.base : in_swap ? swap_limit - processes[i].swap_item.base : 0;
+      bool in_core = processes[i].lru_item.prev != NULL;
+      int core_base = is_victim ? victim_core_item.base : in_core ? processes[i].pool_item.base : -1;
+      int core_size = is_victim ? victim_core_item.limit - core_base : in_core ? processes[i].pool_item.limit - core_base : 0;
+      int swap_limit = is_victim ? victim_swap_item.limit : !in_core ? processes[i].pool_item.limit : 0;
+      int swap_size = is_victim ? swap_limit - victim_swap_item.base : !in_core ? swap_limit - processes[i].pool_item.base : 0;
       int swap_base = ~swap_limit;
       printf("process %d: core [%d,%d) swap [%d,%d)\n", i, core_base, core_base + core_size, swap_base, swap_base + swap_size);
       for (int j = 0; j < processes[i].size; ++j) {