static void init(void) { size_t i; die(dylan_fmt(&format, arena), "fmt_create"); die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mps_pool_create(&pool, arena, mps_class_amc(), format, chain), "pool_create(amc)"); for(i = 0; i < exactRootsCOUNT; ++i) exactRoots[i] = objNULL; for(i = 0; i < ambigRootsCOUNT; ++i) ambigRoots[i] = rnd_addr(); 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)"); }
static void test(void) { mps_pool_t poolamc; mps_thr_t thread; mps_root_t root0, root1; mps_fmt_t format; mps_chain_t chain; mps_ap_t apamc; mycell *a; 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"); 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_ap_create(&apamc, poolamc, MPS_RANK_EXACT), "create ap"); /* alloc lots in an AMC pool; it should be collected away */ for(j=0; j<1000; j++) { a = allocdumb(apamc, 1024ul*1024, MPS_RANK_EXACT); } /* (total allocated is 1000 M) */ mps_root_destroy(root0); mps_root_destroy(root1); comment("Destroyed roots."); mps_ap_destroy(apamc); mps_pool_destroy(poolamc); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); pass(); }
static void test_pool(mps_pool_class_t pool_class, mps_arg_s args[], mps_bool_t haveAmbiguous) { mps_pool_t pool; mps_root_t exactRoot, ambigRoot = NULL; size_t lastStep = 0, i, r; unsigned long objs; mps_ap_t busy_ap; mps_addr_t busy_init; die(mps_pool_create_k(&pool, arena, pool_class, args), "pool_create"); die(mps_ap_create(&ap, pool, mps_rank_exact()), "BufferCreate"); die(mps_ap_create(&busy_ap, pool, mps_rank_exact()), "BufferCreate 2"); for(i = 0; i < exactRootsCOUNT; ++i) exactRoots[i] = objNULL; if (haveAmbiguous) for(i = 0; i < ambigRootsCOUNT; ++i) ambigRoots[i] = rnd_addr(); 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)"); if (haveAmbiguous) die(mps_root_create_table(&ambigRoot, arena, mps_rank_ambig(), (mps_rm_t)0, &ambigRoots[0], ambigRootsCOUNT), "root_create_table(ambig)"); /* create an ap, and leave it busy */ die(mps_reserve(&busy_init, busy_ap, 64), "mps_reserve busy"); die(PoolDescribe(pool, mps_lib_get_stdout(), 0), "PoolDescribe"); objs = 0; totalSize = 0; while(totalSize < totalSizeMAX) { if (totalSize > lastStep + totalSizeSTEP) { lastStep = totalSize; printf("\nSize %"PRIuLONGEST" bytes, %lu objects.\n", (ulongest_t)totalSize, objs); (void)fflush(stdout); for(i = 0; i < exactRootsCOUNT; ++i) cdie(exactRoots[i] == objNULL || dylan_check(exactRoots[i]), "all roots check"); } r = (size_t)rnd(); if (!haveAmbiguous || (r & 1)) { i = (r >> 1) % 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); } else {
int main(void) { mps_arena_t arena; mps_pool_t pool; mps_fmt_t format; mps_ap_t ap; mps_addr_t p; mps_root_t root; locv_fmt.align = sizeof(void *); /* .fmt.align.delayed */ die(mps_arena_create(&arena, mps_arena_class_vm(), testArenaSIZE), "mps_arena_create"); die(mps_root_create_table(&root, arena, mps_rank_exact(), (mps_rm_t)0, roots, (sizeof(roots)/sizeof(*roots))), "RootCreate"); die(mps_fmt_create_A(&format, arena, &locv_fmt), "FormatCreate"); die(mps_pool_create(&pool, arena, mps_class_lo(), format), "LOCreate"); die(mps_ap_create(&ap, pool, mps_rank_exact()), "APCreate"); die(mps_reserve(&p, ap, sizeof(void *)), "mps_reserve min"); *(mps_word_t *)p = sizeof(void *); cdie(mps_commit(ap, p, sizeof(void *)), "commit min"); die(mps_reserve(&roots[1], ap, 2*sizeof(void *)), "mps_reserve 2*min"); p = roots[1]; *(mps_word_t *)p = 2*sizeof(void *); cdie(mps_commit(ap, p, 2*sizeof(void *)), "commit 2*min"); die(mps_reserve(&p, ap, (size_t)4096), "mps_reserve 4096"); *(mps_word_t *)p = 4096; cdie(mps_commit(ap, p, (size_t)4096), "commit 4096"); die(mps_reserve(&p, ap, sizeof(void *)), "mps_reserve last"); *(mps_word_t *)p = sizeof(void *); cdie(mps_commit(ap, p, sizeof(void *)), "commit last"); { size_t count = 0; mps_arena_formatted_objects_walk(arena, stepper, &count, 0); cdie(count == 4, "walk 4 objects"); } mps_ap_destroy(ap); mps_pool_destroy(pool); mps_fmt_destroy(format); mps_root_destroy(root); mps_arena_destroy(arena); fflush(stdout); /* synchronize */ fprintf(stderr, "\nConclusion: Failed to find any defects.\n"); return 0; }
static void test(void *stack_pointer) { int j; mps_ap_t ap; mps_arena_t arena; mps_fmt_t format; mps_chain_t chain; mps_pool_t pool; mps_root_t root1; mps_thr_t thread; /* create an arena that can't grow beyond 30 MB */ cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t)THIRTY_MEG), "create arena"); cdie(mps_arena_commit_limit_set(arena, (size_t)THIRTY_MEG), "commit limit set"); cdie(mps_thread_reg(&thread, arena), "register thread"); cdie(mps_root_create_table(&root1, arena, mps_rank_exact(), 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"); /* allocate a 16 MB live object */ allocdumb(ap, 16*MEG, mps_rank_exact()); comment("collect world..."); for (j=0; j<1000; 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(root1); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void *stack_pointer) { mps_pool_t poollo; mps_thr_t thread; mps_root_t root0, root1; mps_fmt_t format; mps_chain_t chain; mps_ap_t aplo; 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_thread(&root0, 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(&poollo, arena, mps_class_amcz(), format, chain), "create pool"); cdie(mps_ap_create(&aplo, poollo, mps_rank_exact()), "create ap"); /* alloc lots in an LO pool; it should be collected away */ for(j=0; j<1000; j++) { (void)allocdumb(aplo, 1024ul*1024, mps_rank_exact()); } /* (total allocated is 1000 M) */ mps_arena_park(arena); mps_root_destroy(root0); mps_root_destroy(root1); comment("Destroyed roots."); mps_ap_destroy(aplo); mps_pool_destroy(poollo); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); pass(); }
static void test(void) { mps_arena_t arena; mps_thr_t thread; mps_addr_t a[30]; 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(NULL, arena, mps_rank_ambig(), 0, a, sizeof a), "root create"); }
static void test(void) { mps_space_t space; mps_thr_t thread; mps_addr_t a[30]; cdie(mps_space_create(&space), "create space"); cdie(mps_thread_reg(&thread, space), "register thread"); cdie(mps_root_create_table(UNALIGNED, space, MPS_RANK_AMBIG, 0, a, sizeof a), "root create"); }
static void test(void) { mps_space_t space; mps_thr_t thread; mps_root_t root; mps_addr_t a[30]; cdie(mps_space_create(&space), "create space"); cdie(mps_thread_reg(&thread, space), "register thread"); cdie(mps_root_create_table(&root, space, MPS_RANK_AMBIG, 0, a, (size_t) 31), "root create"); }
static void test(void *stack_pointer) { mps_arena_t arena; mps_thr_t thread; mps_root_t root; mps_addr_t a[30]; 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_ambig(), 0, a, (size_t) 31), "root create"); }
static void test(void) { mps_arena_t arena; mps_thr_t thread; mps_root_t root; mps_addr_t a[30]; 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_MAX+1, 0, a, sizeof a), "root create"); }
static void test_air(int interior, int stack) { size_t n_finalized = 0; size_t i, j; obj_t *s[OBJ_COUNT] = {0}; mps_root_t root = NULL; if (!stack) { mps_addr_t *p = (void *)s; die(mps_root_create_table(&root, scheme_arena, mps_rank_ambig(), 0, p, OBJ_COUNT), "mps_root_create_table"); } mps_message_type_enable(scheme_arena, mps_message_type_finalization()); for (j = 0; j < OBJ_COUNT; ++j) { obj_t n = scheme_make_integer(obj_ap, (long)j); obj_t obj = scheme_make_vector(obj_ap, OBJ_LEN, n); mps_addr_t ref = obj; mps_finalize(scheme_arena, &ref); s[j] = obj->vector.vector; } for (i = 1; i < OBJ_LEN; ++i) { obj_t n = scheme_make_integer(obj_ap, (long)i); mps_message_t msg; for (j = 0; j + 1 < OBJ_COUNT; ++j) { *++s[j] = n; } mps_arena_collect(scheme_arena); mps_arena_release(scheme_arena); if (mps_message_get(&msg, scheme_arena, mps_message_type_finalization())) { mps_addr_t ref; mps_message_finalization_ref(&ref, scheme_arena, msg); ++ n_finalized; if (interior) { obj_t o; o = ref; error("wrongly finalized vector %ld at %p", o->vector.vector[0]->integer.integer, (void *)o); } } } if (!interior && n_finalized < OBJ_COUNT) { error("only finalized %"PRIuLONGEST" out of %"PRIuLONGEST" vectors.", (ulongest_t)n_finalized, (ulongest_t)OBJ_COUNT); } if (!stack) { mps_root_destroy(root); } }
static void test(void) { mps_space_t space; mps_root_t root; mps_addr_t roottable[10]; /* cdie(mps_space_create(&space), "create space"); */ cdie( mps_root_create_table(&root, space, MPS_RANK_AMBIG, 0, roottable, sizeof(mps_addr_t[10])), "create root"); mps_root_destroy(root); comment("Destroyed root."); mps_space_destroy(space); comment("Destroyed space."); }
static void test(void) { mps_arena_t arena = (mps_arena_t)1; mps_root_t root; mps_addr_t roottable[10]; /* cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); */ cdie( mps_root_create_table(&root, arena, mps_rank_ambig(), 0, roottable, sizeof(mps_addr_t[10])), "create root"); mps_root_destroy(root); comment("Destroyed root."); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { long int i; long int rsize; int inramp; mycell *r1, *r2, *s1, *s2; cdie(mps_arena_create(&arena1, mps_arena_class_vm(), (size_t) 1024*1024*ARENALIMIT), "create arena"); cdie(mps_arena_create(&arena2, mps_arena_class_vm(), (size_t) 1024*1024*ARENALIMIT), "create arena"); cdie(mps_thread_reg(&thread1, arena1), "register thread"); cdie(mps_thread_reg(&thread2, arena2), "register thread"); cdie( mps_root_create_reg(&root1, arena1, mps_rank_ambig(), 0, thread1, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie( mps_root_create_reg(&root2, arena2, mps_rank_ambig(), 0, thread2, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie( mps_root_create_table(&root1a, arena1, mps_rank_exact(), 0, &objtab1[0], TABSIZE), "create root table"); cdie( mps_root_create_table(&root2a, arena2, mps_rank_exact(), 0, &objtab2[0], TABSIZE), "create root table"); cdie( mps_fmt_create_A(&format1, arena1, &fmtA), "create format"); cdie( mps_fmt_create_A(&format2, arena2, &fmtA), "create format"); cdie( mps_pool_create(&poolamc1, arena1, mps_class_amc(), format1), "create pool"); cdie( mps_pool_create(&poolamc2, arena2, mps_class_amc(), format2), "create pool"); cdie( mps_ap_create(&apamc1, poolamc1, mps_rank_exact()), "create ap"); cdie( mps_ap_create(&apamc2, poolamc2, mps_rank_exact()), "create ap"); inramp = 0; for (i = 0; i < ITERATIONS; i++) { if (i % 10000 == 0) { comment("%ld of %ld", i, ITERATIONS); } alloc_back(); if (inramp) { s1 = allocone(apamc1, 3, mps_rank_exact()); s2 = allocone(apamc2, 3, mps_rank_exact()); setref(r1, 0, s1); setref(r2, 0, s2); setref(s1, 1, r1); setref(s2, 1, r2); r1 = s1; r2 = s2; s1 = allocdumb(apamc1, RAMPSIZE, mps_rank_exact()); s2 = allocdumb(apamc2, RAMPSIZE, mps_rank_exact()); setref(r1, 2, s1); setref(r2, 2, s2); rsize ++; if (ranint(LEAVERAMP) == 0) { r1 = allocone(apamc1, 2, mps_rank_exact()); r2 = allocone(apamc2, 2, mps_rank_exact()); s1 = allocone(apamc1, 2, mps_rank_exact()); s2 = allocone(apamc2, 2, mps_rank_exact()); #ifdef RAMP_INTERFACE mps_ap_alloc_pattern_end(apamc1, mps_alloc_pattern_ramp()); mps_ap_alloc_pattern_end(apamc2, mps_alloc_pattern_ramp()); #endif #ifdef COLLECT_WORLD mps_arena_collect(arena1); mps_arena_collect(arena2); mps_arena_release(arena1); mps_arena_release(arena2); #endif comment("ramp end, %ld objects", rsize); inramp = 0; } } else { if (ranint(ENTERRAMP) == 0) { #ifdef RAMP_INTERFACE mps_ap_alloc_pattern_begin(apamc1, mps_alloc_pattern_ramp()); mps_ap_alloc_pattern_begin(apamc2, mps_alloc_pattern_ramp()); #endif comment("ramp begin"); r1 = allocone(apamc1, 3, mps_rank_exact()); r2 = allocone(apamc2, 3, mps_rank_exact()); inramp = 1; rsize = 0; } } } mps_ap_destroy(apamc1); mps_ap_destroy(apamc2); comment("Destroyed ap."); mps_pool_destroy(poolamc1); mps_pool_destroy(poolamc2); comment("Destroyed pool."); mps_fmt_destroy(format1); mps_fmt_destroy(format2); comment("Destroyed format."); mps_root_destroy(root1); mps_root_destroy(root1a); mps_root_destroy(root2); mps_root_destroy(root2a); comment("Destroyed roots."); mps_thread_dereg(thread1); mps_thread_dereg(thread2); comment("Deregistered thread."); mps_arena_destroy(arena1); mps_arena_destroy(arena2); comment("Destroyed arena."); }
static void test(void) { 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_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 *stack_pointer) { 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_thread(&root0, 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(&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(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 */ comment("b = %p", b); /* suppress compiler warning about unused b */ 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_arena_park(arena); 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(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 base, *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"); die(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"); base = &exfmt_root; addr = base; cdie( mps_root_create_table(&root1,arena,mps_rank_ambig(),0,addr,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"); /* 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"); fillup(); comment("try to make collect by allocating another 1G..."); empty(); for (j=0; j<1000*1024; j++) { res=allocrdumb(&a, ap, 1024, mps_rank_exact()); if (res == MPS_RES_OK) { comment("%i ok", j); } else { break; } } comment("collect world..."); for (j=0; j<10; 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) { 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) { 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; mycell *a, *b, *c, *d, *e, *f, *g; int i; int j; 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 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(&poolamc, arena, mps_class_amc(), format, chain), "create pool"); die(mmqa_pool_create_chain(&poolawl, arena, mps_class_amc(), format, chain), "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 < 100; j++) { comment("%i of 100.", j); a = allocone(apamc, 5, mps_rank_exact()); b = a; c = a; d = a; e = a; f = a; g = a; for (i = 1; i < 5000; i++) { c = allocone(apamc, 20, mps_rank_exact()); d = allocone(apamc, 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_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 poolamc; mps_thr_t thread; mps_root_t root, root2, root3, root4, root5, root6, root7, root1; mps_fmt_t format; mps_chain_t chain; mps_ap_t apamc; typedef mycell * myroot; myroot 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"); cdie( mps_root_create_table(&root1, arena, mps_rank_exact(), 0, (mps_addr_t*)&a, 1), "root"); cdie( mps_root_create_table(&root2, arena, mps_rank_exact(), 0, (mps_addr_t*)&b, 1), "root"); cdie( mps_root_create_table(&root3, arena, mps_rank_exact(), 0, (mps_addr_t*)&c, 1), "root"); cdie( mps_root_create_table(&root4, arena, mps_rank_exact(), 0, (mps_addr_t*)&d, 1), "root"); cdie( mps_root_create_table(&root5, arena, mps_rank_exact(), 0, (mps_addr_t*)&e, 1), "root"); cdie( mps_root_create_table(&root6, arena, mps_rank_exact(), 0, (mps_addr_t*)&f, 1), "root"); cdie( mps_root_create_table(&root7, arena, mps_rank_exact(), 0, (mps_addr_t*)&g, 1), "root"); cdie( mps_root_create_table(&root, arena, mps_rank_exact(), 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_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap"); comment("parking..."); mps_arena_park(arena); b = allocone(apamc, 1, 1); for (j=1; j<10; j++) { comment("%i of 10.", j); a = allocone(apamc, 5, 1); cutoff_id = getid(a); b = a; c = a; d = a; e = a; f = a; g = a; for (i=1; i<1000; i++) { c = allocone(apamc, 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(c, 0, b); setref(c, 1, d); setref(c, 2, e); setref(c, 3, f); setref(c, 4, g); b = c; } for (i=1; i<1000; i++) { c = allocone(apamc, 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(c, 0, b); setref(c, 1, d); setref(c, 2, e); setref(c, 3, f); setref(c, 4, g); b = c; } a = c; b = c; d = c; e = c; f = c; g = c; exfmt_root = c; mps_arena_collect(arena); comment(" reserved: %lu", (unsigned long) mps_arena_reserved(arena)); comment("committed: %lu", (unsigned long) mps_arena_committed(arena)); comment("calling amc_apply:"); checkfrom(c); appcount = 0; apppadcount = 0; junk_size = 0; mps_amc_apply(poolamc, &test_apply, NULL, MAGICSIZE); comment("finished amc_apply"); report("junksize", "%lu", (unsigned long) junk_size); report("appcount", "%ld", appcount); report("apppadcount", "%ld", apppadcount); RC; } mps_arena_release(arena); comment("released."); mps_arena_park(arena); mps_ap_destroy(apamc); mps_pool_destroy(poolamc); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_root_destroy(root1); mps_root_destroy(root2); mps_root_destroy(root3); mps_root_destroy(root4); mps_root_destroy(root5); mps_root_destroy(root6); mps_root_destroy(root7); 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_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 *arg, size_t s) { mps_arena_t arena; mps_fmt_t format; mps_root_t exactRoot, ambigRoot; size_t lastStep = 0, i, r; unsigned long objs; mps_ap_t busy_ap; mps_addr_t busy_init; const char *indent = " "; mps_chain_t chain; static mps_gen_param_s genParam = {1024, 0.2}; arena = (mps_arena_t)arg; (void)s; /* unused */ die(mps_fmt_create_A(&format, arena, dylan_fmt_A()), "fmt_create"); die(mps_chain_create(&chain, arena, 1, &genParam), "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_GEN, 0); die(mps_pool_create_k(&pool, arena, mps_class_amst(), args), "pool_create(amst)"); } MPS_ARGS_END(args); die(mps_ap_create(&ap, pool, mps_rank_exact()), "BufferCreate"); die(mps_ap_create(&busy_ap, pool, mps_rank_exact()), "BufferCreate 2"); for(i = 0; i < exactRootsCOUNT; ++i) exactRoots[i] = objNULL; for(i = 0; i < ambigRootsCOUNT; ++i) ambigRoots[i] = rnd_addr(); 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)"); puts(indent); /* create an ap, and leave it busy */ die(mps_reserve(&busy_init, busy_ap, 64), "mps_reserve busy"); objs = 0; while(totalSize < totalSizeMAX) { if (totalSize > lastStep + totalSizeSTEP) { lastStep = totalSize; printf("\nSize %"PRIuLONGEST" bytes, %"PRIuLONGEST" objects.\n", (ulongest_t)totalSize, (ulongest_t)objs); printf("%s", indent); (void)fflush(stdout); for(i = 0; i < exactRootsCOUNT; ++i) cdie(exactRoots[i] == objNULL || dylan_check(exactRoots[i]), "all roots check"); } r = (size_t)rnd(); if (r & 1) { i = (r >> 1) % 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); } else {
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), "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(void) { mps_arena_t arena; mps_pool_t poolamc, poolawl; mps_thr_t thread; mps_root_t root, root1, root2; mps_fmt_t format; mps_chain_t chain; mps_ap_t apamc, apawl; mycell *a[3]; int j; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); die(mps_thread_reg(&thread, arena), "register thread"); die(mps_root_create_table(&root, arena, mps_rank_exact(), 0, (mps_addr_t*)&a[0], 2), "create table root"); cdie( mps_root_create_table(&root2, arena, mps_rank_ambig(), 0, (mps_addr_t*)&a[2], 1), "ambig table 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_exact()), "create ap"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap"); a[1] = allocone(apawl, 2, 1); a[0] = allocone(apawl, 2, 1); a[2] = allocone(apamc, 2, 1); setref(a[0], 0, a[2]); mps_ap_destroy(apawl); comment("Destroyed awl ap"); for(j=0; j<100; j++) { allocdumb(apamc, 1024*256, 1); } mps_ap_destroy(apamc); comment("Destroyed amc ap."); mps_root_destroy(root1); mps_root_destroy(root2); comment("Destroyed ambiguous roots."); a[1] = a[0]; comment("Now to try arena_collect:"); mps_arena_collect(arena); 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 poollo; mps_thr_t thread; mps_root_t root0, root1; mps_fmt_t format; mps_ap_t aplo; mycell *a; 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"); cdie(mps_pool_create(&poollo, arena, mps_class_lo(), format), "create pool"); cdie(mps_ap_create(&aplo, poollo, mps_rank_exact()), "create ap"); /* alloc lots in an LO pool; it should be collected away */ for(j=0; j<1000; j++) { a = allocdumb(aplo, 1024ul*1024, mps_rank_exact()); } /* (total allocated is 1000 M) */ mps_arena_park(arena); mps_root_destroy(root0); mps_root_destroy(root1); comment("Destroyed roots."); mps_ap_destroy(aplo); comment("Destroyed ap."); mps_pool_destroy(poollo); comment("Destroyed pool."); mps_fmt_destroy(format); comment("Destroyed format."); mps_thread_dereg(thread); comment("Deregistered thread."); mps_arena_destroy(arena); comment("Destroyed arena."); pass(); }
static void test(void *stack_pointer) { long int i; long int rsize = 0; int inramp; mycell *r = NULL, *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_thread(&root, arena, thread, stack_pointer), "thread 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"); inramp = 0; for (i = 0; i < ITERATIONS; i++) { if (i * 10 % ITERATIONS == 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()); #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()); #endif comment("ramp begin"); r = allocone(apamc, 3, mps_rank_exact()); inramp = 1; rsize = 0; } } } mps_arena_park(arena); 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) { /* a is a table of exact roots b a table of ambiguous roots f a table of non-roots */ mycell *a[4], *b[4], *f[4]; mps_addr_t addr; int i, j, k; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); addr = &a[0]; cdie( mps_root_create_table(&root, arena, mps_rank_exact(), 0, addr, 4), "create a root table"); addr = &b[0]; cdie( mps_root_create_table(&root1, arena, mps_rank_ambig(), 0, addr, 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"); cdie( mps_pool_create(&poolamc, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_pool_create(&poollo, arena, mps_class_lo(), format), "create pool"); cdie( mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated), "create pool"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap"); cdie( mps_ap_create(&aplo, poollo, mps_rank_exact()), "create ap"); cdie( mps_ap_create(&apawl, poolawl, mps_rank_exact()), "create ap"); newstamp = 0; for (i=0; i<4; i++) { addr = &a[i]; die(allocrdumb(addr, aplo, 64, mps_rank_exact()), "alloc failed"); addr = &b[i]; die(allocrone(addr, apawl, 5, mps_rank_exact()), "alloc failed"); b[i]->data.ref[0].addr = a[i]; addr = &a[i]; die(allocrone(addr, apamc, 5, mps_rank_exact()), "alloc failed"); 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); addr = &a[k]; die(allocrdumb(addr, aplo, 64, mps_rank_exact()), "alloc failed"); k = ranint(4); addr = &b[k]; die(allocrone(addr, apawl, 5, mps_rank_exact()), "alloc failed"); b[k]->data.ref[0].addr = a[ranint(4)]; b[k]->data.ref[1].addr = b[ranint(4)]; addr = &a[k]; die(allocrone(addr, apamc, 5, mps_rank_exact()), "alloc failed"); f[k] = a[k]->data.ref[2].addr; 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("f[0] = %p", f[0]); /* avoid compiler warning about used f */ comment("ok"); } mps_arena_park(arena); 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_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 *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."); }