Add process flags to track whether the process and/or the core_item are valid

diff --git a/process.c b/process.c
index 3257303..5ddb523 100644 (file)
--- a/process.c
+++ b/process.c
@@ -1,4 +1,5 @@
 #include <assert.h>
+#include <stddef.h>
 #include <stdio.h> // temporary
 #include <stdlib.h>
 #include "core.h"
@@ -17,13 +18,9 @@ struct lru_item lru_head;
 struct process *runner, *victim;
 
 void process_init(int n, int spare) {
-  int i;
-
   processes = calloc(n, sizeof(struct process));
   rassert(processes);
   n_processes = n;
-  for (i = 0; i < n_processes; ++i)
-    processes[i].paras = -1;
 
 #ifndef INDIRECT_CORE
 #ifndef INDIRECT_SWAP
@@ -93,7 +90,9 @@ static bool do_swap_out(int swap_out) {
     do {
       // calculate amount to swap out
       assert(lru_head.prev != &lru_head);
-      victim = (struct process *)lru_head.prev;
+      victim = (struct process *)(
+        (char *)lru_head.prev - offsetof(struct process, lru_item)
+      );
       assert(victim->swap_blocks == 0);
       victim_core_blocks =
         victim->core_item.limit - victim->core_item.base;
@@ -247,6 +246,7 @@ static bool do_swap_out(int swap_out) {
       // remove from core pool
       pool_free(&core_table, &victim->core_item);
 #endif /* ! INDIRECT_CORE */
+      victim->flags &= ~PROCESS_FLAGS_CORE_ITEM;
       victim = NULL;
 
       swap_out -= blocks;
@@ -259,7 +259,7 @@ bool process_alloc(struct process *process, int para, int paras) {
   int blocks;
 
   // must not be already allocated
-  assert(process->paras == -1);
+  assert((process->flags & PROCESS_FLAGS_ACTIVE) == 0);
 
   // check blocks
   blocks = (para + paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
@@ -319,6 +319,7 @@ bool process_alloc(struct process *process, int para, int paras) {
   process->lru_item.next->prev = &process->lru_item;
 
   // track total allocation
+  process->flags = PROCESS_FLAGS_ACTIVE | PROCESS_FLAGS_CORE_ITEM;
   process->para = para;
   process->paras = paras;
   process->swap_blocks = 0;
@@ -329,10 +330,11 @@ bool process_alloc(struct process *process, int para, int paras) {
 bool process_realloc(struct process *process, int paras, bool dir) {
   int old_blocks, para, blocks, blocks_change;
 
-  // must be already allocated
-  assert(process->paras != -1);
-
-  // must be fully in core
+  // must be already allocated and fully in core
+  assert(
+    (process->flags & (PROCESS_FLAGS_ACTIVE | PROCESS_FLAGS_CORE_ITEM)) ==
+      (PROCESS_FLAGS_ACTIVE | PROCESS_FLAGS_CORE_ITEM)
+  );
   assert(process->lru_item.prev != NULL && process->swap_blocks == 0);
 
   // check blocks
@@ -445,10 +447,11 @@ void process_run(struct process *process) {
 #endif /* INDIRECT_CORE */
 
   // must be already allocated
-  assert(process->paras != -1);
+  assert(process->flags & PROCESS_FLAGS_ACTIVE);
 
   // see whether fully in core
   if (process->lru_item.prev != NULL) {
+    assert(process->flags & PROCESS_FLAGS_CORE_ITEM);
     assert(process->swap_blocks == 0);
 
     // yes, remove from LRU list
@@ -461,6 +464,7 @@ void process_run(struct process *process) {
 
     // loop entry code for case of fully in swap
     if (process != victim) {
+      assert((process->flags & PROCESS_FLAGS_CORE_ITEM) == 0);
       assert(
         process->swap_blocks ==
           process->swap_item.limit - process->swap_item.base
@@ -490,6 +494,7 @@ void process_run(struct process *process) {
         )
       );
 #endif /* ! INDIRECT_CORE */
+      process->flags |= PROCESS_FLAGS_CORE_ITEM;
       goto loop_entry_full;
     }
     assert(process->swap_blocks);
@@ -647,10 +652,11 @@ void process_free(struct process *process) {
 #endif /* INDIRECT_CORE */
 
   // must be already allocated
-  assert(process->paras != -1);
+  assert(process->flags & PROCESS_FLAGS_ACTIVE);
 
   // see whether fully in core, victim, or fully in swap
   if (process->lru_item.prev != NULL) {
+    assert(process->flags & PROCESS_FLAGS_CORE_ITEM);
     assert(process->swap_blocks == 0);
 
     // fully in core, remove from LRU list and core pool
@@ -671,6 +677,8 @@ void process_free(struct process *process) {
 #endif /* INDIRECT_CORE */
   }
   else if (process == victim) {
+    assert(process->flags & PROCESS_FLAGS_CORE_ITEM);
+
     // victim, remove from core and swap pools
 #ifdef INDIRECT_SWAP
     swap_base = victim->swap_item.limit - victim->swap_blocks;
@@ -693,6 +701,7 @@ void process_free(struct process *process) {
     victim = NULL;
   }
   else {
+    assert((process->flags & PROCESS_FLAGS_CORE_ITEM) == 0);
     assert(
       process->swap_blocks ==
         process->swap_item.limit - process->swap_item.base
@@ -717,14 +726,15 @@ void process_free(struct process *process) {
 
   // track total allocation
   process_avail += (process->paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
-  process->paras = -1;
+  process->flags = 0;
 }
 
 // improve this later
 void process_get_state(struct process *process, struct process_state *state) {
   if (process->lru_item.prev != NULL) { // fully in core
+    assert(process->flags & PROCESS_FLAGS_CORE_ITEM);
     assert(process->swap_blocks == 0);
- 
+
     assert(process != runner);
     assert(process != victim);
     state->core_base = process->core_item.base;
@@ -738,6 +748,8 @@ void process_get_state(struct process *process, struct process_state *state) {
   }
   else {
     if (process == runner) { // partially in core, partially in swap
+      assert(process->flags & PROCESS_FLAGS_CORE_ITEM);
+
       assert(process != victim);
       state->core_base = process->core_item.base;
       state->core_blocks =
@@ -757,6 +769,8 @@ void process_get_state(struct process *process, struct process_state *state) {
       state->swap_paras = process->paras - state->core_paras;
     }
     else if (process == victim) { // partially in core, partially in swap
+      assert(process->flags & PROCESS_FLAGS_CORE_ITEM);
+
       state->core_base = process->core_item.base;
       state->core_blocks =
 #ifndef INDIRECT_CORE
@@ -775,6 +789,7 @@ void process_get_state(struct process *process, struct process_state *state) {
       state->swap_paras = process->paras - state->core_paras;
     }
     else { // fully in swap
+      assert((process->flags & PROCESS_FLAGS_CORE_ITEM) == 0);
       assert(
         process->swap_blocks ==
           process->swap_item.limit - process->swap_item.base

diff --git a/process.h b/process.h
index 49ebec8..a3c6120 100644 (file)
--- a/process.h
+++ b/process.h
@@ -21,8 +21,12 @@ struct lru_item {
   struct lru_item *next;
 };
 
+#define PROCESS_FLAGS_ACTIVE 1
+#define PROCESS_FLAGS_CORE_ITEM 2
+
 struct process {
-  struct lru_item lru_item; // must be first
+  int flags;
+  struct lru_item lru_item;
   struct pool_item core_item;
   struct pool_item swap_item;
   int para; // wasted space in first block due to prior use of expand-down