Tidy up the actual_old_paras/actual_old_blocks stuff and make the test script include...

diff --git a/Makefile b/Makefile
index 081a63d..bd6ab2d 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,5 @@
-CFLAGS=-g -Wall -D__FUZIX__
-# -DNDEBUG
+CFLAGS=-g -Wall
+# -D__FUZIX__ -DNDEBUG
 
 all: pool_test_gen pool_test_run process_test_gen process_test_run mkfs \
 inode_test_gen inode_test_run
@@ -26,8 +26,8 @@ process_test_run: process_test_run.o process.o process_test.h core.o swap.o bloc
 
 process_test_run.o: process_test_run.c process.h core.h swap.h pool.h fuzix_fs.h util.h
 process.o: process.c process.h core.h swap.h pool.h fuzix_fs.h
-core.o: core.c core.h pool.h
-swap.o: swap.c fuzix_fs.c swap.h core.h pool.h fuzix_fs.h
+core.o: core.c core.h process.h pool.h
+swap.o: swap.c swap.h process.h pool.h
 block_pool.o: block_pool.c block_pool.h
 
 # ucp no longer compiles because many fs routines commented to save space

diff --git a/core.c b/core.c
index 09c0627..f03c92c 100644 (file)
--- a/core.c
+++ b/core.c
@@ -24,13 +24,7 @@ static void core_move(struct pool_item *item, int new_base) {
 
   base = item->base;
   blocks = item->limit - base;
-  //printf(
-  //  "core_move [%d,%d) to [%d,%d)\n",
-  //  base,
-  //  base + blocks,
-  //  new_base,
-  //  new_base + blocks
-  //);
+ printf("core_move [%d,%d) to [%d,%d)\n", base, base + blocks, new_base, new_base + blocks);
   assert(new_base <= base || new_base >= base + blocks);
 #ifndef INDIRECT_CORE
   // see if incomplete last block, if so don't copy extra part
@@ -52,13 +46,7 @@ static void core_move_up(struct pool_item *item, int new_limit) {
 
   limit = item->limit;
   blocks = limit - item->base;
-  //printf(
-  //  "core_move_up [%d,%d) to [%d,%d)\n",
-  //  limit - blocks,
-  //  limit,
-  //  new_limit - blocks,
-  //  new_limit
-  //);
+ printf("core_move_up [%d,%d) to [%d,%d)\n", limit - blocks, limit, new_limit - blocks, new_limit);
   assert(new_limit >= limit || new_limit <= limit - blocks);
   // set up transfer parameters
   limit1 = limit << BLOCK_PARAS_SHIFT;

diff --git a/indirect_core_contiguous_swap/Makefile b/indirect_core_contiguous_swap/Makefile
index 7264a0d..7ce3d4e 100644 (file)
--- a/indirect_core_contiguous_swap/Makefile
+++ b/indirect_core_contiguous_swap/Makefile
@@ -12,8 +12,8 @@ process_test_run: process_test_run.o process.o core.o swap.o block_pool.o pool.o
 
 process_test_run.o: process_test_run.c process.h core.h swap.h pool.h
 process.o: process.c process.h core.h swap.h pool.h
-core.o: core.c core.h pool.h
-swap.o: swap.c swap.h pool.h
+core.o: core.c core.h process.h pool.h
+swap.o: swap.c swap.h process.h pool.h
 block_pool.o: block_pool.c block_pool.h
 pool.o: pool.c pool.h
 

diff --git a/indirect_core_indirect_swap/Makefile b/indirect_core_indirect_swap/Makefile
index 7264a0d..7ce3d4e 100644 (file)
--- a/indirect_core_indirect_swap/Makefile
+++ b/indirect_core_indirect_swap/Makefile
@@ -12,8 +12,8 @@ process_test_run: process_test_run.o process.o core.o swap.o block_pool.o pool.o
 
 process_test_run.o: process_test_run.c process.h core.h swap.h pool.h
 process.o: process.c process.h core.h swap.h pool.h
-core.o: core.c core.h pool.h
-swap.o: swap.c swap.h pool.h
+core.o: core.c core.h process.h pool.h
+swap.o: swap.c swap.h process.h pool.h
 block_pool.o: block_pool.c block_pool.h
 pool.o: pool.c pool.h
 

diff --git a/moveable_core_contiguous_swap/Makefile b/moveable_core_contiguous_swap/Makefile
index 248f2e5..0acd0c8 100644 (file)
--- a/moveable_core_contiguous_swap/Makefile
+++ b/moveable_core_contiguous_swap/Makefile
@@ -12,8 +12,8 @@ process_test_run: process_test_run.o process.o core.o swap.o pool.o
 
 process_test_run.o: process_test_run.c process.h core.h swap.h pool.h
 process.o: process.c process.h core.h swap.h pool.h
-core.o: core.c core.h pool.h
-swap.o: swap.c swap.h pool.h
+core.o: core.c core.h process.h pool.h
+swap.o: swap.c swap.h process.h pool.h
 pool.o: pool.c pool.h
 
 clean:

diff --git a/moveable_core_indirect_swap/Makefile b/moveable_core_indirect_swap/Makefile
index 760d3ed..c24de1a 100644 (file)
--- a/moveable_core_indirect_swap/Makefile
+++ b/moveable_core_indirect_swap/Makefile
@@ -12,8 +12,8 @@ process_test_run: process_test_run.o process.o core.o swap.o block_pool.o pool.o
 
 process_test_run.o: process_test_run.c process.h core.h swap.h pool.h
 process.o: process.c process.h core.h swap.h pool.h
-core.o: core.c core.h pool.h
-swap.o: swap.c swap.h pool.h
+core.o: core.c core.h process.h pool.h
+swap.o: swap.c swap.h process.h pool.h
 block_pool.o: block_pool.c block_pool.h
 pool.o: pool.c pool.h
  

diff --git a/process.c b/process.c
index cf15954..693cb68 100644 (file)
--- a/process.c
+++ b/process.c
@@ -322,7 +322,7 @@ bool process_alloc(struct process *process, int paras) {
 }
 
 bool process_realloc(struct process *process, int paras) {
-  int blocks, old_blocks, blocks_change;
+  int old_blocks, blocks, blocks_change;
 
   // must be already allocated
   assert(process->paras != -1);
@@ -331,8 +331,8 @@ bool process_realloc(struct process *process, int paras) {
   assert(process->lru_item.prev != NULL);
 
   // check blocks
+  old_blocks = process->swap_item.limit - process->swap_item.base;
   blocks = (paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
-  old_blocks = (process->paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
   blocks_change = blocks - old_blocks;
   if (process_avail < blocks_change)
     return false;

diff --git a/process_test.h b/process_test.h
index 4f87de1..9a0045a 100644 (file)
--- a/process_test.h
+++ b/process_test.h
@@ -11,8 +11,10 @@
 struct process_test {
   int type;
   int process;
-  int old_paras;
+  int old_paras; // for checking only
+  int old_blocks; // for checking only
   int paras;
+  int blocks; // for checking only
   bool success;
 };
 

diff --git a/process_test_gen.c b/process_test_gen.c
index ded7f88..8c4e881 100644 (file)
--- a/process_test_gen.c
+++ b/process_test_gen.c
@@ -49,29 +49,32 @@ int main(int argc, char **argv) {
     test.process = rand_int(n_processes);
     test.old_paras = processes[test.process];
     if (test.old_paras == -1) {
+      test.old_blocks = -1;
       test.paras = rand_int(process_paras + 1);
-      int blocks = (test.paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
-      test.success = pool_used + blocks <= pool_blocks;
+      test.blocks = (test.paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
+      test.success = pool_used + test.blocks <= pool_blocks;
 
 #ifdef __FUZIX__
       test.type = PROCESS_TEST_TYPE_ALLOC;
       write(1, &test, sizeof(test));
 #else
       printf(
-        "alloc %d %d %s\n",
+        "alloc %d %d %d %s\n",
         test.process,
         test.paras,
+        test.blocks,
         test.success ? "true" : "false"
       );
 #endif
 
       if (test.success) {
         processes[test.process] = test.paras;
-        pool_used += blocks;
+        pool_used += test.blocks;
       }
     }
     else {
-      int old_blocks = (test.old_paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
+      test.old_blocks =
+        (test.old_paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
       if (rand_int(64)) {
 #ifdef __FUZIX__
         test.type = PROCESS_TEST_TYPE_RUN;
@@ -81,26 +84,31 @@ int main(int argc, char **argv) {
 #endif
 
         if (rand_int(8) == 0) {
-          test.paras = rand_int(process_paras + 1);
-          int blocks = (test.paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
-          test.success = pool_used + blocks - old_blocks <= pool_blocks;
+          test.paras =
+            rand_int(process_paras + 1);
+          test.blocks =
+            (test.paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
+          test.success =
+             pool_used + test.blocks - test.old_blocks <= pool_blocks;
 
 #ifdef __FUZIX__
           test.type = PROCESS_TEST_TYPE_REALLOC;
           write(1, &test, sizeof(test));
 #else
           printf(
-            "realloc %d %d %d %s\n",
+            "realloc %d %d %d %d %d %s\n",
             test.process,
             test.old_paras,
+            test.old_blocks,
             test.paras,
+            test.blocks,
             test.success ? "true" : "false"
           );
 #endif
 
           if (test.success) {
             processes[test.process] = test.paras;
-            pool_used += blocks - old_blocks;
+            pool_used += test.blocks - test.old_blocks;
           }
         }
       }
@@ -109,10 +117,15 @@ int main(int argc, char **argv) {
         test.type = PROCESS_TEST_TYPE_FREE;
         write(1, &test, sizeof(test));
 #else
-        printf("free %d %d\n", test.process, test.old_paras);
+        printf(
+          "free %d %d %d\n",
+          test.process,
+          test.old_paras,
+          test.old_blocks
+        );
 #endif
         processes[test.process] = -1;
-        pool_used -= old_blocks;
+        pool_used -= test.old_blocks;
       }
     }
   }

diff --git a/process_test_run.c b/process_test_run.c
index f538469..5b051d8 100644 (file)
--- a/process_test_run.c
+++ b/process_test_run.c
@@ -70,7 +70,7 @@ void swap_hash_verify(int process, int base, int paras, int offset) {
 void core_copy(int src_base, int dest_base, int paras) {
   int i;
 
- //printf("core_copy %d(%d) %d(%d) %d(%d)\n", src_base, src_base >> BLOCK_PARAS_SHIFT, dest_base, dest_base >> BLOCK_PARAS_SHIFT, paras, (paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT);
+ printf("core_copy %d(%d) %d(%d) %d(%d)\n", src_base, src_base >> BLOCK_PARAS_SHIFT, dest_base, dest_base >> BLOCK_PARAS_SHIFT, paras, (paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT);
   for (i = 0; i < paras; ++i) {
     core_block_mem[dest_base + i] = core_block_mem[src_base + i];
     core_block_mem[src_base + i] = 0xaaaaaaaa;
@@ -80,7 +80,7 @@ void core_copy(int src_base, int dest_base, int paras) {
 void core_copy_up(int src_limit, int dest_limit, int paras) {
   int i;
 
- //printf("core_copy_up %d(%d) %d(%d) %d(%d)\n", src_limit, src_limit >> BLOCK_PARAS_SHIFT, dest_limit, dest_limit >> BLOCK_PARAS_SHIFT, paras, (paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT);
+ printf("core_copy_up %d(%d) %d(%d) %d(%d)\n", src_limit, src_limit >> BLOCK_PARAS_SHIFT, dest_limit, dest_limit >> BLOCK_PARAS_SHIFT, paras, (paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT);
   paras = -paras;
   for (i = -1; i >= paras; --i) {
     core_block_mem[dest_limit + i] = core_block_mem[src_limit + i];
@@ -164,8 +164,7 @@ int main(int argc, char **argv) {
   char buf[256];
 #endif
   bool result;
-  int actual_old_paras;
-  int old_blocks, blocks, actual_old_blocks;
+  int old_paras, old_blocks;
   int swap_base, swap_blocks;
   int swap_paras;
   int core_base, core_blocks;
@@ -247,14 +246,16 @@ int main(int argc, char **argv) {
       test.type = PROCESS_TEST_TYPE_ALLOC;
       rassert(
         scanf(
-          "%d %d %s",
+          "%d %d %d %s",
           &test.process,
           &test.paras,
+          &test.blocks,
           buf
-        ) == 3
+        ) == 4
       );
       rassert(test.process >= 0 && test.process < n_processes);
       rassert(test.paras >= 0);
+      rassert(test.blocks >= 0);
       if (strcmp(buf, "false") == 0)
         test.success = false;
       else if (strcmp(buf, "true") == 0)
@@ -266,16 +267,20 @@ int main(int argc, char **argv) {
       test.type = PROCESS_TEST_TYPE_REALLOC;
       rassert(
         scanf(
-          "%d %d %d %s",
+          "%d %d %d %d %d %s",
           &test.process,
           &test.old_paras,
+          &test.old_blocks,
           &test.paras,
+          &test.blocks,
           buf
-        ) == 4
+        ) == 6
       );
       rassert(test.process >= 0 && test.process < n_processes);
       rassert(test.old_paras >= 0);
+      rassert(test.old_blocks >= 0);
       rassert(test.paras >= 0);
+      rassert(test.blocks >= 0);
       if (strcmp(buf, "false") == 0)
         test.success = false;
       else if (strcmp(buf, "true") == 0)
@@ -290,9 +295,17 @@ int main(int argc, char **argv) {
     }
     else if (strcmp(buf, "free") == 0) {
       test.type = PROCESS_TEST_TYPE_FREE;
-      rassert(scanf("%d %d", &test.process, &test.old_paras) == 2);
+      rassert(
+        scanf(
+          "%d %d %d",
+          &test.process,
+          &test.old_paras,
+          &test.old_blocks
+        ) == 3
+      );
       rassert(test.process >= 0 && test.process < n_processes);
       rassert(test.old_paras >= 0);
+      rassert(test.old_blocks >= 0);
     }
     else
       rassert(false);
@@ -300,9 +313,10 @@ int main(int argc, char **argv) {
     switch (test.type) {
     case PROCESS_TEST_TYPE_ALLOC:
       printf(
-        "alloc %d %d %s\n",
+        "alloc %d %d %d %s\n",
         test.process,
         test.paras,
+        test.blocks,
         test.success ? "true" : "false"
       );
       rassert(processes[test.process].paras == -1);
@@ -320,56 +334,60 @@ int main(int argc, char **argv) {
           processes[test.process].paras = -1;
         }
         else {
-          core_base = processes[test.process].core_item.base;
-          blocks = (test.paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
-          assert(
-            processes[test.process].core_item.limit ==
-              core_base + blocks
+ printf("new core [%d,%d) swap [%d, %d)\n", processes[test.process].core_item.base, processes[test.process].core_item.limit, processes[test.process].swap_item.base, processes[test.process].swap_item.limit);
+          rassert(
+            processes[test.process].swap_item.limit -
+              processes[test.process].swap_item.base ==
+            test.blocks
           );
- printf("new core [%d,%d)\n", core_base, core_base + blocks);
           core_hash_init(
             test.process,
-            core_base << BLOCK_PARAS_SHIFT,
+            processes[test.process].core_item.base << BLOCK_PARAS_SHIFT,
             test.paras,
             0
           );
- printf("new swap [%d,%d)\n", processes[test.process].swap_item.base, processes[test.process].swap_item.limit);
         }
       }
       break;
     case PROCESS_TEST_TYPE_REALLOC:
       printf(
-        "realloc %d %d %d %s\n",
+        "realloc %d %d %d %d %d %s\n",
         test.process,
         test.old_paras,
+        test.old_blocks,
         test.paras,
+        test.blocks,
         test.success ? "true" : "false"
       );
       if (processes[test.process].paras == -1)
         printf("... not allocated, ignore\n");
       else {
-        core_base = processes[test.process].core_item.base;
-        actual_old_paras = processes[test.process].paras;
-        actual_old_blocks =
-          (actual_old_paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
-        rassert(
-          processes[test.process].core_item.limit ==
-            core_base + actual_old_blocks
-        );
-        old_blocks = (test.old_paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
-        if (actual_old_blocks != old_blocks) {
+ printf("old core [%d,%d) swap [%d,%d)\n", processes[test.process].core_item.base, processes[test.process].core_item.limit, processes[test.process].swap_item.base, processes[test.process].swap_item.limit);
+        old_paras = processes[test.process].paras;
+        if (old_paras != test.old_paras) {
+          printf(
+            "... old paras %d, should be %d\n",
+            old_paras,
+            test.old_paras
+          );
+          rassert(old_paras <= test.old_paras);
+        }
+        old_blocks =
+          processes[test.process].swap_item.limit - 
+          processes[test.process].swap_item.base;
+        if (old_blocks != test.old_blocks) {
           printf(
             "... old blocks %d, should be %d\n",
-            actual_old_blocks,
-            old_blocks
+            old_blocks,
+            test.old_blocks
           );
-          rassert(actual_old_blocks <= old_blocks);
+          rassert(old_blocks <= test.old_blocks);
         }
- printf("old core [%d,%d) swap [%d,%d)\n", core_base, core_base + actual_old_blocks, processes[test.process].swap_item.base, processes[test.process].swap_item.limit);
         core_hash_verify(
           test.process,
-          (core_base << BLOCK_PARAS_SHIFT) + test.paras,
-          actual_old_paras - test.paras,
+          (processes[test.process].core_item.base << BLOCK_PARAS_SHIFT) +
+            test.paras,
+          old_paras - test.paras,
           test.paras
         );
         result = process_realloc(processes + test.process, test.paras);
@@ -382,21 +400,23 @@ int main(int argc, char **argv) {
         if (result) {
           if (!test.success) {
             printf("... undo\n");
-            rassert(process_realloc(processes + test.process, actual_old_paras));
+            rassert(
+              process_realloc(processes + test.process, old_paras)
+            );
           }
           else {
-            core_base = processes[test.process].core_item.base;
-            blocks = (int)((test.paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT);
+ printf("new core [%d,%d) swap [%d, %d)\n", processes[test.process].core_item.base, processes[test.process].core_item.limit, processes[test.process].swap_item.base, processes[test.process].swap_item.limit);
             rassert(
-              processes[test.process].core_item.limit ==
-                core_base + blocks
+              processes[test.process].swap_item.limit -
+                processes[test.process].swap_item.base ==
+              test.blocks
             );
- printf("new core [%d,%d) swap [%d,%d)\n", core_base, core_base + blocks, processes[test.process].swap_item.base, processes[test.process].swap_item.limit);
             core_hash_init(
               test.process,
-              (core_base << BLOCK_PARAS_SHIFT) + actual_old_paras,
-              test.paras - actual_old_paras,
-              actual_old_paras
+              (processes[test.process].core_item.base << BLOCK_PARAS_SHIFT) +
+                old_paras,
+              test.paras - old_paras,
+              old_paras
             );
           }
         }
@@ -412,21 +432,34 @@ int main(int argc, char **argv) {
       }
       break;
     case PROCESS_TEST_TYPE_FREE:
-      printf("free %d %d\n", test.process, test.old_paras);
+      printf(
+        "free %d %d %d\n",
+        test.process,
+        test.old_paras,
+        test.old_blocks
+      );
       if (processes[test.process].paras == -1)
         printf("... not allocated, ignore\n");
       else {
-        actual_old_blocks =
-          (processes[test.process].paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
+        old_paras = processes[test.process].paras;
+        if (old_paras != test.old_paras) {
+          printf(
+            "... old paras %d, should be %d\n",
+            old_paras,
+            test.old_paras
+          );
+          rassert(old_paras <= test.old_paras);
+        }
         old_blocks =
-          (test.old_paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
-        if (actual_old_blocks != old_blocks) {
+          processes[test.process].swap_item.limit - 
+          processes[test.process].swap_item.base;
+        if (old_blocks != test.old_blocks) {
           printf(
             "... old blocks %d, should be %d\n",
-            actual_old_blocks,
-            old_blocks
+            old_blocks,
+            test.old_blocks
           );
-          rassert(actual_old_blocks <= old_blocks);
+          rassert(old_blocks <= test.old_blocks);
         }
         if (processes[test.process].lru_item.prev != NULL) { // fully in core
           assert(processes + test.process != victim);
@@ -459,7 +492,6 @@ int main(int argc, char **argv) {
             swap_paras = processes[test.process].paras;
           }
         }
-        rassert(core_blocks + swap_blocks == actual_old_blocks);
  printf("old core [%d,%d) swap [%d,%d)\n", core_base, core_base + core_blocks, swap_base, swap_base + swap_blocks);
  fflush(stdout);
         core_hash_verify(