From 60563d4d313cce856b59d066f8e88dca36c71d33 Mon Sep 17 00:00:00 2001
From: Nick Downing <nick@ndcode.org>
Date: Sat, 23 Mar 2019 16:50:59 +1100
Subject: [PATCH] Print message like 'alloc NN NN true|false' and then perform
 the operation and then '... ok', so that we can see clearly what messages
 come from what operation

---
 pool_test_gen.c    |  21 +++-
 pool_test_run.c    | 138 +++++++++++++----------
 process_test_gen.c |  15 ++-
 process_test_run.c | 266 +++++++++++++++++++++++++++++----------------
 4 files changed, 284 insertions(+), 156 deletions(-)

diff --git a/pool_test_gen.c b/pool_test_gen.c
index 13e5a93..6169616 100644
--- a/pool_test_gen.c
+++ b/pool_test_gen.c
@@ -31,7 +31,12 @@ int main(int argc, char **argv) {
     if (old_size == -1) {
       int size = rand_int(item_size);
       bool success = pool_used + size <= pool_size;
-      printf("alloc %d %d %d\n", item, size, success);
+      printf(
+        "alloc %d %d %s\n",
+        item,
+        size,
+        success ? "true" : "false"
+      );
       if (success) {
         items[item] = size;
         pool_used += size;
@@ -40,14 +45,24 @@ int main(int argc, char **argv) {
     else if (rand_int(4)) {
       int size = rand_int(item_size);
       bool success = pool_used + size - old_size <= pool_size;
-      printf("realloc %d %d %d %d\n", item, old_size, size, success);
+      printf(
+        "realloc %d %d %d %s\n",
+        item,
+        old_size,
+        size,
+        success ? "true" : "false"
+      );
       if (success) {
         items[item] = size;
         pool_used += size - old_size;
       }
     }
     else {
-      printf("free %d %d\n", item, old_size);
+      printf(
+        "free %d %d\n",
+        item,
+        old_size
+      );
       items[item] = -1;
       pool_used -= old_size;
     }
diff --git a/pool_test_run.c b/pool_test_run.c
index 3e016ee..639aae6 100644
--- a/pool_test_run.c
+++ b/pool_test_run.c
@@ -73,35 +73,44 @@ int main(int argc, char **argv) {
       rassert(false);
     }
     if (strcmp(buf, "alloc") == 0) {
-      int item, size, success;
-      rassert(scanf("%d %d %d", &item, &size, &success) == 3);
+      int item, size;
+      rassert(scanf("%d %d %s", &item, &size, buf) == 3);
       rassert(item >= 0 && item < n_items);
-      rassert(size >= 0 && size < pool_size);
-      rassert(success >= 0 && success < 2);
+      rassert(size >= 0);
+      bool success;
+      if (strcmp(buf, "false") == 0)
+        success = false;
+      else if (strcmp(buf, "true") == 0)
+        success = true;
+      else
+        rassert(false);
+      printf(
+        "alloc %d %d %s\n",
+        item,
+        size,
+        success ? "true" : "false"
+      );
       rassert(items[item].prev == NULL);
       bool result =
         moveable ?
           pool_alloc_moveable(&head, items + item, size) :
           pool_alloc(&head, items + item, size);
       printf(
-        "alloc %d %d %d: %s\n",
-        item,
-        size,
-        success,
-        result == (bool)success ?
+        "... %s\n",
+        result == success ?
           "ok" :
           result ? "succeeded, should fail" : "failed, should succeed"
       );
       if (result) {
         if (!success) {
-          printf("undo\n");
+          printf("... undo\n");
           pool_free(&head, items + item);
           items[item].prev = NULL;
         }
         else {
           int base = items[item].base;
+          rassert(items[item].limit == base + size); 
  printf("new region [%d,%d)\n", base, base + size);
- rassert(items[item].limit == base + size); 
           for (int i = 0; i < size; ++i) {
             rassert(mem[base + i] == 0xaaaaaaaa);
             long long hash = item * 17 + i * 29;
@@ -113,48 +122,65 @@ int main(int argc, char **argv) {
       }
     }
     else if (strcmp(buf, "realloc") == 0) {
-      int item, old_size, size, success;
-      rassert(scanf("%d %d %d %d", &item, &old_size, &size, &success) == 4);
+      int item, old_size, size;
+      rassert(scanf("%d %d %d %s", &item, &old_size, &size, buf) == 4);
       rassert(item >= 0 && item < n_items);
-      rassert(old_size >= 0 && old_size < pool_size);
-      rassert(size >= 0 && size < pool_size);
-      rassert(success >= 0 && success < 2);
+      rassert(old_size >= 0);
+      rassert(size >= 0);
+      bool success;
+      if (strcmp(buf, "false") == 0)
+        success = false;
+      else if (strcmp(buf, "true") == 0)
+        success = true;
+      else
+        rassert(false);
+      printf(
+        "realloc %d %d %d %s\n",
+        item,
+        old_size,
+        size,
+        success ? "true" : "false"
+      );
       if (items[item].prev == NULL)
-        printf(
-          "realloc %d %d %d %d: not allocated, ignore\n",
-          item,
-          old_size,
-          size,
-          success
-        );
+        printf("... not allocated, ignore\n");
       else {
- printf("old region [%d,%d)\n", items[item].base, items[item].limit);
+        int base = items[item].base;
         int actual_old_size = items[item].limit - items[item].base;
-        rassert(actual_old_size <= old_size);
+        if (actual_old_size != old_size) {
+          printf(
+            "... old size %d, should be %d\n",
+            actual_old_size,
+            old_size
+          );
+          rassert(actual_old_size <= old_size);
+        }
+ printf("old region [%d,%d)\n", base, base + actual_old_size);
+        for (int i = size; i < actual_old_size; ++i) {
+          long long hash = item * 17 + i * 29;
+          hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
+          hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
+          rassert(mem[base + i] == (int)hash);
+          mem[base + i] = 0xaaaaaaaa;
+        }
         bool result =
           moveable ?
             pool_realloc_moveable(&head, items + item, size) :
             pool_realloc(&head, items + item, size);
         printf(
-          "realloc %d %d(%d) %d %d: %s\n",
-          item,
-          old_size,
-          actual_old_size,
-          size,
-          success,
-          result == (bool)success ?
+          "... %s\n",
+          result == success ?
             "ok" :
             result ? "succeeded, should fail" : "failed, should succeed"
         );
         if (result) {
           if (!success) {
-            printf("undo\n");
+            printf("... undo\n");
             rassert(pool_realloc(&head, items + item, actual_old_size));
           }
           else {
-            int base = items[item].base;
+            base = items[item].base;
+            rassert(items[item].limit == base + size);
  printf("new region [%d,%d)\n", base, base + size);
- rassert(items[item].limit == base + size); 
             for (int i = actual_old_size; i < size; ++i) {
               rassert(mem[base + i] == 0xaaaaaaaa);
               long long hash = item * 17 + i * 29;
@@ -162,13 +188,6 @@ int main(int argc, char **argv) {
               hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
               mem[base + i] = (int)hash;
             }
-            for (int i = size; i < actual_old_size; ++i) {
-              long long hash = item * 17 + i * 29;
-              hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
-              hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
-              rassert(mem[base + i] == (int)hash);
-              mem[base + i] = 0xaaaaaaaa;
-            }
           }
         }
       }
@@ -177,25 +196,25 @@ int main(int argc, char **argv) {
       int item, old_size;
       rassert(scanf("%d %d", &item, &old_size) == 2);
       rassert(item >= 0 && item < n_items);
-      rassert(old_size >= 0 && old_size < pool_size);
+      rassert(old_size >= 0);
+      printf(
+        "free %d %d\n",
+        item,
+        old_size
+      );
       if (items[item].prev == NULL)
-        printf(
-          "free %d %d: not allocated, ignore\n",
-          item,
-          old_size
-        );
+        printf("... not allocated, ignore\n");
       else {
-        int actual_old_size = items[item].limit - items[item].base;
-        rassert(actual_old_size <= old_size);
-        pool_free(&head, items + item);
-        items[item].prev = NULL;
-        printf(
-          "free %d %d(%d): ok\n",
-          item,
-          old_size,
-          actual_old_size
-        );
         int base = items[item].base;
+        int actual_old_size = items[item].limit - base;
+        if (actual_old_size != old_size) {
+          printf(
+            "... old size %d, should be %d\n",
+            actual_old_size,
+            old_size
+          );
+          rassert(actual_old_size <= old_size);
+        }
  printf("old region [%d,%d)\n", base, base + actual_old_size);
         for (int i = 0; i < actual_old_size; ++i) {
           long long hash = item * 17 + i * 29;
@@ -204,6 +223,9 @@ int main(int argc, char **argv) {
           rassert(mem[base + i] == (int)hash);
           mem[base + i] = 0xaaaaaaaa;
         }
+        pool_free(&head, items + item);
+        items[item].prev = NULL;
+        printf("... ok\n");
       }
     }
     else
diff --git a/process_test_gen.c b/process_test_gen.c
index db8075b..67de5cc 100644
--- a/process_test_gen.c
+++ b/process_test_gen.c
@@ -31,7 +31,12 @@ int main(int argc, char **argv) {
     if (old_size == -1) {
       int size = rand_int(process_size);
       bool success = pool_used + size <= pool_size;
-      printf("alloc %d %d %d\n", process, size, success);
+      printf(
+        "alloc %d %d %s\n",
+        process,
+        size,
+        success ? "true" : "false"
+      );
       if (success) {
         processes[process] = size;
         pool_used += size;
@@ -42,7 +47,13 @@ int main(int argc, char **argv) {
       if (rand_int(8) == 0) {
         int size = rand_int(process_size);
         bool success = pool_used + size - old_size <= pool_size;
-        printf("realloc %d %d %d %d\n", process, old_size, size, success);
+        printf(
+          "realloc %d %d %d %s\n",
+          process,
+          old_size,
+          size,
+          success ? "true" : "false"
+        );
         if (success) {
           processes[process] = size;
           pool_used += size - old_size;
diff --git a/process_test_run.c b/process_test_run.c
index c5c4770..5e7aa27 100644
--- a/process_test_run.c
+++ b/process_test_run.c
@@ -59,33 +59,44 @@ int main(int argc, char **argv) {
       rassert(false);
     }
     if (strcmp(buf, "alloc") == 0) {
-      int process, size, success;
-      rassert(scanf("%d %d %d", &process, &size, &success) == 3);
+      int process, size;
+      rassert(scanf("%d %d %s", &process, &size, buf) == 3);
       rassert(process >= 0 && process < n_processes);
       rassert(size >= 0);
-      rassert(success >= 0 && success < 2);
-      rassert(processes[process].size == -1);
-      bool result = process_alloc(processes + process, size);
+      bool success;
+      if (strcmp(buf, "false") == 0)
+        success = false;
+      else if (strcmp(buf, "true") == 0)
+        success = true;
+      else
+        rassert(false);
       printf(
-        "alloc %d %d %d: %s\n",
+        "alloc %d %d %s\n",
         process,
         size,
-        success,
-        result == (bool)success ?
+        success ? "true" : "false"
+      );
+      rassert(processes[process].size == -1);
+      bool result = process_alloc(processes + process, size);
+      printf(
+        "... %s\n",
+        result == success ?
           "ok" :
           result ? "succeeded, should fail" : "failed, should succeed"
       );
       if (result) {
         if (!success) {
-          printf("undo\n");
+          printf("... undo\n");
           process_free(processes + process);
           processes[process].size = -1;
         }
         else {
 #ifdef PREALLOCATE_CORE
           int core_base = processes[process].core_item.base;
+          assert(processes[process].core_item.limit == core_base + size);
 #else
           int core_base = processes[process].pool_item.base;
+          assert(processes[process].pool_item.limit == core_base + size);
 #endif
  printf("new core [%d,%d)\n", core_base, core_base + size);
           for (int i = 0; i < size; ++i) {
@@ -107,20 +118,27 @@ int main(int argc, char **argv) {
       }
     }
     else if (strcmp(buf, "realloc") == 0) {
-      int process, old_size, size, success;
-      rassert(scanf("%d %d %d %d", &process, &old_size, &size, &success) == 4);
+      int process, old_size, size;
+      rassert(scanf("%d %d %d %s", &process, &old_size, &size, buf) == 4);
       rassert(process >= 0 && process < n_processes);
       rassert(old_size >= 0);
       rassert(size >= 0);
-      rassert(success >= 0 && success < 2);
+      bool success;
+      if (strcmp(buf, "false") == 0)
+        success = false;
+      else if (strcmp(buf, "true") == 0)
+        success = true;
+      else
+        rassert(false);
+      printf(
+        "realloc %d %d %d %s\n",
+        process,
+        old_size,
+        size,
+        success ? "true" : "false"
+      );
       if (processes[process].size == -1)
-        printf(
-          "realloc %d %d %d %d: not allocated, ignore\n",
-          process,
-          old_size,
-          size,
-          success
-        );
+        printf("... not allocated, ignore\n");
       else {
 #ifdef PREALLOCATE_CORE
         int core_base = processes[process].core_item.base;
@@ -128,10 +146,25 @@ int main(int argc, char **argv) {
         int core_base = processes[process].pool_item.base;
 #endif
         int actual_old_size = processes[process].size;
-        rassert(actual_old_size <= old_size);
- printf("old core [%d,%d)\n", core_base, core_base + actual_old_size);
+        rassert(
+#ifdef PREALLOCATE_CORE
+          processes[process].core_item.limit == core_base + actual_old_size
+#else
+          processes[process].pool_item.limit == core_base + actual_old_size
+#endif
+        );
+        if (actual_old_size != old_size) {
+          printf(
+            "... old size %d, should be %d\n",
+            actual_old_size,
+            old_size
+          );
+          rassert(actual_old_size <= old_size);
+        }
 #ifdef PREALLOCATE_SWAP
- printf("old swap [%d,%d)\n", ~processes[process].swap_item.limit, ~processes[process].swap_item.base);
+ printf("old core [%d,%d) swap [%d,%d)\n", core_base, core_base + actual_old_size, ~processes[process].swap_item.limit, ~processes[process].swap_item.base);
+#else
+ printf("old core [%d,%d)\n", core_base, core_base + actual_old_size);
 #endif
         for (int i = size; i < actual_old_size; ++i) {
           long long hash = process * 17 + i * 29;
@@ -147,28 +180,29 @@ int main(int argc, char **argv) {
         }
         bool result = process_realloc(processes + process, size);
         printf(
-          "realloc %d %d(%d) %d %d: %s\n",
-          process,
-          old_size,
-          actual_old_size,
-          size,
-          success,
-          result == (bool)success ?
+          "... %s\n",
+          result == success ?
             "ok" :
             result ? "succeeded, should fail" : "failed, should succeed"
         );
         if (result) {
           if (!success) {
-            printf("undo\n");
+            printf("... undo\n");
             rassert(process_realloc(processes + process, actual_old_size));
           }
           else {
 #ifdef PREALLOCATE_CORE
             core_base = processes[process].core_item.base;
+            rassert(processes[process].core_item.limit == core_base + size);
 #else
             core_base = processes[process].pool_item.base;
+            rassert(processes[process].pool_item.limit == core_base + size);
 #endif
+#ifdef PREALLOCATE_SWAP
+ printf("new core [%d,%d) swap [%d,%d)\n", core_base, core_base + size, ~processes[process].swap_item.limit, ~processes[process].swap_item.base);
+#else
  printf("new core [%d,%d)\n", core_base, core_base + size);
+#endif
             for (int i = actual_old_size; i < size; ++i) {
               long long hash = process * 17 + i * 29;
               hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
@@ -181,9 +215,6 @@ int main(int argc, char **argv) {
               rassert(core_block_mem[core_block] == 0xaaaaaaaa);
               core_block_mem[core_block] = (int)hash;
             }
-#ifdef PREALLOCATE_SWAP
- printf("new swap [%d,%d)\n", ~processes[process].swap_item.limit, ~processes[process].swap_item.base);
-#endif
           }
         }
       }
@@ -192,11 +223,12 @@ int main(int argc, char **argv) {
       int process;
       rassert(scanf("%d", &process) == 1);
       rassert(process >= 0 && process < n_processes);
+      printf("run %d\n", process);
       if (processes[process].size == -1)
-        printf("run %d: not allocated, ignore\n", process);
+        printf("... not allocated, ignore\n");
       else {
         process_run(processes + process);
-        printf("run %d\n", process);
+        printf("... ok\n");
       }
     } 
     else if (strcmp(buf, "free") == 0) {
@@ -204,65 +236,85 @@ int main(int argc, char **argv) {
       rassert(scanf("%d %d", &process, &old_size) == 2);
       rassert(process >= 0 && process < n_processes);
       rassert(old_size >= 0);
+      printf("free %d %d\n", process, old_size);
       if (processes[process].size == -1)
-        printf(
-          "free %d %d: not allocated, ignore\n",
-          process,
-          old_size
-        );
+        printf("... not allocated, ignore\n");
       else {
         int actual_old_size = processes[process].size;
-        rassert(actual_old_size <= old_size);
+        if (actual_old_size != old_size) {
+          printf(
+            "... old size %d, should be %d\n",
+            actual_old_size,
+            old_size
+          );
+          rassert(actual_old_size <= old_size);
+        }
         bool is_victim = processes + process == victim;
         bool in_core = processes[process].lru_item.prev != NULL;
 #ifdef PREALLOCATE_CORE
-        int core_size = is_victim ? victim_core_size : in_core ? processes[process].size : 0;
-        int core_base = processes[process].core_item.base;
+        int core_size =
+          is_victim ?
+            victim_core_size :
+            in_core ? processes[process].size : 0;
+        int core_base =
+          processes[process].core_item.base;
 #else
-        int core_base = is_victim ? victim_core_item.base : in_core ? processes[process].pool_item.base : -1;
-        int core_size = is_victim ? victim_core_item.limit - core_base : in_core ? processes[process].pool_item.limit - core_base : 0;
+        int core_base =
+          is_victim ?
+            victim_core_item.base :
+            in_core ? processes[process].pool_item.base : -1;
+        int core_size =
+           is_victim ?
+             victim_core_item.limit - core_base :
+             in_core ? processes[process].pool_item.limit - core_base : 0;
 #endif
 #ifdef PREALLOCATE_SWAP
-        int swap_size = is_victim ? victim_swap_size : !in_core ? processes[process].size : 0;
-        int swap_limit = processes[process].swap_item.base + swap_size;
+        int swap_size =
+          is_victim ?
+          victim_swap_size :
+          !in_core ? processes[process].size : 0;
+        int swap_limit =
+          processes[process].swap_item.base + swap_size;
 #else
-        int swap_limit = is_victim ? victim_swap_item.limit : !in_core ? processes[process].pool_item.limit : 0;
-        int swap_size = is_victim ? swap_limit - victim_swap_item.base : !in_core ? swap_limit - processes[process].pool_item.base : 0;
+        int swap_limit =
+          is_victim ?
+            victim_swap_item.limit :
+            !in_core ? processes[process].pool_item.limit : 0;
+        int swap_size =
+          is_victim ?
+            swap_limit - victim_swap_item.base :
+            !in_core ? swap_limit - processes[process].pool_item.base : 0;
 #endif
-        rassert(core_size + swap_size == actual_old_size);
         int swap_base = ~swap_limit;
  printf("old core [%d,%d) swap [%d,%d)\n", core_base, core_base + core_size, swap_base, swap_base + swap_size);
-        for (int i = 0; i < actual_old_size; ++i) {
+        for (int i = 0; i < core_size; ++i) {
           long long hash = process * 17 + i * 29;
           hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
           hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
-          if (i < core_size) {
 #ifdef INDIRECT_CORE
-            int core_block = core_table_mem[core_base + i];
+          int core_block = core_table_mem[core_base + i];
 #else
-            int core_block = core_base + i;
+          int core_block = core_base + i;
 #endif
-            rassert(core_block_mem[core_block] == (int)hash);
-            core_block_mem[core_block] = 0xaaaaaaaa;
-          }
-          else {
+          rassert(core_block_mem[core_block] == (int)hash);
+          core_block_mem[core_block] = 0xaaaaaaaa;
+        }
+        for (int i = 0; i < swap_size; ++i) {
+          long long hash = process * 17 + (core_size + i) * 29;
+          hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
+          hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
 #ifdef INDIRECT_SWAP
-            int swap_block = swap_table_mem[swap_base + i - core_size];
+          int swap_block = swap_table_mem[swap_base + i];
 #else
-            int swap_block = swap_base + i - core_size;
+          int swap_block = swap_base + i;
 #endif
-            rassert(swap_block_mem[swap_block] == (int)hash);
-            swap_block_mem[swap_block] = 0xaaaaaaaa;
-          }
+          rassert(swap_block_mem[swap_block] == (int)hash);
+          swap_block_mem[swap_block] = 0xaaaaaaaa;
         }
+        rassert(core_size + swap_size == actual_old_size);
         process_free(processes + process);
         processes[process].size = -1;
-        printf(
-          "free %d %d(%d): ok\n",
-          process,
-          old_size,
-          actual_old_size
-        );
+        printf("... ok\n");
       }
     }
     else
@@ -278,45 +330,73 @@ done:
       bool is_victim = processes + i == victim;
       bool in_core = processes[i].lru_item.prev != NULL;
 #ifdef PREALLOCATE_CORE
-      int core_size = is_victim ? victim_core_size : in_core ? processes[i].size : 0;
-      int core_base = processes[i].core_item.base;
+      int core_size =
+        is_victim ?
+          victim_core_size :
+          in_core ? processes[i].size : 0;
+      int core_base =
+        processes[i].core_item.base;
 #else
-      int core_base = is_victim ? victim_core_item.base : in_core ? processes[i].pool_item.base : -1;
-      int core_size = is_victim ? victim_core_item.limit - core_base : in_core ? processes[i].pool_item.limit - core_base : 0;
+      int core_base =
+        is_victim ?
+          victim_core_item.base :
+          in_core ? processes[i].pool_item.base : -1;
+      int core_size =
+         is_victim ?
+           victim_core_item.limit - core_base :
+           in_core ? processes[i].pool_item.limit - core_base : 0;
 #endif
 #ifdef PREALLOCATE_SWAP
-      int swap_size = is_victim ? victim_swap_size : !in_core ? processes[i].size : 0;
-      int swap_limit = processes[i].swap_item.base + swap_size;
+      int swap_size =
+        is_victim ?
+        victim_swap_size :
+        !in_core ? processes[i].size : 0;
+      int swap_limit =
+        processes[i].swap_item.base + swap_size;
 #else
-      int swap_limit = is_victim ? victim_swap_item.limit : !in_core ? processes[i].pool_item.limit : 0;
-      int swap_size = is_victim ? swap_limit - victim_swap_item.base : !in_core ? swap_limit - processes[i].pool_item.base : 0;
+      int swap_limit =
+        is_victim ?
+          victim_swap_item.limit :
+          !in_core ? processes[i].pool_item.limit : 0;
+      int swap_size =
+        is_victim ?
+          swap_limit - victim_swap_item.base :
+          !in_core ? swap_limit - processes[i].pool_item.base : 0;
 #endif
       int swap_base = ~swap_limit;
-      printf("process %d: core [%d,%d) swap [%d,%d)\n", i, core_base, core_base + core_size, swap_base, swap_base + swap_size);
-      for (int j = 0; j < processes[i].size; ++j) {
+      printf(
+        "process %d: core [%d,%d) swap [%d,%d)\n",
+        i,
+        core_base,
+        core_base + core_size,
+        swap_base,
+        swap_base + swap_size
+      );
+      for (int j = 0; j < core_size; ++j) {
         long long hash = i * 17 + j * 29;
         hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
         hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
-        if (j < core_size) {
 #ifdef INDIRECT_CORE
-          int core_block = core_table_mem[core_base + j];
-          core_table_mem[core_base + j] = 0x55555555;
+        int core_block = core_table_mem[core_base + j];
+        core_table_mem[core_base + j] = 0x55555555;
 #else
-          int core_block = core_base + j;
+        int core_block = core_base + j;
 #endif
-          rassert(core_block_mem[core_block] == (int)hash);
-          core_block_mem[core_block] = 0xaaaaaaaa;
-        }
-        else {
+        rassert(core_block_mem[core_block] == (int)hash);
+        core_block_mem[core_block] = 0xaaaaaaaa;
+      }
+      for (int j = 0; j < swap_size; ++j) {
+        long long hash = i * 17 + (core_size + j) * 29;
+        hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
+        hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
 #ifdef INDIRECT_SWAP
-          int swap_block = swap_table_mem[swap_base + j - core_size];
-          swap_table_mem[swap_base + j - core_size] = 0x55555555;
+        int swap_block = swap_table_mem[swap_base + j];
+        swap_table_mem[swap_base + j] = 0x55555555;
 #else
-          int swap_block = swap_base + j - core_size;
+        int swap_block = swap_base + j;
 #endif
-          rassert(swap_block_mem[swap_block] == (int)hash);
-          swap_block_mem[swap_block] = 0xaaaaaaaa;
-        }
+        rassert(swap_block_mem[swap_block] == (int)hash);
+        swap_block_mem[swap_block] = 0xaaaaaaaa;
       }
     }
   }
-- 
2.34.1