Change order of adjusting process_core_blocks/process_swap_blocks/victim_core_blocks...

diff --git a/process.c b/process.c
index dc91ef9..4abeb37 100644 (file)
--- a/process.c
+++ b/process.c
@@ -184,9 +184,10 @@ static void do_swap_out(int swap_out) {
  printf("existing victim %d, swap out %d of %d\n", (int)(victim - processes), blocks, victim_core_blocks);
 
       // increase swap allocation
-      victim_swap_blocks += blocks;
 #ifndef PREALLOCATE_SWAP
-      rassert(swap_table_realloc(&victim->swap_item, victim_swap_blocks));
+      rassert(
+        swap_table_realloc(&victim->swap_item, victim_swap_blocks + blocks)
+      );
 #endif
       goto loop_entry;
     }
@@ -211,29 +212,31 @@ static void do_swap_out(int swap_out) {
  printf("new victim %d, swap out %d of %d\n", (int)(victim - processes), blocks, victim_core_blocks);
 
       // add to swap pool, using dedicated swap item
-      victim_swap_blocks = blocks;
+      victim_swap_blocks = 0;
 #ifndef PREALLOCATE_SWAP
-      rassert(swap_table_alloc(&victim->swap_item, victim_swap_blocks));
+      rassert(swap_table_alloc(&victim->swap_item, blocks));
 #endif
 
     loop_entry:
       // calculate transfer parameters
 #ifdef PREALLOCATE_SWAP
-      swap_base = victim->swap_item.base + victim_swap_blocks - blocks;
+      swap_base = victim->swap_item.base + victim_swap_blocks;
 #else
       swap_base = victim->swap_item.limit - blocks;
 #endif
 #ifdef PREALLOCATE_CORE
-      core_base = victim->core_item.base + victim_swap_blocks - blocks;
+      core_base = victim->core_item.base + victim_swap_blocks;
 #else
       core_base = victim->core_item.base;
 #endif
       size = (long)blocks << BLOCK_SHIFT;
 
       // see if last transfer for victim
-      if (victim_core_blocks == blocks)
+      victim_core_blocks -= blocks;
+      if (victim_core_blocks == 0)
         // yes, correct size for partial last block
         size += ((victim->size - 1L) | -BLOCK_SIZE) + 1L;
+      victim_swap_blocks += blocks;
 
       // transfer data to swap
 #ifdef INDIRECT_SWAP
@@ -245,7 +248,6 @@ static void do_swap_out(int swap_out) {
 #endif
 
       // see if victim fully swapped out
-      victim_core_blocks -= blocks;
       if (victim_core_blocks) {
 #ifndef PREALLOCATE_CORE
         // no, reduce core allocation, using dedicated core item
@@ -403,7 +405,7 @@ bool process_realloc(struct process *process, long size) {
 }
 
 void process_run(struct process *process) {
-  int blocks, swap_out;
+  int blocks, swap_out, excess;
   int process_core_blocks, process_swap_blocks;
   int swap_base, core_base;
   long size;
@@ -431,8 +433,9 @@ void process_run(struct process *process) {
       blocks = process_swap_blocks;
       swap_out = blocks - core_avail();
 #if !defined(PREALLOCATE_SWAP) || defined(INDIRECT_SWAP)
-      if (swap_out > swap_avail()) {
-        blocks += swap_avail() - swap_out;
+      excess = swap_out - swap_avail();
+      if (excess > 0) {
+        blocks -= excess;
         swap_out = swap_avail();
       }
 #endif
@@ -440,10 +443,10 @@ void process_run(struct process *process) {
       // free up as much core as we can
       do_swap_out(swap_out);
 
-      // add to core pool, using dedicated core item
-      process_core_blocks = blocks;
+      // add to core pool
+      process_core_blocks = 0;
 #ifndef PREALLOCATE_CORE
-      rassert(core_table_alloc(&process->core_item, process_core_blocks));
+      rassert(core_table_alloc(&process->core_item, blocks));
 #endif
       goto loop_entry_full;
     }
@@ -494,22 +497,25 @@ void process_run(struct process *process) {
       do_swap_out(swap_out);
 
       // increase core allocation
-      process_core_blocks += blocks;
 #ifndef PREALLOCATE_CORE
       rassert(
-        core_table_realloc_base(&process->core_item, process_core_blocks)
+        core_table_realloc_base(
+          &process->core_item,
+          process_core_blocks + blocks
+        )
       );
 #endif
 
     loop_entry_full:
       // calculate transfer parameters
+      process_swap_blocks -= blocks;
 #ifdef PREALLOCATE_SWAP
-      swap_base = process->swap_item.base + process_swap_blocks - blocks;
+      swap_base = process->swap_item.base + process_swap_blocks;
 #else
       swap_base = process->swap_item.limit - blocks;
 #endif
 #ifdef PREALLOCATE_CORE
-      core_base = process->core_item.base + process_swap_blocks - blocks;
+      core_base = process->core_item.base + process_swap_blocks;
 #else
       core_base = process->core_item.base;
 #endif
@@ -517,9 +523,10 @@ void process_run(struct process *process) {
       size = (long)blocks << BLOCK_SHIFT;
 
       // see if first transfer for process
-      if (process_core_blocks == blocks)
+      if (process_core_blocks == 0)
         // yes, correct size for partial last block
         size += ((process->size - 1L) | -BLOCK_SIZE) + 1L;
+      process_core_blocks += blocks;
 
       // transfer data to core
 #ifdef INDIRECT_CORE
@@ -529,8 +536,6 @@ void process_run(struct process *process) {
 #ifdef INDIRECT_SWAP
       swap_block_free(swap_table_mem + swap_base, blocks);
 #endif
-
-      process_swap_blocks -= blocks;
     } while (process_swap_blocks);
 
 #ifndef PREALLOCATE_SWAP