Change all byte sizes to paras, BLOCK_SIZE to BLOCK_PARAS and so on, make core_block_...

diff --git a/core.c b/core.c
index b203875..09c0627 100644 (file)
--- a/core.c
+++ b/core.c
@@ -17,7 +17,7 @@ static void core_move(struct pool_item *item, int new_base) {
   int base, blocks;
 #ifndef INDIRECT_CORE
   struct process *process;
-  long size;
+  int paras;
 #else /* INDIRECT_CORE */
   int i;
 #endif /* INDIRECT_CORE */
@@ -36,19 +36,19 @@ static void core_move(struct pool_item *item, int new_base) {
   // see if incomplete last block, if so don't copy extra part
   process =
     (struct process *)((char *)item - offsetof(struct process, core_item));
-  size = (long)blocks << BLOCK_SHIFT;
-  if (size > process->size)
-    size = process->size;
+  paras = blocks << BLOCK_PARAS_SHIFT;
+  if (paras > process->paras)
+    paras = process->paras;
 
   // copy by abstract routine
-  core_copy((long)base << BLOCK_SHIFT, (long)new_base << BLOCK_SHIFT, size);
+  core_copy(base << BLOCK_PARAS_SHIFT, new_base << BLOCK_PARAS_SHIFT, paras);
 }
 
 static void core_move_up(struct pool_item *item, int new_limit) {
   int limit, blocks;
-  long limit1, new_limit1, size;
+  int limit1, new_limit1, paras;
   struct process *process;
-  long trim;
+  int trim;
 
   limit = item->limit;
   blocks = limit - item->base;
@@ -61,18 +61,18 @@ static void core_move_up(struct pool_item *item, int new_limit) {
   //);
   assert(new_limit >= limit || new_limit <= limit - blocks);
   // set up transfer parameters
-  limit1 = (long)limit << BLOCK_SHIFT;
-  new_limit1 = (long)new_limit << BLOCK_SHIFT;
-  size = (long)blocks << BLOCK_SHIFT;
+  limit1 = limit << BLOCK_PARAS_SHIFT;
+  new_limit1 = new_limit << BLOCK_PARAS_SHIFT;
+  paras = blocks << BLOCK_PARAS_SHIFT;
 
   // see if incomplete last block, if so don't copy extra part
   process =
     (struct process *)((char *)item - offsetof(struct process, core_item));
-  trim = size - process->size;
+  trim = paras - process->paras;
   if (trim > 0) {
     limit1 -= trim;
     new_limit1 -= trim;
-    size = process->size;
+    paras = process->paras;
 #else /* INDIRECT_CORE */
   for (i = 0; i < blocks; ++i) {
     core_table_mem[new_base + i] = core_table_mem[base + i];
@@ -82,7 +82,7 @@ static void core_move_up(struct pool_item *item, int new_limit) {
 
 #ifndef INDIRECT_CORE
   // copy by abstract routine
-  core_copy_up(limit1, new_limit1, size);
+  core_copy_up(limit1, new_limit1, paras);
 #endif /* ! INDIRECT_CORE */
 }
 

diff --git a/core.h b/core.h
index a596e20..19600b5 100644 (file)
--- a/core.h
+++ b/core.h
@@ -19,8 +19,8 @@ extern struct block_pool core_block_pool;
 void core_init(int n_table);
 
 // abstract
-void core_copy(long src_base, long dest_base, long size);
-void core_copy_up(long src_limit, long dest_limit, long size);
+void core_copy(int src_base, int dest_base, int paras);
+void core_copy_up(int src_limit, int dest_limit, int paras);
 #else /* INDIRECT_CORE */
 void core_init(int n_table, int n_blocks);
 #endif /* INDIRECT_CORE */

diff --git a/process.c b/process.c
index 8ca4ed2..cf15954 100644 (file)
--- a/process.c
+++ b/process.c
@@ -24,7 +24,7 @@ void process_init(int n, int spare) {
   rassert(processes);
   n_processes = n;
   for (i = 0; i < n_processes; ++i)
-    processes[i].size = -1L;
+    processes[i].paras = -1;
 
 #ifndef INDIRECT_CORE
 #ifndef INDIRECT_SWAP
@@ -54,7 +54,7 @@ void process_init(int n, int spare) {
 static bool do_swap_out(int swap_out) {
   int victim_core_blocks;
   int blocks, swap_base, core_base;
-  long size;
+  int paras;
 #ifndef INDIRECT_CORE
 #ifdef INDIRECT_SWAP
   int i, j, core_block, swap_block;
@@ -129,16 +129,16 @@ static bool do_swap_out(int swap_out) {
 #else /* INDIRECT_CORE */
       core_base = victim->core_item.limit - victim_swap_blocks;
 #endif /* INDIRECT_CORE */
-      size = (long)blocks << BLOCK_SHIFT;
+      paras = blocks << BLOCK_PARAS_SHIFT;
 
       // transfer data to swap
 #ifndef INDIRECT_CORE
 #ifndef INDIRECT_SWAP
  printf("write core [%d,%d) to swap [%d,%d)\n", core_base, core_base + blocks, swap_base, swap_base + blocks);
       core_to_swap_copy(
-        (long)core_base << BLOCK_SHIFT,
-        (long)swap_base << BLOCK_SHIFT,
-        size
+        core_base << BLOCK_PARAS_SHIFT,
+        swap_base << BLOCK_PARAS_SHIFT,
+        paras
 #else /* INDIRECT_SWAP */
       rassert(
         block_pool_alloc(&swap_block_pool, swap_table_mem + swap_base, blocks)
@@ -146,7 +146,7 @@ static bool do_swap_out(int swap_out) {
       );
 #ifdef INDIRECT_SWAP
  printf("write core [%d,%d) to swap [%d,%d)\n", core_base, core_base + blocks, swap_base, swap_base + blocks);
-      j = (int)(size >> BLOCK_SHIFT);
+      j = paras >> BLOCK_PARAS_SHIFT;
  printf("blocks");
       for (i = 0; i < j; ++i) {
         core_block = core_base + i;
@@ -154,12 +154,12 @@ static bool do_swap_out(int swap_out) {
         swap_block = swap_table_mem[swap_block];
  printf(" %d", swap_block);
         core_to_swap_copy(
-          (long)core_block << BLOCK_SHIFT,
-          (long)swap_block << BLOCK_SHIFT,
-          BLOCK_SIZE
+          core_block << BLOCK_PARAS_SHIFT,
+          swap_block << BLOCK_PARAS_SHIFT,
+          BLOCK_PARAS
         );
       }
-      j = (int)size & (BLOCK_SIZE - 1);
+      j = (int)paras & (BLOCK_PARAS - 1);
       if (j) {
         core_block = core_base + i;
         swap_block = swap_base + i;
@@ -167,8 +167,8 @@ static bool do_swap_out(int swap_out) {
  printf(" %d", swap_block);
  //putchar('*');
         core_to_swap_copy(
-          (long)core_block << BLOCK_SHIFT,
-          (long)swap_block << BLOCK_SHIFT,
+          core_block << BLOCK_PARAS_SHIFT,
+          swap_block << BLOCK_PARAS_SHIFT,
           j
         );
       }
@@ -181,7 +181,7 @@ static bool do_swap_out(int swap_out) {
       );
 #endif /* INDIRECT_SWAP */
  printf("write core [%d,%d) to swap [%d,%d)\n", core_base, core_base + blocks, swap_base, swap_base + blocks);
-      j = (int)(size >> BLOCK_SHIFT);
+      j = paras >> BLOCK_PARAS_SHIFT;
  printf("blocks");
       for (i = 0; i < j; ++i) {
         core_block = core_base + i;
@@ -193,12 +193,12 @@ static bool do_swap_out(int swap_out) {
  printf(",%d", swap_block);
 #endif /* INDIRECT_SWAP */
         core_to_swap_copy(
-          (long)core_block << BLOCK_SHIFT,
-          (long)swap_block << BLOCK_SHIFT,
-          BLOCK_SIZE
+          core_block << BLOCK_PARAS_SHIFT,
+          swap_block << BLOCK_PARAS_SHIFT,
+          BLOCK_PARAS
         );
       }
-      j = (int)size & (BLOCK_SIZE - 1);
+      j = (int)paras & (BLOCK_PARAS - 1);
       if (j) {
         core_block = core_base + i;
         core_block = core_table_mem[core_block];
@@ -210,8 +210,8 @@ static bool do_swap_out(int swap_out) {
 #endif /* INDIRECT_SWAP */
  //putchar('*');
         core_to_swap_copy(
-          (long)core_block << BLOCK_SHIFT,
-          (long)swap_block << BLOCK_SHIFT,
+          core_block << BLOCK_PARAS_SHIFT,
+          swap_block << BLOCK_PARAS_SHIFT,
           j
         );
       }
@@ -252,14 +252,14 @@ static bool do_swap_out(int swap_out) {
   return true;
 }
 
-bool process_alloc(struct process *process, long size) {
+bool process_alloc(struct process *process, int paras) {
   int blocks;
 
   // must not be already allocated
-  assert(process->size == -1L);
+  assert(process->paras == -1);
 
   // check blocks
-  blocks = (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+  blocks = (paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
   if (
     process_avail < blocks ||
     !pool_alloc(
@@ -316,23 +316,23 @@ bool process_alloc(struct process *process, long size) {
   process->lru_item.next->prev = &process->lru_item;
 
   // track total allocation
-  process->size = size;
+  process->paras = paras;
   process_avail -= blocks;
   return true;
 }
 
-bool process_realloc(struct process *process, long size) {
+bool process_realloc(struct process *process, int paras) {
   int blocks, old_blocks, blocks_change;
 
   // must be already allocated
-  assert(process->size != -1L);
+  assert(process->paras != -1);
 
   // must be fully in core
   assert(process->lru_item.prev != NULL);
 
   // check blocks
-  blocks = (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
-  old_blocks = (int)((process->size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+  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;
@@ -418,7 +418,7 @@ bool process_realloc(struct process *process, long size) {
 #endif /* INDIRECT_CORE */
 
   // track total allocation
-  process->size = size;
+  process->paras = paras;
   process_avail -= blocks_change;
   return true;
 }
@@ -426,7 +426,7 @@ bool process_realloc(struct process *process, long size) {
 void process_run(struct process *process) {
   int blocks, process_core_blocks, process_swap_blocks;
   int swap_base, core_base;
-  long size;
+  int paras;
 #ifndef INDIRECT_CORE
 #ifdef INDIRECT_SWAP
   int i, j;
@@ -436,7 +436,7 @@ void process_run(struct process *process) {
 #endif /* INDIRECT_CORE */
 
   // must be already allocated
-  assert(process->size != -1L);
+  assert(process->paras != -1);
 
   // see whether fully in core
   if (process->lru_item.prev != NULL) {
@@ -526,7 +526,7 @@ void process_run(struct process *process) {
 #endif /* INDIRECT_CORE */
       process_core_blocks += blocks;
       process_swap_blocks -= blocks;
-      size = (long)blocks << BLOCK_SHIFT;
+      paras = blocks << BLOCK_PARAS_SHIFT;
 
       // transfer data to core
 #ifdef INDIRECT_CORE
@@ -536,12 +536,12 @@ void process_run(struct process *process) {
 #ifndef INDIRECT_CORE
 #ifndef INDIRECT_SWAP
       swap_to_core_copy(
-        (long)swap_base << BLOCK_SHIFT,
-        (long)core_base << BLOCK_SHIFT,
-        size
+        swap_base << BLOCK_PARAS_SHIFT,
+        core_base << BLOCK_PARAS_SHIFT,
+        paras
       );
 #else /* INDIRECT_SWAP */
-      j = (int)(size >> BLOCK_SHIFT);
+      j = paras >> BLOCK_PARAS_SHIFT;
  printf("blocks");
       for (i = 0; i < j; ++i) {
         int core_block = core_base + i;
@@ -549,20 +549,20 @@ void process_run(struct process *process) {
         swap_block = swap_table_mem[swap_block];
  printf(",%d", swap_block);
         swap_to_core_copy(
-          (long)swap_block << BLOCK_SHIFT,
-          (long)core_block << BLOCK_SHIFT,
-          BLOCK_SIZE
+          swap_block << BLOCK_PARAS_SHIFT,
+          core_block << BLOCK_PARAS_SHIFT,
+          BLOCK_PARAS
         );
       }
-      j = (int)size & (BLOCK_SIZE - 1);
+      j = (int)paras & (BLOCK_PARAS - 1);
       if (j) {
         int core_block = core_base + i;
         int swap_block = swap_base + i;
         swap_block = swap_table_mem[swap_block];
  printf(",%d", swap_block);
         swap_to_core_copy(
-          (long)swap_block << BLOCK_SHIFT,
-          (long)core_block << BLOCK_SHIFT,
+          swap_block << BLOCK_PARAS_SHIFT,
+          core_block << BLOCK_PARAS_SHIFT,
           j
         );
       }
@@ -570,7 +570,7 @@ void process_run(struct process *process) {
       block_pool_free(&swap_block_pool, swap_table_mem + swap_base, blocks);
 #endif /* INDIRECT_SWAP */
 #else /* INDIRECT_CORE */
-      j = (int)(size >> BLOCK_SHIFT);
+      j = paras >> BLOCK_PARAS_SHIFT;
  printf("blocks");
       for (i = 0; i < j; ++i) {
         int core_block = core_base + i;
@@ -582,12 +582,12 @@ void process_run(struct process *process) {
  printf(",%d", swap_block);
 #endif /* INDIRECT_SWAP */
         swap_to_core_copy(
-          (long)swap_block << BLOCK_SHIFT,
-          (long)core_block << BLOCK_SHIFT,
-          BLOCK_SIZE
+          swap_block << BLOCK_PARAS_SHIFT,
+          core_block << BLOCK_PARAS_SHIFT,
+          BLOCK_PARAS
         );
       }
-      j = (int)size & (BLOCK_SIZE - 1);
+      j = (int)paras & (BLOCK_PARAS - 1);
       if (j) {
         int core_block = core_base + i;
         core_block = core_table_mem[core_block];
@@ -598,8 +598,8 @@ void process_run(struct process *process) {
  printf(",%d", swap_block);
 #endif /* INDIRECT_SWAP */
         swap_to_core_copy(
-          (long)swap_block << BLOCK_SHIFT,
-          (long)core_block << BLOCK_SHIFT,
+          swap_block << BLOCK_PARAS_SHIFT,
+          core_block << BLOCK_PARAS_SHIFT,
           j
         );
       }
@@ -632,7 +632,7 @@ void process_free(struct process *process) {
 #endif /* INDIRECT_CORE */
 
   // must be already allocated
-  assert(process->size != -1L);
+  assert(process->paras != -1);
 
   // see whether fully in core, victim, or fully in swap
   if (process->lru_item.prev != NULL) {
@@ -694,6 +694,6 @@ void process_free(struct process *process) {
   pool_free(&swap_table, &process->swap_item);
 
   // track total allocation
-  process_avail += (int)((process->size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
-  process->size = -1L;
+  process_avail += (process->paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
+  process->paras = -1;
 }

diff --git a/process.h b/process.h
index 40df765..b934ce2 100644 (file)
--- a/process.h
+++ b/process.h
@@ -1,8 +1,18 @@
 #ifndef _PROCESS_H
 #define _PROCESS_H 1
 
-#define BLOCK_SIZE 0x1000
-#define BLOCK_SHIFT 12
+#define PARA_SHIFT 8
+#define BLOCK_SHIFT 9
+//#define PAGE_SHIFT 12
+
+#define BLOCK_PARAS_SHIFT (BLOCK_SHIFT - PARA_SHIFT)
+#define BLOCK_PARAS (1 << BLOCK_PARAS_SHIFT)
+
+//#define PAGE_PARAS_SHIFT (PAGE_SHIFT - PARA_SHIFT)
+//#define PAGE_PARAS (1 << PAGE_PARAS_SHIFT)
+
+//#define PAGE_BLOCKS_SHIFT (PAGE_SHIFT - BLOCK_SHIFT)
+//#define PAGE_BLOCKS (1 << PAGE_BLOCKS_SHIFT)
 
 #include "pool.h"
 
@@ -15,7 +25,7 @@ extern struct process {
   struct lru_item lru_item; // must be first
   struct pool_item core_item;
   struct pool_item swap_item;
-  long size; // brk level
+  int paras; // brk level
 } *processes;
 int n_processes;
 
@@ -27,13 +37,13 @@ extern struct process *victim;
 extern int victim_swap_blocks;
 
 void process_init(int n, int spare);
-bool process_alloc(struct process *process, long size);
-bool process_realloc(struct process *process, long size);
+bool process_alloc(struct process *process, int paras);
+bool process_realloc(struct process *process, int paras);
 void process_run(struct process *process);
 void process_free(struct process *process);
 
 // abstract
-void core_to_swap_copy(long src_base, long dest_base, long size);
-void swap_to_core_copy(long src_base, long dest_base, long size);
+void core_to_swap_copy(int src_base, int dest_base, int paras);
+void swap_to_core_copy(int src_base, int dest_base, int paras);
 
 #endif

diff --git a/process_test.h b/process_test.h
index 5adbfd1..4f87de1 100644 (file)
--- a/process_test.h
+++ b/process_test.h
@@ -11,8 +11,8 @@
 struct process_test {
   int type;
   int process;
-  long old_size;
-  long size;
+  int old_paras;
+  int paras;
   bool success;
 };
 

diff --git a/process_test_gen.c b/process_test_gen.c
index 6f73620..ded7f88 100644 (file)
--- a/process_test_gen.c
+++ b/process_test_gen.c
@@ -9,20 +9,14 @@
 #include "process_test.h"
 #include "rassert.h"
 
-#ifdef __FUZIX__
-#define BLOCK_SIZE 0x10
-#define BLOCK_SHIFT 4
-#else
-#define BLOCK_SIZE 0x1000
-#define BLOCK_SHIFT 12
-#endif
+#define PARA_SHIFT 8
+#define BLOCK_SHIFT 9
+//#define PAGE_SHIFT 12
 
-int rand_int(int n) {
-  assert(sizeof(long) > sizeof(int));
-  return (int)((long)rand() * n / (RAND_MAX + 1L));
-}
+#define BLOCK_PARAS_SHIFT (BLOCK_SHIFT - PARA_SHIFT)
+#define BLOCK_PARAS (1 << BLOCK_PARAS_SHIFT)
 
-long rand_long(long n) {
+int rand_int(int n) {
   assert(sizeof(long) > sizeof(int));
   return (int)((long)rand() * n / (RAND_MAX + 1L));
 }
@@ -38,11 +32,11 @@ int main(int argc, char **argv) {
   int process_blocks = atoi(argv[4]);
   int seed = argc >= 6 ? atoi(argv[5]) : 1;
 
-  long process_size = (long)process_blocks << BLOCK_SHIFT;
+  int process_paras = process_blocks << BLOCK_PARAS_SHIFT;
 
-  int *processes = malloc(n_processes * sizeof(long));
+  int *processes = malloc(n_processes * sizeof(int));
   rassert(processes);
-  memset(processes, -1, n_processes * sizeof(long));
+  memset(processes, -1, n_processes * sizeof(int));
 
   srand(seed);
   int pool_used = 0;
@@ -53,10 +47,10 @@ int main(int argc, char **argv) {
 #endif
 
     test.process = rand_int(n_processes);
-    test.old_size = processes[test.process];
-    if (test.old_size == -1L) {
-      test.size = rand_long(process_size + 1);
-      int blocks = (int)((test.size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+    test.old_paras = processes[test.process];
+    if (test.old_paras == -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;
 
 #ifdef __FUZIX__
@@ -64,20 +58,20 @@ int main(int argc, char **argv) {
       write(1, &test, sizeof(test));
 #else
       printf(
-        "alloc %d %ld %s\n",
+        "alloc %d %d %s\n",
         test.process,
-        test.size,
+        test.paras,
         test.success ? "true" : "false"
       );
 #endif
 
       if (test.success) {
-        processes[test.process] = test.size;
+        processes[test.process] = test.paras;
         pool_used += blocks;
       }
     }
     else {
-      int old_blocks = (int)((test.old_size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+      int old_blocks = (test.old_paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
       if (rand_int(64)) {
 #ifdef __FUZIX__
         test.type = PROCESS_TEST_TYPE_RUN;
@@ -87,8 +81,8 @@ int main(int argc, char **argv) {
 #endif
 
         if (rand_int(8) == 0) {
-          test.size = rand_long(process_size + 1);
-          int blocks = (int)((test.size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+          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;
 
 #ifdef __FUZIX__
@@ -96,16 +90,16 @@ int main(int argc, char **argv) {
           write(1, &test, sizeof(test));
 #else
           printf(
-            "realloc %d %ld %ld %s\n",
+            "realloc %d %d %d %s\n",
             test.process,
-            test.old_size,
-            test.size,
+            test.old_paras,
+            test.paras,
             test.success ? "true" : "false"
           );
 #endif
 
           if (test.success) {
-            processes[test.process] = test.size;
+            processes[test.process] = test.paras;
             pool_used += blocks - old_blocks;
           }
         }
@@ -115,7 +109,7 @@ int main(int argc, char **argv) {
         test.type = PROCESS_TEST_TYPE_FREE;
         write(1, &test, sizeof(test));
 #else
-        printf("free %d %ld\n", test.process, test.old_size);
+        printf("free %d %d\n", test.process, test.old_paras);
 #endif
         processes[test.process] = -1;
         pool_used -= old_blocks;

diff --git a/process_test_run.c b/process_test_run.c
index c271192..f538469 100644 (file)
--- a/process_test_run.c
+++ b/process_test_run.c
@@ -15,125 +15,129 @@
 
 #define TRANSFER_SIZE 0x8000
 
-uint8_t *core_block_mem;
-uint8_t *swap_block_mem;
+int *core_block_mem;
+int *swap_block_mem;
 
-void core_hash_init(int process, long base, long size, long offset) {
-  long i, addr;
+void core_hash_init(int process, int base, int paras, int offset) {
+  int i, addr;
 
- //printf("core_hash_init %d %ld(%d) %ld(%d) %ld(%d)\n", process, base, (int)(base >> BLOCK_SHIFT), size, (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT), offset, (int)(offset >> BLOCK_SHIFT));
-  for (i = 0L; i < size; ++i) {
+ //printf("core_hash_init %d %d(%d) %d(%d) %d(%d)\n", process, base, base >> BLOCK_PARAS_SHIFT, paras, (paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT, offset, offset >> BLOCK_PARAS_SHIFT);
+  for (i = 0; i < paras; ++i) {
     addr = base + i;
 #ifdef INDIRECT_CORE
     addr =
-      (core_table_mem[addr >> BLOCK_SHIFT] << BLOCK_SHIFT) |
-      (addr & (BLOCK_SIZE - 1));
+      (core_table_mem[addr >> BLOCK_PARAS_SHIFT] << BLOCK_PARAS_SHIFT) |
+      (addr & (BLOCK_PARAS - 1));
 #endif /* INDIRECT_CORE */
-    rassert(core_block_mem[addr] == 0xaa);
-    core_block_mem[addr] = (uint8_t)(process * 17 + (i + offset) * 29);
+    rassert(core_block_mem[addr] == 0xaaaaaaaa);
+    core_block_mem[addr] = process * 17 + (i + offset) * 29;
   }
 }
 
-void core_hash_verify(int process, long base, long size, long offset) {
-  long i, addr;
+void core_hash_verify(int process, int base, int paras, int offset) {
+  int i, addr;
 
- //printf("core_hash_verify %d %ld(%d) %ld(%d) %ld(%d)\n", process, base, (int)(base >> BLOCK_SHIFT), size, (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT), offset, (int)(offset >> BLOCK_SHIFT));
-  for (i = 0L; i < size; ++i) {
+ //printf("core_hash_verify %d %d(%d) %d(%d) %d(%d)\n", process, base, base >> BLOCK_PARAS_SHIFT, paras, (paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT, offset, offset >> BLOCK_PARAS_SHIFT);
+  for (i = 0; i < paras; ++i) {
     addr = base + i;
 #ifdef INDIRECT_CORE
     addr =
-      (core_table_mem[addr >> BLOCK_SHIFT] << BLOCK_SHIFT) |
-      (addr & (BLOCK_SIZE - 1));
+      (core_table_mem[addr >> BLOCK_PARAS_SHIFT] << BLOCK_PARAS_SHIFT) |
+      (addr & (BLOCK_PARAS - 1));
 #endif /* INDIRECT_CORE */
-    rassert(
-      core_block_mem[addr] == (uint8_t)(process * 17 + (i + offset) * 29)
-    );
-    core_block_mem[addr] = 0xaa;
+    rassert(core_block_mem[addr] == process * 17 + (i + offset) * 29);
+    core_block_mem[addr] = 0xaaaaaaaa;
   }
 }
 
-void swap_hash_verify(int process, long base, long size, long offset) {
-  long i, addr;
+void swap_hash_verify(int process, int base, int paras, int offset) {
+  int i, addr;
 
- //printf("swap_hash_verify %d %ld(%d) %ld(%d) %ld(%d)\n", process, base, (int)(base >> BLOCK_SHIFT), size, (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT), offset, (int)(offset >> BLOCK_SHIFT));
-  for (i = 0L; i < size; ++i) {
+ //printf("swap_hash_verify %d %d(%d) %d(%d) %d(%d)\n", process, base, base >> BLOCK_PARAS_SHIFT, paras, (paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT, offset, offset >> BLOCK_PARAS_SHIFT);
+  for (i = 0; i < paras; ++i) {
     addr = base + i;
 #ifdef INDIRECT_SWAP
     addr =
-      (swap_table_mem[addr >> BLOCK_SHIFT] << BLOCK_SHIFT) |
-      (addr & (BLOCK_SIZE - 1));
+      (swap_table_mem[addr >> BLOCK_PARAS_SHIFT] << BLOCK_PARAS_SHIFT) |
+      (addr & (BLOCK_PARAS - 1));
 #endif /* INDIRECT_SWAP */
-    rassert(
-      swap_block_mem[addr] == (uint8_t)(process * 17 + (i + offset) * 29)
-    );
-    swap_block_mem[addr] = 0xaa;
+    rassert(swap_block_mem[addr] == process * 17 + (i + offset) * 29);
+    swap_block_mem[addr] = 0xaaaaaaaa;
   }
 }
 
 #ifndef INDIRECT_CORE
-void core_copy(long src_base, long dest_base, long size) {
-  long i;
+void core_copy(int src_base, int dest_base, int paras) {
+  int i;
 
- //printf("core_copy %ld(%d) %ld(%d) %ld(%d)\n", src_base, (int)(src_base >> BLOCK_SHIFT), dest_base, (int)(dest_base >> BLOCK_SHIFT), size, (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT));
-  for (i = 0L; i < size; ++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);
+  for (i = 0; i < paras; ++i) {
     core_block_mem[dest_base + i] = core_block_mem[src_base + i];
-    core_block_mem[src_base + i] = 0xaa;
+    core_block_mem[src_base + i] = 0xaaaaaaaa;
   }
 }
 
-void core_copy_up(long src_limit, long dest_limit, long size) {
-  long i;
+void core_copy_up(int src_limit, int dest_limit, int paras) {
+  int i;
 
- //printf("core_copy_up %ld(%d) %ld(%d) %ld(%d)\n", src_limit, (int)(src_limit >> BLOCK_SHIFT), dest_limit, (int)(dest_limit >> BLOCK_SHIFT), size, (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT));
-  size = -size;
-  for (i = -1L; i >= size; --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);
+  paras = -paras;
+  for (i = -1; i >= paras; --i) {
     core_block_mem[dest_limit + i] = core_block_mem[src_limit + i];
-    core_block_mem[src_limit + i] = 0xaa;
+    core_block_mem[src_limit + i] = 0xaaaaaaaa;
   }
 }
 #endif /* ! INDIRECT_CORE */
 
 #ifndef INDIRECT_SWAP
-void swap_copy(long src_base, long dest_base, long size) {
-  long i;
+void swap_copy(int src_base, int dest_base, int paras) {
+  int i;
 
- //printf("swap_copy %ld(%d) %ld(%d) %ld(%d)\n", src_base, (int)(src_base >> BLOCK_SHIFT), dest_base, (int)(dest_base >> BLOCK_SHIFT), size, (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT));
-  for (i = 0; i < size; ++i) {
+ //printf("swap_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) {
     swap_block_mem[dest_base + i] = swap_block_mem[src_base + i];
-    swap_block_mem[src_base + i] = 0xaa;
+    swap_block_mem[src_base + i] = 0xaaaaaaaa;
   }
 }
 
-void swap_copy_up(long src_limit, long dest_limit, long size) {
-  long i;
+void swap_copy_up(int src_limit, int dest_limit, int paras) {
+  int i;
 
- //printf("swap_copy_up %ld(%d) %ld(%d) %ld(%d)\n", src_limit, (int)(src_limit >> BLOCK_SHIFT), dest_limit, (int)(dest_limit >> BLOCK_SHIFT), size, (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT));
-  size = -size;
-  for (i = -1; i >= size; --i) {
+ //printf("swap_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) {
     swap_block_mem[dest_limit + i] = swap_block_mem[src_limit + i];
-    swap_block_mem[src_limit + i] = 0xaa;
+    swap_block_mem[src_limit + i] = 0xaaaaaaaa;
   }
 }
 #endif /* ! INDIRECT_SWAP */
 
-void core_to_swap_copy(long src_base, long dest_base, long size) {
-  long i;
+void core_to_swap_copy(int src_base, int dest_base, int paras) {
+  int i;
 
- //printf("core_to_swap_copy %ld(%d) %ld(%d) %ld(%d)\n", src_base, (int)(src_base >> BLOCK_SHIFT), dest_base, (int)(dest_base >> BLOCK_SHIFT), size, (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT));
-  for (i = 0; i < size; ++i)
-    rassert(swap_block_mem[dest_base + i] == 0xaa);
-  memcpy(swap_block_mem + dest_base, core_block_mem + src_base, size);
-  memset(core_block_mem + src_base, 0xaa, size);
+ //printf("core_to_swap_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)
+    rassert(swap_block_mem[dest_base + i] == 0xaaaaaaaa);
+  memcpy(
+    swap_block_mem + dest_base,
+    core_block_mem + src_base,
+    paras * sizeof(int)
+  );
+  memset(core_block_mem + src_base, 0xaa, paras * sizeof(int));
 }
 
-void swap_to_core_copy(long src_base, long dest_base, long size) {
-  long i;
+void swap_to_core_copy(int src_base, int dest_base, int paras) {
+  int i;
 
- //printf("swap_to_core_copy %ld(%d) %ld(%d) %ld(%d)\n", src_base, (int)(src_base >> BLOCK_SHIFT), dest_base, (int)(dest_base >> BLOCK_SHIFT), size, (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT));
-  for (i = 0; i < size; ++i)
-    rassert(core_block_mem[dest_base + i] == 0xaa);
-  memcpy(core_block_mem + dest_base, swap_block_mem + src_base, size);
-  memset(swap_block_mem + src_base, 0xaa, size);
+ //printf("swap_to_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)
+    rassert(core_block_mem[dest_base + i] == 0xaaaaaaaa);
+  memcpy(
+    core_block_mem + dest_base,
+    swap_block_mem + src_base,
+    paras * sizeof(int)
+  );
+  memset(swap_block_mem + src_base, 0xaa, paras * sizeof(int));
 }
 
 int main(int argc, char **argv) {
@@ -160,12 +164,12 @@ int main(int argc, char **argv) {
   char buf[256];
 #endif
   bool result;
-  long actual_old_size;
+  int actual_old_paras;
   int old_blocks, blocks, actual_old_blocks;
   int swap_base, swap_blocks;
-  long swap_size;
+  int swap_paras;
   int core_base, core_blocks;
-  long core_size;
+  int core_paras;
 
   if (argc < 5) {
     printf(
@@ -208,22 +212,22 @@ int main(int argc, char **argv) {
 #else /* INDIRECT_CORE */
   core_init(n_core_blocks, core_table_blocks);
 #endif /* INDIRECT_CORE */
-  core_block_mem = malloc((long)n_core_blocks << BLOCK_SHIFT);
+  core_block_mem = malloc(n_core_blocks * (BLOCK_PARAS * sizeof(int)));
   rassert(core_block_mem);
-  memset(core_block_mem, 0xaa, (long)n_core_blocks << BLOCK_SHIFT);
+  memset(core_block_mem, 0xaa, n_core_blocks * (BLOCK_PARAS * sizeof(int)));
 
 #ifndef INDIRECT_SWAP
   swap_init(n_swap_blocks);
 #else /* INDIRECT_SWAP */
   swap_init(n_swap_blocks, swap_table_blocks);
 #endif /* INDIRECT_SWAP */
-  swap_block_mem = malloc((long)n_swap_blocks << BLOCK_SHIFT);
+  swap_block_mem = malloc(n_swap_blocks * (BLOCK_PARAS * sizeof(int)));
   rassert(swap_block_mem);
-  memset(swap_block_mem, 0xaa, (long)n_swap_blocks << BLOCK_SHIFT);
+  memset(swap_block_mem, 0xaa, n_swap_blocks * (BLOCK_PARAS * sizeof(int)));
 
   process_init(n_processes, spare);
   for (i = 0; i < n_processes; ++i)
-    processes[i].size = -1L;
+    processes[i].paras = -1;
 
   while (true) {
  //printf("avail %d %d(%d) %d(%d)\n", process_avail, CORE_AVAIL, core_table.avail, SWAP_AVAIL, swap_table.avail);
@@ -243,14 +247,14 @@ int main(int argc, char **argv) {
       test.type = PROCESS_TEST_TYPE_ALLOC;
       rassert(
         scanf(
-          "%d %ld %s",
+          "%d %d %s",
           &test.process,
-          &test.size,
+          &test.paras,
           buf
         ) == 3
       );
       rassert(test.process >= 0 && test.process < n_processes);
-      rassert(test.size >= 0);
+      rassert(test.paras >= 0);
       if (strcmp(buf, "false") == 0)
         test.success = false;
       else if (strcmp(buf, "true") == 0)
@@ -262,16 +266,16 @@ int main(int argc, char **argv) {
       test.type = PROCESS_TEST_TYPE_REALLOC;
       rassert(
         scanf(
-          "%d %ld %ld %s",
+          "%d %d %d %s",
           &test.process,
-          &test.old_size,
-          &test.size,
+          &test.old_paras,
+          &test.paras,
           buf
         ) == 4
       );
       rassert(test.process >= 0 && test.process < n_processes);
-      rassert(test.old_size >= 0);
-      rassert(test.size >= 0);
+      rassert(test.old_paras >= 0);
+      rassert(test.paras >= 0);
       if (strcmp(buf, "false") == 0)
         test.success = false;
       else if (strcmp(buf, "true") == 0)
@@ -286,9 +290,9 @@ int main(int argc, char **argv) {
     }
     else if (strcmp(buf, "free") == 0) {
       test.type = PROCESS_TEST_TYPE_FREE;
-      rassert(scanf("%d %ld", &test.process, &test.old_size) == 2);
+      rassert(scanf("%d %d", &test.process, &test.old_paras) == 2);
       rassert(test.process >= 0 && test.process < n_processes);
-      rassert(test.old_size >= 0);
+      rassert(test.old_paras >= 0);
     }
     else
       rassert(false);
@@ -296,13 +300,13 @@ int main(int argc, char **argv) {
     switch (test.type) {
     case PROCESS_TEST_TYPE_ALLOC:
       printf(
-        "alloc %d %ld %s\n",
+        "alloc %d %d %s\n",
         test.process,
-        test.size,
+        test.paras,
         test.success ? "true" : "false"
       );
-      rassert(processes[test.process].size == -1L);
-      result = process_alloc(processes + test.process, test.size);
+      rassert(processes[test.process].paras == -1);
+      result = process_alloc(processes + test.process, test.paras);
       printf(
         "... %s\n",
         result == test.success ?
@@ -313,11 +317,11 @@ int main(int argc, char **argv) {
         if (!test.success) {
           printf("... undo\n");
           process_free(processes + test.process);
-          processes[test.process].size = -1L;
+          processes[test.process].paras = -1;
         }
         else {
           core_base = processes[test.process].core_item.base;
-          blocks = (int)((test.size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+          blocks = (test.paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
           assert(
             processes[test.process].core_item.limit ==
               core_base + blocks
@@ -325,9 +329,9 @@ int main(int argc, char **argv) {
  printf("new core [%d,%d)\n", core_base, core_base + blocks);
           core_hash_init(
             test.process,
-            (long)core_base << BLOCK_SHIFT,
-            test.size,
-            0L
+            core_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);
         }
@@ -335,24 +339,24 @@ int main(int argc, char **argv) {
       break;
     case PROCESS_TEST_TYPE_REALLOC:
       printf(
-        "realloc %d %ld %ld %s\n",
+        "realloc %d %d %d %s\n",
         test.process,
-        test.old_size,
-        test.size,
+        test.old_paras,
+        test.paras,
         test.success ? "true" : "false"
       );
-      if (processes[test.process].size == -1L)
+      if (processes[test.process].paras == -1)
         printf("... not allocated, ignore\n");
       else {
         core_base = processes[test.process].core_item.base;
-        actual_old_size = processes[test.process].size;
+        actual_old_paras = processes[test.process].paras;
         actual_old_blocks =
-          (int)((actual_old_size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+          (actual_old_paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
         rassert(
           processes[test.process].core_item.limit ==
             core_base + actual_old_blocks
         );
-        old_blocks = (int)((test.old_size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+        old_blocks = (test.old_paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
         if (actual_old_blocks != old_blocks) {
           printf(
             "... old blocks %d, should be %d\n",
@@ -364,11 +368,11 @@ int main(int argc, char **argv) {
  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,
-          ((long)core_base << BLOCK_SHIFT) + test.size,
-          actual_old_size - test.size,
-          test.size
+          (core_base << BLOCK_PARAS_SHIFT) + test.paras,
+          actual_old_paras - test.paras,
+          test.paras
         );
-        result = process_realloc(processes + test.process, test.size);
+        result = process_realloc(processes + test.process, test.paras);
         printf(
           "... %s\n",
           result == test.success ?
@@ -378,11 +382,11 @@ int main(int argc, char **argv) {
         if (result) {
           if (!test.success) {
             printf("... undo\n");
-            rassert(process_realloc(processes + test.process, actual_old_size));
+            rassert(process_realloc(processes + test.process, actual_old_paras));
           }
           else {
             core_base = processes[test.process].core_item.base;
-            blocks = (int)((test.size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+            blocks = (int)((test.paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT);
             rassert(
               processes[test.process].core_item.limit ==
                 core_base + blocks
@@ -390,9 +394,9 @@ int main(int argc, char **argv) {
  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,
-              ((long)core_base << BLOCK_SHIFT) + actual_old_size,
-              test.size - actual_old_size,
-              actual_old_size
+              (core_base << BLOCK_PARAS_SHIFT) + actual_old_paras,
+              test.paras - actual_old_paras,
+              actual_old_paras
             );
           }
         }
@@ -400,7 +404,7 @@ int main(int argc, char **argv) {
       break;
     case PROCESS_TEST_TYPE_RUN:
       printf("run %d\n", test.process);
-      if (processes[test.process].size == -1L)
+      if (processes[test.process].paras == -1)
         printf("... not allocated, ignore\n");
       else {
         process_run(processes + test.process);
@@ -408,14 +412,14 @@ int main(int argc, char **argv) {
       }
       break;
     case PROCESS_TEST_TYPE_FREE:
-      printf("free %d %ld\n", test.process, test.old_size);
-      if (processes[test.process].size == -1L)
+      printf("free %d %d\n", test.process, test.old_paras);
+      if (processes[test.process].paras == -1)
         printf("... not allocated, ignore\n");
       else {
         actual_old_blocks =
-          (int)((processes[test.process].size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+          (processes[test.process].paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
         old_blocks =
-          (int)((test.old_size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT);
+          (test.old_paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT;
         if (actual_old_blocks != old_blocks) {
           printf(
             "... old blocks %d, should be %d\n",
@@ -428,10 +432,10 @@ int main(int argc, char **argv) {
           assert(processes + test.process != victim);
           core_base = processes[test.process].core_item.base;
           core_blocks = processes[test.process].core_item.limit - core_base;
-          core_size = processes[test.process].size;
+          core_paras = processes[test.process].paras;
           swap_base = -1;
           swap_blocks = 0;
-          swap_size = 0L;
+          swap_paras = 0;
         }
         else {
           if (processes + test.process == victim) { // victim
@@ -441,18 +445,18 @@ int main(int argc, char **argv) {
 #else /* INDIRECT_CORE */
             core_blocks = victim->core_item.limit - core_base - victim_swap_blocks;
 #endif /* INDIRECT_CORE */
-            core_size = core_blocks << BLOCK_SHIFT;
+            core_paras = core_blocks << BLOCK_PARAS_SHIFT;
             swap_base = victim->swap_item.limit - victim_swap_blocks;
             swap_blocks = victim_swap_blocks;
-            swap_size = victim->size - core_size;
+            swap_paras = victim->paras - core_paras;
           }
           else { // fully in swap
             core_base = -1;
             core_blocks = 0;
-            core_size = 0L;
+            core_paras = 0;
             swap_base = processes[test.process].swap_item.base;
             swap_blocks = processes[test.process].swap_item.limit - swap_base;
-            swap_size = processes[test.process].size;
+            swap_paras = processes[test.process].paras;
           }
         }
         rassert(core_blocks + swap_blocks == actual_old_blocks);
@@ -460,18 +464,18 @@ int main(int argc, char **argv) {
  fflush(stdout);
         core_hash_verify(
           test.process,
-          (long)core_base << BLOCK_SHIFT,
-          core_size,
+          core_base << BLOCK_PARAS_SHIFT,
+          core_paras,
           0 
         );
         swap_hash_verify(
           test.process,
-          (long)swap_base << BLOCK_SHIFT,
-          swap_size,
-          core_size
+          swap_base << BLOCK_PARAS_SHIFT,
+          swap_paras,
+          core_paras
         );
         process_free(processes + test.process);
-        processes[test.process].size = -1L;
+        processes[test.process].paras = -1;
         printf("... ok\n");
       }
       break;
@@ -483,17 +487,17 @@ done:
 #endif
   printf("final state:\n");
   for (i = 0; i < n_processes; ++i) {
-    if (processes[i].size == -1L)
+    if (processes[i].paras == -1)
       printf("process %d: not allocated\n", i);
     else {
       if (processes[i].lru_item.prev != NULL) { // fully in core
         assert(processes + i != victim);
         core_base = processes[i].core_item.base;
         core_blocks = processes[i].core_item.limit - core_base;
-        core_size = processes[i].size;
+        core_paras = processes[i].paras;
         swap_base = -1;
         swap_blocks = 0;
-        swap_size = 0L;
+        swap_paras = 0;
       }
       else {
         if (processes + i == victim) { // victim
@@ -503,23 +507,23 @@ done:
 #else /* INDIRECT_CORE */
           core_blocks = victim->core_item.limit - core_base - victim_swap_blocks;
 #endif /* INDIRECT_CORE */
-          core_size = core_blocks << BLOCK_SHIFT;
+          core_paras = core_blocks << BLOCK_PARAS_SHIFT;
           swap_base = victim->swap_item.limit - victim_swap_blocks;
           swap_blocks = victim_swap_blocks;
-          swap_size = victim->size - core_size;
+          swap_paras = victim->paras - core_paras;
         }
         else { // fully in swap
           core_base = -1;
           core_blocks = 0;
-          core_size = 0L;
+          core_paras = 0;
           swap_base = processes[i].swap_item.base;
           swap_blocks = processes[i].swap_item.limit - swap_base;
-          swap_size = processes[i].size;
+          swap_paras = processes[i].paras;
         }
       }
       rassert(
         core_blocks + swap_blocks ==
-          (int)((processes[i].size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT)
+          (processes[i].paras + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT
       );
       printf(
         "process %d: core [%d,%d) swap [%d,%d)\n",
@@ -531,8 +535,8 @@ done:
       );
       core_hash_verify(
         i,
-        (long)core_base << BLOCK_SHIFT,
-        core_size,
+        core_base << BLOCK_PARAS_SHIFT,
+        core_paras,
         0
       );
 #ifdef INDIRECT_CORE
@@ -544,9 +548,9 @@ done:
 #endif /* INDIRECT_CORE */
       swap_hash_verify(
         i,
-        (long)swap_base << BLOCK_SHIFT,
-        swap_size,
-        core_size
+        swap_base << BLOCK_PARAS_SHIFT,
+        swap_paras,
+        core_paras
       );
 #ifdef INDIRECT_SWAP
       block_pool_free(
@@ -570,9 +574,9 @@ done:
       rassert(core_block_pool.bitmap[j] == (uint8_t)~(-1 << k));
   }
 #endif /* INDIRECT_CORE */
-  j = n_core_blocks << BLOCK_SHIFT;
+  j = n_core_blocks << BLOCK_PARAS_SHIFT;
   for (i = 0; i < j; ++i)
-    rassert(core_block_mem[i] == 0xaa);
+    rassert(core_block_mem[i] == 0xaaaaaaaa);
 #ifdef INDIRECT_SWAP
   for (i = 0; i < swap_table_blocks; ++i)
     rassert(swap_table_mem[i] == 0x55555555);
@@ -585,9 +589,9 @@ done:
       rassert(swap_block_pool.bitmap[j] == (uint8_t)~(-1 << k));
   }
 #endif /* INDIRECT_SWAP */
-  j = n_swap_blocks << BLOCK_SHIFT;
+  j = n_swap_blocks << BLOCK_PARAS_SHIFT;
   for (i = 0; i < j; ++i)
-    rassert(swap_block_mem[i] == 0xaa);
+    rassert(swap_block_mem[i] == 0xaaaaaaaa);
 
   return 0;
 }

diff --git a/swap.c b/swap.c
index a0d3573..e3a3797 100644 (file)
--- a/swap.c
+++ b/swap.c
@@ -17,7 +17,7 @@ static void swap_move(struct pool_item *item, int new_base) {
   int base, blocks;
 #ifndef INDIRECT_SWAP
   struct process *process;
-  long size;
+  int paras;
 #else /* INDIRECT_SWAP */
   int i;
 #endif /* INDIRECT_SWAP */
@@ -36,12 +36,12 @@ static void swap_move(struct pool_item *item, int new_base) {
   // see if incomplete last block, if so don't copy extra part
   process =
     (struct process *)((char *)item - offsetof(struct process, swap_item));
-  size = (long)blocks << BLOCK_SHIFT;
-  if (size > process->size)
-    size = process->size;
+  paras = blocks << BLOCK_PARAS_SHIFT;
+  if (paras > process->paras)
+    paras = process->paras;
 
   // copy by abstract routine
-  swap_copy((long)base << BLOCK_SHIFT, (long)new_base << BLOCK_SHIFT, size);
+  swap_copy(base << BLOCK_PARAS_SHIFT, new_base << BLOCK_PARAS_SHIFT, paras);
 #else /* INDIRECT_SWAP */
   for (i = 0; i < blocks; ++i) {
     swap_table_mem[new_base + i] = swap_table_mem[base + i];

diff --git a/swap.h b/swap.h
index 11ed669..9b9a640 100644 (file)
--- a/swap.h
+++ b/swap.h
@@ -19,8 +19,8 @@ extern struct block_pool swap_block_pool;
 void swap_init(int n_table);
 
 // abstract
-void swap_copy(long src_base, long dest_base, long size);
-void swap_copy_up(long src_limit, long dest_limit, long size);
+void swap_copy(int src_base, int dest_base, int paras);
+void swap_copy_up(int src_limit, int dest_limit, int paras);
 #else /* INDIRECT_SWAP */
 void swap_init(int n_table, int n_blocks);
 #endif /* INDIRECT_SWAP */