static void test(void) {
mps_pool_t poolmv, poolawl, poolamc;
mps_thr_t thread;
mps_root_t root0, root1, root2;
mps_addr_t p;
mps_chain_t chain;
mps_fmt_t format;
mps_ap_t apawl, apamc;
mps_addr_t base;
mps_addr_t *addr;
int i,j,merge,stale,prevstale;
mycell *held[AMBIGHOLD];
RC;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), 100*1024*1024),
"create arena");
cdie(mps_thread_reg(&thread, arena), "register thread");
base = &exfmt_root;
addr = base;
cdie(
mps_root_create_table(&root0, arena, mps_rank_ambig(), 0, addr, 1),
"create exfmt root");
cdie(
mps_root_create_table(&root2, arena, mps_rank_exact(), 0,
(mps_addr_t *)obj_table, MAXLDS),
"create table root");
cdie(
mps_root_create_reg(&root1, arena, mps_rank_ambig(), 0, thread,
mps_stack_scan_ambig, stackpointer, 0),
"create register and stack root");
cdie(
mps_fmt_create_A(&format, arena, &fmtA),
"create format");
cdie(
mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated),
"create awl pool");
cdie(
mps_pool_create(&poolmv, arena, mps_class_mv(), 0x4000, 128, 0x4000),
"create mv pool");
cdie(
mps_ap_create(&apawl, poolawl, mps_rank_exact()),
"create ap");
cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create");
cdie(
mps_pool_create(&poolamc, arena, mps_class_amc(), format, chain),
"create amc pool");
cdie(
mps_ap_create(&apamc, poolamc, mps_rank_exact()),
"create ap");
/* allocate MAXLDS objects, and make each LD depend on the corresponding
object
*/
for (i=0; i < MAXLDS; i++) {
mps_alloc(&p, poolmv, sizeof(mps_ld_s));
lds[i] = (mps_ld_t) p;
mps_alloc(&p, poolmv, sizeof(mps_ld_s));
ldm[i] = (mps_ld_t) p;
}
for (i=0; i < MAXLDS; i++) {
obj_table[i] = allocone(apamc, ranint(1000), mps_rank_exact());
mps_ld_reset(lds[i], arena);
mps_ld_add(lds[i], arena, (mps_addr_t) obj_table[i]);
addr_table[i] = obj_table[i];
}
for (merge = 1; merge <= MAXMERGE; merge++) {
comment("Merge %d", merge);
for (i=0; i < MAXLDS; i++) {
if (ranint(100) < BLATPERCENT) {
obj_table[i] = allocone(apamc, ranint(1000), mps_rank_exact());
mps_ld_reset(lds[i], arena);
mps_ld_add(lds[i], arena, (mps_addr_t) obj_table[i]);
addr_table[i] = obj_table[i];
}
}
mergelds(merge);
stale = 0;
prevstale = 0;
i = 0;
while (stale < MAXLDS) {
for (j = 0; j < AMBIGHOLD; j++) {
held[j] = obj_table[ranint(MAXLDS)];
}
i++;
stale = checklds(merge);
if (stale > prevstale) {
prevstale = stale;
comment("inc to %d at %d", stale, i);
}
for (j = 0; j < JUNK; j++) {
(void)allocdumb(apamc, ranint(1000), mps_rank_exact());
}
}
}
comment("held[0] = %p", held[0]); /* avoid warning about unused variable */
mps_arena_park(arena);
mps_ap_destroy(apawl);
mps_ap_destroy(apamc);
comment("Destroyed aps.");
mps_pool_destroy(poolmv);
mps_pool_destroy(poolamc);
mps_pool_destroy(poolawl);
comment("Destroyed pools.");
mps_fmt_destroy(format);
comment("Destroyed format.");
mps_chain_destroy(chain);
comment("Destroyed chain.");
mps_root_destroy(root0);
mps_root_destroy(root1);
mps_root_destroy(root2);
comment("Destroyed roots.");
mps_thread_dereg(thread);
comment("Deregistered thread.");
mps_arena_destroy(arena);
comment("Destroyed arena.");
}
static void test(void)
{
mps_pool_t poolmv, poolawl, poolamc;
mps_thr_t thread;
mps_root_t root0, root1, root2;
mps_addr_t p;
mps_fmt_t format;
mps_chain_t chain;
mps_ap_t apawl, apamc;
mycell *a, *b;
int i,j;
RC;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t)1024*1024*30),
"create arena");
cdie(mps_thread_reg(&thread, arena), "register thread");
cdie(mps_root_create_table(&root0, arena, mps_rank_ambig(), 0,
(mps_addr_t*)&exfmt_root, 1),
"create exfmt root");
cdie(mps_root_create_table(&root2, arena, mps_rank_exact(), 0,
(mps_addr_t *)obj_table, MAXLDS),
"create table root");
cdie(mps_root_create_reg(&root1, arena, mps_rank_ambig(), 0, thread,
mps_stack_scan_ambig, stackpointer, 0),
"create register and stack root");
cdie(mps_fmt_create_A(&format, arena, &fmtA),
"create format");
cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create");
cdie(mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated),
"create awl pool");
cdie(mps_pool_create(&poolmv, arena, mps_class_mv(), 0x4000, 128, 0x4000),
"create mv pool");
cdie(mps_ap_create(&apawl, poolawl, mps_rank_exact()),
"create ap");
/* First we'll use only pool classes MV and AWL. So LDs shouldn't */
/* go stale at all. */
b = allocone(apawl, 5, mps_rank_exact());
for (i=0; i < MAXLDS; i++) {
comment("%d", i);
mps_alloc(&p, poolmv, sizeof(mps_ld_s));
a = allocone(apawl, 5, mps_rank_exact());
setref(a, 0, b);
b = a;
a = allocdumb(apawl, 256*1024, mps_rank_exact());
comment("alloc");
lds[i] = p;
mps_ld_reset(lds[i], arena);
comment("reset");
if (i>0) {
mps_ld_add(lds[i], arena, (mps_addr_t) b);
}
comment("add");
}
for (i=0; i < MAXLDS; i++) {
comment("%d", i);
asserts(mps_ld_isstale(lds[i], arena, p) == 0,
"%d stale but shouldn't be", i);
}
/* Then use AMC, so object do move and LDs go stale. */
die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain),
"create pool");
cdie(
mps_ap_create(&apamc, poolamc, mps_rank_exact()),
"create ap");
/* Allocate MAXLDS objects, and make each LD depend on the corresponding */
/* object. */
for (i=0; i < MAXLDS; i++) {
comment("%d", i);
obj_table[i] = allocone(apamc, ranint(100), mps_rank_exact());
mps_ld_add(lds[i], arena, (mps_addr_t) obj_table[i]);
}
for (i=0; i < 1000; i++) {
comment("%d of 1000", i);
checklds();
for (j=0; j < 8; j++) {
a = allocdumb(apamc, 32*1024, mps_rank_exact());
}
}
mps_ap_destroy(apawl);
mps_ap_destroy(apamc);
mps_pool_destroy(poolmv);
mps_pool_destroy(poolamc);
mps_pool_destroy(poolawl);
comment("Destroyed pools.");
mps_chain_destroy(chain);
mps_fmt_destroy(format);
mps_root_destroy(root0);
mps_root_destroy(root1);
mps_root_destroy(root2);
comment("Destroyed roots.");
mps_thread_dereg(thread);
mps_arena_destroy(arena);
comment("Destroyed arena.");
}
static void test(void) {
mps_pool_t poolmv, poolawl, poolamc;
mps_thr_t thread;
mps_root_t root0, root1, root2;
mps_addr_t p;
mps_fmt_t format;
mps_ap_t apawl, apamc;
mycell *a, *b;
int i,j;
RC;
cdie(mps_space_create(&space), "create space");
cdie(mps_thread_reg(&thread, space), "register thread");
cdie(
mps_root_create_table(&root0, space, MPS_RANK_AMBIG, 0, &exfmt_root, 1),
"create exfmt root");
cdie(
mps_root_create_table(&root2, space, MPS_RANK_EXACT, 0,
(mps_addr_t *)obj_table, MAXLDS),
"create table root");
cdie(
mps_root_create_reg(&root1, space, MPS_RANK_AMBIG, 0, thread,
mps_stack_scan_ambig, stackpointer, 0),
"create register and stack root");
cdie(
mps_fmt_create_A(&format, space, &fmtA),
"create format");
cdie(
mps_pool_create(&poolawl, space, mps_class_awl(), format),
"create awl pool");
cdie(
mps_pool_create(&poolmv, space, mps_class_mv(), 0x4000, 128, 0x4000),
"create mv pool");
cdie(
mps_ap_create(&apawl, poolawl, MPS_RANK_EXACT),
"create ap");
cdie(
mps_pool_create(&poolamc, space, mps_class_amc(), format),
"create amc pool");
cdie(
mps_ap_create(&apamc, poolamc, MPS_RANK_EXACT),
"create ap");
/* first we'll use only pool classes MV and AWL. So LDs shouldn't
go stale at all.
*/
b = allocone(apawl, 5, MPS_RANK_EXACT);
for (i=0; i < MAXLDS; i++) {
comment("%d", i);
mps_alloc(&p, poolmv, sizeof(mps_ld_s));
a = allocone(apawl, 5, MPS_RANK_EXACT);
setref(a, 0, b);
b = a;
a = allocdumb(apamc, 256*1024, MPS_RANK_EXACT);
a = allocdumb(apawl, 256*1024, MPS_RANK_EXACT);
comment("alloc");
lds[i] = p;
mps_ld_reset(lds[i], space);
comment("reset");
if (i>0) {
mps_ld_add(lds[i], space, (mps_addr_t) b);
}
comment("add");
}
for (i=0; i < MAXLDS; i++) {
comment("%d", i);
asserts(mps_ld_isstale(lds[i], space, p) == 0,
"%d stale but shouldn't be", i);
}
/* allocate MAXLDS objects, and make each LD depend on the corresponding
object
*/
for (i=0; i < MAXLDS; i++) {
comment("%d", i);
obj_table[i] = allocone(apamc, ranint(100), MPS_RANK_EXACT);
mps_ld_add(lds[i], space, (mps_addr_t) obj_table[i]);
}
for (i=0; i < 1000; i++) {
comment("%d of 1000", i);
checklds();
for (j=0; j < 4; j++) {
a = allocdumb(apamc, 32*1024, MPS_RANK_EXACT);
}
}
mps_ap_destroy(apawl);
mps_ap_destroy(apamc);
comment("Destroyed aps.");
mps_pool_destroy(poolmv);
mps_pool_destroy(poolamc);
mps_pool_destroy(poolawl);
comment("Destroyed pools.");
mps_fmt_destroy(format);
comment("Destroyed format.");
mps_root_destroy(root0);
mps_root_destroy(root1);
mps_root_destroy(root2);
comment("Destroyed roots.");
mps_thread_dereg(thread);
comment("Deregistered thread.");
mps_space_destroy(space);
comment("Destroyed space.");
}
