Change test script to refer to bytes, although everything still done in blocks

diff --git a/core.h b/core.h
index d707e05..3fddba1 100644 (file)
--- a/core.h
+++ b/core.h
@@ -7,6 +7,7 @@
 #define INDIRECT_CORE 1
 #define MOVEABLE_CORE 1
 #define BLOCK_SIZE 0x1000
+#define BLOCK_SHIFT 12
 
 #ifdef MOVEABLE_CORE
 #define core_table_alloc(item, size) \

diff --git a/process_test_gen.c b/process_test_gen.c
index 67de5cc..c055849 100644 (file)
--- a/process_test_gen.c
+++ b/process_test_gen.c
@@ -4,66 +4,80 @@
 #include <string.h>
 #include "rassert.h"
 
+#define BLOCK_SIZE 0x1000
+#define BLOCK_SHIFT 12
+
 int rand_int(int n) {
   return (int)((long long)rand() * n / (RAND_MAX + 1LL));
 }
 
+long rand_long(long n) {
+  return (long)((long long)rand() * n / (RAND_MAX + 1LL));
+}
+
 int main(int argc, char **argv) {
   if (argc < 5) {
-    printf("usage: %s n_processes pool_size n_events process_size [seed]\n", argv[0]);
+    printf("usage: %s n_processes pool_blocks n_events process_blocks [seed]\n", argv[0]);
     exit(EXIT_FAILURE);
   }
   int n_processes = atoi(argv[1]);
-  int pool_size = atoi(argv[2]);
+  int pool_blocks = atoi(argv[2]);
   int n_events = atoi(argv[3]);
-  int process_size = atoi(argv[4]);
+  int process_blocks = atoi(argv[4]);
   int seed = argc >= 6 ? atoi(argv[5]) : 1;
 
-  int *processes = malloc(n_processes * sizeof(int));
+  long process_size = (long)process_blocks * BLOCK_SIZE;
+
+  int *processes = malloc(n_processes * sizeof(long));
   rassert(processes);
-  memset(processes, -1, n_processes * sizeof(int));
+  memset(processes, -1, n_processes * sizeof(long));
 
   srand(seed);
   int pool_used = 0;
   for (int i = 0; i < n_events; ++i) {
     int process = rand_int(n_processes);
-    int old_size = processes[process];
-    if (old_size == -1) {
-      int size = rand_int(process_size);
-      bool success = pool_used + size <= pool_size;
+    long old_size = processes[process];
+    if (old_size == -1L) {
+      long size = rand_long(process_size + 1);
+      int blocks = (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+      bool success = pool_used + blocks <= pool_blocks;
       printf(
-        "alloc %d %d %s\n",
+        "alloc %d %ld %s\n",
         process,
         size,
         success ? "true" : "false"
       );
       if (success) {
         processes[process] = size;
-        pool_used += size;
+        pool_used += blocks;
       }
     }
-    else if (rand_int(64)) {
-      printf("run %d\n", process);
-      if (rand_int(8) == 0) {
-        int size = rand_int(process_size);
-        bool success = pool_used + size - old_size <= pool_size;
-        printf(
-          "realloc %d %d %d %s\n",
-          process,
-          old_size,
-          size,
-          success ? "true" : "false"
-        );
-        if (success) {
-          processes[process] = size;
-          pool_used += size - old_size;
+    else {
+      int old_blocks = (int)((old_size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+      if (rand_int(64)) {
+        printf("run %d\n", process);
+        if (rand_int(8) == 0) {
+          long size = rand_long(process_size + 1);
+          int blocks = (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+          bool success = pool_used + blocks - old_blocks <= pool_blocks;
+          printf(
+            "realloc %d %ld %ld %s\n",
+            process,
+            old_size,
+            size,
+            success ? "true" : "false"
+          );
+          if (success) {
+            processes[process] = size;
+            pool_used += blocks - old_blocks;
+          }
         }
       }
-    }
-    else {
-      printf("free %d %d\n", process, old_size);
-      processes[process] = -1;
-      pool_used -= old_size;
+      else {
+        printf("free %d %ld\n", process, old_size);
+        processes[process] = -1;
+        pool_used -= old_blocks;
+      }
     }
   }
 

diff --git a/process_test_run.c b/process_test_run.c
index 990df48..7551f17 100644 (file)
--- a/process_test_run.c
+++ b/process_test_run.c
@@ -59,10 +59,11 @@ int main(int argc, char **argv) {
       rassert(false);
     }
     if (strcmp(buf, "alloc") == 0) {
-      int process, blocks;
-      rassert(scanf("%d %d %s", &process, &blocks, buf) == 3);
+      int process;
+      long size;
+      rassert(scanf("%d %ld %s", &process, &size, buf) == 3);
       rassert(process >= 0 && process < n_processes);
-      rassert(blocks >= 0);
+      rassert(size >= 0);
       bool success;
       if (strcmp(buf, "false") == 0)
         success = false;
@@ -71,12 +72,13 @@ int main(int argc, char **argv) {
       else
         rassert(false);
       printf(
-        "alloc %d %d %s\n",
+        "alloc %d %ld %s\n",
         process,
-        blocks,
+        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);
       printf(
         "... %s\n",
@@ -105,11 +107,12 @@ int main(int argc, char **argv) {
       }
     }
     else if (strcmp(buf, "realloc") == 0) {
-      int process, old_blocks, blocks;
-      rassert(scanf("%d %d %d %s", &process, &old_blocks, &blocks, buf) == 4);
+      int process;
+      long old_size, size;
+      rassert(scanf("%d %ld %ld %s", &process, &old_size, &size, buf) == 4);
       rassert(process >= 0 && process < n_processes);
-      rassert(old_blocks >= 0);
-      rassert(blocks >= 0);
+      rassert(old_size >= 0);
+      rassert(size >= 0);
       bool success;
       if (strcmp(buf, "false") == 0)
         success = false;
@@ -118,10 +121,10 @@ int main(int argc, char **argv) {
       else
         rassert(false);
       printf(
-        "realloc %d %d %d %s\n",
+        "realloc %d %ld %ld %s\n",
         process,
-        old_blocks,
-        blocks,
+        old_size,
+        size,
         success ? "true" : "false"
       );
       if (processes[process].blocks == -1)
@@ -133,6 +136,7 @@ int main(int argc, char **argv) {
           PER_PROCESS_CORE_ITEM(processes + process).limit ==
             core_base + actual_old_blocks
         );
+        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",
@@ -146,6 +150,7 @@ int main(int argc, char **argv) {
 #else
  printf("old core [%d,%d)\n", core_base, core_base + actual_old_blocks);
 #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);
         printf(
@@ -188,15 +193,17 @@ int main(int argc, char **argv) {
       }
     } 
     else if (strcmp(buf, "free") == 0) {
-      int process, old_blocks;
-      rassert(scanf("%d %d", &process, &old_blocks) == 2);
+      int process;
+      long old_size;
+      rassert(scanf("%d %ld", &process, &old_size) == 2);
       rassert(process >= 0 && process < n_processes);
-      rassert(old_blocks >= 0);
-      printf("free %d %d\n", process, old_blocks);
+      rassert(old_size >= 0);
+      printf("free %d %ld\n", process, old_size);
       if (processes[process].blocks == -1)
         printf("... not allocated, ignore\n");
       else {
         int actual_old_blocks = processes[process].blocks;
+        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",

diff --git a/swap.h b/swap.h
index 9c887ba..384ad49 100644 (file)
--- a/swap.h
+++ b/swap.h
@@ -4,7 +4,7 @@
 #include <stdint.h>
 #include "pool.h"
 
-//#define INDIRECT_SWAP 1
+#define INDIRECT_SWAP 1
 //#define MOVEABLE_SWAP 1
 
 #ifdef MOVEABLE_SWAP