rassert(false);
}
if (strcmp(buf, "alloc") == 0) {
- int item, size, success;
- rassert(scanf("%d %d %d", &item, &size, &success) == 3);
+ int item, size;
+ rassert(scanf("%d %d %s", &item, &size, buf) == 3);
rassert(item >= 0 && item < n_items);
- rassert(size >= 0 && size < pool_size);
- rassert(success >= 0 && success < 2);
+ rassert(size >= 0);
+ bool success;
+ if (strcmp(buf, "false") == 0)
+ success = false;
+ else if (strcmp(buf, "true") == 0)
+ success = true;
+ else
+ rassert(false);
+ printf(
+ "alloc %d %d %s\n",
+ item,
+ size,
+ success ? "true" : "false"
+ );
rassert(items[item].prev == NULL);
bool result =
moveable ?
pool_alloc_moveable(&head, items + item, size) :
pool_alloc(&head, items + item, size);
printf(
- "alloc %d %d %d: %s\n",
- item,
- size,
- success,
- result == (bool)success ?
+ "... %s\n",
+ result == success ?
"ok" :
result ? "succeeded, should fail" : "failed, should succeed"
);
if (result) {
if (!success) {
- printf("undo\n");
+ printf("... undo\n");
pool_free(&head, items + item);
items[item].prev = NULL;
}
else {
int base = items[item].base;
+ rassert(items[item].limit == base + size);
printf("new region [%d,%d)\n", base, base + size);
- rassert(items[item].limit == base + size);
for (int i = 0; i < size; ++i) {
rassert(mem[base + i] == 0xaaaaaaaa);
long long hash = item * 17 + i * 29;
}
}
else if (strcmp(buf, "realloc") == 0) {
- int item, old_size, size, success;
- rassert(scanf("%d %d %d %d", &item, &old_size, &size, &success) == 4);
+ int item, old_size, size;
+ rassert(scanf("%d %d %d %s", &item, &old_size, &size, buf) == 4);
rassert(item >= 0 && item < n_items);
- rassert(old_size >= 0 && old_size < pool_size);
- rassert(size >= 0 && size < pool_size);
- rassert(success >= 0 && success < 2);
+ rassert(old_size >= 0);
+ rassert(size >= 0);
+ bool success;
+ if (strcmp(buf, "false") == 0)
+ success = false;
+ else if (strcmp(buf, "true") == 0)
+ success = true;
+ else
+ rassert(false);
+ printf(
+ "realloc %d %d %d %s\n",
+ item,
+ old_size,
+ size,
+ success ? "true" : "false"
+ );
if (items[item].prev == NULL)
- printf(
- "realloc %d %d %d %d: not allocated, ignore\n",
- item,
- old_size,
- size,
- success
- );
+ printf("... not allocated, ignore\n");
else {
- printf("old region [%d,%d)\n", items[item].base, items[item].limit);
+ int base = items[item].base;
int actual_old_size = items[item].limit - items[item].base;
- rassert(actual_old_size <= old_size);
+ if (actual_old_size != old_size) {
+ printf(
+ "... old size %d, should be %d\n",
+ actual_old_size,
+ old_size
+ );
+ rassert(actual_old_size <= old_size);
+ }
+ printf("old region [%d,%d)\n", base, base + actual_old_size);
+ for (int i = size; i < actual_old_size; ++i) {
+ long long hash = item * 17 + i * 29;
+ hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
+ hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
+ rassert(mem[base + i] == (int)hash);
+ mem[base + i] = 0xaaaaaaaa;
+ }
bool result =
moveable ?
pool_realloc_moveable(&head, items + item, size) :
pool_realloc(&head, items + item, size);
printf(
- "realloc %d %d(%d) %d %d: %s\n",
- item,
- old_size,
- actual_old_size,
- size,
- success,
- result == (bool)success ?
+ "... %s\n",
+ result == success ?
"ok" :
result ? "succeeded, should fail" : "failed, should succeed"
);
if (result) {
if (!success) {
- printf("undo\n");
+ printf("... undo\n");
rassert(pool_realloc(&head, items + item, actual_old_size));
}
else {
- int base = items[item].base;
+ base = items[item].base;
+ rassert(items[item].limit == base + size);
printf("new region [%d,%d)\n", base, base + size);
- rassert(items[item].limit == base + size);
for (int i = actual_old_size; i < size; ++i) {
rassert(mem[base + i] == 0xaaaaaaaa);
long long hash = item * 17 + i * 29;
hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
mem[base + i] = (int)hash;
}
- for (int i = size; i < actual_old_size; ++i) {
- long long hash = item * 17 + i * 29;
- hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
- hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
- rassert(mem[base + i] == (int)hash);
- mem[base + i] = 0xaaaaaaaa;
- }
}
}
}
int item, old_size;
rassert(scanf("%d %d", &item, &old_size) == 2);
rassert(item >= 0 && item < n_items);
- rassert(old_size >= 0 && old_size < pool_size);
+ rassert(old_size >= 0);
+ printf(
+ "free %d %d\n",
+ item,
+ old_size
+ );
if (items[item].prev == NULL)
- printf(
- "free %d %d: not allocated, ignore\n",
- item,
- old_size
- );
+ printf("... not allocated, ignore\n");
else {
- int actual_old_size = items[item].limit - items[item].base;
- rassert(actual_old_size <= old_size);
- pool_free(&head, items + item);
- items[item].prev = NULL;
- printf(
- "free %d %d(%d): ok\n",
- item,
- old_size,
- actual_old_size
- );
int base = items[item].base;
+ int actual_old_size = items[item].limit - base;
+ if (actual_old_size != old_size) {
+ printf(
+ "... old size %d, should be %d\n",
+ actual_old_size,
+ old_size
+ );
+ rassert(actual_old_size <= old_size);
+ }
printf("old region [%d,%d)\n", base, base + actual_old_size);
for (int i = 0; i < actual_old_size; ++i) {
long long hash = item * 17 + i * 29;
rassert(mem[base + i] == (int)hash);
mem[base + i] = 0xaaaaaaaa;
}
+ pool_free(&head, items + item);
+ items[item].prev = NULL;
+ printf("... ok\n");
}
}
else
rassert(false);
}
if (strcmp(buf, "alloc") == 0) {
- int process, size, success;
- rassert(scanf("%d %d %d", &process, &size, &success) == 3);
+ int process, size;
+ rassert(scanf("%d %d %s", &process, &size, buf) == 3);
rassert(process >= 0 && process < n_processes);
rassert(size >= 0);
- rassert(success >= 0 && success < 2);
- rassert(processes[process].size == -1);
- bool result = process_alloc(processes + process, size);
+ bool success;
+ if (strcmp(buf, "false") == 0)
+ success = false;
+ else if (strcmp(buf, "true") == 0)
+ success = true;
+ else
+ rassert(false);
printf(
- "alloc %d %d %d: %s\n",
+ "alloc %d %d %s\n",
process,
size,
- success,
- result == (bool)success ?
+ success ? "true" : "false"
+ );
+ rassert(processes[process].size == -1);
+ bool result = process_alloc(processes + process, size);
+ printf(
+ "... %s\n",
+ result == success ?
"ok" :
result ? "succeeded, should fail" : "failed, should succeed"
);
if (result) {
if (!success) {
- printf("undo\n");
+ printf("... undo\n");
process_free(processes + process);
processes[process].size = -1;
}
else {
#ifdef PREALLOCATE_CORE
int core_base = processes[process].core_item.base;
+ assert(processes[process].core_item.limit == core_base + size);
#else
int core_base = processes[process].pool_item.base;
+ assert(processes[process].pool_item.limit == core_base + size);
#endif
printf("new core [%d,%d)\n", core_base, core_base + size);
for (int i = 0; i < size; ++i) {
}
}
else if (strcmp(buf, "realloc") == 0) {
- int process, old_size, size, success;
- rassert(scanf("%d %d %d %d", &process, &old_size, &size, &success) == 4);
+ int process, old_size, size;
+ rassert(scanf("%d %d %d %s", &process, &old_size, &size, buf) == 4);
rassert(process >= 0 && process < n_processes);
rassert(old_size >= 0);
rassert(size >= 0);
- rassert(success >= 0 && success < 2);
+ bool success;
+ if (strcmp(buf, "false") == 0)
+ success = false;
+ else if (strcmp(buf, "true") == 0)
+ success = true;
+ else
+ rassert(false);
+ printf(
+ "realloc %d %d %d %s\n",
+ process,
+ old_size,
+ size,
+ success ? "true" : "false"
+ );
if (processes[process].size == -1)
- printf(
- "realloc %d %d %d %d: not allocated, ignore\n",
- process,
- old_size,
- size,
- success
- );
+ printf("... not allocated, ignore\n");
else {
#ifdef PREALLOCATE_CORE
int core_base = processes[process].core_item.base;
int core_base = processes[process].pool_item.base;
#endif
int actual_old_size = processes[process].size;
- rassert(actual_old_size <= old_size);
- printf("old core [%d,%d)\n", core_base, core_base + actual_old_size);
+ rassert(
+#ifdef PREALLOCATE_CORE
+ processes[process].core_item.limit == core_base + actual_old_size
+#else
+ processes[process].pool_item.limit == core_base + actual_old_size
+#endif
+ );
+ if (actual_old_size != old_size) {
+ printf(
+ "... old size %d, should be %d\n",
+ actual_old_size,
+ old_size
+ );
+ rassert(actual_old_size <= old_size);
+ }
#ifdef PREALLOCATE_SWAP
- printf("old swap [%d,%d)\n", ~processes[process].swap_item.limit, ~processes[process].swap_item.base);
+ printf("old core [%d,%d) swap [%d,%d)\n", core_base, core_base + actual_old_size, ~processes[process].swap_item.limit, ~processes[process].swap_item.base);
+#else
+ printf("old core [%d,%d)\n", core_base, core_base + actual_old_size);
#endif
for (int i = size; i < actual_old_size; ++i) {
long long hash = process * 17 + i * 29;
}
bool result = process_realloc(processes + process, size);
printf(
- "realloc %d %d(%d) %d %d: %s\n",
- process,
- old_size,
- actual_old_size,
- size,
- success,
- result == (bool)success ?
+ "... %s\n",
+ result == success ?
"ok" :
result ? "succeeded, should fail" : "failed, should succeed"
);
if (result) {
if (!success) {
- printf("undo\n");
+ printf("... undo\n");
rassert(process_realloc(processes + process, actual_old_size));
}
else {
#ifdef PREALLOCATE_CORE
core_base = processes[process].core_item.base;
+ rassert(processes[process].core_item.limit == core_base + size);
#else
core_base = processes[process].pool_item.base;
+ rassert(processes[process].pool_item.limit == core_base + size);
#endif
+#ifdef PREALLOCATE_SWAP
+ printf("new core [%d,%d) swap [%d,%d)\n", core_base, core_base + size, ~processes[process].swap_item.limit, ~processes[process].swap_item.base);
+#else
printf("new core [%d,%d)\n", core_base, core_base + size);
+#endif
for (int i = actual_old_size; i < size; ++i) {
long long hash = process * 17 + i * 29;
hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
rassert(core_block_mem[core_block] == 0xaaaaaaaa);
core_block_mem[core_block] = (int)hash;
}
-#ifdef PREALLOCATE_SWAP
- printf("new swap [%d,%d)\n", ~processes[process].swap_item.limit, ~processes[process].swap_item.base);
-#endif
}
}
}
int process;
rassert(scanf("%d", &process) == 1);
rassert(process >= 0 && process < n_processes);
+ printf("run %d\n", process);
if (processes[process].size == -1)
- printf("run %d: not allocated, ignore\n", process);
+ printf("... not allocated, ignore\n");
else {
process_run(processes + process);
- printf("run %d\n", process);
+ printf("... ok\n");
}
}
else if (strcmp(buf, "free") == 0) {
rassert(scanf("%d %d", &process, &old_size) == 2);
rassert(process >= 0 && process < n_processes);
rassert(old_size >= 0);
+ printf("free %d %d\n", process, old_size);
if (processes[process].size == -1)
- printf(
- "free %d %d: not allocated, ignore\n",
- process,
- old_size
- );
+ printf("... not allocated, ignore\n");
else {
int actual_old_size = processes[process].size;
- rassert(actual_old_size <= old_size);
+ if (actual_old_size != old_size) {
+ printf(
+ "... old size %d, should be %d\n",
+ actual_old_size,
+ old_size
+ );
+ rassert(actual_old_size <= old_size);
+ }
bool is_victim = processes + process == victim;
bool in_core = processes[process].lru_item.prev != NULL;
#ifdef PREALLOCATE_CORE
- int core_size = is_victim ? victim_core_size : in_core ? processes[process].size : 0;
- int core_base = processes[process].core_item.base;
+ int core_size =
+ is_victim ?
+ victim_core_size :
+ in_core ? processes[process].size : 0;
+ int core_base =
+ processes[process].core_item.base;
#else
- int core_base = is_victim ? victim_core_item.base : in_core ? processes[process].pool_item.base : -1;
- int core_size = is_victim ? victim_core_item.limit - core_base : in_core ? processes[process].pool_item.limit - core_base : 0;
+ int core_base =
+ is_victim ?
+ victim_core_item.base :
+ in_core ? processes[process].pool_item.base : -1;
+ int core_size =
+ is_victim ?
+ victim_core_item.limit - core_base :
+ in_core ? processes[process].pool_item.limit - core_base : 0;
#endif
#ifdef PREALLOCATE_SWAP
- int swap_size = is_victim ? victim_swap_size : !in_core ? processes[process].size : 0;
- int swap_limit = processes[process].swap_item.base + swap_size;
+ int swap_size =
+ is_victim ?
+ victim_swap_size :
+ !in_core ? processes[process].size : 0;
+ int swap_limit =
+ processes[process].swap_item.base + swap_size;
#else
- int swap_limit = is_victim ? victim_swap_item.limit : !in_core ? processes[process].pool_item.limit : 0;
- int swap_size = is_victim ? swap_limit - victim_swap_item.base : !in_core ? swap_limit - processes[process].pool_item.base : 0;
+ int swap_limit =
+ is_victim ?
+ victim_swap_item.limit :
+ !in_core ? processes[process].pool_item.limit : 0;
+ int swap_size =
+ is_victim ?
+ swap_limit - victim_swap_item.base :
+ !in_core ? swap_limit - processes[process].pool_item.base : 0;
#endif
- rassert(core_size + swap_size == actual_old_size);
int swap_base = ~swap_limit;
printf("old core [%d,%d) swap [%d,%d)\n", core_base, core_base + core_size, swap_base, swap_base + swap_size);
- for (int i = 0; i < actual_old_size; ++i) {
+ for (int i = 0; i < core_size; ++i) {
long long hash = process * 17 + i * 29;
hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
- if (i < core_size) {
#ifdef INDIRECT_CORE
- int core_block = core_table_mem[core_base + i];
+ int core_block = core_table_mem[core_base + i];
#else
- int core_block = core_base + i;
+ int core_block = core_base + i;
#endif
- rassert(core_block_mem[core_block] == (int)hash);
- core_block_mem[core_block] = 0xaaaaaaaa;
- }
- else {
+ rassert(core_block_mem[core_block] == (int)hash);
+ core_block_mem[core_block] = 0xaaaaaaaa;
+ }
+ for (int i = 0; i < swap_size; ++i) {
+ long long hash = process * 17 + (core_size + i) * 29;
+ hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
+ hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
#ifdef INDIRECT_SWAP
- int swap_block = swap_table_mem[swap_base + i - core_size];
+ int swap_block = swap_table_mem[swap_base + i];
#else
- int swap_block = swap_base + i - core_size;
+ int swap_block = swap_base + i;
#endif
- rassert(swap_block_mem[swap_block] == (int)hash);
- swap_block_mem[swap_block] = 0xaaaaaaaa;
- }
+ rassert(swap_block_mem[swap_block] == (int)hash);
+ swap_block_mem[swap_block] = 0xaaaaaaaa;
}
+ rassert(core_size + swap_size == actual_old_size);
process_free(processes + process);
processes[process].size = -1;
- printf(
- "free %d %d(%d): ok\n",
- process,
- old_size,
- actual_old_size
- );
+ printf("... ok\n");
}
}
else
bool is_victim = processes + i == victim;
bool in_core = processes[i].lru_item.prev != NULL;
#ifdef PREALLOCATE_CORE
- int core_size = is_victim ? victim_core_size : in_core ? processes[i].size : 0;
- int core_base = processes[i].core_item.base;
+ int core_size =
+ is_victim ?
+ victim_core_size :
+ in_core ? processes[i].size : 0;
+ int core_base =
+ processes[i].core_item.base;
#else
- int core_base = is_victim ? victim_core_item.base : in_core ? processes[i].pool_item.base : -1;
- int core_size = is_victim ? victim_core_item.limit - core_base : in_core ? processes[i].pool_item.limit - core_base : 0;
+ int core_base =
+ is_victim ?
+ victim_core_item.base :
+ in_core ? processes[i].pool_item.base : -1;
+ int core_size =
+ is_victim ?
+ victim_core_item.limit - core_base :
+ in_core ? processes[i].pool_item.limit - core_base : 0;
#endif
#ifdef PREALLOCATE_SWAP
- int swap_size = is_victim ? victim_swap_size : !in_core ? processes[i].size : 0;
- int swap_limit = processes[i].swap_item.base + swap_size;
+ int swap_size =
+ is_victim ?
+ victim_swap_size :
+ !in_core ? processes[i].size : 0;
+ int swap_limit =
+ processes[i].swap_item.base + swap_size;
#else
- int swap_limit = is_victim ? victim_swap_item.limit : !in_core ? processes[i].pool_item.limit : 0;
- int swap_size = is_victim ? swap_limit - victim_swap_item.base : !in_core ? swap_limit - processes[i].pool_item.base : 0;
+ int swap_limit =
+ is_victim ?
+ victim_swap_item.limit :
+ !in_core ? processes[i].pool_item.limit : 0;
+ int swap_size =
+ is_victim ?
+ swap_limit - victim_swap_item.base :
+ !in_core ? swap_limit - processes[i].pool_item.base : 0;
#endif
int swap_base = ~swap_limit;
- printf("process %d: core [%d,%d) swap [%d,%d)\n", i, core_base, core_base + core_size, swap_base, swap_base + swap_size);
- for (int j = 0; j < processes[i].size; ++j) {
+ printf(
+ "process %d: core [%d,%d) swap [%d,%d)\n",
+ i,
+ core_base,
+ core_base + core_size,
+ swap_base,
+ swap_base + swap_size
+ );
+ for (int j = 0; j < core_size; ++j) {
long long hash = i * 17 + j * 29;
hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
- if (j < core_size) {
#ifdef INDIRECT_CORE
- int core_block = core_table_mem[core_base + j];
- core_table_mem[core_base + j] = 0x55555555;
+ int core_block = core_table_mem[core_base + j];
+ core_table_mem[core_base + j] = 0x55555555;
#else
- int core_block = core_base + j;
+ int core_block = core_base + j;
#endif
- rassert(core_block_mem[core_block] == (int)hash);
- core_block_mem[core_block] = 0xaaaaaaaa;
- }
- else {
+ rassert(core_block_mem[core_block] == (int)hash);
+ core_block_mem[core_block] = 0xaaaaaaaa;
+ }
+ for (int j = 0; j < swap_size; ++j) {
+ long long hash = i * 17 + (core_size + j) * 29;
+ hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
+ hash = (hash & 0xffffffffffffffffLL) + (hash >> 32);
#ifdef INDIRECT_SWAP
- int swap_block = swap_table_mem[swap_base + j - core_size];
- swap_table_mem[swap_base + j - core_size] = 0x55555555;
+ int swap_block = swap_table_mem[swap_base + j];
+ swap_table_mem[swap_base + j] = 0x55555555;
#else
- int swap_block = swap_base + j - core_size;
+ int swap_block = swap_base + j;
#endif
- rassert(swap_block_mem[swap_block] == (int)hash);
- swap_block_mem[swap_block] = 0xaaaaaaaa;
- }
+ rassert(swap_block_mem[swap_block] == (int)hash);
+ swap_block_mem[swap_block] = 0xaaaaaaaa;
}
}
}