Change process->swap_blocks to process->core_blocks, stored iff INDIRECT_CORE

diff --git a/process.c b/process.c
index 1db34e7..40a1350 100644 (file)
--- a/process.c
+++ b/process.c
@@ -47,7 +47,7 @@ void process_init(int n, int spare) {
 // note: swap_out argument can be negative, indicates a no-op
 static bool do_swap_out(int swap_out) {
   struct process *process;
-  int core_blocks;
+  int core_blocks, swap_blocks;
   int blocks, swap_base, core_base;
   int paras;
 #ifndef INDIRECT_CORE
@@ -66,14 +66,12 @@ static bool do_swap_out(int swap_out) {
 
     // calculate amount to swap out
 #ifndef INDIRECT_CORE
-    core_blocks =
-      process->core_item.limit - process->core_item.base;
+    core_blocks = process->core_item.limit - process->core_item.base;
 #else /* INDIRECT_CORE */
-    core_blocks =
-      process->core_item.limit -
-        process->core_item.base -
-        process->swap_blocks;
+    core_blocks = process->core_blocks;
 #endif /* INDIRECT_CORE */
+    swap_blocks =
+      process->swap_item.limit - process->swap_item.base - core_blocks;
 #ifndef INDIRECT_SWAP
     blocks = swap_out < core_blocks ? swap_out : core_blocks;
 #else /* INDIRECT_SWAP */
@@ -89,12 +87,15 @@ static bool do_swap_out(int swap_out) {
 
     // calculate transfer parameters
     core_blocks -= blocks;
-    process->swap_blocks += blocks;
-    swap_base = process->swap_item.limit - process->swap_blocks;
+#ifdef INDIRECT_CORE
+    process->core_blocks = core_blocks;
+#endif
+    swap_blocks += blocks;
+    swap_base = process->swap_item.limit - swap_blocks;
 #ifndef INDIRECT_CORE
     core_base = process->core_item.limit - blocks;
 #else /* INDIRECT_CORE */
-    core_base = process->core_item.limit - process->swap_blocks;
+    core_base = process->core_item.limit - swap_blocks;
 #endif /* INDIRECT_CORE */
     paras = blocks << BLOCK_PARAS_SHIFT;
 
@@ -204,10 +205,6 @@ static bool do_swap_out(int swap_out) {
       // report whether aborted due to swap space or user request
       return swap_out == blocks;
     }
-    assert(
-      process->swap_blocks ==
-        process->swap_item.limit - process->swap_item.base
-    );
  printf("victimized %d\n", (int)(process - processes));
 
 #ifndef INDIRECT_CORE
@@ -293,7 +290,9 @@ bool process_alloc(struct process *process, int para, int paras) {
 #endif /* INDIRECT_CORE */
   process->para = para;
   process->paras = paras;
-  process->swap_blocks = 0;
+#ifdef INDIRECT_CORE
+  process->core_blocks = blocks;
+#endif
   process_avail -= blocks;
   return true;
 }
@@ -307,8 +306,16 @@ bool process_realloc(struct process *process, int paras, bool dir) {
   // must be fully in core
 #ifndef INDIRECT_CORE
   assert(process->flags & PROCESS_FLAGS_CORE_ITEM);
+  assert(
+    process->core_item.limit - process->core_item.base ==
+      process->swap_item.limit - process->swap_item.base
+  );
+#else
+  assert(
+    process->core_blocks ==
+      process->swap_item.limit - process->swap_item.base
+  );
 #endif /* ! INDIRECT_CORE */
-  assert(process->swap_blocks == 0);
 
   // check blocks
   old_blocks = process->swap_item.limit - process->swap_item.base;
@@ -410,12 +417,15 @@ bool process_realloc(struct process *process, int paras, bool dir) {
   if (dir)
     process->para = (blocks << BLOCK_PARAS_SHIFT) - para - paras;
   process->paras = paras;
+#ifdef INDIRECT_CORE
+  process->core_blocks = blocks;
+#endif
   process_avail -= blocks_change;
   return true;
 }
 
 void process_run(struct process *process) {
-  int blocks, core_blocks;
+  int core_blocks, swap_blocks, blocks;
   int swap_base, core_base;
   int paras;
 #ifndef INDIRECT_CORE
@@ -435,30 +445,28 @@ void process_run(struct process *process) {
   process->lru_item.prev->next = process->lru_item.next;
   process->lru_item.next->prev = process->lru_item.prev;
 
-#ifndef INDIRECT_CORE
   do {
+#ifndef INDIRECT_CORE
     core_blocks =
       process->flags & PROCESS_FLAGS_CORE_ITEM ?
         process->core_item.limit - process->core_item.base :
         0;
 #else /* INDIRECT_CORE */
-  while (process->swap_blocks) {
-    core_blocks =
-      process->core_item.limit -
-        process->core_item.base -
-        process->swap_blocks;
+    core_blocks = process->core_blocks;
 #endif /* INDIRECT_CORE */
+    swap_blocks =
+      process->swap_item.limit - process->swap_item.base - core_blocks;
 
     // free up as much core as we can
 #ifndef INDIRECT_CORE
-    do_swap_out(process->swap_blocks - core_table.avail);
+    do_swap_out(swap_blocks - core_table.avail);
     blocks = core_table.avail;
 #else /* INDIRECT_CORE */
-    do_swap_out(process->swap_blocks - core_block_pool.avail);
+    do_swap_out(swap_blocks - core_block_pool.avail);
     blocks = core_block_pool.avail;
 #endif /* INDIRECT_CORE */
-    if (blocks > process->swap_blocks)
-      blocks = process->swap_blocks;
+    if (blocks > swap_blocks)
+      blocks = swap_blocks;
 
 #ifndef INDIRECT_CORE
     // increase core allocation
@@ -476,14 +484,17 @@ void process_run(struct process *process) {
 #endif /* ! INDIRECT_CORE */
 
     // calculate transfer parameters
-    swap_base = process->swap_item.limit - process->swap_blocks;
+    swap_base = process->swap_item.limit - swap_blocks;
 #ifndef INDIRECT_CORE
     core_base = process->core_item.limit - blocks;
 #else /* INDIRECT_CORE */
-    core_base = process->core_item.limit - process->swap_blocks;
+    core_base = process->core_item.limit - swap_blocks;
 #endif /* INDIRECT_CORE */
     core_blocks += blocks;
-    process->swap_blocks -= blocks;
+#ifdef INDIRECT_CORE
+    process->core_blocks = core_blocks;
+#endif
+    swap_blocks -= blocks;
     paras = blocks << BLOCK_PARAS_SHIFT;
 
     // transfer data to core
@@ -527,7 +538,6 @@ void process_run(struct process *process) {
  printf("\n");
     block_pool_free(&swap_block_pool, swap_table_mem + swap_base, blocks);
 #endif /* INDIRECT_SWAP */
-  } while (process->swap_blocks);
 #else /* INDIRECT_CORE */
     j = paras >> BLOCK_PARAS_SHIFT;
  printf("blocks");
@@ -566,8 +576,8 @@ void process_run(struct process *process) {
 #ifdef INDIRECT_SWAP
     block_pool_free(&swap_block_pool, swap_table_mem + swap_base, blocks);
 #endif /* INDIRECT_SWAP */
-  }
 #endif /* INDIRECT_CORE */
+  } while (swap_blocks);
 
   // insert at head of LRU list
   process->lru_item.prev = &lru_head;
@@ -577,6 +587,10 @@ void process_run(struct process *process) {
 }
 
 void process_free(struct process *process) {
+#ifdef INDIRECT_SWAP
+  int core_blocks, swap_blocks;
+#endif /* INDIRECT_SWAP */
+ 
   // must be already allocated
   assert(process->flags & PROCESS_FLAGS_ACTIVE);
 
@@ -586,6 +600,20 @@ void process_free(struct process *process) {
   process->lru_item.prev->next = process->lru_item.next;
   process->lru_item.next->prev = process->lru_item.prev;
 
+#ifdef INDIRECT_SWAP
+  // calculate blocks before freeing anything
+#ifndef INDIRECT_CORE
+  core_blocks =
+    process->flags & PROCESS_FLAGS_CORE_ITEM ?
+      process->core_item.limit - process->core_item.base :
+      0;
+#else /* INDIRECT_CORE */
+  core_blocks = process->core_blocks;
+#endif /* INDIRECT_CORE */
+  swap_blocks =
+    process->swap_item.limit - process->swap_item.base - core_blocks;
+#endif /* INDIRECT_SWAP */
+
   // remove from core pool
 #ifndef INDIRECT_CORE
   if (process->flags & PROCESS_FLAGS_CORE_ITEM)
@@ -594,9 +622,11 @@ void process_free(struct process *process) {
   block_pool_free(
     &core_block_pool,
     core_table_mem + process->core_item.base,
-    process->core_item.limit -
-      process->core_item.base -
-      process->swap_blocks
+#ifdef INDIRECT_SWAP
+    core_blocks
+#else /* ! INDIRECT_SWAP */
+    process->core_blocks
+#endif /* ! INDIRECT_SWAP */
   );
   pool_free(&core_table, &process->core_item);
 #endif /* INDIRECT_CORE */
@@ -605,8 +635,8 @@ void process_free(struct process *process) {
 #ifdef INDIRECT_SWAP
   block_pool_free(
     &swap_block_pool,
-    swap_table_mem + process->swap_item.limit - process->swap_blocks,
-    process->swap_blocks
+    swap_table_mem + process->swap_item.base + core_blocks,
+    swap_blocks
   );
 #endif /* INDIRECT_SWAP */
   pool_free(&swap_table, &process->swap_item);
@@ -631,10 +661,7 @@ void process_get_state(struct process *process, struct process_state *state) {
   }
 #else /* INDIRECT_CORE */
   state->core_base = process->core_item.base;
-  state->core_blocks =
-    process->core_item.limit -
-      process->core_item.base -
-      process->swap_blocks;
+  state->core_blocks = process->core_blocks;
 #endif /* INDIRECT_CORE */
   state->core_para = process->para;
   state->core_paras =
@@ -644,8 +671,10 @@ void process_get_state(struct process *process, struct process_state *state) {
   if (state->core_paras > process->paras)
     state->core_paras = process->paras;
 
-  state->swap_base = process->swap_item.limit - process->swap_blocks;
-  state->swap_blocks = process->swap_blocks;
+  state->swap_base =
+    process->swap_item.base + state->core_blocks;
+  state->swap_blocks =
+    process->swap_item.limit - process->swap_item.base - state->core_blocks;
   para = 
     (
       (process->swap_item.limit - process->swap_item.base) <<
@@ -653,12 +682,12 @@ void process_get_state(struct process *process, struct process_state *state) {
     ) - process->para - process->paras;
  //printf("a %d+%d+%d=%d*%d\n", process->para, process->paras, para, process->swap_item.limit - process->swap_item.base, BLOCK_PARAS);
   state->swap_paras =
-    (process->swap_blocks << BLOCK_PARAS_SHIFT) - para;
+    (state->swap_blocks << BLOCK_PARAS_SHIFT) - para;
   if (state->swap_paras < 0)
     state->swap_paras = 0;
   if (state->swap_paras > process->paras)
     state->swap_paras = process->paras;
   state->swap_para =
-    (process->swap_blocks << BLOCK_PARAS_SHIFT) - para - state->swap_paras;
+    (state->swap_blocks << BLOCK_PARAS_SHIFT) - para - state->swap_paras;
  //printf("b %d+%d+%d=%d*%d\n", state->swap_para, state->swap_paras, para, process->swap_blocks, BLOCK_PARAS);
 }

diff --git a/process.h b/process.h
index 8ea04ed..3e5084e 100644 (file)
--- a/process.h
+++ b/process.h
@@ -15,6 +15,7 @@
 //#define PAGE_BLOCKS (1 << PAGE_BLOCKS_SHIFT)
 
 #include "pool.h"
+#include "core.h" // TEMPORARY, JUST TO GET INDIRECT_CORE SETTING
 
 struct lru_item {
   struct lru_item *prev;
@@ -22,7 +23,9 @@ struct lru_item {
 };
 
 #define PROCESS_FLAGS_ACTIVE 1
+#ifndef INDIRECT_CORE
 #define PROCESS_FLAGS_CORE_ITEM 2
+#endif
 
 struct process {
   int flags;
@@ -31,7 +34,9 @@ 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;
+#ifdef INDIRECT_CORE
+  int core_blocks;
+#endif
 };
 
 // improve this later