Make only the active (bytewise not blockwise) portion of process be hashed

diff --git a/process_test_run.c b/process_test_run.c
index 4ae4086..52c5c99 100644 (file)
--- a/process_test_run.c
+++ b/process_test_run.c
@@ -156,7 +156,7 @@ int main(int argc, char **argv) {
           core_hash_init(
             process,
             (long)core_base << BLOCK_SHIFT,
-            (long)blocks << BLOCK_SHIFT,
+            size,
             0L
           );
 #ifdef PREALLOCATE_SWAP
@@ -190,8 +190,9 @@ int main(int argc, char **argv) {
         printf("... not allocated, ignore\n");
       else {
         int core_base = PER_PROCESS_CORE_ITEM(processes + process).base;
+        int actual_old_size = processes[process].size;
         int actual_old_blocks =
-          (int)((processes[process].size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+          (int)((actual_old_size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
         rassert(
           PER_PROCESS_CORE_ITEM(processes + process).limit ==
             core_base + actual_old_blocks
@@ -210,12 +211,11 @@ int main(int argc, char **argv) {
 #else
  printf("old core [%d,%d)\n", core_base, core_base + actual_old_blocks);
 #endif
-        int blocks = (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
         core_hash_verify(
           process,
-          (long)(core_base + blocks) << BLOCK_SHIFT,
-          (long)(actual_old_blocks - blocks) << BLOCK_SHIFT,
-          (long)blocks << BLOCK_SHIFT
+          ((long)core_base << BLOCK_SHIFT) + size,
+          actual_old_size - size,
+          size
         );
         bool result = process_realloc(processes + process, size);
         printf(
@@ -231,6 +231,7 @@ int main(int argc, char **argv) {
           }
           else {
             core_base = PER_PROCESS_CORE_ITEM(processes + process).base;
+            int blocks = (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
             rassert(
               PER_PROCESS_CORE_ITEM(processes + process).limit ==
                 core_base + blocks
@@ -242,9 +243,9 @@ int main(int argc, char **argv) {
 #endif
             core_hash_init(
               process,
-              (long)(core_base + actual_old_blocks) << BLOCK_SHIFT,
-              (long)(blocks - actual_old_blocks) << BLOCK_SHIFT,
-              (long)actual_old_blocks << BLOCK_SHIFT
+              ((long)core_base << BLOCK_SHIFT) + actual_old_size,
+              size - actual_old_size,
+              actual_old_size
             );
           }
         }
@@ -284,29 +285,38 @@ int main(int argc, char **argv) {
           );
           rassert(actual_old_blocks <= old_blocks);
         }
-        int swap_base, swap_blocks, core_base, core_blocks;
+        int swap_base, swap_blocks;
+        long swap_size;
+        int core_base, core_blocks;
+        long core_size;
         if (processes[process].lru_item.prev != NULL) { // fully in core
           assert(processes + process != victim);
           swap_base = -1;
           swap_blocks = 0;
+          swap_size = 0L;
           core_base =
             PER_PROCESS_CORE_ITEM(processes + process).base;
           core_blocks =
             PER_PROCESS_CORE_ITEM(processes + process).limit - core_base;
+          core_size = processes[process].size;
         }
         else if (processes + process == victim) { // victim
           swap_base = DEDICATED_SWAP_ITEM(victim).base;
           swap_blocks = DEDICATED_SWAP_BLOCKS(victim);
+          swap_size = swap_blocks << BLOCK_SHIFT;
           core_base = DEDICATED_CORE_BASE(victim, swap_blocks);
           core_blocks = DEDICATED_CORE_BLOCKS(victim);
+          core_size = processes[process].size - swap_size;
         }
         else { // fully in swap
           swap_base =
             PER_PROCESS_SWAP_ITEM(processes + process).base;
           swap_blocks =
             PER_PROCESS_SWAP_ITEM(processes + process).limit - swap_base;
+          swap_size = processes[process].size;
           core_base = -1;
           core_blocks = 0;
+          core_size = 0L;
         }
         rassert(core_blocks + swap_blocks == actual_old_blocks);
  printf("old core [%d,%d) swap [%d,%d)\n", core_base, core_base + core_blocks, swap_base, swap_base + swap_blocks);
@@ -314,13 +324,13 @@ int main(int argc, char **argv) {
         core_hash_verify(
           process,
           (long)core_base << BLOCK_SHIFT,
-          (long)core_blocks << BLOCK_SHIFT,
-          (long)swap_blocks << BLOCK_SHIFT
+          core_size,
+          swap_size
         );
         swap_hash_verify(
           process,
           (long)swap_base << BLOCK_SHIFT,
-          (long)swap_blocks << BLOCK_SHIFT,
+          swap_size,
           0L
         );
         process_free(processes + process);
@@ -338,25 +348,38 @@ done:
     if (processes[i].size == -1L)
       printf("process %d: not allocated\n", i);
     else {
-      int swap_base, swap_blocks, core_base, core_blocks;
+      int swap_base, swap_blocks;
+      long swap_size;
+      int core_base, core_blocks;
+      long core_size;
       if (processes[i].lru_item.prev != NULL) { // fully in core
         assert(processes + i != victim);
         swap_base = -1;
         swap_blocks = 0;
-        core_base = PER_PROCESS_CORE_ITEM(processes + i).base;
-        core_blocks = PER_PROCESS_CORE_ITEM(processes + i).limit - core_base;
+        swap_size = 0L;
+        core_base =
+          PER_PROCESS_CORE_ITEM(processes + i).base;
+        core_blocks =
+          PER_PROCESS_CORE_ITEM(processes + i).limit - core_base;
+        core_size = processes[i].size;
       }
       else if (processes + i == victim) { // victim
         swap_base = DEDICATED_SWAP_ITEM(victim).base;
         swap_blocks = DEDICATED_SWAP_BLOCKS(victim);
+        swap_size = swap_blocks << BLOCK_SHIFT;
         core_base = DEDICATED_CORE_BASE(victim, swap_blocks);
         core_blocks = DEDICATED_CORE_BLOCKS(victim);
+        core_size = processes[i].size - swap_size;
       }
       else { // fully in swap
-        swap_base = PER_PROCESS_SWAP_ITEM(processes + i).base;
-        swap_blocks = PER_PROCESS_SWAP_ITEM(processes + i).limit - swap_base;
+        swap_base =
+          PER_PROCESS_SWAP_ITEM(processes + i).base;
+        swap_blocks =
+          PER_PROCESS_SWAP_ITEM(processes + i).limit - swap_base;
+        swap_size = processes[i].size;
         core_base = -1;
         core_blocks = 0;
+        core_size = 0L;
       }
       rassert(
         core_blocks + swap_blocks ==
@@ -373,8 +396,8 @@ done:
       core_hash_verify(
         i,
         (long)core_base << BLOCK_SHIFT,
-        (long)core_blocks << BLOCK_SHIFT,
-        (long)swap_blocks << BLOCK_SHIFT
+        core_size,
+        swap_size
       );
 #ifdef INDIRECT_CORE
       core_block_free(core_table_mem + core_base, core_blocks);
@@ -382,7 +405,7 @@ done:
       swap_hash_verify(
         i,
         (long)swap_base << BLOCK_SHIFT,
-        (long)swap_blocks << BLOCK_SHIFT,
+        swap_size,
         0L
       );
 #ifdef INDIRECT_SWAP