struct process *victim;
#ifdef PREALLOCATE_CORE
-int victim_core_size;
+int victim_core_blocks;
#else
struct pool_item victim_core_item;
#endif
#ifdef PREALLOCATE_SWAP
-int victim_swap_size;
+int victim_swap_blocks;
#else
struct pool_item victim_swap_item;
#endif
#endif
if (victim == NULL) {
#ifdef PREALLOCATE_CORE
- assert(victim_core_size == 0);
+ assert(victim_core_blocks == 0);
#else
assert(victim_core_item.prev == NULL && victim_core_item.next == NULL);
#endif
#ifdef PREALLOCATE_SWAP
- assert(victim_swap_size == 0);
+ assert(victim_swap_blocks == 0);
#else
assert(victim_swap_item.prev == NULL && victim_swap_item.prev == NULL);
#endif
}
for (int i = 0; i < n_processes; ++i)
- if (processes[i].size == -1) {
+ if (processes[i].blocks == -1) {
#ifdef PREALLOCATE_CORE
assert(
processes[i].core_item.prev == NULL &&
#else
assert(processes[i].pool_item.prev && processes[i].pool_item.next);
assert(
- processes[i].size ==
+ processes[i].blocks ==
processes[i].pool_item.limit -
processes[i].pool_item.base
);
#endif
#ifndef PREALLOCATE_CORE
assert(victim_core_item.prev && victim_core_item.next);
- int victim_core_size = victim_core_item.limit - victim_core_item.base;
+ int victim_core_blocks = victim_core_item.limit - victim_core_item.base;
#endif
- assert(victim_core_size);
+ assert(victim_core_blocks);
#ifndef PREALLOCATE_SWAP
assert(victim_swap_item.prev && victim_swap_item.next);
- int victim_swap_size = victim_swap_item.limit - victim_swap_item.base;
+ int victim_swap_blocks = victim_swap_item.limit - victim_swap_item.base;
#endif
- assert(victim_swap_size);
- assert(processes[i].size == victim_core_size + victim_swap_size);
+ assert(victim_swap_blocks);
+ assert(processes[i].blocks == victim_core_blocks + victim_swap_blocks);
}
else {
#ifdef PREALLOCATE_SWAP
#else
assert(processes[i].pool_item.prev && processes[i].pool_item.next);
assert(
- processes[i].size ==
+ processes[i].blocks ==
processes[i].pool_item.limit -
processes[i].pool_item.base
);
#endif
}
- avail -= processes[i].size;
+ avail -= processes[i].blocks;
}
assert(avail == process_avail);
}
n_processes = n;
#ifndef NDEBUG
for (int i = 0; i < n_processes; ++i)
- processes[i].size = -1;
+ processes[i].blocks = -1;
#endif
process_avail = core_avail() + swap_avail() - spare;
victim = NULL;
#ifndef NDEBUG
#ifdef PREALLOCATE_CORE
- victim_core_size = 0;
+ victim_core_blocks = 0;
#else
memset(&victim_core_item, 0, sizeof(victim_core_item));
#endif
#ifdef PREALLOCATE_SWAP
- victim_swap_size = 0;
+ victim_swap_blocks = 0;
#else
memset(&victim_swap_item, 0, sizeof(victim_swap_item));
#endif
static void do_swap_out(int swap_out) {
#ifndef PREALLOCATE_CORE
- int victim_core_size;
+ int victim_core_blocks;
#endif
#ifndef PREALLOCATE_SWAP
- int victim_swap_size;
+ int victim_swap_blocks;
#endif
- int size, swap_base, core_base;
+ int blocks, swap_base, core_base;
// loop entry code for the case of an existing victim
if (swap_out > 0) {
if (victim) {
// calculate amount to swap out
#ifndef PREALLOCATE_CORE
- victim_core_size = victim_core_item.limit - victim_core_item.base;
+ victim_core_blocks = victim_core_item.limit - victim_core_item.base;
#endif
#ifndef PREALLOCATE_SWAP
- victim_swap_size = victim_swap_item.limit - victim_swap_item.base;
+ victim_swap_blocks = victim_swap_item.limit - victim_swap_item.base;
#endif
- size = swap_out < victim_core_size ? swap_out : victim_core_size;
- printf("existing victim %d, swap out %d of %d\n", (int)(victim - processes), size, victim_core_size);
+ blocks = swap_out < victim_core_blocks ? swap_out : victim_core_blocks;
+ printf("existing victim %d, swap out %d of %d\n", (int)(victim - processes), blocks, victim_core_blocks);
// increase swap allocation
- victim_swap_size += size;
+ victim_swap_blocks += blocks;
#ifndef PREALLOCATE_SWAP
- rassert(swap_table_realloc(&victim_swap_item, victim_swap_size));
+ rassert(swap_table_realloc(&victim_swap_item, victim_swap_blocks));
#endif
goto loop_entry;
}
// fully in core, take over only the per-process core item
#ifdef PREALLOCATE_CORE
- victim_core_size = victim->size;
+ victim_core_blocks = victim->blocks;
#else
pool_move_item(&victim->pool_item, &victim_core_item);
- victim_core_size = victim_core_item.limit - victim_core_item.base;
- assert(victim_core_size == victim->size);
+ victim_core_blocks = victim_core_item.limit - victim_core_item.base;
+ assert(victim_core_blocks == victim->blocks);
#endif
// calculate amount to swap out
- size = swap_out < victim_core_size ? swap_out : victim_core_size;
- printf("new victim %d, swap out %d of %d\n", (int)(victim - processes), size, victim_core_size);
+ blocks = swap_out < victim_core_blocks ? swap_out : victim_core_blocks;
+ printf("new victim %d, swap out %d of %d\n", (int)(victim - processes), blocks, victim_core_blocks);
// add to swap pool, using dedicated swap item
- victim_swap_size = size;
+ victim_swap_blocks = blocks;
#ifndef PREALLOCATE_SWAP
- rassert(swap_table_alloc(&victim_swap_item, victim_swap_size));
+ rassert(swap_table_alloc(&victim_swap_item, victim_swap_blocks));
#endif
loop_entry:
// transfer data to swap
- swap_base = DEDICATED_SWAP_LIMIT(victim, victim_swap_size) - size;
- core_base = DEDICATED_CORE_BASE(victim, victim_swap_size - size);
+ swap_base = DEDICATED_SWAP_LIMIT(victim, victim_swap_blocks) - blocks;
+ core_base = DEDICATED_CORE_BASE(victim, victim_swap_blocks - blocks);
#ifdef INDIRECT_SWAP
- rassert(swap_block_alloc(swap_table_mem + swap_base, size));
+ rassert(swap_block_alloc(swap_table_mem + swap_base, blocks));
#endif
- swap_write(swap_base, core_base, size);
+ swap_write(swap_base, core_base, blocks);
#ifdef INDIRECT_CORE
- core_block_free(core_table_mem + core_base, size);
+ core_block_free(core_table_mem + core_base, blocks);
#endif
// see if victim fully swapped out
- victim_core_size -= size;
- if (victim_core_size) {
+ victim_core_blocks -= blocks;
+ if (victim_core_blocks) {
#ifndef PREALLOCATE_CORE
// no, reduce core allocation, using dedicated core item
- rassert(core_table_realloc_base(&victim_core_item, victim_core_size));
+ rassert(core_table_realloc_base(&victim_core_item, victim_core_blocks));
#endif
- // as an optimization, skip the calculation of swap_out -= size
+ // as an optimization, skip the calculation of swap_out -= blocks
return;
}
pool_move_item(&victim_swap_item, &victim->pool_item);
#endif
- swap_out -= size;
+ swap_out -= blocks;
} while (swap_out);
victim = NULL;
#ifdef PREALLOCATE_CORE
- assert(victim_core_size == 0);
+ assert(victim_core_blocks == 0);
#endif
#ifdef PREALLOCATE_SWAP
- victim_swap_size = 0;
+ victim_swap_blocks = 0;
#endif
}
}
-bool process_alloc(struct process *process, int size) {
+bool process_alloc(struct process *process, int blocks) {
int swap_out;
// must not be already allocated
- assert(process->size == -1);
+ assert(process->blocks == -1);
- // check size
+ // check blocks
if (
- process_avail < size
+ process_avail < blocks
#if defined(PREALLOCATE_SWAP) && !defined(MOVEABLE_SWAP)
- || !swap_table_alloc(&process->swap_item, size)
+ || !swap_table_alloc(&process->swap_item, blocks)
#endif
)
return false;
// free up as much core as we need to
- swap_out = size - core_avail();
+ swap_out = blocks - core_avail();
do_swap_out(swap_out);
// allocate core and possible swap
#ifdef MOVEABLE_CORE
- rassert(core_table_alloc(&PER_PROCESS_CORE_ITEM(process), size));
+ rassert(core_table_alloc(&PER_PROCESS_CORE_ITEM(process), blocks));
#else
- if (!core_table_alloc(&PER_PROCESS_CORE_ITEM(process), size)) {
+ if (!core_table_alloc(&PER_PROCESS_CORE_ITEM(process), blocks)) {
#if defined(PREALLOCATE_SWAP) && !defined(MOVEABLE_SWAP)
swap_table_free(&process->swap_item);
#endif
}
#endif
#if defined(PREALLOCATE_SWAP) && defined(MOVEABLE_SWAP)
- rassert(swap_table_alloc(&process->swap_item, size));
+ rassert(swap_table_alloc(&process->swap_item, blocks));
#endif
#ifdef INDIRECT_CORE
rassert(
core_block_alloc(
core_table_mem + PER_PROCESS_CORE_ITEM(process).base,
- size
+ blocks
)
);
#endif
process->lru_item.next->prev = &process->lru_item;
// track total allocation
- process->size = size;
- process_avail -= size;
+ process->blocks = blocks;
+ process_avail -= blocks;
check_invariants();
return true;
}
-bool process_realloc(struct process *process, int size) {
+bool process_realloc(struct process *process, int blocks) {
int swap_out;
// must be already allocated
- assert(process->size != -1);
+ assert(process->blocks != -1);
// must be fully in core
assert(process->lru_item.prev != NULL);
- // check size
- int size_change = size - process->size;
- if (process_avail < size_change)
+ // check blocks
+ int blocks_change = blocks - process->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, size)) {
- rassert(swap_table_alloc(&process->swap_item, process->size));
+ if (!swap_table_alloc(&process->swap_item, blocks)) {
+ rassert(swap_table_alloc(&process->swap_item, process->blocks));
return false;
}
#endif
// free up as much core as we need to
- swap_out = size_change - core_avail();
+ swap_out = blocks_change - core_avail();
do_swap_out(swap_out);
// reallocate core and possible swap
#ifdef MOVEABLE_CORE
- rassert(core_table_realloc(&PER_PROCESS_CORE_ITEM(process), size));
+ rassert(core_table_realloc(&PER_PROCESS_CORE_ITEM(process), blocks));
#else
- if (!core_table_realloc(&PER_PROCESS_CORE_ITEM(process), size)) {
+ 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->size));
+ rassert(swap_table_alloc(&process->swap_item, process->blocks));
#endif
return false;
}
#endif
#if defined(PREALLOCATE_SWAP) && defined(MOVEABLE_SWAP)
swap_table_free(&process->swap_item);
- rassert(swap_table_alloc(&process->swap_item, size));
+ rassert(swap_table_alloc(&process->swap_item, blocks));
#endif
#ifdef INDIRECT_CORE
// populate new table with physical blocks or discard them
- if (size_change >= 0)
+ if (blocks_change >= 0)
rassert(
core_block_alloc(
- core_table_mem + PER_PROCESS_CORE_ITEM(process).limit - size_change,
- size_change
+ core_table_mem + PER_PROCESS_CORE_ITEM(process).limit - blocks_change,
+ blocks_change
)
);
else
core_block_free(
core_table_mem + PER_PROCESS_CORE_ITEM(process).limit,
- -size_change
+ -blocks_change
);
#endif
// track total allocation
- process->size = size;
- process_avail -= size_change;
+ process->blocks = blocks;
+ process_avail -= blocks_change;
check_invariants();
return true;
}
void process_run(struct process *process) {
- int size, swap_out;
- int process_core_size;
+ int blocks, swap_out;
+ int process_core_blocks;
#ifndef PREALLOCATE_CORE
struct pool_item process_core_item;
#endif
- int process_swap_size;
+ int process_swap_blocks;
#ifndef PREALLOCATE_SWAP
struct pool_item process_swap_item;
#endif
int swap_base, core_base;
// must be already allocated
- assert(process->size != -1);
+ assert(process->blocks != -1);
// see whether fully in core
if (process->lru_item.prev != NULL) {
if (process != victim) {
// fully in swap, take over only the per-process swap item
#ifdef PREALLOCATE_SWAP
- process_swap_size = process->size;
+ process_swap_blocks = process->blocks;
#else
pool_move_item(&process->pool_item, &process_swap_item);
- process_swap_size = process_swap_item.limit - process_swap_item.base;
- assert(process_swap_size == process->size);
+ process_swap_blocks = process_swap_item.limit - process_swap_item.base;
+ assert(process_swap_blocks == process->blocks);
#endif
// calculate amounts to swap out then in
- size = process_swap_size;
- swap_out = size - core_avail();
+ blocks = process_swap_blocks;
+ swap_out = blocks - core_avail();
#if !defined(PREALLOCATE_SWAP) || defined(INDIRECT_SWAP)
if (swap_out > swap_avail()) {
- size += swap_avail() - swap_out;
+ blocks += swap_avail() - swap_out;
swap_out = swap_avail();
}
#endif
do_swap_out(swap_out);
// add to core pool, using dedicated core item
- process_core_size = size;
+ process_core_blocks = blocks;
#ifndef PREALLOCATE_CORE
- rassert(core_table_alloc(&process_core_item, process_core_size));
+ rassert(core_table_alloc(&process_core_item, process_core_blocks));
#endif
goto loop_entry_full;
}
// victim, take over the dedicated pool items
victim = NULL;
#ifdef PREALLOCATE_CORE
- process_core_size = victim_core_size;
+ process_core_blocks = victim_core_blocks;
#ifndef NDEBUG
- victim_core_size = 0;
+ victim_core_blocks = 0;
#endif
#else
pool_move_item(&victim_core_item, &process_core_item);
- process_core_size = process_core_item.limit - process_core_item.base;
+ process_core_blocks = process_core_item.limit - process_core_item.base;
#endif
#ifdef PREALLOCATE_SWAP
- process_swap_size = victim_swap_size;
+ process_swap_blocks = victim_swap_blocks;
#ifndef NDEBUG
- victim_swap_size = 0;
+ victim_swap_blocks = 0;
#endif
#else
pool_move_item(&victim_swap_item, &process_swap_item);
- process_swap_size = process_swap_item.limit - process_swap_item.base;
+ process_swap_blocks = process_swap_item.limit - process_swap_item.base;
goto loop_entry_partial;
#endif
do {
#ifndef PREALLOCATE_SWAP
// reduce swap allocation
- rassert(swap_table_realloc(&process_swap_item, process_swap_size));
+ rassert(swap_table_realloc(&process_swap_item, process_swap_blocks));
loop_entry_partial:
#endif
// calculate amounts to swap out then in
- size = process_swap_size;
- swap_out = size - core_avail();
+ blocks = process_swap_blocks;
+ swap_out = blocks - core_avail();
#if !defined(PREALLOCATE_SWAP) || defined(INDIRECT_SWAP)
if (swap_out > swap_avail()) {
- size += swap_avail() - swap_out;
+ blocks += swap_avail() - swap_out;
swap_out = swap_avail();
}
#endif
do_swap_out(swap_out);
// increase core allocation
- process_core_size += size;
+ process_core_blocks += blocks;
#ifndef PREALLOCATE_CORE
- rassert(core_table_realloc_base(&process_core_item, process_core_size));
+ rassert(core_table_realloc_base(&process_core_item, process_core_blocks));
#endif
loop_entry_full:
// transfer data to core
- swap_base = DEDICATED_SWAP_LIMIT(process, process_swap_size) - size;
- core_base = DEDICATED_CORE_BASE(process, process_swap_size - size);
+ swap_base = DEDICATED_SWAP_LIMIT(process, process_swap_blocks) - blocks;
+ core_base = DEDICATED_CORE_BASE(process, process_swap_blocks - blocks);
#ifdef INDIRECT_CORE
- core_block_alloc(core_table_mem + core_base, size);
+ core_block_alloc(core_table_mem + core_base, blocks);
#endif
- swap_read(swap_base, core_base, size);
+ swap_read(swap_base, core_base, blocks);
#ifdef INDIRECT_SWAP
- swap_block_free(swap_table_mem + swap_base, size);
+ swap_block_free(swap_table_mem + swap_base, blocks);
#endif
- process_swap_size -= size;
- } while (process_swap_size);
+ process_swap_blocks -= blocks;
+ } while (process_swap_blocks);
#ifndef PREALLOCATE_CORE
// move dedicated to per-process core item
void process_free(struct process *process) {
// must be already allocated
- assert(process->size != -1);
+ assert(process->blocks != -1);
// see whether fully in core, victim, or fully in swap
if (process->lru_item.prev != NULL) {
#ifdef INDIRECT_CORE
core_block_free(
core_table_mem +
- DEDICATED_CORE_BASE(victim, DEDICATED_SWAP_SIZE(victim)),
- DEDICATED_CORE_SIZE(victim)
+ DEDICATED_CORE_BASE(victim, DEDICATED_SWAP_BLOCKS(victim)),
+ DEDICATED_CORE_BLOCKS(victim)
);
#endif
#ifdef PREALLOCATE_CORE
- victim_core_size = 0;
+ victim_core_blocks = 0;
#else
core_table_free(&victim_core_item);
#endif
#ifdef INDIRECT_SWAP
swap_block_free(
swap_table_mem + DEDICATED_SWAP_ITEM(victim).base,
- DEDICATED_SWAP_SIZE(victim)
+ DEDICATED_SWAP_BLOCKS(victim)
);
#endif
#ifdef PREALLOCATE_SWAP
- victim_swap_size = 0;
+ victim_swap_blocks = 0;
#else
swap_table_free(&victim_swap_item);
#endif
#endif
// track total allocation
- process_avail += process->size;
+ process_avail += process->blocks;
#ifndef NDEBUG
- process->size = -1;
+ process->blocks = -1;
#endif
check_invariants();
}
#define PREALLOCATE_SWAP 1
#ifdef PREALLOCATE_CORE
-#define DEDICATED_CORE_BASE(process, swap_size) \
- (process->core_item.base + (swap_size))
+#define DEDICATED_CORE_BASE(process, swap_blocks) \
+ (process->core_item.base + (swap_blocks))
#define DEDICATED_CORE_ITEM(process) \
process->core_item
-#define DEDICATED_CORE_SIZE(process) \
- process##_core_size
+#define DEDICATED_CORE_BLOCKS(process) \
+ process##_core_blocks
#define PER_PROCESS_CORE_ITEM(process) \
(process)->core_item
#else
-#define DEDICATED_CORE_BASE(process, swap_size) \
+#define DEDICATED_CORE_BASE(process, swap_blocks) \
process##_core_item.base
#define DEDICATED_CORE_ITEM(process) \
process##_core_item
-#define DEDICATED_CORE_SIZE(process) \
+#define DEDICATED_CORE_BLOCKS(process) \
(process##_core_item.limit - process##_core_item.base)
#define PER_PROCESS_CORE_ITEM(process) \
(process)->pool_item
#ifdef PREALLOCATE_SWAP
#define DEDICATED_SWAP_ITEM(process) \
process->swap_item
-#define DEDICATED_SWAP_LIMIT(process, swap_size) \
- (process->swap_item.base + (swap_size))
-#define DEDICATED_SWAP_SIZE(process) \
- process##_swap_size
+#define DEDICATED_SWAP_LIMIT(process, swap_blocks) \
+ (process->swap_item.base + (swap_blocks))
+#define DEDICATED_SWAP_BLOCKS(process) \
+ process##_swap_blocks
#define PER_PROCESS_SWAP_ITEM(process) \
(process)->swap_item
#else
#define DEDICATED_SWAP_ITEM(process) \
process##_swap_item
-#define DEDICATED_SWAP_LIMIT(process, swap_size) \
+#define DEDICATED_SWAP_LIMIT(process, swap_blocks) \
process##_swap_item.limit
-#define DEDICATED_SWAP_SIZE(process) \
+#define DEDICATED_SWAP_BLOCKS(process) \
(process##_swap_item.limit - process##_swap_item.base)
#define PER_PROCESS_SWAP_ITEM(process) \
(process)->pool_item
#if !defined(PREALLOCATE_SWAP) || !defined(PREALLOCATE_CORE)
struct pool_item pool_item;
#endif
- int size; // brk level
+ int blocks; // brk level
} *processes;
int n_processes;
extern struct process *victim;
#ifdef PREALLOCATE_CORE
-extern int victim_core_size;
+extern int victim_core_blocks;
#else
extern struct pool_item victim_core_item;
#endif
#ifdef PREALLOCATE_SWAP
-extern int victim_swap_size;
+extern int victim_swap_blocks;
#else
extern struct pool_item victim_swap_item;
#endif
void process_init(int n, int spare);
-bool process_alloc(struct process *process, int size);
-bool process_realloc(struct process *process, int size);
+bool process_alloc(struct process *process, int blocks);
+bool process_realloc(struct process *process, int blocks);
void process_run(struct process *process);
void process_free(struct process *process);
int main(int argc, char **argv) {
if (argc < 5) {
#if defined(INDIRECT_CORE) && defined(INDIRECT_SWAP)
- printf("usage: %s n_processes n_core_blocks n_swap_blocks spare [core_table_size [swap_table_size]]\n", argv[0]);
+ printf("usage: %s n_processes n_core_blocks n_swap_blocks spare [core_table_blocks [swap_table_blocks]]\n", argv[0]);
#elif defined(INDIRECT_CORE)
- printf("usage: %s n_processes n_core_blocks n_swap_blocks spare [core_table_size]\n", argv[0]);
+ printf("usage: %s n_processes n_core_blocks n_swap_blocks spare [core_table_blocks]\n", argv[0]);
#elif defined(INDIRECT_SWAP)
- printf("usage: %s n_processes n_core_blocks n_swap_blocks spare [swap_table_size]\n", argv[0]);
+ printf("usage: %s n_processes n_core_blocks n_swap_blocks spare [swap_table_blocks]\n", argv[0]);
#else
printf("usage: %s n_processes n_core_blocks n_swap_blocks spare\n", argv[0]);
#endif
int n_swap_blocks = atoi(argv[3]);
int spare = atoi(argv[4]);
#if defined(INDIRECT_CORE) && defined(INDIRECT_SWAP)
- int core_table_size = argc >= 6 ? atoi(argv[5]) : n_core_blocks;
- int swap_table_size = argc >= 7 ? atoi(argv[6]) : n_swap_blocks;
+ int core_table_blocks = argc >= 6 ? atoi(argv[5]) : n_core_blocks;
+ int swap_table_blocks = argc >= 7 ? atoi(argv[6]) : n_swap_blocks;
#elif defined(INDIRECT_CORE)
- int core_table_size = argc >= 6 ? atoi(argv[5]) : n_core_blocks;
+ int core_table_blocks = argc >= 6 ? atoi(argv[5]) : n_core_blocks;
#elif defined(INDIRECT_SWAP)
- int swap_table_size = argc >= 6 ? atoi(argv[5]) : n_swap_blocks;
+ int swap_table_blocks = argc >= 6 ? atoi(argv[5]) : n_swap_blocks;
#endif
#ifdef INDIRECT_CORE
- core_init(n_core_blocks, core_table_size);
+ core_init(n_core_blocks, core_table_blocks);
#else
core_init(n_core_blocks);
#endif
#ifdef INDIRECT_SWAP
- swap_init(n_swap_blocks, swap_table_size);
+ swap_init(n_swap_blocks, swap_table_blocks);
#else
swap_init(n_swap_blocks);
#endif
process_init(n_processes, spare);
for (int i = 0; i < n_processes; ++i)
- processes[i].size = -1;
+ processes[i].blocks = -1;
while (true) {
//printf("avail %d %d(%d) %d(%d)\n", process_avail, core_avail(), core_table.avail, swap_avail(), swap_table.avail);
rassert(false);
}
if (strcmp(buf, "alloc") == 0) {
- int process, size;
- rassert(scanf("%d %d %s", &process, &size, buf) == 3);
+ int process, blocks;
+ rassert(scanf("%d %d %s", &process, &blocks, buf) == 3);
rassert(process >= 0 && process < n_processes);
- rassert(size >= 0);
+ rassert(blocks >= 0);
bool success;
if (strcmp(buf, "false") == 0)
success = false;
printf(
"alloc %d %d %s\n",
process,
- size,
+ blocks,
success ? "true" : "false"
);
- rassert(processes[process].size == -1);
- bool result = process_alloc(processes + process, size);
+ rassert(processes[process].blocks == -1);
+ bool result = process_alloc(processes + process, blocks);
printf(
"... %s\n",
result == success ?
if (!success) {
printf("... undo\n");
process_free(processes + process);
- processes[process].size = -1;
+ processes[process].blocks = -1;
}
else {
int core_base = PER_PROCESS_CORE_ITEM(processes + process).base;
assert(
PER_PROCESS_CORE_ITEM(processes + process).limit ==
- core_base + size
+ core_base + blocks
);
- printf("new core [%d,%d)\n", core_base, core_base + size);
- core_hash_init(process, core_base, 0, size);
+ printf("new core [%d,%d)\n", core_base, core_base + blocks);
+ core_hash_init(process, core_base, 0, blocks);
#ifdef PREALLOCATE_SWAP
printf("new swap [%d,%d)\n", PER_PROCESS_SWAP_ITEM(processes + process).base, PER_PROCESS_SWAP_ITEM(processes + process).limit);
#endif
}
}
else if (strcmp(buf, "realloc") == 0) {
- int process, old_size, size;
- rassert(scanf("%d %d %d %s", &process, &old_size, &size, buf) == 4);
+ int process, old_blocks, blocks;
+ rassert(scanf("%d %d %d %s", &process, &old_blocks, &blocks, buf) == 4);
rassert(process >= 0 && process < n_processes);
- rassert(old_size >= 0);
- rassert(size >= 0);
+ rassert(old_blocks >= 0);
+ rassert(blocks >= 0);
bool success;
if (strcmp(buf, "false") == 0)
success = false;
printf(
"realloc %d %d %d %s\n",
process,
- old_size,
- size,
+ old_blocks,
+ blocks,
success ? "true" : "false"
);
- if (processes[process].size == -1)
+ if (processes[process].blocks == -1)
printf("... not allocated, ignore\n");
else {
int core_base = PER_PROCESS_CORE_ITEM(processes + process).base;
- int actual_old_size = processes[process].size;
+ int actual_old_blocks = processes[process].blocks;
rassert(
PER_PROCESS_CORE_ITEM(processes + process).limit ==
- core_base + actual_old_size
+ core_base + actual_old_blocks
);
- if (actual_old_size != old_size) {
+ if (actual_old_blocks != old_blocks) {
printf(
- "... old size %d, should be %d\n",
- actual_old_size,
- old_size
+ "... old blocks %d, should be %d\n",
+ actual_old_blocks,
+ old_blocks
);
- rassert(actual_old_size <= old_size);
+ rassert(actual_old_blocks <= old_blocks);
}
#ifdef PREALLOCATE_SWAP
- printf("old core [%d,%d) swap [%d,%d)\n", core_base, core_base + actual_old_size, PER_PROCESS_SWAP_ITEM(processes + process).base, PER_PROCESS_SWAP_ITEM(processes + process).limit);
+ printf("old core [%d,%d) swap [%d,%d)\n", core_base, core_base + actual_old_blocks, PER_PROCESS_SWAP_ITEM(processes + process).base, PER_PROCESS_SWAP_ITEM(processes + process).limit);
#else
- printf("old core [%d,%d)\n", core_base, core_base + actual_old_size);
+ printf("old core [%d,%d)\n", core_base, core_base + actual_old_blocks);
#endif
- core_hash_verify(process, core_base, size, actual_old_size);
- bool result = process_realloc(processes + process, size);
+ core_hash_verify(process, core_base, blocks, actual_old_blocks);
+ bool result = process_realloc(processes + process, blocks);
printf(
"... %s\n",
result == success ?
if (result) {
if (!success) {
printf("... undo\n");
- rassert(process_realloc(processes + process, actual_old_size));
+ rassert(process_realloc(processes + process, actual_old_blocks));
}
else {
core_base = PER_PROCESS_CORE_ITEM(processes + process).base;
rassert(
PER_PROCESS_CORE_ITEM(processes + process).limit ==
- core_base + size
+ core_base + blocks
);
#ifdef PREALLOCATE_SWAP
- printf("new core [%d,%d) swap [%d,%d)\n", core_base, core_base + size, PER_PROCESS_SWAP_ITEM(processes + process).base, PER_PROCESS_SWAP_ITEM(processes + process).limit);
+ printf("new core [%d,%d) swap [%d,%d)\n", core_base, core_base + blocks, PER_PROCESS_SWAP_ITEM(processes + process).base, PER_PROCESS_SWAP_ITEM(processes + process).limit);
#else
- printf("new core [%d,%d)\n", core_base, core_base + size);
+ printf("new core [%d,%d)\n", core_base, core_base + blocks);
#endif
- core_hash_init(process, core_base, actual_old_size, size);
+ core_hash_init(process, core_base, actual_old_blocks, blocks);
}
}
}
rassert(scanf("%d", &process) == 1);
rassert(process >= 0 && process < n_processes);
printf("run %d\n", process);
- if (processes[process].size == -1)
+ if (processes[process].blocks == -1)
printf("... not allocated, ignore\n");
else {
process_run(processes + process);
}
}
else if (strcmp(buf, "free") == 0) {
- int process, old_size;
- rassert(scanf("%d %d", &process, &old_size) == 2);
+ int process, old_blocks;
+ rassert(scanf("%d %d", &process, &old_blocks) == 2);
rassert(process >= 0 && process < n_processes);
- rassert(old_size >= 0);
- printf("free %d %d\n", process, old_size);
- if (processes[process].size == -1)
+ rassert(old_blocks >= 0);
+ printf("free %d %d\n", process, old_blocks);
+ if (processes[process].blocks == -1)
printf("... not allocated, ignore\n");
else {
- int actual_old_size = processes[process].size;
- if (actual_old_size != old_size) {
+ int actual_old_blocks = processes[process].blocks;
+ if (actual_old_blocks != old_blocks) {
printf(
- "... old size %d, should be %d\n",
- actual_old_size,
- old_size
+ "... old blocks %d, should be %d\n",
+ actual_old_blocks,
+ old_blocks
);
- rassert(actual_old_size <= old_size);
+ rassert(actual_old_blocks <= old_blocks);
}
- int swap_base, swap_size, core_base, core_size;
+ int swap_base, swap_blocks, core_base, core_blocks;
if (processes[process].lru_item.prev != NULL) { // fully in core
assert(processes + process != victim);
swap_base = -1;
- swap_size = 0;
+ swap_blocks = 0;
core_base =
PER_PROCESS_CORE_ITEM(processes + process).base;
- core_size =
+ core_blocks =
PER_PROCESS_CORE_ITEM(processes + process).limit - core_base;
}
else if (processes + process == victim) { // victim
swap_base = DEDICATED_SWAP_ITEM(victim).base;
- swap_size = DEDICATED_SWAP_SIZE(victim);
- core_base = DEDICATED_CORE_BASE(victim, swap_size);
- core_size = DEDICATED_CORE_SIZE(victim);
+ swap_blocks = DEDICATED_SWAP_BLOCKS(victim);
+ core_base = DEDICATED_CORE_BASE(victim, swap_blocks);
+ core_blocks = DEDICATED_CORE_BLOCKS(victim);
}
else { // fully in swap
swap_base =
PER_PROCESS_SWAP_ITEM(processes + process).base;
- swap_size =
+ swap_blocks =
PER_PROCESS_SWAP_ITEM(processes + process).limit - swap_base;
core_base = -1;
- core_size = 0;
+ core_blocks = 0;
}
- rassert(core_size + swap_size == actual_old_size);
- printf("old core [%d,%d) swap [%d,%d)\n", core_base, core_base + core_size, swap_base, swap_base + swap_size);
+ 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(
process,
- core_base - swap_size,
- swap_size,
- swap_size + core_size
+ core_base - swap_blocks,
+ swap_blocks,
+ swap_blocks + core_blocks
);
- swap_hash_verify(process, swap_base, 0, swap_size);
+ swap_hash_verify(process, swap_base, 0, swap_blocks);
process_free(processes + process);
- processes[process].size = -1;
+ processes[process].blocks = -1;
printf("... ok\n");
}
}
done:
printf("final state:\n");
for (int i = 0; i < n_processes; ++i) {
- if (processes[i].size == -1)
+ if (processes[i].blocks == -1)
printf("process %d: not allocated\n", i);
else {
- int swap_base, swap_size, core_base, core_size;
+ int swap_base, swap_blocks, core_base, core_blocks;
if (processes[i].lru_item.prev != NULL) { // fully in core
assert(processes + i != victim);
swap_base = -1;
- swap_size = 0;
+ swap_blocks = 0;
core_base = PER_PROCESS_CORE_ITEM(processes + i).base;
- core_size = PER_PROCESS_CORE_ITEM(processes + i).limit - core_base;
+ core_blocks = PER_PROCESS_CORE_ITEM(processes + i).limit - core_base;
}
else if (processes + i == victim) { // victim
swap_base = DEDICATED_SWAP_ITEM(victim).base;
- swap_size = DEDICATED_SWAP_SIZE(victim);
- core_base = DEDICATED_CORE_BASE(victim, swap_size);
- core_size = DEDICATED_CORE_SIZE(victim);
+ swap_blocks = DEDICATED_SWAP_BLOCKS(victim);
+ core_base = DEDICATED_CORE_BASE(victim, swap_blocks);
+ core_blocks = DEDICATED_CORE_BLOCKS(victim);
}
else { // fully in swap
swap_base = PER_PROCESS_SWAP_ITEM(processes + i).base;
- swap_size = PER_PROCESS_SWAP_ITEM(processes + i).limit - swap_base;
+ swap_blocks = PER_PROCESS_SWAP_ITEM(processes + i).limit - swap_base;
core_base = -1;
- core_size = 0;
+ core_blocks = 0;
}
- rassert(core_size + swap_size == processes[i].size);
+ rassert(core_blocks + swap_blocks == processes[i].blocks);
printf(
"process %d: core [%d,%d) swap [%d,%d)\n",
i,
core_base,
- core_base + core_size,
+ core_base + core_blocks,
swap_base,
- swap_base + swap_size
+ swap_base + swap_blocks
);
core_hash_verify(
i,
- core_base - swap_size,
- swap_size,
- swap_size + core_size
+ core_base - swap_blocks,
+ swap_blocks,
+ swap_blocks + core_blocks
);
#ifdef INDIRECT_CORE
- core_block_free(core_table_mem + core_base, core_size);
+ core_block_free(core_table_mem + core_base, core_blocks);
#endif
- swap_hash_verify(i, swap_base, 0, swap_size);
+ swap_hash_verify(i, swap_base, 0, swap_blocks);
#ifdef INDIRECT_SWAP
- swap_block_free(swap_table_mem + swap_base, swap_size);
+ swap_block_free(swap_table_mem + swap_base, swap_blocks);
#endif
}
}
#ifdef INDIRECT_CORE
- for (int i = 0; i < core_table_size; ++i)
+ for (int i = 0; i < core_table_blocks; ++i)
rassert(core_table_mem[i] == 0x55555555);
{
int j = n_core_blocks >> 3;
for (int j = 0; j < BLOCK_SIZE; ++j)
rassert(core_block_mem[i * BLOCK_SIZE + j] == 0xaa);
#ifdef INDIRECT_SWAP
- for (int i = 0; i < swap_table_size; ++i)
+ for (int i = 0; i < swap_table_blocks; ++i)
rassert(swap_table_mem[i] == 0x55555555);
{
int j = n_swap_blocks >> 3;
public / moveable_pool.git / commitdiff