Change process_realloc() calling convention to be the same as process_alloc()

diff --git a/process.c b/process.c
index 68296cb..b5d5fc5 100644 (file)
--- a/process.c
+++ b/process.c
@@ -264,8 +264,14 @@ bool process_alloc(struct process *process, int para_base, int para_limit) {
   return true;
 }
 
-bool process_realloc(struct process *process, int para_base_limit, bool dir) {
-  int old_blocks, blocks, blocks_change;
+bool process_realloc(
+  struct process *process,
+  int para_base,
+  int para_limit,
+  bool dir
+) {
+  struct process_calc calc;
+  int old_blocks, block_base, block_limit, blocks, blocks_change;
 
   // must be already allocated
   assert(process->flags & PROCESS_FLAGS_ACTIVE);
@@ -273,23 +279,15 @@ bool process_realloc(struct process *process, int para_base_limit, bool dir) {
   // must be fully in core
 #ifndef INDIRECT_CORE
   assert(process->flags & PROCESS_FLAGS_CORE_ITEM);
-  assert(
-    process->core_item.limit - process->core_item.base ==
-      process->swap_item.limit - process->swap_item.base
-  );
-#else
-  assert(
-    process->in_core_block ==
-      (process->para_limit + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT
-  );
 #endif /* ! INDIRECT_CORE */
+  process_calc(process, &calc);
+  assert(calc.in_core_block == calc.block_limit);
 
   // check blocks
-  old_blocks = calc_blocks(process->para_base, process->para_limit);
-  blocks =
-    dir ?
-      calc_blocks(para_base_limit, process->para_limit) :
-      calc_blocks(process->para_base, para_base_limit);
+  old_blocks = calc.block_limit - calc.block_base;
+  block_base = para_base >> BLOCK_PARAS_SHIFT;
+  block_limit = (para_limit + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
+  blocks = block_limit - block_base;
   blocks_change = blocks - old_blocks;
   if (process_avail < blocks_change)
     return false;
@@ -319,12 +317,13 @@ bool process_realloc(struct process *process, int para_base_limit, bool dir) {
   // discard physical blocks as needed
   block_pool_free(
     &core_block_pool,
-    core_table_mem + (
-      dir ?
-        process->core_item.base :
-        process->core_item.limit + blocks_change
-    ),
-    -blocks_change
+    core_table_mem + calc.core_origin + calc.block_base,
+    block_base - calc.block_base
+  );
+  block_pool_free(
+    &core_block_pool,
+    core_table_mem + calc.core_origin + block_limit,
+    calc.block_limit - block_limit
   );
 
   // reallocate core
@@ -348,6 +347,7 @@ bool process_realloc(struct process *process, int para_base_limit, bool dir) {
     );
     return false;
   }
+  calc.core_origin = process->core_item.base - block_base;
 
   // free up as much core as we need to
   rassert(do_swap_out(blocks_change - core_block_pool.avail));
@@ -356,21 +356,22 @@ bool process_realloc(struct process *process, int para_base_limit, bool dir) {
   rassert(
     block_pool_alloc(
       &core_block_pool,
-      core_table_mem + (
-        dir ?
-          process->core_item.base :
-          process->core_item.limit - blocks_change
-      ),
-      blocks_change
+      core_table_mem + calc.core_origin + block_base,
+      calc.block_base - block_base
+    ) &&
+    block_pool_alloc(
+      &core_block_pool,
+      core_table_mem + calc.core_origin + calc.block_limit,
+      block_limit - calc.block_limit
     )
   );
 #endif /* INDIRECT_CORE */
 
   // track total allocation
-  *(dir ? &process->para_base : &process->para_limit) = para_base_limit;
+  process->para_base = para_base;
+  process->para_limit = para_limit;
 #ifdef INDIRECT_CORE
-  process->in_core_block =
-    (process->para_limit + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
+  process->in_core_block = block_limit;
 #endif
   process_avail -= blocks_change;
   return true;

diff --git a/process.h b/process.h
index 838da3b..1f0d722 100644 (file)
--- a/process.h
+++ b/process.h
@@ -56,8 +56,13 @@ extern int process_avail;
 extern struct lru_item lru_head, *victim;
 
 void process_init(int n, int spare);
-bool process_alloc(struct process *process, int para, int paras);
-bool process_realloc(struct process *process, int paras, bool dir);
+bool process_alloc(struct process *process, int para_base, int para_limit);
+bool process_realloc(
+  struct process *process,
+  int para_base,
+  int para_limit,
+  bool dir
+);
 void process_run(struct process *process);
 void process_free(struct process *process);
 void process_calc(struct process *process, struct process_calc *calc);

diff --git a/process_test_run.c b/process_test_run.c
index 660fc04..c481100 100644 (file)
--- a/process_test_run.c
+++ b/process_test_run.c
@@ -362,7 +362,12 @@ int main(int argc, char **argv) {
           old_para_limit - test.para_limit,
           test.para_limit - process->para_base
         );
-        result = process_realloc(process, test.para_limit, false);
+        result = process_realloc(
+          process,
+          process->para_base,
+          test.para_limit,
+          false
+        );
         printf(
           "... %s\n",
           result == test.success ?
@@ -372,7 +377,14 @@ int main(int argc, char **argv) {
         if (result) {
           if (!test.success) {
             printf("... undo\n");
-            rassert(process_realloc(process, old_para_limit, false));
+            rassert(
+              process_realloc(
+                process,
+                process->para_base,
+                old_para_limit,
+                false
+              )
+            );
           }
           else {
             process_calc(process, &calc);
@@ -415,7 +427,12 @@ int main(int argc, char **argv) {
           test.para_base - old_para_base,
           0
         );
-        result = process_realloc(process, test.para_base, true);
+        result = process_realloc(
+          process,
+          test.para_base,
+          process->para_limit,
+          true
+        );
         printf(
           "... %s\n",
           result == test.success ?
@@ -425,7 +442,14 @@ int main(int argc, char **argv) {
         if (result) {
           if (!test.success) {
             printf("... undo\n");
-            rassert(process_realloc(process, old_para_base, true));
+            rassert(
+              process_realloc(
+                process,
+                old_para_base,
+                process->para_limit,
+                true 
+              )
+            );
           }
           else {
             process_calc(process, &calc);