Reverse swap addressing, so that swap is allocated from top down, and copies between...

diff --git a/process.c b/process.c
index 64b4922..09bec11 100644 (file)
--- a/process.c
+++ b/process.c
@@ -118,9 +118,9 @@ static void do_swap_out(int swap_out) {
     );
 
     // transfer data to swap
-    swap_push(
-      victim->core_item.limit,
-      victim->swap_item.limit - size,
+    swap_write(
+      ~victim->swap_item.limit,
+      victim->core_item.limit - size,
       size
     );
 
@@ -250,8 +250,8 @@ void process_run(struct process *process) {
       );
 
       // transfer data to core
-      swap_pop(
-        process->swap_item.limit,
+      swap_read(
+        ~process->swap_item.limit,
         process->core_item.limit - swap_in,
         swap_in
       );

diff --git a/process_test_run.c b/process_test_run.c
index 5a7b68f..8beb1c9 100644 (file)
--- a/process_test_run.c
+++ b/process_test_run.c
@@ -24,6 +24,29 @@ int main(int argc, char **argv) {
   process_init(n_processes, spare);
 
   while (true) {
+#if 0
+ for (int i = 0; i < n_processes; ++i) {
+  if (processes[i].lru_item.prev != NULL) {
+   bool in_core = processes[i].core_item.prev != NULL;
+   int core_base = in_core ? processes[i].core_item.base : -1;
+   int core_size = in_core ? processes[i].core_item.limit - core_base : 0;
+   bool in_swap = processes[i].swap_item.prev != NULL;
+   int swap_limit = in_swap ? processes[i].swap_item.limit : 0;
+   int swap_size = in_swap ? swap_limit - processes[i].swap_item.base : 0;
+   rassert(core_size + swap_size == processes[i].size);
+   int swap_base = ~swap_limit;
+   for (int j = 0; j < processes[i].size; ++j) {
+    long long hash = i * 17 + j * 29;
+    hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
+    hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
+    if (j < core_size)
+     rassert(core_mem[core_base + j] == (int)hash);
+    else
+     rassert(swap_mem[swap_base + j - core_size] == (int)hash);
+   }
+  }
+ }
+#endif
  //printf("avail %d %d %d\n", process_avail, core_head.avail, swap_head.avail);
     char buf[256];
     switch (scanf("%s", buf)) {
@@ -165,8 +188,10 @@ int main(int argc, char **argv) {
         );
         int core_base = in_core ? processes[process].core_item.base : -1;
         int core_size = in_core ? processes[process].core_item.limit - core_base : 0;
-        int swap_base = in_swap ? processes[process].swap_item.base : -1;
- int swap_size = in_swap ? processes[process].swap_item.limit - swap_base : 0;
+        int swap_limit = in_swap ? processes[process].swap_item.limit : 0;
+        int swap_size = in_swap ? swap_limit - processes[process].swap_item.base : 0;
+        rassert(core_size + swap_size == processes[process].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 < processes[process].size; ++i) {
           long long hash = process * 17 + i * 29;
@@ -177,8 +202,8 @@ int main(int argc, char **argv) {
             core_mem[core_base + i] = 0xaaaaaaaa;
           }
           else {
-            rassert(swap_mem[swap_base + processes[process].size + ~i] == (int)hash);
-            swap_mem[swap_base + processes[process].size + ~i] = 0xaaaaaaaa;
+            rassert(swap_mem[swap_base + i - core_size] == (int)hash);
+            swap_mem[swap_base + i - core_size] = 0xaaaaaaaa;
           }
         }
       }
@@ -197,8 +222,9 @@ done:
       int core_base = in_core ? processes[i].core_item.base : -1;
       int core_size = in_core ? processes[i].core_item.limit - core_base : 0;
       bool in_swap = processes[i].swap_item.prev != NULL;
-      int swap_base = in_swap ? processes[i].swap_item.base : -1;
-      int swap_size = in_swap ? processes[i].swap_item.limit - swap_base : 0;
+      int swap_limit = in_swap ? processes[i].swap_item.limit : 0;
+      int swap_size = in_swap ? swap_limit - processes[i].swap_item.base : 0;
+      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) {
         long long hash = i * 17 + j * 29;
@@ -209,8 +235,8 @@ done:
           core_mem[core_base + j] = 0xaaaaaaaa;
         }
         else {
-          rassert(swap_mem[swap_base + processes[i].size + ~j] == (int)hash);
-          swap_mem[swap_base + processes[i].size + ~j] = 0xaaaaaaaa;
+          rassert(swap_mem[swap_base + j - core_size] == (int)hash);
+          swap_mem[swap_base + j - core_size] = 0xaaaaaaaa;
         }
       }
     }

diff --git a/swap.c b/swap.c
index 591e583..257bed6 100644 (file)
--- a/swap.c
+++ b/swap.c
@@ -8,63 +8,74 @@
 struct pool_head swap_head;
 int *swap_mem;
 
+// swap address native wrt. pool and complemented wrt. backing store,
+// means that swap_move() moves upward in backing store, do backward
 static void swap_move(struct pool_item *item, int new_base) {
   int base = item->base;
-  int size = item->limit - base;
+  int neg_size = base - item->limit;
+
+  int limit = ~base;
+  int new_limit = ~new_base;
   printf(
     "swap_move [%d,%d) to [%d,%d)\n",
-    base,
-    base + size,
-    new_base,
-    new_base + size
+    limit + neg_size,
+    limit,
+    new_limit + neg_size,
+    new_limit
   );
-  assert(new_base < base || new_base >= base + size);
-  for (int i = 0; i < size; ++i) {
-    swap_mem[new_base + i] = swap_mem[base + i];
-    swap_mem[base + i] = 0xaaaaaaaa;
+  assert(new_limit >= limit || new_limit <= limit + neg_size);
+  for (int i = -1; i >= neg_size; --i) {
+    swap_mem[new_limit + i] = swap_mem[limit + i];
+    swap_mem[limit + i] = 0xaaaaaaaa;
   }
+
 }
 
+// swap address native wrt. pool and complemented wrt. backing store,
+// means that swap_move_up() moves downward in backing store, do forward
 static void swap_move_up(struct pool_item *item, int new_limit) {
   int limit = item->limit;
-  assert(limit != new_limit);
-  int neg_size = item->base - limit;
+  int size = limit - item->base;
+
+  int base = ~limit;
+  int new_base = ~new_limit;
   printf(
     "swap_move_up [%d,%d) to [%d,%d)\n",
-    limit + neg_size,
-    limit,
-    new_limit + neg_size,
-    new_limit
+    base,
+    base + size,
+    new_base,
+    new_base + size
   );
-  assert(new_limit > limit || new_limit <= limit + neg_size);
-  for (int i = -1; i >= neg_size; --i) {
-    swap_mem[new_limit + i] = swap_mem[limit + i];
-    swap_mem[limit + i] = 0xaaaaaaaa;
+  assert(new_base <= base || new_base >= base + size);
+  for (int i = 0; i < size; ++i) {
+    swap_mem[new_base + i] = swap_mem[base + i];
+    swap_mem[base + i] = 0xaaaaaaaa;
   }
 }
 
 void swap_init(int swap, int spare) {
-  pool_init(&swap_head, 0, swap, spare, swap_move, swap_move_up);
+  pool_init(&swap_head, ~swap, -1, spare, swap_move, swap_move_up);
 
   swap_mem = malloc(swap * sizeof(int));
   memset(swap_mem, 0xaa, swap * sizeof(int));
 }
 
-// read forward from swap_base and write backward from core_limit
-void swap_pop(int swap_limit, int core_base, int size) {
- printf("swap_pop swap [%d,%d) to core [%d,%d)\n", swap_limit - size, swap_limit, core_base, core_base + size);
+// swap address complemented wrt. pool and native wrt. backing store
+void swap_read(int swap_base, int core_base, int size) {
+ printf("swap_read swap [%d,%d) to core [%d,%d)\n", swap_base, swap_base + size, core_base, core_base + size);
   for (int i = 0; i < size; ++i) {
     assert(core_mem[core_base + i] == 0xaaaaaaaa);
-    core_mem[core_base + i] = swap_mem[swap_limit + ~i];
-    swap_mem[swap_limit + ~i] = 0xaaaaaaaa;
+    core_mem[core_base + i] = swap_mem[swap_base + i];
+    swap_mem[swap_base + i] = 0xaaaaaaaa;
   }
 }
 
-void swap_push(int core_limit, int swap_base, int size) {
- printf("swap_push core [%d,%d) to swap [%d,%d)\n", core_limit - size, core_limit, swap_base, swap_base + size);
+// swap address complemented wrt. pool and native wrt. backing store
+void swap_write(int swap_base, int core_base, int size) {
+ printf("swap_write core [%d,%d) to swap [%d,%d)\n", core_base, core_base + size, swap_base, swap_base + size);
   for (int i = 0; i < size; ++i) {
     assert(swap_mem[swap_base + i] == 0xaaaaaaaa);
-    swap_mem[swap_base + i] = core_mem[core_limit + ~i];
-    core_mem[core_limit + ~i] = 0xaaaaaaaa;
+    swap_mem[swap_base + i] = core_mem[core_base + i];
+    core_mem[core_base + i] = 0xaaaaaaaa;
   }
 }

diff --git a/swap.h b/swap.h
index ffdb52d..a3d9c7f 100644 (file)
--- a/swap.h
+++ b/swap.h
@@ -7,7 +7,7 @@ extern struct pool_head swap_head;
 extern int *swap_mem;
 
 void swap_init(int swap, int spare);
-void swap_pop(int swap_limit, int core_base, int size);
-void swap_push(int core_limit, int swap_base, int size);
+void swap_read(int swap_base, int core_base, int size);
+void swap_write(int swap_base, int core_base, int size);
 
 #endif