Get rid of the DEDICATED_xxx() macros in favour of more optimal inline code

diff --git a/process.c b/process.c
index 58caca2..517d2a3 100644 (file)
--- a/process.c
+++ b/process.c
@@ -224,8 +224,16 @@ static void do_swap_out(int swap_out) {
 
     loop_entry:
       // calculate transfer parameters
-      swap_base = DEDICATED_SWAP_LIMIT(victim, victim_swap_blocks) - blocks;
-      core_base = DEDICATED_CORE_BASE(victim, victim_swap_blocks - blocks);
+#ifdef PREALLOCATE_SWAP
+      swap_base = victim->swap_item.base + victim_swap_blocks - blocks;
+#else
+      swap_base = victim->swap_item.limit - blocks;
+#endif
+#ifdef PREALLOCATE_CORE
+      core_base = victim->core_item.base + victim_swap_blocks - blocks;
+#else
+      core_base = victim->core_item.base;
+#endif
       size = (long)blocks << BLOCK_SHIFT;
 
       // see if last transfer for victim
@@ -447,13 +455,23 @@ void process_run(struct process *process) {
     }
 
     // victim, take over the dedicated pool items
-    process_core_blocks = DEDICATED_CORE_BLOCKS(victim);
-#if !defined(NDEBUG) && defined(PREALLOCATE_CORE)
+#ifdef PREALLOCATE_CORE
+    process_core_blocks = victim_core_blocks;
+#ifndef NDEBUG
     victim_core_blocks = 0;
 #endif
-    process_swap_blocks = DEDICATED_SWAP_BLOCKS(victim);
-#if !defined(NDEBUG) && defined(PREALLOCATE_SWAP)
+#else
+    process_core_blocks =
+      victim->core_item.limit - victim->core_item.base;
+#endif
+#ifdef PREALLOCATE_SWAP
+    process_swap_blocks = victim_swap_blocks;
+#ifndef NDEBUG
     victim_swap_blocks = 0;
+#endif
+#else
+    process_swap_blocks =
+      victim->swap_item.limit - victim->swap_item.base;
 #endif
     victim = NULL;
 #ifndef PREALLOCATE_SWAP
@@ -491,8 +509,17 @@ void process_run(struct process *process) {
 
     loop_entry_full:
       // calculate transfer parameters
-      swap_base = DEDICATED_SWAP_LIMIT(process, process_swap_blocks) - blocks;
-      core_base = DEDICATED_CORE_BASE(process, process_swap_blocks - blocks);
+#ifdef PREALLOCATE_SWAP
+      swap_base = process->swap_item.base + process_swap_blocks - blocks;
+#else
+      swap_base = process->swap_item.limit - blocks;
+#endif
+#ifdef PREALLOCATE_CORE
+      core_base = process->core_item.base + process_swap_blocks - blocks;
+#else
+      core_base = process->core_item.base;
+#endif
+
       size = (long)blocks << BLOCK_SHIFT;
 
       // see if first transfer for process
@@ -527,6 +554,19 @@ void process_run(struct process *process) {
 }
 
 void process_free(struct process *process) {
+#ifdef INDIRECT_SWAP
+  int swap_base;
+#ifndef PREALLOCATE_SWAP
+  int victim_swap_blocks;
+#endif
+#endif
+#ifdef INDIRECT_CORE
+  int core_base;
+#ifndef PREALLOCATE_CORE
+  int victim_core_blocks;
+#endif
+#endif
+
   // must be already allocated
   assert(process->size != -1L);
 
@@ -550,29 +590,39 @@ void process_free(struct process *process) {
 #endif
   }
   else if (process == victim) {
-    // victim, free the dedicated pool items
-#ifdef INDIRECT_CORE
-    core_block_free(
-      core_table_mem +
-        DEDICATED_CORE_BASE(victim, DEDICATED_SWAP_BLOCKS(victim)),
-      DEDICATED_CORE_BLOCKS(victim)
-    );
-#endif
-#ifdef PREALLOCATE_CORE
-    victim_core_blocks = 0;
-#else
-    core_table_free(&victim->core_item);
-#endif
+    // victim, remove from core and swap pools
 #ifdef INDIRECT_SWAP
-    swap_block_free(
-      swap_table_mem + victim->swap_item.base,
-      DEDICATED_SWAP_BLOCKS(victim)
-    );
+    swap_base = victim->swap_item.base;
+#ifndef PREALLOCATE_SWAP
+    victim_swap_blocks = victim->swap_item.limit - swap_base;
+#endif
+    swap_block_free(swap_table_mem + swap_base, victim_swap_blocks);
 #endif
 #ifdef PREALLOCATE_SWAP
     victim_swap_blocks = 0;
 #else
     swap_table_free(&victim->swap_item);
+#endif
+#ifdef INDIRECT_CORE
+#ifdef PREALLOCATE_CORE
+#if defined(PREALLOCATE_SWAP) || defined(INDIRECT_SWAP)
+    core_base = victim->core_item.base + victim_swap_blocks;
+#else
+    core_base =
+      victim->core_item.base +
+      victim->swap_item.limit -
+      victim->swap_item.base;
+#endif
+#else
+    core_base = victim->core_item.base;
+    victim_core_blocks = victim->core_item.limit - core_base;
+#endif
+    core_block_free(core_table_mem + core_base, victim_core_blocks);
+#endif
+#ifdef PREALLOCATE_CORE
+    victim_core_blocks = 0;
+#else
+    core_table_free(&victim->core_item);
 #endif
     victim = NULL;
   }

diff --git a/process.h b/process.h
index 451617e..1e37161 100644 (file)
--- a/process.h
+++ b/process.h
@@ -6,30 +6,6 @@
 //#define PREALLOCATE_CORE 1
 #define PREALLOCATE_SWAP 1
 
-#ifdef PREALLOCATE_CORE
-#define DEDICATED_CORE_BASE(process, swap_blocks) \
-  (process->core_item.base + (swap_blocks))
-#define DEDICATED_CORE_BLOCKS(process) \
-  process##_core_blocks
-#else
-#define DEDICATED_CORE_BASE(process, swap_blocks) \
-  process->core_item.base
-#define DEDICATED_CORE_BLOCKS(process) \
-  (process->core_item.limit - process->core_item.base)
-#endif
-
-#ifdef PREALLOCATE_SWAP
-#define DEDICATED_SWAP_LIMIT(process, swap_blocks) \
-  (process->swap_item.base + (swap_blocks))
-#define DEDICATED_SWAP_BLOCKS(process) \
-  process##_swap_blocks
-#else
-#define DEDICATED_SWAP_LIMIT(process, swap_blocks) \
-  process->swap_item.limit
-#define DEDICATED_SWAP_BLOCKS(process) \
-  (process->swap_item.limit - process->swap_item.base)
-#endif
-
 struct lru_item {
   struct lru_item *prev;
   struct lru_item *next;

diff --git a/process_test_run.c b/process_test_run.c
index 2b2ec2e..57dac14 100644 (file)
--- a/process_test_run.c
+++ b/process_test_run.c
@@ -300,10 +300,19 @@ int main(int argc, char **argv) {
         }
         else if (processes + process == victim) { // victim
           swap_base = victim->swap_item.base;
-          swap_blocks = DEDICATED_SWAP_BLOCKS(victim);
+#ifdef PREALLOCATE_SWAP
+          swap_blocks = victim_swap_blocks;
+#else
+          swap_blocks = victim->swap_item.limit - victim->swap_item.base;
+#endif
           swap_size = swap_blocks << BLOCK_SHIFT;
-          core_base = DEDICATED_CORE_BASE(victim, swap_blocks);
-          core_blocks = DEDICATED_CORE_BLOCKS(victim);
+#ifdef PREALLOCATE_CORE
+          core_base = victim->core_item.base + swap_blocks;
+          core_blocks = victim_core_blocks;
+#else
+          core_base = victim->core_item.base;
+          core_blocks = victim->core_item.limit - core_base;
+#endif
           core_size = victim->size - swap_size;
         }
         else { // fully in swap
@@ -359,10 +368,19 @@ done:
       }
       else if (processes + i == victim) { // victim
         swap_base = victim->swap_item.base;
-        swap_blocks = DEDICATED_SWAP_BLOCKS(victim);
+#ifdef PREALLOCATE_SWAP
+        swap_blocks = victim_swap_blocks;
+#else
+        swap_blocks = victim->swap_item.limit - victim->swap_item.base;
+#endif
         swap_size = swap_blocks << BLOCK_SHIFT;
-        core_base = DEDICATED_CORE_BASE(victim, swap_blocks);
-        core_blocks = DEDICATED_CORE_BLOCKS(victim);
+#ifdef PREALLOCATE_CORE
+        core_base = victim->core_item.base + swap_blocks;
+        core_blocks = victim_core_blocks;
+#else
+        core_base = victim->core_item.base;
+        core_blocks = victim->core_item.limit - core_base;
+#endif
         core_size = victim->size - swap_size;
       }
       else { // fully in swap