Add per-process tracking of amount swapped (formerly was in victim_swap_blocks)

diff --git a/process.c b/process.c
index 3d736c9..3257303 100644 (file)
--- a/process.c
+++ b/process.c
@@ -14,11 +14,7 @@ int process_avail;
 
 struct lru_item lru_head;
 
-struct process *runner;
-int runner_swap_blocks;
-
-struct process *victim;
-int victim_swap_blocks;
+struct process *runner, *victim;
 
 void process_init(int n, int spare) {
   int i;
@@ -74,7 +70,7 @@ static bool do_swap_out(int swap_out) {
 #ifndef INDIRECT_CORE
        victim->core_item.limit - victim->core_item.base;
 #else
-       victim->core_item.limit - victim->core_item.base - victim_swap_blocks;
+       victim->core_item.limit - victim->core_item.base - victim->swap_blocks;
 #endif
 #ifndef INDIRECT_SWAP
       blocks = swap_out < victim_core_blocks ? swap_out : victim_core_blocks;
@@ -98,7 +94,7 @@ static bool do_swap_out(int swap_out) {
       // calculate amount to swap out
       assert(lru_head.prev != &lru_head);
       victim = (struct process *)lru_head.prev;
-      victim_swap_blocks = 0;
+      assert(victim->swap_blocks == 0);
       victim_core_blocks =
         victim->core_item.limit - victim->core_item.base;
 #ifndef INDIRECT_SWAP
@@ -125,12 +121,12 @@ static bool do_swap_out(int swap_out) {
     loop_entry:
       // calculate transfer parameters
       victim_core_blocks -= blocks;
-      victim_swap_blocks += blocks;
-      swap_base = victim->swap_item.limit - victim_swap_blocks;
+      victim->swap_blocks += blocks;
+      swap_base = victim->swap_item.limit - victim->swap_blocks;
 #ifndef INDIRECT_CORE
       core_base = victim->core_item.limit - blocks;
 #else /* INDIRECT_CORE */
-      core_base = victim->core_item.limit - victim_swap_blocks;
+      core_base = victim->core_item.limit - victim->swap_blocks;
 #endif /* INDIRECT_CORE */
       paras = blocks << BLOCK_PARAS_SHIFT;
 
@@ -241,6 +237,10 @@ static bool do_swap_out(int swap_out) {
         // report whether aborted due to swap space or user request
         return swap_out == blocks;
       }
+      assert(
+        victim->swap_blocks ==
+          victim->swap_item.limit - victim->swap_item.base
+      );
  printf("victimized %d\n", (int)(victim - processes));
 
 #ifndef INDIRECT_CORE
@@ -321,6 +321,7 @@ bool process_alloc(struct process *process, int para, int paras) {
   // track total allocation
   process->para = para;
   process->paras = paras;
+  process->swap_blocks = 0;
   process_avail -= blocks;
   return true;
 }
@@ -332,7 +333,7 @@ bool process_realloc(struct process *process, int paras, bool dir) {
   assert(process->paras != -1);
 
   // must be fully in core
-  assert(process->lru_item.prev != NULL);
+  assert(process->lru_item.prev != NULL && process->swap_blocks == 0);
 
   // check blocks
   old_blocks = process->swap_item.limit - process->swap_item.base;
@@ -448,6 +449,8 @@ void process_run(struct process *process) {
 
   // see whether fully in core
   if (process->lru_item.prev != NULL) {
+    assert(process->swap_blocks == 0);
+
     // yes, remove from LRU list
     assert(process != victim);
     process->lru_item.prev->next = process->lru_item.next;
@@ -458,20 +461,21 @@ void process_run(struct process *process) {
 
     // loop entry code for case of fully in swap
     if (process != victim) {
-      // fully in swap, only the swap item is meaningful
-      runner_swap_blocks =
-        process->swap_item.limit - process->swap_item.base;
+      assert(
+        process->swap_blocks ==
+          process->swap_item.limit - process->swap_item.base
+      );
 
       // free up as much core as we can
 #ifndef INDIRECT_CORE
-      do_swap_out(runner_swap_blocks - core_table.avail);
+      do_swap_out(process->swap_blocks - core_table.avail);
       blocks = core_table.avail;
 #else /* INDIRECT_CORE */
-      do_swap_out(runner_swap_blocks - core_block_pool.avail);
+      do_swap_out(process->swap_blocks - core_block_pool.avail);
       blocks = core_block_pool.avail;
 #endif /* INDIRECT_CORE */
-      if (blocks > runner_swap_blocks)
-        blocks = runner_swap_blocks;
+      if (blocks > process->swap_blocks)
+        blocks = process->swap_blocks;
 
       // add to core pool
       runner = process;
@@ -488,6 +492,7 @@ void process_run(struct process *process) {
 #endif /* ! INDIRECT_CORE */
       goto loop_entry_full;
     }
+    assert(process->swap_blocks);
 
     // victim, take over the dedicated pool items
     runner = victim;
@@ -495,23 +500,22 @@ void process_run(struct process *process) {
 #ifndef INDIRECT_CORE
       victim->core_item.limit - victim->core_item.base;
 #else /* INDIRECT_CORE */
-      victim->core_item.limit - victim->core_item.base - victim_swap_blocks;
+      victim->core_item.limit - victim->core_item.base - victim->swap_blocks;
 #endif /* INDIRECT_CORE */
-    runner_swap_blocks = victim_swap_blocks;
     victim = NULL;
 
     // loop for case of partially in core, partially in swap
     do {
       // free up as much core as we can
 #ifndef INDIRECT_CORE
-      do_swap_out(runner_swap_blocks - core_table.avail);
+      do_swap_out(process->swap_blocks - core_table.avail);
       blocks = core_table.avail;
 #else /* INDIRECT_CORE */
-      do_swap_out(runner_swap_blocks - core_block_pool.avail);
+      do_swap_out(process->swap_blocks - core_block_pool.avail);
       blocks = core_block_pool.avail;
 #endif /* INDIRECT_CORE */
-      if (blocks > runner_swap_blocks)
-        blocks = runner_swap_blocks;
+      if (blocks > process->swap_blocks)
+        blocks = process->swap_blocks;
 
       // increase core allocation
 #ifndef INDIRECT_CORE
@@ -528,14 +532,14 @@ void process_run(struct process *process) {
 
     loop_entry_full:
       // calculate transfer parameters
-      swap_base = process->swap_item.limit - runner_swap_blocks;
+      swap_base = process->swap_item.limit - process->swap_blocks;
 #ifndef INDIRECT_CORE
       core_base = process->core_item.limit - blocks;
 #else /* INDIRECT_CORE */
-      core_base = process->core_item.limit - runner_swap_blocks;
+      core_base = process->core_item.limit - process->swap_blocks;
 #endif /* INDIRECT_CORE */
       runner_core_blocks += blocks;
-      runner_swap_blocks -= blocks;
+      process->swap_blocks -= blocks;
       paras = blocks << BLOCK_PARAS_SHIFT;
 
       // transfer data to core
@@ -618,7 +622,7 @@ void process_run(struct process *process) {
       block_pool_free(&swap_block_pool, swap_table_mem + swap_base, blocks);
 #endif /* INDIRECT_SWAP */
 #endif /* INDIRECT_CORE */
-    } while (runner_swap_blocks);
+    } while (process->swap_blocks);
   }
   runner = NULL;
 
@@ -647,6 +651,8 @@ void process_free(struct process *process) {
 
   // see whether fully in core, victim, or fully in swap
   if (process->lru_item.prev != NULL) {
+    assert(process->swap_blocks == 0);
+
     // fully in core, remove from LRU list and core pool
     assert(process != victim);
 
@@ -667,11 +673,11 @@ void process_free(struct process *process) {
   else if (process == victim) {
     // victim, remove from core and swap pools
 #ifdef INDIRECT_SWAP
-    swap_base = victim->swap_item.limit - victim_swap_blocks;
+    swap_base = victim->swap_item.limit - victim->swap_blocks;
     block_pool_free(
       &swap_block_pool,
       swap_table_mem + swap_base,
-      victim_swap_blocks
+      victim->swap_blocks
     );
 #endif /* INDIRECT_SWAP */
 #ifndef INDIRECT_CORE
@@ -681,12 +687,17 @@ void process_free(struct process *process) {
     block_pool_free(
       &core_block_pool,
       core_table_mem + core_base,
-      victim->core_item.limit - core_base - victim_swap_blocks
+      victim->core_item.limit - core_base - victim->swap_blocks
     );
 #endif /* INDIRECT_CORE */
     victim = NULL;
   }
   else {
+    assert(
+      process->swap_blocks ==
+        process->swap_item.limit - process->swap_item.base
+    );
+
     // fully in swap, remove from swap pool
 #ifdef INDIRECT_SWAP
     int swap_base = process->swap_item.base;
@@ -712,6 +723,8 @@ void process_free(struct process *process) {
 // 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->swap_blocks == 0);
+ 
     assert(process != runner);
     assert(process != victim);
     state->core_base = process->core_item.base;
@@ -733,13 +746,13 @@ void process_get_state(struct process *process, struct process_state *state) {
 #else /* INDIRECT_CORE */
         process->core_item.limit -
           process->core_item.base -
-          runner_swap_blocks;
+          runner->swap_blocks;
 #endif /* INDIRECT_CORE */
       state->core_para = process->para;
       state->core_paras =
         (state->core_blocks << BLOCK_PARAS_SHIFT) - process->para;
-      state->swap_base = process->swap_item.limit - runner_swap_blocks;
-      state->swap_blocks = runner_swap_blocks;
+      state->swap_base = process->swap_item.limit - runner->swap_blocks;
+      state->swap_blocks = runner->swap_blocks;
       state->swap_para = 0;
       state->swap_paras = process->paras - state->core_paras;
     }
@@ -751,17 +764,22 @@ void process_get_state(struct process *process, struct process_state *state) {
 #else /* INDIRECT_CORE */
         process->core_item.limit -
           process->core_item.base -
-          victim_swap_blocks;
+          victim->swap_blocks;
 #endif /* INDIRECT_CORE */
       state->core_para = process->para;
       state->core_paras =
         (state->core_blocks << BLOCK_PARAS_SHIFT) - process->para;
-      state->swap_base = process->swap_item.limit - victim_swap_blocks;
-      state->swap_blocks = victim_swap_blocks;
+      state->swap_base = process->swap_item.limit - victim->swap_blocks;
+      state->swap_blocks = victim->swap_blocks;
       state->swap_para = 0;
       state->swap_paras = process->paras - state->core_paras;
     }
     else { // fully in swap
+      assert(
+        process->swap_blocks ==
+          process->swap_item.limit - process->swap_item.base
+      );
+
       state->core_base = -1;
       state->core_blocks = 0;
       state->core_para = 0;

diff --git a/process.h b/process.h
index f181532..49ebec8 100644 (file)
--- a/process.h
+++ b/process.h
@@ -27,6 +27,7 @@ struct process {
   struct pool_item swap_item;
   int para; // wasted space in first block due to prior use of expand-down
   int paras; // brk level
+  int swap_blocks;
 };
 
 // improve this later
@@ -48,11 +49,7 @@ extern int process_avail;
 
 extern struct lru_item lru_head;
 
-extern struct process *runner;
-extern int runner_swap_blocks;
-
-extern struct process *victim;
-extern int victim_swap_blocks;
+extern struct process *runner, *victim;
 
 void process_init(int n, int spare);
 bool process_alloc(struct process *process, int para, int paras);