Implement further macros DEDICATED_CORE_BASE() and DEDICATED_SWAP_LIMIT() which know...

diff --git a/process.c b/process.c
index f4232ae..caf2b23 100644 (file)
--- a/process.c
+++ b/process.c
@@ -249,16 +249,8 @@ static void do_swap_out(int swap_out) {
 
     loop_entry:
       // transfer data to swap
-#ifdef PREALLOCATE_SWAP
-      swap_base = victim->swap_item.base + victim_swap_size - size;
-#else
-      swap_base = victim_swap_item.limit - size;
-#endif
-#ifdef PREALLOCATE_CORE
-      core_base = victim->core_item.base + victim_swap_size - size;
-#else
-      core_base = victim_core_item.base;
-#endif
+      swap_base = DEDICATED_SWAP_LIMIT(victim, victim_swap_size) - size;
+      core_base = DEDICATED_CORE_BASE(victim, victim_swap_size - size);
 #ifdef INDIRECT_SWAP
       rassert(swap_block_alloc(swap_table_mem + swap_base, size));
 #endif
@@ -540,16 +532,8 @@ void process_run(struct process *process) {
 
     loop_entry_full:
       // transfer data to core
-#ifdef PREALLOCATE_SWAP
-      swap_base = process->swap_item.base + process_swap_size - size;
-#else
-      swap_base = process_swap_item.limit - size;
-#endif
-#ifdef PREALLOCATE_CORE
-      core_base = process->core_item.base + process_swap_size - size;
-#else
-      core_base = process_core_item.base;
-#endif
+      swap_base = DEDICATED_SWAP_LIMIT(process, process_swap_size) - size;
+      core_base = DEDICATED_CORE_BASE(process, process_swap_size - size);
 #ifdef INDIRECT_CORE
       core_block_alloc(core_table_mem + core_base, size);
 #endif
@@ -607,11 +591,8 @@ void process_free(struct process *process) {
     // victim, free the dedicated pool items
 #ifdef INDIRECT_CORE
     core_block_free(
-#ifdef PREALLOCATE_CORE
-      core_table_mem + victim->core_item.base + DEDICATED_SWAP_SIZE(victim),
-#else
-      core_table_mem + victim_core_item.base,
-#endif
+      core_table_mem +
+        DEDICATED_CORE_BASE(victim, DEDICATED_SWAP_SIZE(victim)),
       DEDICATED_CORE_SIZE(victim)
     );
 #endif

diff --git a/process.h b/process.h
index 6bcd1dd..562efe4 100644 (file)
--- a/process.h
+++ b/process.h
@@ -7,6 +7,8 @@
 #define PREALLOCATE_SWAP 1
 
 #ifdef PREALLOCATE_CORE
+#define DEDICATED_CORE_BASE(process, swap_size) \
+  (process->core_item.base + (swap_size))
 #define DEDICATED_CORE_ITEM(process) \
   process->core_item
 #define DEDICATED_CORE_SIZE(process) \
@@ -14,6 +16,8 @@
 #define PER_PROCESS_CORE_ITEM(process) \
   (process)->core_item
 #else
+#define DEDICATED_CORE_BASE(process, swap_size) \
+  process##_core_item.base
 #define DEDICATED_CORE_ITEM(process) \
   process##_core_item
 #define DEDICATED_CORE_SIZE(process) \
@@ -25,6 +29,8 @@
 #ifdef PREALLOCATE_SWAP
 #define DEDICATED_SWAP_ITEM(process) \
   process->swap_item
+#define DEDICATED_SWAP_LIMIT(process, swap_size) \
+  (process->swap_item.base + (swap_size))
 #define DEDICATED_SWAP_SIZE(process) \
   process##_swap_size
 #define PER_PROCESS_SWAP_ITEM(process) \
@@ -32,6 +38,8 @@
 #else
 #define DEDICATED_SWAP_ITEM(process) \
   process##_swap_item
+#define DEDICATED_SWAP_LIMIT(process, swap_size) \
+  process##_swap_item.limit
 #define DEDICATED_SWAP_SIZE(process) \
   (process##_swap_item.limit - process##_swap_item.base)
 #define PER_PROCESS_SWAP_ITEM(process) \

diff --git a/process_test_run.c b/process_test_run.c
index 5fbfbe8..3a0d37a 100644 (file)
--- a/process_test_run.c
+++ b/process_test_run.c
@@ -91,17 +91,15 @@ int main(int argc, char **argv) {
           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
+          int core_base = PER_PROCESS_CORE_ITEM(processes + process).base;
+          assert(
+            PER_PROCESS_CORE_ITEM(processes + process).limit ==
+              core_base + size
+          );
  printf("new core [%d,%d)\n", core_base, core_base + size);
           core_hash_init(process, core_base, 0, size);
 #ifdef PREALLOCATE_SWAP
- printf("new swap [%d,%d)\n", processes[process].swap_item.base, processes[process].swap_item.limit);
+ printf("new swap [%d,%d)\n", PER_PROCESS_SWAP_ITEM(processes + process).base, PER_PROCESS_SWAP_ITEM(processes + process).limit);
 #endif
         }
       }
@@ -129,18 +127,11 @@ int main(int argc, char **argv) {
       if (processes[process].size == -1)
         printf("... not allocated, ignore\n");
       else {
-#ifdef PREALLOCATE_CORE
-        int core_base = processes[process].core_item.base;
-#else
-        int core_base = processes[process].pool_item.base;
-#endif
+        int core_base = PER_PROCESS_CORE_ITEM(processes + process).base;
         int actual_old_size = processes[process].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
+          PER_PROCESS_CORE_ITEM(processes + process).limit ==
+            core_base + actual_old_size
         );
         if (actual_old_size != old_size) {
           printf(
@@ -151,7 +142,7 @@ int main(int argc, char **argv) {
           rassert(actual_old_size <= old_size);
         }
 #ifdef PREALLOCATE_SWAP
- printf("old core [%d,%d) swap [%d,%d)\n", core_base, core_base + actual_old_size, processes[process].swap_item.base, processes[process].swap_item.limit);
+ printf("old core [%d,%d) swap [%d,%d)\n", core_base, core_base + actual_old_size, PER_PROCESS_SWAP_ITEM(processes + process).base, PER_PROCESS_SWAP_ITEM(processes + process).limit);
 #else
  printf("old core [%d,%d)\n", core_base, core_base + actual_old_size);
 #endif
@@ -169,15 +160,13 @@ int main(int argc, char **argv) {
             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
+            core_base = PER_PROCESS_CORE_ITEM(processes + process).base;
+            rassert(
+              PER_PROCESS_CORE_ITEM(processes + process).limit ==
+                core_base + size
+            );
 #ifdef PREALLOCATE_SWAP
- printf("new core [%d,%d) swap [%d,%d)\n", core_base, core_base + size, processes[process].swap_item.base, processes[process].swap_item.limit);
+ printf("new core [%d,%d) swap [%d,%d)\n", core_base, core_base + size, PER_PROCESS_SWAP_ITEM(processes + process).base, PER_PROCESS_SWAP_ITEM(processes + process).limit);
 #else
  printf("new core [%d,%d)\n", core_base, core_base + size);
 #endif
@@ -216,46 +205,39 @@ int main(int argc, char **argv) {
           );
           rassert(actual_old_size <= old_size);
         }
-        bool is_victim = processes + process == victim;
-        bool in_core = processes[process].lru_item.prev != NULL;
-#ifdef PREALLOCATE_SWAP
-        int swap_size =
-          is_victim ?
-            victim_swap_size :
-            !in_core ? processes[process].size : 0;
-        int swap_base =
-          processes[process].swap_item.base;
-#else
-        int swap_base =
-          is_victim ?
-            victim_swap_item.base :
-            !in_core ? processes[process].pool_item.base : -1;
-        int swap_size =
-           is_victim ?
-             victim_swap_item.limit - swap_base :
-             !in_core ? processes[process].pool_item.limit - swap_base : 0;
-#endif
-#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 + swap_size;
-#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;
-#endif
+        int swap_base, swap_size, core_base, core_size;
+        if (processes[process].lru_item.prev != NULL) { // fully in core
+          assert(processes + process != victim);
+          swap_base = -1;
+          swap_size = 0;
+          core_base =
+            PER_PROCESS_CORE_ITEM(processes + process).base;
+          core_size =
+            PER_PROCESS_CORE_ITEM(processes + process).limit - core_base;
+        }
+        else if (processes + process == victim) { // victim
+          swap_base = DEDICATED_SWAP_ITEM(victim).base;
+          swap_size = DEDICATED_SWAP_SIZE(victim);
+          core_base = DEDICATED_CORE_BASE(victim, swap_size);
+          core_size = DEDICATED_CORE_SIZE(victim);
+        }
+        else { // fully in swap
+          swap_base =
+            PER_PROCESS_SWAP_ITEM(processes + process).base;
+          swap_size =
+            PER_PROCESS_SWAP_ITEM(processes + process).limit - swap_base;
+          core_base = -1;
+          core_size = 0;
+        }
         rassert(core_size + swap_size == actual_old_size);
  printf("old core [%d,%d) swap [%d,%d)\n", core_base, core_base + core_size, swap_base, swap_base + swap_size);
  fflush(stdout);
-        core_hash_verify(process, core_base - swap_size, swap_size, swap_size + core_size);
+        core_hash_verify(
+          process,
+          core_base - swap_size,
+          swap_size,
+          swap_size + core_size
+        );
         swap_hash_verify(process, swap_base, 0, swap_size);
         process_free(processes + process);
         processes[process].size = -1;
@@ -272,42 +254,26 @@ done:
     if (processes[i].size == -1)
       printf("process %d: not allocated\n", i);
     else {
-      bool is_victim = processes + i == victim;
-      bool in_core = processes[i].lru_item.prev != NULL;
-#ifdef PREALLOCATE_SWAP
-      int swap_size =
-        is_victim ?
-          victim_swap_size :
-          !in_core ? processes[i].size : 0;
-      int swap_base =
-        processes[i].swap_item.base;
-#else
-      int swap_base =
-        is_victim ?
-          victim_swap_item.base :
-          !in_core ? processes[i].pool_item.base : -1;
-      int swap_size =
-         is_victim ?
-           victim_swap_item.limit - swap_base :
-           !in_core ? processes[i].pool_item.limit - swap_base : 0;
-#endif
-#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 + swap_size;
-#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;
-#endif
+      int swap_base, swap_size, core_base, core_size;
+      if (processes[i].lru_item.prev != NULL) { // fully in core
+        assert(processes + i != victim);
+        swap_base = -1;
+        swap_size = 0;
+        core_base = PER_PROCESS_CORE_ITEM(processes + i).base;
+        core_size = PER_PROCESS_CORE_ITEM(processes + i).limit - core_base;
+      }
+      else if (processes + i == victim) { // victim
+        swap_base = DEDICATED_SWAP_ITEM(victim).base;
+        swap_size = DEDICATED_SWAP_SIZE(victim);
+        core_base = DEDICATED_CORE_BASE(victim, swap_size);
+        core_size = DEDICATED_CORE_SIZE(victim);
+      }
+      else { // fully in swap
+        swap_base = PER_PROCESS_SWAP_ITEM(processes + i).base;
+        swap_size = PER_PROCESS_SWAP_ITEM(processes + i).limit - swap_base;
+        core_base = -1;
+        core_size = 0;
+      }
       rassert(core_size + swap_size == processes[i].size);
       printf(
         "process %d: core [%d,%d) swap [%d,%d)\n",
@@ -317,7 +283,12 @@ done:
         swap_base,
         swap_base + swap_size
       );
-      core_hash_verify(i, core_base - swap_size, swap_size, swap_size + core_size);
+      core_hash_verify(
+        i,
+        core_base - swap_size,
+        swap_size,
+        swap_size + core_size
+      );
 #ifdef INDIRECT_CORE
       core_block_free(core_table_mem + core_base, core_size);
 #endif