Change process.blocks to process.size, do rounding and shifting at each access

diff --git a/process.c b/process.c
index 7a19a6d..318b791 100644 (file)
--- a/process.c
+++ b/process.c
@@ -65,7 +65,7 @@ static void check_invariants() {
 #endif
   }
   for (int i = 0; i < n_processes; ++i)
-    if (processes[i].blocks == -1) {
+    if (processes[i].size == -1L) {
 #ifdef PREALLOCATE_CORE
       assert(
         processes[i].core_item.prev == NULL &&
@@ -100,9 +100,8 @@ static void check_invariants() {
 #else
         assert(processes[i].pool_item.prev && processes[i].pool_item.next);
         assert(
-          processes[i].blocks ==
-            processes[i].pool_item.limit -
-            processes[i].pool_item.base
+          (int)((processes[i].size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT) ==
+            processes[i].pool_item.limit - processes[i].pool_item.base
         );
 #endif
       } 
@@ -123,7 +122,10 @@ static void check_invariants() {
         int victim_swap_blocks = victim_swap_item.limit - victim_swap_item.base;
 #endif
         assert(victim_swap_blocks);
-        assert(processes[i].blocks == victim_core_blocks + victim_swap_blocks);
+        assert(
+          (int)((processes[i].size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT) ==
+            victim_core_blocks + victim_swap_blocks
+        );
       }
       else {
 #ifdef PREALLOCATE_SWAP
@@ -136,13 +138,12 @@ static void check_invariants() {
 #else
         assert(processes[i].pool_item.prev && processes[i].pool_item.next);
         assert(
-          processes[i].blocks ==
-            processes[i].pool_item.limit -
-            processes[i].pool_item.base
+          (int)((processes[i].size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT) ==
+            processes[i].pool_item.limit - processes[i].pool_item.base
         );
 #endif
       }
-      avail -= processes[i].blocks;
+      avail -= (int)((processes[i].size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
     }
   assert(avail == process_avail);
 }
@@ -154,7 +155,7 @@ void process_init(int n, int spare) {
   n_processes = n;
 #ifndef NDEBUG
   for (int i = 0; i < n_processes; ++i)
-    processes[i].blocks = -1;
+    processes[i].size = -1L;
 #endif
 
   process_avail = core_avail() + swap_avail() - spare;
@@ -230,11 +231,15 @@ static void do_swap_out(int swap_out) {
 
       // fully in core, take over only the per-process core item
 #ifdef PREALLOCATE_CORE
-      victim_core_blocks = victim->blocks;
+      victim_core_blocks =
+       (int)((victim->size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
 #else
       pool_move_item(&victim->pool_item, &victim_core_item);
       victim_core_blocks = victim_core_item.limit - victim_core_item.base;
- assert(victim_core_blocks == victim->blocks);
+ assert(
+  victim_core_blocks ==
+   (int)((victim->size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT)
+ );
 #endif
 
       // calculate amount to swap out
@@ -294,13 +299,14 @@ static void do_swap_out(int swap_out) {
   }
 }
 
-bool process_alloc(struct process *process, int blocks) {
-  int swap_out;
+bool process_alloc(struct process *process, long size) {
+  int blocks, swap_out;
 
   // must not be already allocated
-  assert(process->blocks == -1);
+  assert(process->size == -1L);
 
   // check blocks
+  blocks = (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
   if (
     process_avail < blocks
 #if defined(PREALLOCATE_SWAP) && !defined(MOVEABLE_SWAP)
@@ -345,29 +351,31 @@ bool process_alloc(struct process *process, int blocks) {
   process->lru_item.next->prev = &process->lru_item;
 
   // track total allocation
-  process->blocks = blocks;
+  process->size = size;
   process_avail -= blocks;
  check_invariants();
   return true;
 }
 
-bool process_realloc(struct process *process, int blocks) {
-  int swap_out;
+bool process_realloc(struct process *process, long size) {
+  int blocks, old_blocks, swap_out;
 
   // must be already allocated
-  assert(process->blocks != -1);
+  assert(process->size != -1L);
 
   // must be fully in core
   assert(process->lru_item.prev != NULL);
 
   // check blocks
-  int blocks_change = blocks - process->blocks;
+  blocks = (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+  old_blocks = (int)((process->size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+  int blocks_change = blocks - old_blocks;
   if (process_avail < blocks_change)
     return false;
 #if defined(PREALLOCATE_SWAP) && !defined(MOVEABLE_SWAP)
   swap_table_free(&process->swap_item);
   if (!swap_table_alloc(&process->swap_item, blocks)) {
-    rassert(swap_table_alloc(&process->swap_item, process->blocks));
+    rassert(swap_table_alloc(&process->swap_item, old_blocks));
     return false;
   }
 #endif
@@ -383,7 +391,7 @@ bool process_realloc(struct process *process, int blocks) {
   if (!core_table_realloc(&PER_PROCESS_CORE_ITEM(process), blocks)) {
 #if defined(PREALLOCATE_SWAP) && !defined(MOVEABLE_SWAP)
     swap_table_free(&process->swap_item);
-    rassert(swap_table_alloc(&process->swap_item, process->blocks));
+    rassert(swap_table_alloc(&process->swap_item, old_blocks));
 #endif
     return false;
   }
@@ -410,7 +418,7 @@ bool process_realloc(struct process *process, int blocks) {
 #endif
  
   // track total allocation
-  process->blocks = blocks;
+  process->size = size;
   process_avail -= blocks_change;
  check_invariants();
   return true;
@@ -429,7 +437,7 @@ void process_run(struct process *process) {
   int swap_base, core_base;
 
   // must be already allocated
-  assert(process->blocks != -1);
+  assert(process->size != -1L);
 
   // see whether fully in core
   if (process->lru_item.prev != NULL) {
@@ -453,11 +461,15 @@ void process_run(struct process *process) {
     if (process != victim) {
       // fully in swap, take over only the per-process swap item
 #ifdef PREALLOCATE_SWAP
-      process_swap_blocks = process->blocks;
+      process_swap_blocks =
+        (int)((process->size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
 #else
       pool_move_item(&process->pool_item, &process_swap_item);
       process_swap_blocks = process_swap_item.limit - process_swap_item.base;
- assert(process_swap_blocks == process->blocks);
+ assert(
+  process_swap_blocks ==
+   (int)((process->size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT)
+ );
 #endif
 
       // calculate amounts to swap out then in
@@ -566,7 +578,7 @@ void process_run(struct process *process) {
 
 void process_free(struct process *process) {
   // must be already allocated
-  assert(process->blocks != -1);
+  assert(process->size != -1L);
 
   // see whether fully in core, victim, or fully in swap
   if (process->lru_item.prev != NULL) {
@@ -637,9 +649,9 @@ void process_free(struct process *process) {
 #endif
  
   // track total allocation
-  process_avail += process->blocks;
+  process_avail += (int)((process->size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
 #ifndef NDEBUG
-  process->blocks = -1;
+  process->size = -1L;
 #endif
  check_invariants();
 }

diff --git a/process.h b/process.h
index 2d26900..c0228cd 100644 (file)
--- a/process.h
+++ b/process.h
@@ -62,7 +62,7 @@ extern struct process {
 #if !defined(PREALLOCATE_SWAP) || !defined(PREALLOCATE_CORE)
   struct pool_item pool_item;
 #endif
-  int blocks; // brk level
+  long size; // brk level
 } *processes;
 int n_processes;
 
@@ -83,8 +83,8 @@ extern struct pool_item victim_swap_item;
 #endif
 
 void process_init(int n, int spare);
-bool process_alloc(struct process *process, int blocks);
-bool process_realloc(struct process *process, int blocks);
+bool process_alloc(struct process *process, long size);
+bool process_realloc(struct process *process, long size);
 void process_run(struct process *process);
 void process_free(struct process *process);
  

diff --git a/process_test_run.c b/process_test_run.c
index 7551f17..d13ec8a 100644 (file)
--- a/process_test_run.c
+++ b/process_test_run.c
@@ -45,7 +45,7 @@ int main(int argc, char **argv) {
 #endif
   process_init(n_processes, spare);
   for (int i = 0; i < n_processes; ++i)
-    processes[i].blocks = -1;
+    processes[i].size = -1L;
 
   while (true) {
  //printf("avail %d %d(%d) %d(%d)\n", process_avail, core_avail(), core_table.avail, swap_avail(), swap_table.avail);
@@ -77,9 +77,8 @@ int main(int argc, char **argv) {
         size,
         success ? "true" : "false"
       );
-      rassert(processes[process].blocks == -1);
-      int blocks = (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
-      bool result = process_alloc(processes + process, blocks);
+      rassert(processes[process].size == -1L);
+      bool result = process_alloc(processes + process, size);
       printf(
         "... %s\n",
         result == success ?
@@ -90,10 +89,11 @@ int main(int argc, char **argv) {
         if (!success) {
           printf("... undo\n");
           process_free(processes + process);
-          processes[process].blocks = -1;
+          processes[process].size = -1L;
         }
         else {
           int core_base = PER_PROCESS_CORE_ITEM(processes + process).base;
+          int blocks = (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
           assert(
             PER_PROCESS_CORE_ITEM(processes + process).limit ==
               core_base + blocks
@@ -127,11 +127,12 @@ int main(int argc, char **argv) {
         size,
         success ? "true" : "false"
       );
-      if (processes[process].blocks == -1)
+      if (processes[process].size == -1L)
         printf("... not allocated, ignore\n");
       else {
         int core_base = PER_PROCESS_CORE_ITEM(processes + process).base;
-        int actual_old_blocks = processes[process].blocks;
+        int actual_old_blocks =
+          (int)((processes[process].size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
         rassert(
           PER_PROCESS_CORE_ITEM(processes + process).limit ==
             core_base + actual_old_blocks
@@ -152,7 +153,7 @@ int main(int argc, char **argv) {
 #endif
         int blocks = (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
         core_hash_verify(process, core_base, blocks, actual_old_blocks);
-        bool result = process_realloc(processes + process, blocks);
+        bool result = process_realloc(processes + process, size);
         printf(
           "... %s\n",
           result == success ?
@@ -185,7 +186,7 @@ int main(int argc, char **argv) {
       rassert(scanf("%d", &process) == 1);
       rassert(process >= 0 && process < n_processes);
       printf("run %d\n", process);
-      if (processes[process].blocks == -1)
+      if (processes[process].size == -1L)
         printf("... not allocated, ignore\n");
       else {
         process_run(processes + process);
@@ -199,11 +200,13 @@ int main(int argc, char **argv) {
       rassert(process >= 0 && process < n_processes);
       rassert(old_size >= 0);
       printf("free %d %ld\n", process, old_size);
-      if (processes[process].blocks == -1)
+      if (processes[process].size == -1L)
         printf("... not allocated, ignore\n");
       else {
-        int actual_old_blocks = processes[process].blocks;
-        int old_blocks = (int)((old_size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+        int actual_old_blocks =
+          (int)((processes[process].size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+        int old_blocks =
+          (int)((old_size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
         if (actual_old_blocks != old_blocks) {
           printf(
             "... old blocks %d, should be %d\n",
@@ -247,7 +250,7 @@ int main(int argc, char **argv) {
         );
         swap_hash_verify(process, swap_base, 0, swap_blocks);
         process_free(processes + process);
-        processes[process].blocks = -1;
+        processes[process].size = -1L;
         printf("... ok\n");
       }
     }
@@ -258,7 +261,7 @@ int main(int argc, char **argv) {
 done:
   printf("final state:\n");
   for (int i = 0; i < n_processes; ++i) {
-    if (processes[i].blocks == -1)
+    if (processes[i].size == -1L)
       printf("process %d: not allocated\n", i);
     else {
       int swap_base, swap_blocks, core_base, core_blocks;
@@ -281,7 +284,10 @@ done:
         core_base = -1;
         core_blocks = 0;
       }
-      rassert(core_blocks + swap_blocks == processes[i].blocks);
+      rassert(
+        core_blocks + swap_blocks ==
+          (int)((processes[i].size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT)
+      );
       printf(
         "process %d: core [%d,%d) swap [%d,%d)\n",
         i,