From: Nick Downing Date: Thu, 4 Apr 2019 09:07:11 +0000 (+1100) Subject: Change process.blocks to process.size, do rounding and shifting at each access X-Git-Url: https://git.ndcode.org/public/gitweb.cgi?a=commitdiff_plain;h=c929efbafa68aff39a52b1b2d311c2135b49f44c;p=moveable_pool.git Change process.blocks to process.size, do rounding and shifting at each access --- diff --git a/process.c b/process.c index 7a19a6d..318b791 100644 --- a/process.c +++ b/process.c @@ -65,7 +65,7 @@ static void check_invariants() { #endif } for (int i = 0; i < n_processes; ++i) - if (processes[i].blocks == -1) { + if (processes[i].size == -1L) { #ifdef PREALLOCATE_CORE assert( processes[i].core_item.prev == NULL && @@ -100,9 +100,8 @@ static void check_invariants() { #else assert(processes[i].pool_item.prev && processes[i].pool_item.next); assert( - processes[i].blocks == - processes[i].pool_item.limit - - processes[i].pool_item.base + (int)((processes[i].size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT) == + processes[i].pool_item.limit - processes[i].pool_item.base ); #endif } @@ -123,7 +122,10 @@ static void check_invariants() { int victim_swap_blocks = victim_swap_item.limit - victim_swap_item.base; #endif assert(victim_swap_blocks); - assert(processes[i].blocks == victim_core_blocks + victim_swap_blocks); + assert( + (int)((processes[i].size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT) == + victim_core_blocks + victim_swap_blocks + ); } else { #ifdef PREALLOCATE_SWAP @@ -136,13 +138,12 @@ static void check_invariants() { #else assert(processes[i].pool_item.prev && processes[i].pool_item.next); assert( - processes[i].blocks == - processes[i].pool_item.limit - - processes[i].pool_item.base + (int)((processes[i].size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT) == + processes[i].pool_item.limit - processes[i].pool_item.base ); #endif } - avail -= processes[i].blocks; + avail -= (int)((processes[i].size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT); } assert(avail == process_avail); } @@ -154,7 +155,7 @@ void process_init(int n, int spare) { n_processes = n; #ifndef NDEBUG for (int i = 0; i < n_processes; ++i) - processes[i].blocks = -1; + processes[i].size = -1L; #endif process_avail = core_avail() + swap_avail() - spare; @@ -230,11 +231,15 @@ static void do_swap_out(int swap_out) { // fully in core, take over only the per-process core item #ifdef PREALLOCATE_CORE - victim_core_blocks = victim->blocks; + victim_core_blocks = + (int)((victim->size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT); #else pool_move_item(&victim->pool_item, &victim_core_item); victim_core_blocks = victim_core_item.limit - victim_core_item.base; - assert(victim_core_blocks == victim->blocks); + assert( + victim_core_blocks == + (int)((victim->size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT) + ); #endif // calculate amount to swap out @@ -294,13 +299,14 @@ static void do_swap_out(int swap_out) { } } -bool process_alloc(struct process *process, int blocks) { - int swap_out; +bool process_alloc(struct process *process, long size) { + int blocks, swap_out; // must not be already allocated - assert(process->blocks == -1); + assert(process->size == -1L); // check blocks + blocks = (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT); if ( process_avail < blocks #if defined(PREALLOCATE_SWAP) && !defined(MOVEABLE_SWAP) @@ -345,29 +351,31 @@ bool process_alloc(struct process *process, int blocks) { process->lru_item.next->prev = &process->lru_item; // track total allocation - process->blocks = blocks; + process->size = size; process_avail -= blocks; check_invariants(); return true; } -bool process_realloc(struct process *process, int blocks) { - int swap_out; +bool process_realloc(struct process *process, long size) { + int blocks, old_blocks, swap_out; // must be already allocated - assert(process->blocks != -1); + assert(process->size != -1L); // must be fully in core assert(process->lru_item.prev != NULL); // check blocks - int blocks_change = blocks - process->blocks; + blocks = (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT); + old_blocks = (int)((process->size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT); + int blocks_change = blocks - old_blocks; if (process_avail < blocks_change) return false; #if defined(PREALLOCATE_SWAP) && !defined(MOVEABLE_SWAP) swap_table_free(&process->swap_item); if (!swap_table_alloc(&process->swap_item, blocks)) { - rassert(swap_table_alloc(&process->swap_item, process->blocks)); + rassert(swap_table_alloc(&process->swap_item, old_blocks)); return false; } #endif @@ -383,7 +391,7 @@ bool process_realloc(struct process *process, int blocks) { if (!core_table_realloc(&PER_PROCESS_CORE_ITEM(process), blocks)) { #if defined(PREALLOCATE_SWAP) && !defined(MOVEABLE_SWAP) swap_table_free(&process->swap_item); - rassert(swap_table_alloc(&process->swap_item, process->blocks)); + rassert(swap_table_alloc(&process->swap_item, old_blocks)); #endif return false; } @@ -410,7 +418,7 @@ bool process_realloc(struct process *process, int blocks) { #endif // track total allocation - process->blocks = blocks; + process->size = size; process_avail -= blocks_change; check_invariants(); return true; @@ -429,7 +437,7 @@ void process_run(struct process *process) { int swap_base, core_base; // must be already allocated - assert(process->blocks != -1); + assert(process->size != -1L); // see whether fully in core if (process->lru_item.prev != NULL) { @@ -453,11 +461,15 @@ void process_run(struct process *process) { if (process != victim) { // fully in swap, take over only the per-process swap item #ifdef PREALLOCATE_SWAP - process_swap_blocks = process->blocks; + process_swap_blocks = + (int)((process->size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT); #else pool_move_item(&process->pool_item, &process_swap_item); process_swap_blocks = process_swap_item.limit - process_swap_item.base; - assert(process_swap_blocks == process->blocks); + assert( + process_swap_blocks == + (int)((process->size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT) + ); #endif // calculate amounts to swap out then in @@ -566,7 +578,7 @@ void process_run(struct process *process) { void process_free(struct process *process) { // must be already allocated - assert(process->blocks != -1); + assert(process->size != -1L); // see whether fully in core, victim, or fully in swap if (process->lru_item.prev != NULL) { @@ -637,9 +649,9 @@ void process_free(struct process *process) { #endif // track total allocation - process_avail += process->blocks; + process_avail += (int)((process->size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT); #ifndef NDEBUG - process->blocks = -1; + process->size = -1L; #endif check_invariants(); } diff --git a/process.h b/process.h index 2d26900..c0228cd 100644 --- a/process.h +++ b/process.h @@ -62,7 +62,7 @@ extern struct process { #if !defined(PREALLOCATE_SWAP) || !defined(PREALLOCATE_CORE) struct pool_item pool_item; #endif - int blocks; // brk level + long size; // brk level } *processes; int n_processes; @@ -83,8 +83,8 @@ extern struct pool_item victim_swap_item; #endif void process_init(int n, int spare); -bool process_alloc(struct process *process, int blocks); -bool process_realloc(struct process *process, int blocks); +bool process_alloc(struct process *process, long size); +bool process_realloc(struct process *process, long size); 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 7551f17..d13ec8a 100644 --- a/process_test_run.c +++ b/process_test_run.c @@ -45,7 +45,7 @@ int main(int argc, char **argv) { #endif process_init(n_processes, spare); for (int i = 0; i < n_processes; ++i) - processes[i].blocks = -1; + processes[i].size = -1L; while (true) { //printf("avail %d %d(%d) %d(%d)\n", process_avail, core_avail(), core_table.avail, swap_avail(), swap_table.avail); @@ -77,9 +77,8 @@ int main(int argc, char **argv) { 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); + rassert(processes[process].size == -1L); + bool result = process_alloc(processes + process, size); printf( "... %s\n", result == success ? @@ -90,10 +89,11 @@ int main(int argc, char **argv) { if (!success) { printf("... undo\n"); process_free(processes + process); - processes[process].blocks = -1; + processes[process].size = -1L; } else { int core_base = PER_PROCESS_CORE_ITEM(processes + process).base; + int blocks = (int)((size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT); assert( PER_PROCESS_CORE_ITEM(processes + process).limit == core_base + blocks @@ -127,11 +127,12 @@ int main(int argc, char **argv) { size, success ? "true" : "false" ); - if (processes[process].blocks == -1) + if (processes[process].size == -1L) printf("... not allocated, ignore\n"); else { int core_base = PER_PROCESS_CORE_ITEM(processes + process).base; - int actual_old_blocks = processes[process].blocks; + int actual_old_blocks = + (int)((processes[process].size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT); rassert( PER_PROCESS_CORE_ITEM(processes + process).limit == core_base + actual_old_blocks @@ -152,7 +153,7 @@ int main(int argc, char **argv) { #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); + bool result = process_realloc(processes + process, size); printf( "... %s\n", result == success ? @@ -185,7 +186,7 @@ int main(int argc, char **argv) { rassert(scanf("%d", &process) == 1); rassert(process >= 0 && process < n_processes); printf("run %d\n", process); - if (processes[process].blocks == -1) + if (processes[process].size == -1L) printf("... not allocated, ignore\n"); else { process_run(processes + process); @@ -199,11 +200,13 @@ int main(int argc, char **argv) { rassert(process >= 0 && process < n_processes); rassert(old_size >= 0); printf("free %d %ld\n", process, old_size); - if (processes[process].blocks == -1) + if (processes[process].size == -1L) printf("... not allocated, ignore\n"); else { - int actual_old_blocks = processes[process].blocks; - int old_blocks = (int)((old_size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT); + int actual_old_blocks = + (int)((processes[process].size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT); + 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", @@ -247,7 +250,7 @@ int main(int argc, char **argv) { ); swap_hash_verify(process, swap_base, 0, swap_blocks); process_free(processes + process); - processes[process].blocks = -1; + processes[process].size = -1L; printf("... ok\n"); } } @@ -258,7 +261,7 @@ int main(int argc, char **argv) { done: printf("final state:\n"); for (int i = 0; i < n_processes; ++i) { - if (processes[i].blocks == -1) + if (processes[i].size == -1L) printf("process %d: not allocated\n", i); else { int swap_base, swap_blocks, core_base, core_blocks; @@ -281,7 +284,10 @@ done: core_base = -1; core_blocks = 0; } - rassert(core_blocks + swap_blocks == processes[i].blocks); + rassert( + core_blocks + swap_blocks == + (int)((processes[i].size + (BLOCK_SIZE - 1)) >> BLOCK_SHIFT) + ); printf( "process %d: core [%d,%d) swap [%d,%d)\n", i,