Simplify process_free() and process_get_state() so that we rely completely on process...

diff --git a/process.c b/process.c
index 3de3863..3641ed8 100644 (file)
--- a/process.c
+++ b/process.c
@@ -649,91 +649,44 @@ void process_run(struct process *process) {
 }
 
 void process_free(struct process *process) {
-#ifndef INDIRECT_CORE
-#ifdef INDIRECT_SWAP
-  int swap_base;
-#endif /* INDIRECT_SWAP */
-#else /* INDIRECT_CORE */
-
-#ifdef INDIRECT_SWAP
-  int swap_base;
-#endif /* INDIRECT_SWAP */
-  int core_base;
-#endif /* INDIRECT_CORE */
-
   // must be already allocated
   assert(process->flags & PROCESS_FLAGS_ACTIVE);
 
-  // see whether fully in core, victim, or fully in swap
+  // remove from LRU list
   if (process->lru_item.prev != NULL) {
-    assert(process->flags & PROCESS_FLAGS_CORE_ITEM);
-    assert(process->swap_blocks == 0);
-
-    // fully in core, remove from LRU list and core pool
-    assert(process != victim);
-
     process->lru_item.prev->next = process->lru_item.next;
     process->lru_item.next->prev = process->lru_item.prev;
-
-#ifndef INDIRECT_CORE
-    pool_free(&core_table, &process->core_item);
-#else /* INDIRECT_CORE */
-    int core_base = process->core_item.base;
-    block_pool_free(
-      &core_block_pool,
-      core_table_mem + core_base,
-      process->core_item.limit - core_base
-    );
-#endif /* INDIRECT_CORE */
   }
-  else if (process == victim) {
-    assert(process->flags & PROCESS_FLAGS_CORE_ITEM);
 
-    // victim, remove from core and swap pools
-#ifdef INDIRECT_SWAP
-    swap_base = victim->swap_item.limit - victim->swap_blocks;
-    block_pool_free(
-      &swap_block_pool,
-      swap_table_mem + swap_base,
-      victim->swap_blocks
-    );
-#endif /* INDIRECT_SWAP */
+  // remove from core pool
 #ifndef INDIRECT_CORE
-    pool_free(&core_table, &victim->core_item);
+  if (process->flags & PROCESS_FLAGS_CORE_ITEM)
+    pool_free(&core_table, &process->core_item);
 #else /* INDIRECT_CORE */
-    core_base = victim->core_item.base;
-    block_pool_free(
-      &core_block_pool,
-      core_table_mem + core_base,
-      victim->core_item.limit - core_base - victim->swap_blocks
-    );
+  block_pool_free(
+    &core_block_pool,
+    core_table_mem + process->core_item.base,
+    process->core_item.limit -
+      process->core_item.base -
+      process->swap_blocks
+  );
+  pool_free(&core_table, &process->core_item);
 #endif /* INDIRECT_CORE */
-    victim = NULL;
-  }
-  else {
-    assert((process->flags & PROCESS_FLAGS_CORE_ITEM) == 0);
-    assert(
-      process->swap_blocks ==
-        process->swap_item.limit - process->swap_item.base
-    );
 
-    // fully in swap, remove from swap pool
+  // remove from swap pool
 #ifdef INDIRECT_SWAP
-    int swap_base = process->swap_item.base;
-    block_pool_free(
-      &swap_block_pool,
-      swap_table_mem + swap_base,
-      process->swap_item.limit - swap_base
-    );
+  block_pool_free(
+    &swap_block_pool,
+    swap_table_mem + process->swap_item.limit - process->swap_blocks,
+    process->swap_blocks
+  );
 #endif /* INDIRECT_SWAP */
-  }
-
-  // free the per-process table entries
-#ifdef INDIRECT_CORE
-  pool_free(&core_table, &process->core_item);
-#endif /* INDIRECT_CORE */
   pool_free(&swap_table, &process->swap_item);
 
+  // fix this later
+  if (process == victim)
+    victim = NULL;
+
   // track total allocation
   process_avail += (process->paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
   process->flags = 0;
@@ -741,78 +694,47 @@ void process_free(struct process *process) {
 
 // improve this later
 void process_get_state(struct process *process, struct process_state *state) {
-  if (process->lru_item.prev != NULL) { // fully in core
-    assert(process->flags & PROCESS_FLAGS_CORE_ITEM);
-    assert(process->swap_blocks == 0);
+  int para;
 
-    assert(process != runner);
-    assert(process != victim);
+#ifndef INDIRECT_CORE
+  if (process->flags & PROCESS_FLAGS_CORE_ITEM) {
     state->core_base = process->core_item.base;
     state->core_blocks = process->core_item.limit - process->core_item.base;
-    state->core_para = process->para;
-    state->core_paras = process->paras;
-    state->swap_base = -1;
-    state->swap_blocks = 0;
-    state->swap_para = 0;
-    state->swap_paras = 0;
   }
   else {
-    if (process == runner) { // partially in core, partially in swap
-      assert(process->flags & PROCESS_FLAGS_CORE_ITEM);
-
-      assert(process != victim);
-      state->core_base = process->core_item.base;
-      state->core_blocks =
-#ifndef INDIRECT_CORE
-        process->core_item.limit - process->core_item.base;
-#else /* INDIRECT_CORE */
-        process->core_item.limit -
-          process->core_item.base -
-          runner->swap_blocks;
-#endif /* INDIRECT_CORE */
-      state->core_para = process->para;
-      state->core_paras =
-        (state->core_blocks << BLOCK_PARAS_SHIFT) - process->para;
-      state->swap_base = process->swap_item.limit - runner->swap_blocks;
-      state->swap_blocks = runner->swap_blocks;
-      state->swap_para = 0;
-      state->swap_paras = process->paras - state->core_paras;
-    }
-    else if (process == victim) { // partially in core, partially in swap
-      assert(process->flags & PROCESS_FLAGS_CORE_ITEM);
-
-      state->core_base = process->core_item.base;
-      state->core_blocks =
-#ifndef INDIRECT_CORE
-        process->core_item.limit - process->core_item.base;
+    state->core_base = -1;
+    state->core_blocks = 0;
+  }
 #else /* INDIRECT_CORE */
-        process->core_item.limit -
-          process->core_item.base -
-          victim->swap_blocks;
+  state->core_base = process->core_item.base;
+  state->core_blocks =
+    process->core_item.limit -
+      process->core_item.base -
+      process->swap_blocks;
 #endif /* INDIRECT_CORE */
-      state->core_para = process->para;
-      state->core_paras =
-        (state->core_blocks << BLOCK_PARAS_SHIFT) - process->para;
-      state->swap_base = process->swap_item.limit - victim->swap_blocks;
-      state->swap_blocks = victim->swap_blocks;
-      state->swap_para = 0;
-      state->swap_paras = process->paras - state->core_paras;
-    }
-    else { // fully in swap
-      assert((process->flags & PROCESS_FLAGS_CORE_ITEM) == 0);
-      assert(
-        process->swap_blocks ==
-          process->swap_item.limit - process->swap_item.base
-      );
+  state->core_para = process->para;
+  state->core_paras =
+    (state->core_blocks << BLOCK_PARAS_SHIFT) - process->para;
+  if (state->core_paras < 0)
+    state->core_paras = 0;
+  if (state->core_paras > process->paras)
+    state->core_paras = process->paras;
 
-      state->core_base = -1;
-      state->core_blocks = 0;
-      state->core_para = 0;
-      state->core_paras = 0;
-      state->swap_base = process->swap_item.base;
-      state->swap_blocks = process->swap_item.limit - process->swap_item.base;
-      state->swap_para = process->para;
-      state->swap_paras = process->paras;
-    }
-  }
+  state->swap_base = process->swap_item.limit - process->swap_blocks;
+  state->swap_blocks = process->swap_blocks;
+  para = 
+    (
+      (process->swap_item.limit - process->swap_item.base) <<
+      BLOCK_PARAS_SHIFT
+    ) - process->para - process->paras;
+ //printf("a %d+%d+%d=%d*%d\n", process->para, process->paras, para, process->swap_item.limit - process->swap_item.base, BLOCK_PARAS);
+  state->swap_paras =
+    (process->swap_blocks << BLOCK_PARAS_SHIFT) - para;
+  if (state->swap_paras < 0)
+    state->swap_paras = 0;
+  if (state->swap_paras > process->paras)
+    state->swap_paras = process->paras;
+  state->swap_para =
+    (process->swap_blocks << BLOCK_PARAS_SHIFT) - para - state->swap_paras;
+ //printf("b %d+%d+%d=%d*%d\n", state->swap_para, state->swap_paras, para, process->swap_blocks, BLOCK_PARAS);
 }