Unify process_alloc() and process_realloc() with PROCESS_ALLOC_MODE_REALLOC bit

diff --git a/pool.c b/pool.c
index c884c6d..a34e6be 100644 (file)
--- a/pool.c
+++ b/pool.c
@@ -61,7 +61,7 @@ bool pool_alloc(
 #endif
   int base_offset, limit_offset;
 
-  // see if request is for "alloc" or "realloc"
+  // check mode
   size_change = size;
   if (mode & POOL_ALLOC_MODE_REALLOC) {
     // realloc, item must be already allocated

diff --git a/pool.h b/pool.h
index f6dbb7a..8b1c900 100644 (file)
--- a/pool.h
+++ b/pool.h
@@ -17,9 +17,9 @@ struct pool_head {
   void (*move_up)(struct pool_item *item, int new_limit);
 };
 
-#define POOL_ALLOC_MODE_LAST_FIT 1
-#define POOL_ALLOC_MODE_MOVEABLE 2
-#define POOL_ALLOC_MODE_REALLOC 4
+#define POOL_ALLOC_MODE_REALLOC 1
+#define POOL_ALLOC_MODE_LAST_FIT 2
+#define POOL_ALLOC_MODE_MOVEABLE 4
 
 void pool_init(
   struct pool_head *head,

diff --git a/process.c b/process.c
index 4c7656c..e0e4e33 100644 (file)
--- a/process.c
+++ b/process.c
@@ -196,107 +196,53 @@ static int calc_blocks(int para_base, int para_limit) {
       (para_base >> BLOCK_PARAS_SHIFT);
 }
 
-bool process_alloc(struct process *process, int para_base, int para_limit) {
-  int blocks;
-
-  // must not be already allocated
-  assert((process->flags & PROCESS_FLAGS_ACTIVE) == 0);
-
-  // check blocks
-  blocks = calc_blocks(para_base, para_limit);
-  if (
-    process_avail < blocks ||
-    !pool_alloc(&swap_table, &process->swap_item, blocks, 0)
-  )
-    return false;
-
-#ifndef INDIRECT_CORE
-  // free up as much core as we need to
-  rassert(do_swap_out(blocks - core_table.avail));
-
-  // allocate core and possible swap
-  rassert(
-    pool_alloc(
-      &core_table,
-      &process->core_item,
-      blocks,
-      POOL_ALLOC_MODE_MOVEABLE
-    )
-  );
-#else /* INDIRECT_CORE */
-  // allocate core and possible swap
-  if (!pool_alloc(&core_table, &process->core_item, blocks, 0)) {
-    pool_free(&swap_table, &process->swap_item);
-    return false;
-  }
-
-  // free up as much core as we need to
-  rassert(do_swap_out(blocks - core_block_pool.avail));
-
-  // populate physical blocks as needed
-  rassert(
-    block_pool_alloc(
-      &core_block_pool,
-      core_table_mem + process->core_item.base,
-      blocks
-    )
-  );
-#endif /* INDIRECT_CORE */
-
-  // insert at head of LRU list
-  process->lru_item.prev = &lru_head;
-  process->lru_item.next = lru_head.next;
-  process->lru_item.prev->next = &process->lru_item;
-  process->lru_item.next->prev = &process->lru_item;
-
-  // track total allocation
-#ifndef INDIRECT_CORE
-  process->flags = PROCESS_FLAGS_ACTIVE | PROCESS_FLAGS_CORE_ITEM;
-#else /* INDIRECT_CORE */
-  process->flags = PROCESS_FLAGS_ACTIVE;
-#endif /* INDIRECT_CORE */
-  process->para_base = para_base;
-  process->para_limit = para_limit;
-#ifdef INDIRECT_CORE
-  process->in_core_block =
-    (para_limit + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
-#endif
-  process_avail -= blocks;
-  return true;
-}
-
-bool process_realloc(
+bool process_alloc(
   struct process *process,
   int para_base,
   int para_limit,
-  bool dir
+  int mode
 ) {
+  int block_base, block_limit, blocks, blocks_change;
   struct process_calc calc;
-  int old_blocks, block_base, block_limit, blocks, blocks_change;
-
-  // must be already allocated
-  assert(process->flags & PROCESS_FLAGS_ACTIVE);
-
-  // must be fully in core
-#ifndef INDIRECT_CORE
-  assert(process->flags & PROCESS_FLAGS_CORE_ITEM);
-#endif /* ! INDIRECT_CORE */
-  process_calc(process, &calc);
-  assert(calc.in_core_block == calc.block_limit);
-
-  // for now, not allowed to resize both ends at once
-  // (in case we free physical blocks then fail to resize)
-  assert(
-    para_base == process->para_base ||
-      para_limit == process->para_limit
-  );
+  int old_blocks;
 
   // check blocks
-  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;
+
+  // check mode
+  blocks_change = blocks;
+  if ((mode & PROCESS_ALLOC_MODE_REALLOC) == 0) {
+    // alloc, must not be already allocated
+    assert((process->flags & PROCESS_FLAGS_ACTIVE) == 0);
+
+    // set up dummy calculations
+    calc.block_base = block_base;
+    calc.block_limit = block_base;
+    calc.core_origin = 0;
+  }
+  else {
+    // realloc, must be already allocated
+    assert(process->flags & PROCESS_FLAGS_ACTIVE);
+
+    // for now, not allowed to resize both ends at once
+    // (in case we free physical blocks then fail to resize)
+    assert(
+      para_base == process->para_base ||
+        para_limit == process->para_limit
+    );
+
+    // must be fully in core
+    process_calc(process, &calc);
+    assert(calc.in_core_block == calc.block_limit);
+#ifndef INDIRECT_CORE
+    assert(process->flags & PROCESS_FLAGS_CORE_ITEM);
+#endif /* ! INDIRECT_CORE */
+
+    old_blocks = calc.block_limit - calc.block_base;
+    blocks_change -= old_blocks;
+  }
   if (process_avail < blocks_change)
     return false;
 
@@ -306,7 +252,7 @@ bool process_realloc(
       &swap_table,
       &process->swap_item,
       blocks,
-      dir | POOL_ALLOC_MODE_REALLOC,
+      mode,
       0 //calc.block_base - block_base
     )
   )
@@ -322,12 +268,13 @@ bool process_realloc(
       &core_table,
       &process->core_item,
       blocks,
-      dir | (POOL_ALLOC_MODE_MOVEABLE | POOL_ALLOC_MODE_REALLOC),
+      mode | POOL_ALLOC_MODE_MOVEABLE,
       calc.block_base - block_base
     )
   );
 #else /* INDIRECT_CORE */
   // discard physical blocks as needed
+  // note: base pointer is garbage in the alloc case
   block_pool_free(
     &core_block_pool,
     core_table_mem + calc.core_origin + calc.block_base,
@@ -345,21 +292,24 @@ bool process_realloc(
       &core_table,
       &process->core_item,
       blocks,
-      dir | POOL_ALLOC_MODE_REALLOC,
+      mode,
       calc.block_base - block_base
     )
   ) {
     // note: if we get to here we are resizing larger,
     // so we can't have freed any physical blocks above
-    rassert(
-      pool_alloc(
-        &swap_table,
-        &process->swap_item,
-        old_blocks,
-        dir | POOL_ALLOC_MODE_REALLOC,
-        0 //calc.block_base - block_base
-      )
-    );
+    if ((mode & PROCESS_ALLOC_MODE_REALLOC) == 0)
+      pool_free(&swap_table, &process->swap_item);
+    else
+      rassert(
+        pool_alloc(
+          &swap_table,
+          &process->swap_item,
+          old_blocks,
+          mode,
+          0 //calc.block_base - block_base
+        )
+      );
     return false;
   }
   calc.core_origin = process->core_item.base - block_base;
@@ -382,6 +332,21 @@ bool process_realloc(
   );
 #endif /* INDIRECT_CORE */
 
+  // for alloc, perform remaining initialization
+  if ((process->flags & PROCESS_ALLOC_MODE_REALLOC) == 0) {
+    // insert at head of LRU list
+    process->lru_item.prev = &lru_head;
+    process->lru_item.next = lru_head.next;
+    process->lru_item.prev->next = &process->lru_item;
+    process->lru_item.next->prev = &process->lru_item;
+
+#ifndef INDIRECT_CORE
+    process->flags = PROCESS_FLAGS_ACTIVE | PROCESS_FLAGS_CORE_ITEM;
+#else /* INDIRECT_CORE */
+    process->flags = PROCESS_FLAGS_ACTIVE;
+#endif /* INDIRECT_CORE */
+  } 
+
   // track total allocation
   process->para_base = para_base;
   process->para_limit = para_limit;

diff --git a/process.h b/process.h
index 1f0d722..fdbad9e 100644 (file)
--- a/process.h
+++ b/process.h
@@ -55,13 +55,15 @@ extern int process_avail;
 
 extern struct lru_item lru_head, *victim;
 
+#define PROCESS_ALLOC_MODE_REALLOC 1 // must = POOL_ALLOC_MODE_REALLOC
+#define PROCESS_ALLOC_MODE_LAST_FIT 2 // must = POOL_ALLOC_MODE_LAST_FIT
+
 void process_init(int n, int spare);
-bool process_alloc(struct process *process, int para_base, int para_limit);
-bool process_realloc(
+bool process_alloc(
   struct process *process,
   int para_base,
   int para_limit,
-  bool dir
+  int mode
 );
 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 c481100..fd8a5ba 100644 (file)
--- a/process_test_run.c
+++ b/process_test_run.c
@@ -310,7 +310,7 @@ int main(int argc, char **argv) {
         test.success ? "true" : "false"
       );
       rassert((process->flags & PROCESS_FLAGS_ACTIVE) == 0);
-      result = process_alloc(process, test.para_base, test.para_limit);
+      result = process_alloc(process, test.para_base, test.para_limit, 0);
       printf(
         "... %s\n",
         result == test.success ?
@@ -362,11 +362,11 @@ int main(int argc, char **argv) {
           old_para_limit - test.para_limit,
           test.para_limit - process->para_base
         );
-        result = process_realloc(
+        result = process_alloc(
           process,
           process->para_base,
           test.para_limit,
-          false
+          PROCESS_ALLOC_MODE_REALLOC
         );
         printf(
           "... %s\n",
@@ -378,11 +378,11 @@ int main(int argc, char **argv) {
           if (!test.success) {
             printf("... undo\n");
             rassert(
-              process_realloc(
+              process_alloc(
                 process,
                 process->para_base,
                 old_para_limit,
-                false
+                PROCESS_ALLOC_MODE_REALLOC
               )
             );
           }
@@ -427,11 +427,11 @@ int main(int argc, char **argv) {
           test.para_base - old_para_base,
           0
         );
-        result = process_realloc(
+        result = process_alloc(
           process,
           test.para_base,
           process->para_limit,
-          true
+          PROCESS_ALLOC_MODE_REALLOC | PROCESS_ALLOC_MODE_LAST_FIT
         );
         printf(
           "... %s\n",
@@ -443,11 +443,11 @@ int main(int argc, char **argv) {
           if (!test.success) {
             printf("... undo\n");
             rassert(
-              process_realloc(
+              process_alloc(
                 process,
                 old_para_base,
                 process->para_limit,
-                true 
+                PROCESS_ALLOC_MODE_REALLOC | PROCESS_ALLOC_MODE_LAST_FIT
               )
             );
           }