static void test(void) { mps_arena_t arena; mps_pool_t poolamc, poolawl; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_chain_t chain; mps_ap_t apamc, apawl, apran; mycell *a[100], *c; int i; int j; int k,z; alloccomments = 1; skipcomments = 1; formatcomments = 1; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); die(mps_thread_reg(&thread, arena), "register thread"); die(mps_root_create_reg(&root, arena, MPS_RANK_AMBIG, 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); die(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_pool_create(&poolawl, arena, mps_class_awl(), format), "create pool"); cdie( mps_ap_create(&apawl, poolawl, MPS_RANK_EXACT), "create ap"); cdie( mps_ap_create(&apamc, poolamc, MPS_RANK_EXACT), "create ap"); for(i=0; i<100; i++) { a[i] = allocone(apamc, 6, 1); } for(i=0; i<10000; i++) { j = ranint(100); k = 5 + ranint(500); if (ranint(2)==1) { apran = apawl; } else { apran = apamc; } c = a[j]; a[j] = allocone(apran, k, 1); k = ranint(100); z = ranint(2); setref(a[k], 0, c); setref(a[j], z, a[k]); } mps_ap_destroy(apawl); mps_ap_destroy(apamc); mps_pool_destroy(poolamc); mps_pool_destroy(poolawl); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_pool_t pool; mps_thr_t thread; mps_root_t root, root1; mps_fmt_t format; mps_chain_t chain; mps_ap_t ap; mycell *a, *b; mps_addr_t addr; mps_res_t res; int j; /* create an arena that can't grow beyond 30 M */ cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*30)), "create arena"); cdie(mps_arena_commit_limit_set(arena, (size_t) (1024*1024*30)), "limit"); die(mps_thread_reg(&thread, arena), "register thread"); die(mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie(mps_root_create_table(&root1, arena, mps_rank_ambig(), 0, (mps_addr_t *)&exfmt_root, 1), "create table root"); die(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&pool, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_ap_create(&ap, pool, mps_rank_exact()), "create ap"); /* allocate 16 M of (live) stuff */ b = allocone(ap, 2, mps_rank_exact()); for (j=0; j<160; j++) { a = allocone(ap, 2, mps_rank_exact()); setref(a, 0, b); b = allocdumb(ap, 1024*100, mps_rank_exact()); setref(a, 1, b); b = a; } comment("created 16M of live objects"); for (j=0; j<1000; j++) { res=allocrdumb(&a, ap, 1024*1024, mps_rank_exact()); } fillup(); comment("finalizing..."); addr = a; for (j=0; j<100; j++) { comment(err_text(mps_finalize(arena, &addr))); } comment("try to make collectm by allocating another 1G..."); empty(); for (j=0; j<1024; j++) { res=allocrdumb(&a, ap, 1024 * 1024, mps_rank_exact()); if (res == MPS_RES_OK) { comment("%i ok", j); } else { break; } } comment("collect world..."); for (j=0; j<100; j++) { mps_arena_collect(arena); } mps_arena_park(arena); mps_ap_destroy(ap); mps_pool_destroy(pool); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_root_destroy(root1); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void *test(void *arg, size_t s) { unsigned i; /* index */ mps_ap_t ap; mps_fmt_t fmt; mps_chain_t chain; mps_pool_t amc; mps_res_t e; mps_root_t mps_root[2]; mps_addr_t nullref = NULL; int state[rootCOUNT]; mps_arena_t arena; void *p = NULL; mps_message_t message; arena = (mps_arena_t)arg; (void)s; die(mps_fmt_create_A(&fmt, arena, dylan_fmt_A()), "fmt_create\n"); die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mps_pool_create(&amc, arena, mps_class_amc(), fmt, chain), "pool_create amc\n"); die(mps_root_create_table(&mps_root[0], arena, mps_rank_exact(), (mps_rm_t)0, root, (size_t)rootCOUNT), "root_create\n"); die(mps_root_create_table(&mps_root[1], arena, mps_rank_exact(), (mps_rm_t)0, &p, (size_t)1), "root_create\n"); die(mps_ap_create(&ap, amc, mps_rank_exact()), "ap_create\n"); /* Make registered-for-finalization objects. */ /* <design/poolmrg/#test.promise.ut.alloc> */ for(i = 0; i < rootCOUNT; ++i) { do { MPS_RESERVE_BLOCK(e, p, ap, vectorSIZE); die(e, "MPS_RES_OK"); die(dylan_init(p, vectorSIZE, &nullref, 1), "dylan_init"); } while (!mps_commit(ap, p, vectorSIZE)); /* store index in vector's slot */ ((mps_word_t *)p)[vectorSLOT] = dylan_int(i); die(mps_finalize(arena, &p), "finalize\n"); root[i] = p; state[i] = rootSTATE; } p = NULL; mps_message_type_enable(arena, mps_message_type_finalization()); /* <design/poolmrg/#test.promise.ut.churn> */ while (mps_collections(arena) < collectionCOUNT) { /* Perhaps cause (minor) collection */ churn(ap); /* Maybe make some objects ready-to-finalize */ /* <design/poolmrg/#test.promise.ut.drop> */ for (i = 0; i < rootCOUNT; ++i) { if (root[i] != NULL && state[i] == rootSTATE) { if (rnd() % finalizationRATE == 0) { /* for this object, either... */ if (rnd() % 2 == 0) { /* ...definalize it, or */ die(mps_definalize(arena, &root[i]), "definalize\n"); state[i] = deadSTATE; } else { /* ...expect it to be finalized soon */ state[i] = finalizableSTATE; } /* Drop the root reference to it; this makes it */ /* non-E-reachable: so either dead, or ready-to-finalize. */ root[i] = NULL; } } } /* Test any finalized objects, and perhaps resurrect some */ while (mps_message_poll(arena)) { mps_word_t *obj; mps_word_t objind; mps_addr_t objaddr; /* <design/poolmrg/#test.promise.ut.message> */ cdie(mps_message_get(&message, arena, mps_message_type_finalization()), "get"); cdie(0 == mps_message_clock(arena, message), "message clock should be 0 (unset) for finalization messages"); mps_message_finalization_ref(&objaddr, arena, message); obj = objaddr; objind = dylan_int_int(obj[vectorSLOT]); printf("Finalizing: object %lu at %p\n", objind, objaddr); /* <design/poolmrg/#test.promise.ut.final.check> */ cdie(root[objind] == NULL, "finalized live"); cdie(state[objind] == finalizableSTATE, "finalized dead"); state[objind] = finalizedSTATE; /* sometimes resurrect */ if (rnd() % 2 == 0) root[objind] = objaddr; mps_message_discard(arena, message); } } /* @@@@ <design/poolmrg/#test.promise.ut.nofinal.check> missing */ mps_ap_destroy(ap); mps_root_destroy(mps_root[1]); mps_root_destroy(mps_root[0]); mps_pool_destroy(amc); mps_chain_destroy(chain); mps_fmt_destroy(fmt); return NULL; }
static void test(void *stack_pointer) { mps_arena_t arena; mps_pool_t pool; mps_thr_t thread; mps_root_t root, root1; mps_fmt_t format; mps_chain_t chain; mps_ap_t ap; mycell *a[3]; int i,j,k; clock_t time0, time1; formatcomments = 1; 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(&root, arena, mps_rank_ambig(), 0, (mps_addr_t*)&a[0], 3), "create table root"); cdie(mps_root_create_table(&root1, arena, mps_rank_ambig(), 0, (mps_addr_t *)&exfmt_root, 1), "exfmt root"); cdie(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&pool, arena, mps_class_amc(), format, chain), "create pool"); cdie(mps_ap_create(&ap, pool, mps_rank_exact()), "create ap"); time0 = clock(); asserts(time0 != -1, "processor time not available"); for (k=0; k<100; k++) { for (j=0; j<100; j++) { a[0] = allocone(ap, 50, mps_rank_exact()); a[1] = a[0]; for (i=1; i<100; i++) { a[2] = allocone(ap, 50, mps_rank_exact()); setref(a[1], 0, a[2]); a[1] = a[2]; } } time1 = clock(); comment("%d: %i", k, (int) (100*(time1-time0)/CLOCKS_PER_SEC)); time0 = time1; } mps_arena_park(arena); mps_ap_destroy(ap); mps_pool_destroy(pool); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_root_destroy(root1); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mycell *a[4], /* a is a table of exact roots */ *b[4]; /* b is a table of ambiguous roots */ int i, j, k; mps_chain_t chain; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); cdie(mps_root_create_table(&root, arena, mps_rank_exact(), 0, (mps_addr_t *)&a[0], 4), "create a root table"); cdie(mps_root_create_table(&root1, arena, mps_rank_ambig(), 0, (mps_addr_t *)&b[0], 4), "create b root table"); cdie(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain), "create pool(amc)"); die(mmqa_pool_create_chain(&poollo, arena, mps_class_amcz(), format, chain), "create pool(amcz)"); die(mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated), "create pool(awl)"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap(amc)"); cdie( mps_ap_create(&aplo, poollo, mps_rank_exact()), "create ap(amcz)"); cdie( mps_ap_create(&apawl, poolawl, mps_rank_exact()), "create ap(awl)"); newstamp = 0; for (i=0; i<4; i++) { die(allocrdumb(&a[i], aplo, 64, mps_rank_exact()), "alloc failed"); a[i]->data.checkedflag = newstamp; die(allocrone(&b[i], apawl, 5, mps_rank_exact()), "alloc failed"); b[i]->data.checkedflag = newstamp; b[i]->data.ref[0].addr = a[i]; die(allocrone(&a[i], apamc, 5, mps_rank_exact()), "alloc failed"); a[i]->data.checkedflag = newstamp; a[i]->data.ref[0].addr = b[i]; } for (j=0; j<100; j++) { comment("%i of 100", j); for (i=0; i<10000; i++) { k = ranint(4); die(allocrdumb(&a[k], aplo, 64, mps_rank_exact()), "alloc failed"); a[k]->data.checkedflag = newstamp; k = ranint(4); die(allocrone(&b[k], apawl, 5, mps_rank_exact()), "alloc failed"); b[k]->data.checkedflag = newstamp; b[k]->data.ref[0].addr = a[ranint(4)]; b[k]->data.ref[1].addr = b[ranint(4)]; die(allocrone(&a[k], apamc, 5, mps_rank_exact()), "alloc failed"); a[k]->data.checkedflag = newstamp; a[k]->data.ref[2].addr = b[ranint(4)]; } comment("walking..."); mps_arena_park(arena); mps_arena_collect(arena); oldstamp = newstamp; newstamp += 1; mps_arena_formatted_objects_walk(arena, stepper, (void *)MAGICPOINT, MAGICSIZE); mps_arena_release(arena); comment("tracing..."); oldstamp = newstamp; newstamp += 1; tracegraph((mycell *) exfmt_root); tracegraph(a[0]); tracegraph(a[1]); tracegraph(a[2]); tracegraph(a[3]); tracegraph(b[0]); tracegraph(b[1]); tracegraph(b[2]); tracegraph(b[3]); comment("ok"); } mps_ap_destroy(apamc); mps_ap_destroy(aplo); mps_ap_destroy(apawl); comment("Destroyed aps."); mps_pool_destroy(poolamc); mps_pool_destroy(poollo); mps_pool_destroy(poolawl); comment("Destroyed pools."); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_root_destroy(root1); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void *test(void *arg, size_t s) { mps_arena_t arena; mps_fmt_t fmt; mps_chain_t chain; mps_pool_t amc; mps_root_t mps_root[2]; mps_ap_t ap; mps_res_t e; int i; mps_addr_t nullref = NULL; void *p = NULL; int N = rootCOUNT - 1; arena = (mps_arena_t)arg; (void)s; die(mps_fmt_create_A(&fmt, arena, dylan_fmt_A()), "fmt_create\n"); die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mps_pool_create(&amc, arena, mps_class_amc(), fmt, chain), "pool_create amc\n"); die(mps_root_create_table(&mps_root[0], arena, MPS_RANK_EXACT, (mps_rm_t)0, root, (size_t)rootCOUNT), "root_create\n"); die(mps_root_create_table(&mps_root[1], arena, MPS_RANK_EXACT, (mps_rm_t)0, &p, (size_t)1), "root_create\n"); die(mps_ap_create(&ap, amc, MPS_RANK_EXACT), "ap_create\n"); /* Make registered-for-finalization objects. */ /* <design/poolmrg/#test.promise.ut.alloc> */ for(i = 0; i < rootCOUNT; ++i) { do { MPS_RESERVE_BLOCK(e, p, ap, vectorSIZE(2)); die(e, "MPS_RES_OK"); die(dylan_init(p, vectorSIZE(2), &nullref, 1), "dylan_init"); } while (!mps_commit(ap, p, vectorSIZE(2))); /* set vector's slots */ ((mps_word_t *)p)[vectorSLOT(0)] = dylan_int(i); ((mps_word_t *)p)[vectorSLOT(1)] = (mps_word_t)NULL; die(mps_finalize(arena, &p), "finalize\n"); root[i] = p; state[i] = rootSTATE; } p = NULL; mps_message_type_enable(arena, mps_message_type_finalization()); mps_arena_collect(arena); report(arena, 0); /* make 0 and N finalizable */ root[0] = NULL; state[0] = finalizableSTATE; root[N] = NULL; state[N] = finalizableSTATE; mps_arena_collect(arena); report(arena, 2); /* make 1 and N-1 refer to each other and finalizable */ ((mps_word_t *)root[1])[vectorSLOT(1)] = (mps_word_t)root[N-1]; ((mps_word_t *)root[N-1])[vectorSLOT(1)] = (mps_word_t)root[1]; root[1] = NULL; state[1] = finalizableSTATE; root[N-1] = NULL; state[N-1] = finalizableSTATE; mps_arena_collect(arena); report(arena, 2); mps_arena_collect(arena); report(arena, 0); /* @@@@ <design/poolmrg/#test.promise.ut.nofinal.check> missing */ mps_ap_destroy(ap); mps_root_destroy(mps_root[1]); mps_root_destroy(mps_root[0]); mps_pool_destroy(amc); mps_chain_destroy(chain); mps_fmt_destroy(fmt); return NULL; }
static void test(void) { mps_arena_t arena; mps_pool_t pool; mps_thr_t thread; mps_root_t root; mps_ap_t apA, apB; mps_fmt_t format; mps_chain_t chain; mycell *ambigref; size_t bytes; size_t alignment; mps_addr_t q; int i; formatcomments = 1; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); cdie(mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); cdie(mmqa_pool_create_chain(&pool, arena, mps_class_amc(), format, chain), "create pool"); die(mps_ap_create(&apA, pool, mps_rank_exact()), "create apA"); die(mps_ap_create(&apB, pool, mps_rank_exact()), "create apB"); bytes = offsetof(struct data, ref) + sizeof(struct refitem); alignment = MPS_PF_ALIGN; bytes = (bytes+alignment-1)&~(alignment-1); die(mps_reserve(&q, apB, bytes), "reserve: "); comment("Reserve"); ambigref = q; ambigref->data.tag = MCdata; ambigref->data.id = MCerrorid; ambigref->data.numrefs = 0; ambigref->data.size = bytes; comment("Midallocation"); for(i = 0; i < 40; i++) { allocdumb(apA, 1024*256); } comment("Commit"); asserts(mps_commit(apB, q, bytes) == 0, "Commit succeeded!"); comment("Postallocation"); for(i = 0; i < 40; i++) { allocdumb(apA, 1024*256); } comment("Finished"); mps_ap_destroy(apA); mps_ap_destroy(apB); mps_pool_destroy(pool); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_arena_t arena; mps_pool_t poolamc, poolawl; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_chain_t chain; mps_ap_t apamc, apawl; mycell *a, *b, *c, *d, *e, *f, *g; int i; int j; RC; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); die(mps_thread_reg(&thread, arena), "register thread"); die(mps_root_create_reg(&root, arena, MPS_RANK_AMBIG, 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); die(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_pool_create(&poolawl, arena, mps_class_awl(), format), "create pool"); cdie( mps_ap_create(&apawl, poolawl, MPS_RANK_EXACT), "create ap"); cdie( mps_ap_create(&apamc, poolamc, MPS_RANK_EXACT), "create ap"); b = allocone(apamc, 1, 1); for (j=1; j<100; j++) { comment("%i of 100.", j); UC; a = allocone(apamc, 5, 1); b = a; c = a; d = a; e = a; f = a; g = a; for (i=1; i<5000; i++) { UC; c = allocone(apamc, 20, 1); d = allocone(apawl, 20, 1); if (ranint(8) == 0) e = c; if (ranint(8) == 0) f = c; if (ranint(8) == 0) g = c; UC; setref(b, 0, c); UC; setref(c, 1, d); UC; setref(c, 2, e); UC; setref(c, 3, f); UC; setref(c, 4, g); UC; b = c; } DC; DMC; } mps_ap_destroy(apawl); mps_ap_destroy(apamc); mps_pool_destroy(poolamc); mps_pool_destroy(poolawl); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); 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_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), "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 *arg, size_t s) { mps_ap_t ap; mps_fmt_t fmt; mps_chain_t chain; mps_word_t finals; mps_pool_t amc; mps_root_t mps_root; mps_arena_t arena; mps_message_t message; size_t i; arena = (mps_arena_t)arg; (void)s; die(mps_fmt_create_A(&fmt, arena, dylan_fmt_A()), "fmt_create\n"); die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mps_pool_create(&amc, arena, mps_class_amc(), fmt, chain), "pool_create amc\n"); die(mps_root_create_table(&mps_root, arena, mps_rank_exact(), (mps_rm_t)0, root, (size_t)rootCOUNT), "root_create\n"); die(mps_ap_create(&ap, amc, mps_rank_exact()), "ap_create\n"); mps_message_type_enable(arena, mps_message_type_finalization()); mps_arena_park(arena); object_count = 0; printf("Making some finalized trees of objects.\n"); /* make some trees */ for(i = 0; i < rootCOUNT; ++i) { root[i] = (void *)make_numbered_tree(maxtreeDEPTH, ap); register_numbered_tree((mps_word_t)root[i], arena); } mps_arena_unsafe_expose_remember_protection(arena); mps_arena_unsafe_restore_protection(arena); printf("Losing all pointers to the trees.\n"); /* clean out the roots */ for(i = 0; i < rootCOUNT; ++i) { root[i] = 0; } finals = 0; while ((finals < object_count) && (mps_collections(arena) < collectionCOUNT)) { mps_word_t final_this_time = 0; printf("Collecting..."); (void)fflush(stdout); die(mps_arena_collect(arena), "collect"); printf(" Done.\n"); while (mps_message_poll(arena)) { mps_word_t obj; mps_addr_t objaddr; cdie(mps_message_get(&message, arena, mps_message_type_finalization()), "get"); mps_message_finalization_ref(&objaddr, arena, message); obj = (mps_word_t)objaddr; mps_message_discard(arena, message); ++ final_this_time; testlib_unused(obj); } finals += final_this_time; printf("%"PRIuLONGEST" objects finalized: total %"PRIuLONGEST " of %"PRIuLONGEST"\n", (ulongest_t)final_this_time, (ulongest_t)finals, (ulongest_t)object_count); } object_count = 0; printf("Making some indirectly finalized trees of objects.\n"); /* make some trees */ for(i = 0; i < rootCOUNT; ++i) { root[i] = (void *)make_indirect_tree(maxtreeDEPTH, ap); register_indirect_tree((mps_word_t)root[i], arena); } printf("Losing all pointers to the trees.\n"); /* clean out the roots */ for(i = 0; i < rootCOUNT; ++i) { root[i] = 0; } finals = 0; while ((finals < object_count) && (mps_collections(arena) < collectionCOUNT)) { mps_word_t final_this_time = 0; printf("Collecting..."); (void)fflush(stdout); die(mps_arena_collect(arena), "collect"); printf(" Done.\n"); while (mps_message_poll(arena)) { mps_word_t obj; mps_addr_t objaddr; cdie(mps_message_get(&message, arena, mps_message_type_finalization()), "get"); mps_message_finalization_ref(&objaddr, arena, message); obj = (mps_word_t)objaddr; mps_message_discard(arena, message); ++ final_this_time; testlib_unused(obj); } finals += final_this_time; printf("%"PRIuLONGEST" objects finalized: total %"PRIuLONGEST " of %"PRIuLONGEST"\n", (ulongest_t)final_this_time, (ulongest_t)finals, (ulongest_t)object_count); } mps_ap_destroy(ap); mps_root_destroy(mps_root); mps_pool_destroy(amc); mps_chain_destroy(chain); mps_fmt_destroy(fmt); return NULL; }
static void test(void *stack_pointer) { mps_arena_t arena; mps_pool_t pool; mps_thr_t thread; mps_root_t root; mps_chain_t chain; mps_fmt_t format; mps_ap_t ap; mps_addr_t p; mps_addr_t q; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); cdie(mps_root_create_thread(&root, arena, thread, stack_pointer), "thread 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(&pool, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_ap_create(&ap, pool, mps_rank_exact()), "create ap"); do { cdie(mps_reserve(&p, ap, 0x100), "Reserve: "); q = (mps_addr_t) ((char *)p); } while (!mps_commit(ap, q, 0x110)); comment("Committed."); mps_ap_destroy(ap); comment("Destroyed ap."); mps_pool_destroy(pool); comment("Destroyed pool."); mps_fmt_destroy(format); comment("Destroyed format."); mps_chain_destroy(chain); comment("Destroyed chain."); mps_root_destroy(root); comment("Destroyed root."); mps_thread_dereg(thread); comment("Deregistered thread."); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_pool_t poolamc, poolawl, poollo; mps_thr_t thread; mps_root_t root0, root1; mps_chain_t chain; mps_fmt_t format; mps_ap_t apamc, apawl, aplo; mycell *a, *b, *c, *d, *z; long int j; cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t)(1024*1024*40)), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); cdie(mps_root_create_reg(&root0, arena, mps_rank_ambig(), 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie(mps_root_create_table(&root1, arena, mps_rank_ambig(), 0, (mps_addr_t *)&exfmt_root, 1), "create table root"); cdie(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain), "create pool(amc)"); die(mmqa_pool_create_chain(&poollo, arena, mps_class_amcz(), format, chain), "create pool(amcz)"); cdie(mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated), "create pool(awl)"); cdie(mps_ap_create(&apawl, poolawl, mps_rank_weak()), "create ap(awl)"); cdie(mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap(amc)"); cdie(mps_ap_create(&aplo, poollo, mps_rank_exact()), "create ap(amcz)"); mps_message_type_enable(arena, mps_message_type_finalization()); mps_message_type_enable(arena, mps_message_type_gc()); /* register loads of objects for finalization (1000*4) */ a = allocone(apamc, 2, 1); for (j=0; j<1000; j++) { b = allocone(apamc, 2, mps_rank_exact()); c = allocone(apawl, 2, mps_rank_weak()); d = allocone(aplo, 2, mps_rank_exact()); /* rank irrelevant here! */ mps_finalize(arena, (mps_addr_t*)&b); mps_finalize(arena, (mps_addr_t*)&c); mps_finalize(arena, (mps_addr_t*)&d); mps_finalize(arena, (mps_addr_t*)&d); final_count += 4; setref(a, 0, b); setref(a, 1, c); setref(c, 1, d); a = b; } /* throw them all away and collect everything */ a = NULL; b = NULL; c = NULL; d = NULL; exfmt_root = NULL; for (j=0; j<5; j++) { mps_arena_collect(arena); while (mps_message_poll(arena)) { messagepoll(&z, FINAL_DISCARD); } } /* how many are left? (n.b. ideally this would be 0 but there's no guarantee) */ report("count1", "%i", final_count); /* now to test leaving messages open for a long time! */ for (j=0; j<10; j++) { comment("%d of 10", j); a = allocone(apamc, 10000, mps_rank_exact()); mps_finalize(arena, (mps_addr_t*)&a); final_count +=1; comment("finalize"); messagepoll(&z, FINAL_QUEUE); } comment("reregister"); for (j=0; j<10; j++) { comment("%d of 10", j); qpoll(&z, FINAL_REREGISTER); } b = a; z = a; for (j=0; j<10; j++) { comment("%d of 10", j); messagepoll(&z, FINAL_QUEUE); qpoll(&z, FINAL_STORE); a = allocone(apamc, 2, mps_rank_exact()); setref(z, 0, b); setref(a, 1, z); b = a; } for (j=0; j<10; j++) { a = allocone(apamc, 2, mps_rank_exact()); qpoll(&z, FINAL_DISCARD); messagepoll(&z, FINAL_DISCARD); setref(a, 0, b); b = a; } /* Force old objects to be killed */ while (qmt() == 0) { qpoll(&z, FINAL_DISCARD); } while (mps_message_poll(arena)) { messagepoll(&z, FINAL_DISCARD); } mps_arena_park(arena); mps_root_destroy(root0); mps_root_destroy(root1); comment("Destroyed roots."); mps_ap_destroy(apawl); mps_ap_destroy(apamc); mps_ap_destroy(aplo); comment("Destroyed aps."); mps_arena_collect(arena); comment("Collected arena."); while (mps_message_poll(arena)) { messagepoll(&z, FINAL_DISCARD); } report("count2", "%d", final_count); mps_arena_park(arena); mps_pool_destroy(poolamc); mps_pool_destroy(poolawl); mps_pool_destroy(poollo); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void *test(mps_arena_t arena, mps_class_t pool_class) { mps_chain_t chain; mps_fmt_t format; mps_pool_t pool; mps_root_t exactRoot; size_t i; unsigned long objs; struct stepper_data sdStruct, *sd; die(dylan_fmt(&format, arena), "fmt_create"); die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_FORMAT, format); MPS_ARGS_ADD(args, MPS_KEY_CHAIN, chain); MPS_ARGS_ADD(args, MPS_KEY_AWL_FIND_DEPENDENT, test_awl_find_dependent); die(mps_pool_create_k(&pool, arena, pool_class, args), "pool_create"); } MPS_ARGS_END(args); die(mps_ap_create(&ap, pool, mps_rank_exact()), "ap_create"); for(i = 0; i < exactRootsCOUNT; ++i) exactRoots[i] = objNULL; die(mps_root_create_table_masked(&exactRoot, arena, mps_rank_exact(), (mps_rm_t)0, &exactRoots[0], exactRootsCOUNT, (mps_word_t)1), "root_create_table(exact)"); objs = 0; while(objs < objCOUNT) { size_t r; r = objs; i = r % exactRootsCOUNT; if(exactRoots[i] != objNULL) { cdie(dylan_check(exactRoots[i]), "dying root check"); } exactRoots[i] = make(); if(exactRoots[(exactRootsCOUNT-1) - i] != objNULL) dylan_write(exactRoots[(exactRootsCOUNT-1) - i], exactRoots, exactRootsCOUNT); ++objs; } sd = &sdStruct; sd->arena = arena; sd->expect_pool = pool; sd->expect_fmt = format; sd->count = 0; mps_arena_formatted_objects_walk(arena, stepper, sd, sizeof *sd); /* Note: stepper finds more than we expect, due to pad objects */ /* printf("stepper found %ld objs\n", sd->count); */ mps_ap_destroy(ap); mps_root_destroy(exactRoot); mps_pool_destroy(pool); mps_chain_destroy(chain); mps_fmt_destroy(format); return NULL; }
static void test(void) { mps_arena_t arena; mps_pool_t pool; mps_thr_t thread; mps_root_t root; mps_chain_t chain; mps_fmt_t format; mps_ap_t ap; mycell *a, *b; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); cdie( mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create 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(&pool, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_ap_create(&ap, pool, mps_rank_exact()), "create ap"); a = allocone(ap, 1024, 1); z = a; b = allocone(ap, 1024, 1); setref(b, 0, a); a = allocdumb(ap, 1024*64, 1); a = allocdumb(ap, 1024*64, 1); comment("Collecting..."); mps_arena_collect(arena); asserts(z != a, "Didn't move!"); comment("Writing bad pointer..."); b->data.ref[0].addr = z; mps_arena_collect(arena); comment("Bad pointer not spotted in collection"); fail(); mps_ap_destroy(ap); comment("Destroyed ap."); mps_pool_destroy(pool); comment("Destroyed pool."); mps_fmt_destroy(format); comment("Destroyed format."); mps_chain_destroy(chain); comment("Destroyed chain."); mps_root_destroy(root); comment("Destroyed root."); mps_thread_dereg(thread); comment("Deregistered thread."); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_arena_t arena; mps_pool_t poolamc1, poolamc2; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_chain_t chain; mps_ap_t ap1, ap2; mycell *a, *b; int i; int j; RC; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); die(mps_thread_reg(&thread, arena), "register thread"); die(mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); die(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&poolamc1, arena, mps_class_amc(), format, chain), "create pool(1)"); die(mmqa_pool_create_chain(&poolamc2, arena, mps_class_amc(), format, chain), "create pool(2)"); cdie( mps_ap_create(&ap1, poolamc1, mps_rank_exact()), "create ap"); cdie( mps_ap_create(&ap2, poolamc2, mps_rank_exact()), "create ap"); for (j = 1; j < 100; j++) { comment("%i of 100.", j); for (i = 1; i < 10000; i++) { UC; a = allocone(ap1, 2, 1); b = allocone(ap1, 2, 1); setref(a, 0, b); setref(b, 0, a); UC; } DC; DMC; } mps_ap_destroy(ap1); mps_ap_destroy(ap2); mps_pool_destroy(poolamc1); mps_pool_destroy(poolamc2); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void *test(void *arg, size_t s) { mps_arena_t arena; mps_fmt_t format; mps_chain_t chain; mps_root_t exactRoot, ambigRoot, singleRoot, fmtRoot; unsigned long i; /* Leave arena clamped until we have allocated this many objects. is 0 when arena has not been clamped. */ unsigned long clamp_until = 0; size_t j; mps_word_t collections; mps_pool_t mv; mps_addr_t alloced_obj; size_t asize = 32; /* size of alloced obj */ mps_addr_t obj; mps_ld_s ld; mps_alloc_pattern_t ramp = mps_alloc_pattern_ramp(); size_t rampCount = 0; mps_res_t res; arena = (mps_arena_t)arg; testlib_unused(s); die(dylan_fmt(&format, arena), "fmt_create"); die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mps_pool_create(&mv, arena, mps_class_mv(), 0x10000, 32, 0x10000), "pool_create(mv)"); pool_create_v_test(arena, format, chain); /* creates amc pool */ ap_create_v_test(amcpool); die(mps_ap_create(&ap, amcpool), "ap_create"); for(j = 0; j < exactRootsCOUNT; ++j) { exactRoots[j] = objNULL; } for(j = 0; j < ambigRootsCOUNT; ++j) { ambigRoots[j] = (mps_addr_t)rnd(); } die(mps_root_create_table_masked(&exactRoot, arena, MPS_RANK_EXACT, (mps_rm_t)0, &exactRoots[0], exactRootsCOUNT, (mps_word_t)1), "root_create_table(exact)"); die(mps_root_create_table(&ambigRoot, arena, MPS_RANK_AMBIG, (mps_rm_t)0, &ambigRoots[0], ambigRootsCOUNT), "root_create_table(ambig)"); obj = objNULL; die(mps_root_create(&singleRoot, arena, MPS_RANK_EXACT, (mps_rm_t)0, &root_single, &obj, 0), "root_create(single)"); /* test non-inlined reserve/commit */ obj = make_no_inline(); die(mps_alloc(&alloced_obj, mv, asize), "mps_alloc"); die(dylan_init(alloced_obj, asize, exactRoots, exactRootsCOUNT), "dylan_init(alloced_obj)"); die(mps_root_create_fmt(&fmtRoot, arena, MPS_RANK_EXACT, (mps_rm_t)0, dylan_fmt_A()->scan, alloced_obj, (mps_addr_t)(((char*)alloced_obj)+asize)), "root_create_fmt"); mps_ld_reset(&ld, arena); mps_ld_add(&ld, arena, obj); if (mps_ld_isstale(&ld, arena, obj)) { mps_ld_reset(&ld, arena); mps_ld_add(&ld, arena, obj); } collections = mps_collections(arena); for(i = 0; i < OBJECTS; ++i) { unsigned c; size_t r; c = mps_collections(arena); if(collections != c) { collections = c; printf("\nCollection %u, %lu objects.\n", c, i); for(r = 0; r < exactRootsCOUNT; ++r) { cdie(exactRoots[r] == objNULL || dylan_check(exactRoots[r]), "all roots check"); } if(collections == 1) { mps_arena_clamp(arena); clamp_until = i + 10000; } if(collections % 6 == 0) { mps_arena_expose(arena); mps_arena_release(arena); } if(collections % 6 == 3) { mps_arena_unsafe_expose_remember_protection(arena); mps_arena_unsafe_restore_protection(arena); mps_arena_release(arena); } if(collections % 6 == 4) { mps_arena_unsafe_expose_remember_protection(arena); mps_arena_release(arena); } if(collections % 3 == 2) { mps_arena_park(arena); mps_arena_release(arena); } } if(clamp_until && i >= clamp_until) { mps_arena_release(arena); clamp_until = 0; } if (rnd() % patternFREQ == 0) { switch(rnd() % 4) { case 0: case 1: die(mps_ap_alloc_pattern_begin(ap, ramp), "alloc_pattern_begin"); ++rampCount; break; case 2: res = mps_ap_alloc_pattern_end(ap, ramp); cdie(rampCount > 0 ? res == MPS_RES_OK : res == MPS_RES_FAIL, "alloc_pattern_end"); if (rampCount > 0) { --rampCount; } break; case 3: die(mps_ap_alloc_pattern_reset(ap), "alloc_pattern_reset"); rampCount = 0; break; } } if (rnd() & 1) { exactRoots[rnd() % exactRootsCOUNT] = make(); } else { ambigRoots[rnd() % ambigRootsCOUNT] = make(); } r = rnd() % exactRootsCOUNT; if (exactRoots[r] != objNULL) { cdie(dylan_check(exactRoots[r]), "random root check"); } } arena_commit_test(arena); reservoir_test(arena); alignmentTest(arena); die(mps_arena_collect(arena), "collect"); mps_free(mv, alloced_obj, 32); alloc_v_test(mv); mps_pool_destroy(mv); mps_ap_destroy(ap); mps_root_destroy(fmtRoot); mps_root_destroy(singleRoot); mps_root_destroy(exactRoot); mps_root_destroy(ambigRoot); mps_pool_destroy(amcpool); mps_chain_destroy(chain); mps_fmt_destroy(format); return NULL; }
static void test(void) { mps_arena_t arena; mps_pool_t pool; mps_thr_t thread; mps_root_t root; mps_chain_t chain; mps_fmt_t format; mps_ap_t ap; mycell *a,*b,*c; size_t inpsize; int i,j; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); cdie( mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie( mps_fmt_create_A(&format, arena, &fmtA), "create format"); formatcomments = 0; cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); cdie( mps_pool_create(&pool, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_ap_create(&ap, pool, mps_rank_exact()), "create ap"); scanf("%lx", &inpsize); for (j=0; j<10000; j++) { a = allocone(ap, 0, NULL, NULL, inpsize); b = a; for (i=1; i<100; i++) { c = allocone(ap, i, NULL, NULL, inpsize); b->ref[0] = c; b = c; } comment("%d: %x", j, (int) a); } mps_ap_destroy(ap); comment("Destroyed ap."); mps_pool_destroy(pool); comment("Destroyed pool."); mps_fmt_destroy(format); comment("Destroyed format."); mps_chain_destroy(chain); comment("Destroyed chain."); mps_root_destroy(root); comment("Destroyed root."); mps_thread_dereg(thread); comment("Deregistered thread."); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_pool_t poolamc, poolawl, poollo; mps_thr_t thread; mps_root_t root0, root1; mps_fmt_t format; mps_chain_t chain; mps_ap_t apamc, apawl, aplo; mycell *a, *b, *c, *d, *z; long int i,j; 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_reg(&root0, arena, MPS_RANK_AMBIG, 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie(mps_root_create_table(&root1, arena, MPS_RANK_AMBIG, 0, (mps_addr_t*)&exfmt_root, 1), "create table root"); cdie(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain), "create pool(amc)"); cdie(mps_pool_create(&poolawl, arena, mps_class_awl(), format), "create pool(awl)"); cdie(mmqa_pool_create_chain(&poollo, arena, mps_class_amcz(), format, chain), "create pool(amcz)"); cdie(mps_ap_create(&apawl, poolawl, MPS_RANK_WEAK), "create ap(awl)"); cdie(mps_ap_create(&apamc, poolamc, MPS_RANK_EXACT), "create ap(amc)"); cdie(mps_ap_create(&aplo, poollo, MPS_RANK_EXACT), "create ap(amcz)"); mps_message_type_enable(arena, mps_message_type_finalization()); /* register loads of objects for finalization (1000*4) */ a = allocone(apamc, 2, 1); b = a; for (j=0; j<1000; j++) { a = allocone(apamc, 2, MPS_RANK_EXACT); c = allocone(apawl, 2, MPS_RANK_WEAK); d = allocone(aplo, 2, MPS_RANK_EXACT); /* rank irrelevant here! */ mps_finalize(arena, (mps_addr_t*)&a); mps_finalize(arena, (mps_addr_t*)&c); mps_finalize(arena, (mps_addr_t*)&d); mps_finalize(arena, (mps_addr_t*)&d); final_count += 4; } /* throw them all away and collect everything */ a = NULL; b = NULL; c = NULL; d = NULL; mps_root_destroy(root0); mps_root_destroy(root1); comment("Destroyed roots."); mps_arena_collect(arena); i = 0; while (final_count != 0 && i < 10) { finalpoll(&z, FINAL_DISCARD); if (mps_message_poll(arena) == 0) { i++; a = allocdumb(apawl, 1024, MPS_RANK_WEAK); a = allocdumb(apamc, 1024, MPS_RANK_EXACT); a = allocdumb(aplo, 1024, MPS_RANK_EXACT); mps_arena_collect(arena); comment(" %i", final_count); } } /* how many are left? (Ideally, this would be 0 but there's no guarantee.) */ report("count", "%i", final_count); report("iter", "%i", i); /* now to test leaving messages open for a long time! */ mps_ap_destroy(apawl); mps_ap_destroy(apamc); mps_ap_destroy(aplo); comment("Destroyed aps."); mps_pool_destroy(poolamc); mps_pool_destroy(poolawl); mps_pool_destroy(poollo); comment("Destroyed pools."); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void *testscriptB(void *arg, size_t s) { trampDataStruct trampData; mps_arena_t arena; mps_thr_t thr; const char *script; mps_fmt_t fmt; mps_chain_t chain; mps_pool_t amc; mps_root_t root_table; mps_ap_t ap; mps_root_t root_stackreg; size_t i; int N = myrootCOUNT - 1; void *stack_starts_here; /* stack scanning starts here */ Insist(s == sizeof(trampDataStruct)); trampData = *(trampDataStruct*)arg; arena = trampData.arena; thr = trampData.thr; script = trampData.script; die(mps_fmt_create_A(&fmt, arena, dylan_fmt_A()), "fmt_create"); die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mps_pool_create(&amc, arena, mps_class_amc(), fmt, chain), "pool_create amc"); for(i = 0; i < myrootCOUNT; ++i) { myroot[i] = NULL; } die(mps_root_create_table(&root_table, arena, mps_rank_exact(), (mps_rm_t)0, myroot, (size_t)myrootCOUNT), "root_create"); die(mps_ap_create(&ap, amc, mps_rank_exact()), "ap_create"); /* root_stackreg: stack & registers are ambiguous roots = mutator's workspace */ die(mps_root_create_reg(&root_stackreg, arena, mps_rank_ambig(), (mps_rm_t)0, thr, mps_stack_scan_ambig, &stack_starts_here, 0), "root_stackreg"); /* Make myrootCOUNT registered-for-finalization objects. */ /* Each is a dylan vector with 2 slots, inited to: (index, NULL) */ for(i = 0; i < myrootCOUNT; ++i) { mps_word_t v; mps_addr_t v_ref; die(make_dylan_vector(&v, ap, 2), "make_dylan_vector"); DYLAN_VECTOR_SLOT(v, 0) = DYLAN_INT(i); DYLAN_VECTOR_SLOT(v, 1) = (mps_word_t)NULL; v_ref = (mps_addr_t)v; die(mps_finalize(arena, &v_ref), "finalize"); myroot[i] = (void*)v; state[i] = rootSTATE; } /* .keep-alive: Create some additional inter-object references. * * 1 and N-1 don't die until myroot refs to both have been nulled. * * 2 and 3 don't die until myroot refs to both have been nulled. * * We do this to check that reachability via non-root refs prevents * finalization. */ /* Leave 0 and N containing NULL refs */ /* Make 1 and N-1 refer to each other */ DYLAN_VECTOR_SLOT(myroot[1] , 1) = (mps_word_t)myroot[N-1]; DYLAN_VECTOR_SLOT(myroot[N-1], 1) = (mps_word_t)myroot[1]; /* Make 2 and 3 refer to each other */ DYLAN_VECTOR_SLOT(myroot[2], 1) = (mps_word_t)myroot[3]; DYLAN_VECTOR_SLOT(myroot[3], 1) = (mps_word_t)myroot[2]; /* Stop stack scanning, otherwise stack or register dross from */ /* these setup functions can cause unwanted object retention, */ /* which would mean we don't get the finalization messages we */ /* expect. */ mps_root_destroy(root_stackreg); mps_message_type_enable(arena, mps_message_type_gc_start()); mps_message_type_enable(arena, mps_message_type_gc()); mps_message_type_enable(arena, mps_message_type_finalization()); testscriptC(arena, script); mps_ap_destroy(ap); mps_root_destroy(root_table); mps_pool_destroy(amc); mps_chain_destroy(chain); mps_fmt_destroy(fmt); return NULL; }
static void test(void *stack_pointer) { mps_arena_t arena; mps_pool_t poolamc, poolawl; mps_thr_t thread; mps_root_t root, rootb; mps_addr_t base; mps_addr_t *addr; mps_chain_t chain; mps_fmt_t format; mps_ap_t apamc, apawl; mps_word_t i, c; cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (60ul*1024*1024)), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); base = &b; addr = base; cdie(mps_root_create_table(&root, arena, mps_rank_ambig(), 0, addr, 1), "creat root"); base = &exfmt_root; addr = base; cdie(mps_root_create_table(&rootb, arena, mps_rank_ambig(), 0, addr, 1), "create root b"); cdie( mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); cdie( mps_pool_create(&poolamc, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated), "create pool"); cdie( mps_ap_create(&apawl, poolawl, mps_rank_weak()), "create ap"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap"); formatcomments = 0; b = allocone(apamc, 1024, mps_rank_exact()); c = mps_collections(arena); for (i=1; i<100; i++) { comment("%i of 100.", i); while (mps_collections(arena) == c) { a = allocone(apamc, 1024, mps_rank_exact()); if (ranint(5)) { setref(a, 0, b); } b = a; } c = mps_collections(arena); a = allocone(apawl, 1, mps_rank_weak()); a->data.id = 0; setref(a, 0, b); } mps_arena_park(arena); mps_ap_destroy(apawl); mps_ap_destroy(apamc); comment("Destroyed aps."); 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(root); mps_root_destroy(rootb); comment("Destroyed roots."); mps_thread_dereg(thread); comment("Deregistered thread."); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { long int i; long int rsize; mps_message_t message; int inramp; mycell *r, *s; cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) 1024*1024*ARENALIMIT), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); cdie( mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie( mps_root_create_table(&root1, arena, mps_rank_exact(), 0, &objtab[0], TABSIZE), "create root table"); cdie( mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); cdie( mps_pool_create(&poolamc, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap"); mps_message_type_enable(arena, mps_message_type_collection_stats()); inramp = 0; for (i = 0; i < ITERATIONS; i++) { if (i % 10000 == 0) { comment("%ld of %ld", i, ITERATIONS); } alloc_back(); if (inramp) { s = allocone(apamc, 3, mps_rank_exact()); setref(r, 0, s); setref(s, 1, r); r = s; s = allocdumb(apamc, RAMPSIZE, mps_rank_exact()); setref(r, 2, s); rsize ++; if (ranint(LEAVERAMP) == 0) { r = allocone(apamc, 2, mps_rank_exact()); s = allocone(apamc, 2, mps_rank_exact()); #ifdef RAMP_INTERFACE mps_ap_alloc_pattern_end(apamc, mps_alloc_pattern_ramp_collect_all()); #endif #ifdef COLLECT_WORLD mps_arena_collect(arena); mps_arena_release(arena); #endif comment("ramp end, %ld objects", rsize); inramp = 0; } } else { if (ranint(ENTERRAMP) == 0) { #ifdef RAMP_INTERFACE mps_ap_alloc_pattern_begin(apamc, mps_alloc_pattern_ramp_collect_all()); #endif comment("ramp begin"); r = allocone(apamc, 3, mps_rank_exact()); inramp = 1; rsize = 0; } } if(mps_message_get(&message, arena, mps_message_type_collection_stats())) { unsigned long live, condemned, notCondemned; live = mps_message_collection_stats_live_size(arena, message); condemned = mps_message_collection_stats_condemned_size(arena, message); notCondemned = mps_message_collection_stats_not_condemned_size(arena, message); comment("Collection: live=%ld, condemned=%ld, not condemned = %ld", live, condemned, notCondemned); mps_message_discard(arena, message); } } mps_ap_destroy(apamc); comment("Destroyed ap."); mps_pool_destroy(poolamc); comment("Destroyed pool."); mps_fmt_destroy(format); comment("Destroyed format."); mps_chain_destroy(chain); comment("Destroyed chain."); mps_root_destroy(root1); mps_root_destroy(root); comment("Destroyed roots."); mps_thread_dereg(thread); comment("Deregistered thread."); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_arena_t arena; mps_pool_t poolamc, poolawl; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_chain_t chain; mps_ap_t apamc, apawl, apweak; mycell *a, *b; RC; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); die(mps_thread_reg(&thread, arena), "register thread"); die(mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); die(mps_fmt_create_A(&format, arena, &fmtA), "create format"); die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain), "create pool(amc)"); cdie(mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated), "create pool(awl)"); cdie(mps_ap_create(&apweak, poolawl, mps_rank_weak()), "create ap(weak)"); cdie(mps_ap_create(&apawl, poolawl, mps_rank_exact()), "create ap(awl)"); cdie(mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap(amc)"); b = allocone(apamc, 1, mps_rank_exact()); a = allocone(apweak, 1, mps_rank_weak()); mps_ap_destroy(apawl); mps_ap_destroy(apamc); mps_ap_destroy(apweak); comment("Destroyed aps."); /* buffered segments aren't condemned! */ setref(a, 0, b); mps_arena_collect(arena); asserts(getref(a, 0) == b, "Reference changed or was splatted."); mps_pool_destroy(poolamc); mps_pool_destroy(poolawl); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void *stack_pointer) { mps_arena_t arena; mps_pool_t pool; mps_thr_t thread; mps_root_t root, root1; mps_fmt_t format; mps_chain_t chain; mps_ap_t ap; mycell *a, *b; int j; /* create an arena that can't grow beyond 1 Mb */ cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*1)), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); cdie(mps_root_create_thread(&root, arena, thread, stack_pointer), "thread root"); cdie(mps_root_create_table(&root1, arena, mps_rank_ambig(), 0, (mps_addr_t*)&exfmt_root, 1), "create table root"); cdie(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&pool, arena, mps_class_amc(), format, chain), "create pool"); cdie(mps_ap_create(&ap, pool, mps_rank_exact()), "create ap"); comment("ready"); b = allocone(ap, 2, mps_rank_exact()); /* allocate lots of little objects */ for (;;) { comment("reserved %ld, committed %ld", mps_arena_reserved(arena), mps_arena_committed(arena)); if (mps_arena_committed(arena) > 1024ul*1024ul*10) { break; } for (j=0; j<10000; j++) { a = allocone(ap, 2, mps_rank_exact()); setref(a, 0, b); b = a; a = allocone(ap, 1, mps_rank_exact()); setref(b, 1, a); } mps_arena_collect(arena); mps_arena_release(arena); } mps_arena_park(arena); mps_ap_destroy(ap); mps_pool_destroy(pool); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_root_destroy(root1); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_arena_t arena; mps_pool_t poolamc, poollo; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_chain_t chain; mps_ap_t apamc, aplo; mycell *a[100]; int i; int j; int k,z; alloccomments = 1; formatcomments = 1; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); die(mps_thread_reg(&thread, arena), "register thread"); die(mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); die(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain), "create pool(amc)"); die(mps_pool_create(&poollo, arena, mps_class_lo(), format), "create pool(lo)"); cdie( mps_ap_create(&aplo, poollo, mps_rank_exact()), "create ap"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap"); for(i=0; i<100; i++) { a[i] = allocone(aplo, 6, 1); } for(i=0; i<10000; i++) { j = ranint(100); comment("New object %i", j); a[j] = allocone(aplo, 5+ranint(50), 1); k = ranint(50); z = ranint(5); comment("setting %i (%p) %i", k, a[k], z); setref(a[k], z, a[j]); (void)allocdumb(apamc, 0x400*64, 0); } mps_arena_park(arena); mps_ap_destroy(aplo); mps_ap_destroy(apamc); comment("Destroyed aps."); mps_pool_destroy(poolamc); mps_pool_destroy(poollo); comment("Destroyed pools."); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_arena_t arena; mps_pool_t poolamc, poolawl; mps_thr_t thread; mps_root_t root, root1; mps_chain_t chain; mps_fmt_t format; mps_ap_t apamc, apawl; mycell *a, *b, *c, *d, *e, *f, *g; int i; int j; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); cdie( mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie( mps_root_create_table(&root1,arena,mps_rank_ambig(),0,&exfmt_root,1), "create table 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(&poolamc, arena, mps_class_awl(), format, chain), "create pool"); cdie( mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated), "create pool"); cdie( mps_ap_create(&apawl, poolawl, mps_rank_exact()), "create ap"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap"); b = allocone(apamc, 1, mps_rank_exact()); for (j=1; j<=ITERATIONS; j++) { comment("%i of %i.", j, ITERATIONS); a = allocone(apamc, 5, mps_rank_exact()); b = a; c = a; d = a; e = a; f = a; g = a; for (i=1; i<=1000; i++) { c = allocone(apamc, 20, mps_rank_exact()); d = allocone(apawl, 20, mps_rank_exact()); if (ranint(8) == 0) e = c; if (ranint(8) == 0) f = c; if (ranint(8) == 0) g = c; setref(b, 0, c); setref(c, 1, d); setref(c, 2, e); setref(c, 3, f); setref(c, 4, g); b = c; } } mps_arena_park(arena); mps_ap_destroy(apawl); mps_ap_destroy(apamc); comment("Destroyed aps."); 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(root); mps_root_destroy(root1); comment("Destroyed roots."); mps_thread_dereg(thread); comment("Deregistered thread."); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_arena_t arena; mps_pool_t poolamc, poolawl; mps_thr_t thread; mps_root_t root, root1; mps_fmt_t format; mps_chain_t chain; mps_ap_t apamc, apawl; size_t size0, size1; mycell *a, *b, *c, *d, *e, *f, *g; int i; int j; RC; deathcomments = 0; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); die(mps_thread_reg(&thread, arena), "register thread"); die(mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie( mps_root_create_table(&root1, arena, mps_rank_ambig(), 0, &exfmt_root, 1), "create exfmt root"); die(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated), "create pool"); cdie( mps_ap_create(&apawl, poolawl, mps_rank_weak()), "create ap"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap"); b = allocone(apamc, 1, 1); for (j=1; j<10; j++) { comment("%i of 10.", j); a = allocone(apawl, 5, 1); setref(b, 0, a); b = a; c = a; d = a; e = a; f = a; g = a; for (i=1; i<1000; i++) { if (i%100 == 0) { comment(" %i", i); } if (ranint(2)) { c = allocone(apamc, 1000, 1); } else { c = allocone(apawl, 1000, 1); } if (ranint(8) == 0) d = c; if (ranint(8) == 0) e = c; if (ranint(8) == 0) f = c; if (ranint(8) == 0) g = c; setref(b, 0, c); setref(c, 1, d); setref(c, 2, e); setref(c, 3, f); setref(c, 4, g); b = c; } if (j==3) { DC; comment("...collecting:"); RC; size0 = arena_committed_and_used(arena); mps_arena_collect(arena); size1 = arena_committed_and_used(arena); report("sizebefore0", "%lu", (unsigned long) size0); report("sizeafter0", "%lu", (unsigned long) size1); report("diff0", "%lu", (unsigned long) size0-size1); DC; mps_arena_release(arena); comment("...released"); } DC; comment("clamping..."); mps_arena_park(arena); RC; for (i=1; i<1000; i++) { if (i%100 == 0) { comment(" %i", i); } if (ranint(2)) { c = allocone(apamc, 1000, 1); } else { c = allocone(apawl, 1000, 1); } if (ranint(8) == 0) d = c; if (ranint(8) == 0) e = c; if (ranint(8) == 0) f = c; if (ranint(8) == 0) g = c; setref(b, 0, c); setref(c, 1, d); setref(c, 2, e); setref(c, 3, f); setref(c, 4, g); b = c; } asserts(counters[COPY_COUNT]==0, "Eppur si muove!"); DC; if (j==9) { comment("collecting..."); size0 = arena_committed_and_used(arena); mps_arena_collect(arena); size1 = arena_committed_and_used(arena); report("sizebefore1", "%lu", (unsigned long) size0); report("sizeafter1", "%lu", (unsigned long) size1); report("diff1", "%lu", (unsigned long) size0-size1); DC; } mps_arena_release(arena); comment("released."); RC; } mps_ap_destroy(apawl); mps_ap_destroy(apamc); mps_pool_destroy(poolamc); mps_pool_destroy(poolawl); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_root_destroy(root1); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_arena_t arena; mps_pool_t pool; mps_thr_t thread; mps_root_t root; mps_chain_t chain; mps_fmt_t format; mps_ap_t ap; mps_addr_t p; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); cdie( mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create 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(&pool, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_ap_create(&ap, pool, mps_rank_exact()), "create ap"); allocone(ap, 0, NULL, NULL, 0x20); do { /* cdie(mps_reserve(&p, ap, 0x100), "Reserve: "); */ } while (!mps_commit(ap, p, 0x20)); comment("Committed."); mps_ap_destroy(ap); comment("Destroyed ap."); mps_pool_destroy(pool); comment("Destroyed pool."); mps_fmt_destroy(format); comment("Destroyed format."); mps_chain_destroy(chain); comment("Destroyed chain."); mps_root_destroy(root); comment("Destroyed root."); mps_thread_dereg(thread); comment("Deregistered thread."); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { int i; mps_ap_t ap, sap; mps_arena_t arena; mps_fmt_t format; mps_chain_t chain; mps_pool_t pool, spool; mps_thr_t thread; mps_frame_t frame1; mycell *p, *q; size_t com, com1, com2; formatcomments=1; alloccomments=1; fixcomments=1; /* create an arena (no particular size limit) */ cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t)ARENA_SIZE), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); /* because we know objects in the stack pool don't move, */ /* we can do without roots. Hooray! */ cdie(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&pool, arena, mps_class_amc(), format, chain), "create pool(amc)"); cdie(mps_ap_create(&ap, pool, mps_rank_exact()), "create ap(amc)"); cdie(mps_pool_create(&spool, arena, mps_class_snc(), format), "create SNC pool"); cdie(mps_ap_create(&sap, spool, mps_rank_exact()), "create ap"); /* push, alloc, check object is scanned */ com = arena_committed_and_used(arena); report("com", "%ld", com); cdie(mps_ap_frame_push(&frame1, sap), "push"); p = allocone(sap, 2, mps_rank_exact()); q = allocdumb(ap, BIGSIZE, mps_rank_exact()); setref(p, 0, q); q = allocdumb(ap, SMALLSIZE, mps_rank_exact()); report("com", "%ld", arena_committed_and_used(arena)); comment("collect..."); mps_arena_collect(arena); com1 = arena_committed_and_used(arena); mps_arena_release(arena); report("com", "%ld", com1); report("inc1", "%d", (com1-com)/BIGSIZE); /* pop, check object isn't scanned */ cdie(mps_ap_frame_pop(sap, frame1), "pop"); comment("collect..."); mps_arena_collect(arena); com1 = arena_committed_and_used(arena); mps_arena_release(arena); report("com", "%ld", com1); report("inc2", "%ld", (com1-com)/BIGSIZE); /* check initial frame is scanned */ p = allocone(sap, 2, mps_rank_exact()); q = allocdumb(ap, BIGSIZE, mps_rank_exact()); setref(p, 1, q); q = allocdumb(ap, SMALLSIZE, mps_rank_exact()); mps_arena_collect(arena); com2 = arena_committed_and_used(arena); mps_arena_release(arena); report("inc3", "%ld", (com2-com1)/BIGSIZE); /* even in ordinary collection */ for (i=0; i < 500; i++) { q = allocdumb(ap, BIGSIZE, mps_rank_exact()); } q = allocdumb(ap, SMALLSIZE, mps_rank_exact()); mps_arena_collect(arena); com2 = arena_committed_and_used(arena); mps_arena_release(arena); report("inc4", "%ld", (com2-com1)/BIGSIZE); mps_ap_destroy(ap); mps_ap_destroy(sap); mps_pool_destroy(pool); mps_pool_destroy(spool); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_pool_t poolamc, poolawl, poollo; mps_thr_t thread; mps_root_t root0, root1; mps_fmt_t format; mps_chain_t chain; mps_ap_t apamc, apawl, aplo; mycell *a, *b, *c, *d; long int j; 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_reg(&root0, arena, mps_rank_ambig(), 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie(mps_root_create_table(&root1, arena, mps_rank_ambig(), 0, (mps_addr_t*)&exfmt_root, 1), "create table root"); cdie(mps_fmt_create_A(&format, arena, &fmtA), "create format"); die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain), "create pool(amc)"); cdie(mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated), "create pool(awl)"); cdie(mps_pool_create(&poollo, arena, mps_class_lo(), format), "create pool"); cdie(mps_ap_create(&apawl, poolawl, mps_rank_weak()), "create ap(amc)"); cdie(mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap(awl)"); cdie(mps_ap_create(&aplo, poollo, mps_rank_exact()), "create ap"); mps_message_type_enable(arena, mps_message_type_finalization()); /* register loads of objects for finalization (1000*4) */ a = allocone(apamc, 2, 1); b = a; for (j=0; j<1000; j++) { a = allocone(apamc, 2, mps_rank_exact()); c = allocone(apawl, 2, mps_rank_weak()); d = allocone(aplo, 2, mps_rank_exact()); /* rank irrelevant here! */ mps_finalize(arena, (mps_addr_t*)&a); mps_finalize(arena, (mps_addr_t*)&c); mps_finalize(arena, (mps_addr_t*)&d); mps_finalize(arena, (mps_addr_t*)&d); final_count += 4; } /* throw them all away and collect everything */ a = NULL; b = NULL; c = NULL; d = NULL; mps_root_destroy(root0); mps_root_destroy(root1); comment("Destroyed roots."); mps_arena_collect(arena); while(mps_message_poll(arena) == 0) { a = allocdumb(apawl, 1024, mps_rank_weak()); a = allocdumb(apamc, 1024, mps_rank_exact()); a = allocdumb(aplo, 1024, mps_rank_exact()); mps_arena_collect(arena); } /* how many are left? (n.b. ideally this would be 0 but there's no guarantee) */ /* now to test leaving messages open for a long time! */ mps_ap_destroy(apawl); mps_ap_destroy(apamc); mps_ap_destroy(aplo); comment("Destroyed aps."); mps_pool_destroy(poolamc); mps_pool_destroy(poolawl); mps_pool_destroy(poollo); comment("Destroyed pools."); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(mps_arena_t arena, mps_pool_class_t pool_class) { mps_chain_t chain; mps_fmt_t format; mps_pool_t pool; mps_root_t exactRoot; size_t i; size_t totalSize, freeSize, allocSize, bufferSize; unsigned long objs; struct stepper_data sdStruct, *sd; PoolClass class; die(dylan_fmt(&format, arena), "fmt_create"); die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_FORMAT, format); MPS_ARGS_ADD(args, MPS_KEY_CHAIN, chain); die(mps_pool_create_k(&pool, arena, pool_class, args), "pool_create"); } MPS_ARGS_END(args); die(mps_ap_create(&ap, pool, mps_rank_exact()), "ap_create"); for(i = 0; i < exactRootsCOUNT; ++i) exactRoots[i] = objNULL; die(mps_root_create_table_masked(&exactRoot, arena, mps_rank_exact(), (mps_rm_t)0, &exactRoots[0], exactRootsCOUNT, (mps_word_t)1), "root_create_table(exact)"); objs = 0; while(objs < objCOUNT) { size_t r; r = objs; i = r % exactRootsCOUNT; if(exactRoots[i] != objNULL) { cdie(dylan_check(exactRoots[i]), "dying root check"); } exactRoots[i] = make(); if(exactRoots[(exactRootsCOUNT-1) - i] != objNULL) dylan_write(exactRoots[(exactRootsCOUNT-1) - i], exactRoots, exactRootsCOUNT); ++objs; } mps_arena_park(arena); sd = &sdStruct; sd->arena = arena; sd->expect_pool = pool; sd->expect_fmt = format; sd->count = 0; sd->objSize = 0; sd->padSize = 0; mps_arena_formatted_objects_walk(arena, stepper, sd, sizeof *sd); Insist(sd->count == objs); totalSize = mps_pool_total_size(pool); freeSize = mps_pool_free_size(pool); allocSize = totalSize - freeSize; bufferSize = AddrOffset(ap->init, ap->limit); class = ClassOfPoly(Pool, pool); printf("%s: obj=%lu pad=%lu total=%lu free=%lu alloc=%lu buffer=%lu\n", ClassName(class), (unsigned long)sd->objSize, (unsigned long)sd->padSize, (unsigned long)totalSize, (unsigned long)freeSize, (unsigned long)allocSize, (unsigned long)bufferSize); Insist(sd->objSize + sd->padSize + bufferSize == allocSize); mps_ap_destroy(ap); mps_root_destroy(exactRoot); mps_pool_destroy(pool); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_arena_release(arena); }