Make do_swap_read_write(), do_swap_out(), and process_run() use process_calc()

diff --git a/process.c b/process.c
index 267c062..5d734b4 100644 (file)
--- a/process.c
+++ b/process.c
@@ -46,23 +46,23 @@ void process_init(int n, int spare) {
 
 static void do_swap_read_write(
   struct process *process,
-  int block,
+  struct process_calc *calc,
   int blocks,
   bool dir
 ) {
 #ifndef INDIRECT_CORE
 #ifndef INDIRECT_SWAP
   swap_read_write(
-    process->core_item.base + block,
-    process->swap_item.base + block,
+    calc->core_origin + calc->in_core_block,
+    calc->swap_origin + calc->in_core_block,
     blocks,
     dir
   );
 #else /* INDIRECT_SWAP */
   int core_block, swap_block, i;
 
-  core_block = process->core_item.base + block;
-  swap_block = process->swap_item.base + block;
+  core_block = calc->core_origin + calc->in_core_block;
+  swap_block = calc->swap_origin + calc->in_core_block;
  printf("blocks");
   for (i = 0; i < blocks; ++i)
  {
@@ -79,8 +79,8 @@ static void do_swap_read_write(
 #else /* INDIRECT_CORE */
   int core_block, swap_block, i;
 
-  core_block = process->core_item.base + block;
-  swap_block = process->swap_item.base + block;
+  core_block = calc->core_origin + calc->in_core_block;
+  swap_block = calc->swap_origin + calc->in_core_block;
  printf("blocks");
   for (i = 0; i < blocks; ++i)
  {
@@ -105,39 +105,38 @@ static void do_swap_read_write(
 }
 
 // note: swap_out argument can be negative, indicates a no-op
+// note: not allowed to move any core, or caller must refresh
 static bool do_swap_out(int swap_out) {
   struct process *process;
-  int block, blocks;
+  struct process_calc calc;
+  int blocks;
 
   for (; swap_out > 0; swap_out -= blocks) {
+#ifdef INDIRECT_SWAP
+    if (swap_block_pool.avail == 0)
+      return false;
+#endif
+
     assert(victim->prev != &lru_head);
     process = (struct process *)(
       (char *)victim->prev - offsetof(struct process, lru_item)
     );
+    process_calc(process, &calc);
 
     // calculate amount to swap out
-#ifndef INDIRECT_CORE
-    block = process->core_item.limit - process->core_item.base;
-#else /* INDIRECT_CORE */
-    block = process->in_core_blocks;
-#endif /* INDIRECT_CORE */
+    blocks = calc.in_core_block - calc.block_base;
 #ifndef INDIRECT_SWAP
-    blocks = swap_out < block ? swap_out : block;
-#else /* INDIRECT_SWAP */
-    blocks = swap_block_pool.avail;
-    if (blocks == 0)
-      return false;
+    if (blocks > swap_block_pool.avail)
+      blocks = swap_block_pool.avail;
+#endif
     if (blocks > swap_out)
       blocks = swap_out;
-    if (blocks > block)
-      blocks = block;
-#endif /* INDIRECT_SWAP */
- printf("victim %d, swap out %d of %d\n", (int)(process - processes), blocks, block);
+ printf("victim %d, swap out %d of %d\n", (int)(process - processes), blocks, calc.in_core_block - calc.block_base);
 
     // adjust swap pointer
-    block -= blocks;
+    calc.in_core_block -= blocks;
 #ifdef INDIRECT_CORE
-    process->in_core_blocks = block;
+    process->in_core_blocks = calc.in_core_block - calc.block_base;
 #endif
 
     // transfer data to swap
@@ -145,30 +144,30 @@ static bool do_swap_out(int swap_out) {
     rassert(
       block_pool_alloc(
         &swap_block_pool,
-        swap_table_mem + process->swap_item.base + block,
+        swap_table_mem + calc.swap_origin + calc.in_core_block,
         blocks
       )
     );
 #endif /* INDIRECT_SWAP */
- printf("write core [%d,%d) to swap [%d,%d)\n", process->core_item.base + block, process->core_item.base + block + blocks, process->swap_item.base + block, process->swap_item.base + block + blocks);
-    do_swap_read_write(process, block, blocks, true);
+ printf("write core [%d,%d) to swap [%d,%d)\n", calc.core_origin + calc.in_core_block, calc.core_origin + calc.in_core_block + blocks, calc.swap_origin + calc.in_core_block, calc.swap_origin + calc.in_core_block + blocks);
+    do_swap_read_write(process, &calc, blocks, true);
 #ifdef INDIRECT_CORE
     block_pool_free(
       &core_block_pool,
-      core_table_mem + process->core_item.base + block,
+      core_table_mem + calc.core_origin + calc.in_core_block,
       blocks
     );
 #endif /* INDIRECT_CORE */
 
     // see if victim fully swapped out
-    if (block) {
+    if (calc.in_core_block > calc.block_base) {
 #ifndef INDIRECT_CORE
       // no, reduce core allocation
       rassert(
         pool_alloc(
           &core_table,
           &process->core_item,
-          block,
+          calc.in_core_block - calc.block_base,
           POOL_ALLOC_MODE_MOVEABLE | POOL_ALLOC_MODE_REALLOC
         )
       );
@@ -376,7 +375,8 @@ bool process_realloc(struct process *process, int para_base_limit, bool dir) {
 }
 
 void process_run(struct process *process) {
-  int block, swap_in, blocks;
+  struct process_calc calc;
+  int swap_in, blocks;
 
   // must be already allocated
   assert(process->flags & PROCESS_FLAGS_ACTIVE);
@@ -388,17 +388,9 @@ void process_run(struct process *process) {
   process->lru_item.next->prev = process->lru_item.prev;
 
   // loop to swap out then swap in
-#ifndef INDIRECT_CORE
-  block =
-    process->flags & PROCESS_FLAGS_CORE_ITEM ?
-      process->core_item.limit - process->core_item.base :
-      0;
-#else /* INDIRECT_CORE */
-  block = process->in_core_blocks;
-#endif /* INDIRECT_CORE */
+  process_calc(process, &calc);
   for (
-    swap_in =
-      process->swap_item.limit - process->swap_item.base - block;
+    swap_in = calc.block_limit - calc.in_core_block;
 #ifndef INDIRECT_CORE
     (process->flags & PROCESS_FLAGS_CORE_ITEM) == 0 || swap_in > 0;
 #else
@@ -423,35 +415,40 @@ void process_run(struct process *process) {
       pool_alloc(
         &core_table,
         &process->core_item,
-        block + blocks,
+        calc.in_core_block - calc.block_base + blocks,
         process->flags & PROCESS_FLAGS_CORE_ITEM ?
           POOL_ALLOC_MODE_MOVEABLE | POOL_ALLOC_MODE_REALLOC :
           POOL_ALLOC_MODE_MOVEABLE
       )
     );
     process->flags |= PROCESS_FLAGS_CORE_ITEM;
+    calc.core_origin = process->core_item.base - calc.block_base;
 #endif /* ! INDIRECT_CORE */
 
     // transfer data to core
 #ifdef INDIRECT_CORE
     rassert(
-      block_pool_alloc(&core_block_pool, core_table_mem + process->core_item.base + block, blocks)
+      block_pool_alloc(
+        &core_block_pool,
+        core_table_mem + calc.core_origin + calc.in_core_block,
+        blocks
+      )
     );
 #endif /* INDIRECT_CORE */
- printf("read swap [%d,%d) to core [%d,%d)\n", process->swap_item.base + block, process->swap_item.base + block + blocks, process->core_item.base + block, process->core_item.base + block + blocks);
-    do_swap_read_write(process, block, blocks, false);
+ printf("read swap [%d,%d) to core [%d,%d)\n", calc.swap_origin + calc.in_core_block, calc.swap_origin + calc.in_core_block + blocks, calc.core_origin + calc.in_core_block, calc.core_origin + calc.in_core_block + blocks);
+    do_swap_read_write(process, &calc, blocks, false);
 #ifdef INDIRECT_SWAP
     block_pool_free(
       &swap_block_pool,
-      swap_table_mem + process->swap_item.base + block,
+      swap_table_mem + calc.swap_origin + calc.in_core_block,
       blocks
     );
 #endif /* INDIRECT_SWAP */
 
     // adjust swap pointer
-    block += blocks;
+    calc.in_core_block += blocks;
 #ifdef INDIRECT_CORE
-    process->in_core_blocks = block;
+    process->in_core_blocks = calc.in_core_block - calc.block_base;
 #endif /* INDIRECT_CORE */
   }