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 {
/* v serves two purposes: * A pseudo stack base for the stack root. * Pointer to a guff structure, which packages some values needed * (arena and thr mostly) */ static void *setup(void *v, size_t s) { struct guff_s *guff; mps_arena_t arena; mps_pool_t leafpool; mps_pool_t tablepool; mps_fmt_t dylanfmt; mps_fmt_t dylanweakfmt; mps_ap_t leafap, exactap, weakap, bogusap; mps_root_t stack; mps_thr_t thr; guff = (struct guff_s *)v; (void)s; arena = guff->arena; thr = guff->thr; die(mps_root_create_reg(&stack, arena, MPS_RANK_AMBIG, 0, thr, mps_stack_scan_ambig, v, 0), "Root Create\n"); die(mps_fmt_create_A(&dylanfmt, arena, dylan_fmt_A()), "Format Create\n"); die(mps_fmt_create_A(&dylanweakfmt, arena, dylan_fmt_A_weak()), "Format Create (weak)\n"); die(mps_pool_create(&leafpool, arena, mps_class_lo(), dylanfmt), "Leaf Pool Create\n"); die(mps_pool_create(&tablepool, arena, mps_class_awl(), dylanweakfmt, dylan_weak_dependent), "Table Pool Create\n"); die(mps_ap_create(&leafap, leafpool, MPS_RANK_EXACT), "Leaf AP Create\n"); die(mps_ap_create(&exactap, tablepool, MPS_RANK_EXACT), "Exact AP Create\n"); die(mps_ap_create(&weakap, tablepool, MPS_RANK_WEAK), "Weak AP Create\n"); die(mps_ap_create(&bogusap, tablepool, MPS_RANK_EXACT), "Bogus AP Create\n"); test(leafap, exactap, weakap, bogusap); mps_ap_destroy(bogusap); mps_ap_destroy(weakap); mps_ap_destroy(exactap); mps_ap_destroy(leafap); mps_pool_destroy(tablepool); mps_pool_destroy(leafpool); mps_fmt_destroy(dylanweakfmt); mps_fmt_destroy(dylanfmt); mps_root_destroy(stack); return NULL; }
static void test(void *stack_pointer) { mps_arena_t arena; mps_pool_t pool; mps_fmt_t format; mps_ap_t ap; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_fmt_create_k(&format, arena, mps_args_none), "create format"); cdie(mps_pool_create(&pool, arena, mps_class_lo(), format), "create pool"); mps_pool_destroy(pool); comment("Destroyed pool."); cdie(mps_ap_create(&ap, pool, mps_rank_exact()), "create ap"); mps_ap_destroy(ap); comment("Destroyed ap."); mps_fmt_destroy(format); comment("Destroyed format."); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_arena_t arena; mps_pool_t poolamc1; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_chain_t chain; mps_ap_t ap1; 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)"); cdie( mps_ap_create(&ap1, poolamc1, 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_pool_destroy(poolamc1); 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; mps_chain_t chain; mps_fmt_t format; mps_ap_t ap; 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"); 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, UNALIGNED, mps_rank_exact()), "create ap"); }
static void test(void) { mps_space_t space; mps_pool_t pool; size_t extendBy; size_t avgSize; size_t maxSize; mps_ap_t ap; mps_addr_t obj; extendBy = (size_t) 4096; avgSize = (size_t) 32; maxSize = (size_t) 65536; cdie(mps_space_create(&space), "create space"); cdie( mps_pool_create(&pool, space, mps_class_mv(), extendBy, avgSize, maxSize), "create pool"); cdie(mps_ap_create(&ap, pool, MPS_RANK_EXACT), "create ap"); mps_pool_destroy(pool); comment("Destroyed pool"); mps_space_destroy(space); comment("Destroyed space."); }
static void test(void) { mps_arena_t arena; mps_pool_t pool; size_t extendBy; size_t avgSize; size_t maxSize; mps_ap_t ap; mps_addr_t obj; extendBy = (size_t) 4096; avgSize = (size_t) 32; maxSize = (size_t) 65536; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie( mps_pool_create(&pool, arena, mps_class_mv(), extendBy, avgSize, maxSize), "create pool"); cdie(mps_ap_create(&ap, pool, mps_rank_exact()), "create ap"); mps_pool_destroy(pool); comment("Destroyed pool"); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_space_t space; mps_pool_t pool; mps_thr_t thread; mps_root_t root; mps_fmt_t format; cdie(mps_space_create(&space), "create space"); cdie(mps_thread_reg(&thread, space), "register thread"); cdie( mps_root_create_reg(&root, space, MPS_RANK_AMBIG, 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie( mps_fmt_create_A(&format, space, &fmtA), "create format"); formatcomments = 0; cdie( mps_pool_create(&pool, space, mps_class_amc(), format), "create pool"); cdie( mps_ap_create(NULL, pool, MPS_RANK_EXACT), "create ap"); }
static void test (void) { mps_thr_t thread; mps_pool_t pool; mps_ap_t ap; int i; cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*100)), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); die( mps_pool_create(&pool, arena, mps_class_mv2(), OBJSIZE, OBJSIZE, OBJSIZE, DEPTH, FRAGLIMIT), "create MV2 pool"); die(mps_ap_create(&ap, pool, MPS_RANK_AMBIG), "create ap"); for (i = 0; i < OBJECTS; i++) { die(mv2_alloc(&objs[i], ap, OBJSIZE), "alloc"); } report("size1", "%ld", mps_arena_committed(arena)); for (i = 0; i < OBJECTS; i+=2) { mps_free(pool, objs[i], OBJSIZE); die(mv2_alloc(&objs[i], ap, OBJSIZE), "alloc"); } report("size2", "%ld", mps_arena_committed(arena)); mps_ap_destroy(ap); mps_pool_destroy(pool); mps_thread_dereg(thread); mps_arena_destroy(arena); }
static void test(void *stack_pointer) { mps_arena_t arena; mps_pool_t pool; mps_fmt_t format; mps_ap_t ap; mps_addr_t obj; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_fmt_create_k(&format, arena, mps_args_none), "create format"); cdie(mps_pool_create(&pool, arena, mps_class_lo(), format), "create pool"); cdie(mps_ap_create(&ap, pool), "create ap"); cdie(mps_reserve(&obj, ap, 256), "reserve"); (void)mps_commit(ap, &obj, 256); mps_free(pool, obj, 256); comment("Freed."); mps_free(pool, obj, 256); comment("Freed again."); mps_pool_destroy(pool); comment("Destroyed pool"); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { int i = 0; mps_ap_t sap; mps_arena_t arena; mps_fmt_t format; mps_pool_t spool; mps_thr_t thread; mps_frame_t frame; mycell *p; /* create an arena that can't grow beyond 30 M */ 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_fmt_create_A(&format, arena, &fmtA), "create format"); cdie( mps_pool_create(&spool, arena, mps_class_snc(), format), "create SNC pool"); cdie( mps_ap_create(&sap, spool, mps_rank_exact()), "create ap"); /* repeatedly push, alloc 1MB object, and pop to first stack frame. This shouldn't use much more than 1MB of memory. */ for (i=0; i < ITERATIONS; i++) { die(mps_ap_frame_push(&frame, sap), "push"); p = allocdumb(sap, OBJSIZE, mps_rank_exact()); die(mps_ap_frame_pop(sap, frame), "pop"); comment("%i of %i", i, ITERATIONS); } mps_ap_destroy(sap); comment("Destroyed ap."); mps_pool_destroy(spool); comment("Destroyed pool."); mps_fmt_destroy(format); comment("Destroyed format."); mps_thread_dereg(thread); comment("Deregistered thread."); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_space_t space; mps_pool_t pool; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_ap_t ap; mps_addr_t p; mps_addr_t q; cdie(mps_space_create(&space), "create space"); cdie(mps_thread_reg(&thread, space), "register thread"); cdie( mps_root_create_reg(&root, space, MPS_RANK_AMBIG, 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie( mps_fmt_create_A(&format, space, &fmtA), "create format"); cdie( mps_pool_create(&pool, space, mps_class_amc(), format), "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_root_destroy(root); comment("Destroyed root."); mps_thread_dereg(thread); comment("Deregistered thread."); mps_space_destroy(space); comment("Destroyed space."); }
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(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; int i; 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"); for(i=1; i<1000; i++) { do { die(mps_reserve(&p, ap, OBJSIZE), "Reserve: "); } while (!mps_commit(ap, p, OBJSIZE)); comment("%i at %p", i, p); comment("%i objects of 10 megabytes each allocated", i); } mps_arena_park(arena); mps_ap_destroy(ap); mps_pool_destroy(pool); mps_fmt_destroy(format); mps_chain_destroy(chain); mps_root_destroy(root); mps_thread_dereg(thread); mps_arena_destroy(arena); }
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) { 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; 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"); { mps_addr_t p; cdie(mps_reserve(&p, ap, 0x100), "Reserve: "); } 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 *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_pool_t pool; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_chain_t chain; int h; mycell *p, *q, *r; 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"); cdie(mmqa_pool_create_chain(&pool, arena, mps_class_amc(), format, chain), "create pool"); cdie(mps_ap_create(&ap, pool, mps_rank_exact()), "create ap"); r = allocone(ap, 1000); for (h = 0; h < 10000; h++) { if (h % 10 == 0) { report("iter", "%i", h); } q = allocone(ap, 1000); p = allocone(ap, 1000); setref(p, 1, q); r = allocone(ap, 1000); setref(q, 50, r); setref(r, 1, p); } mps_ap_destroy(ap); 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 *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) { mps_arena_t arena; mps_pool_t pool; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_chain_t chain; locell *a,*b,*c,*z; int i; alloclocomments = 0; allowlocopies = 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"); die(mps_fmt_create_A(&format, arena, &fmtLO), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&pool, arena, mps_class_amcz(), format, chain), "create pool"); cdie( mps_ap_create(&ap, pool, mps_rank_exact()), "create ap"); a = string_ch("Hello there"); b = string_ch("Wibble wobble foo"); c = string_ch("Ba "); for (i=0; i<10000; i++) { a = conc(string_ch("B"), a); c = conc(string_ch("Hello there"), string_ch(" folks!")); z = alloclo(ap, 0x4000); } 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_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_space_t space; mps_pool_t pool; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_ap_t ap; cdie(mps_space_create(&space), "create space"); cdie(mps_thread_reg(&thread, space), "register thread"); cdie( mps_root_create_reg(&root, space, MPS_RANK_AMBIG, 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie( mps_fmt_create_A(&format, space, &fmtA), "create format"); cdie( mps_pool_create(&pool, space, mps_class_amc(), format), "create pool"); cdie( mps_ap_create(&ap, pool, MPS_RANK_EXACT), "create ap"); mps_ap_destroy(ap); comment("Destroyed ap."); allocone(ap, 0, NULL, NULL, 0x100); mps_pool_destroy(pool); comment("Destroyed pool."); mps_fmt_destroy(format); comment("Destroyed format."); mps_root_destroy(root); comment("Destroyed root."); mps_thread_dereg(thread); comment("Deregistered thread."); mps_space_destroy(space); comment("Destroyed space."); }
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"); 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"); do{ cdie( mps_reserve(&p, ap, (size_t) 64), "reserve"); } while (!mps_commit(ap, p, (size_t) HIGHBIT_SIZE+64)); }
static void test(void) { mps_arena_t arena; mps_pool_t pool; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_chain_t chain; mps_ap_t ap; mycell *a; 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"); cdie( mps_ap_create(&ap, pool, MPS_RANK_EXACT), "create ap"); a = allocdumb(ap, 1024*1024*80); mps_ap_destroy(ap); mps_pool_destroy(pool); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_thread_dereg(thread); mps_arena_destroy(arena); }
static void test(void) { mps_arena_t arena; mps_pool_t pool; mps_thr_t thread; mps_root_t root; mps_ap_t ap; mps_fmt_t format; 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_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(&ap, pool, mps_rank_exact()), "create ap"); while (mps_collections(arena) == 0) { allocdumb(ap, 1024*256); } mps_ap_destroy(ap); mps_pool_destroy(pool); comment("Destroyed pool."); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_thread_dereg(thread); mps_arena_destroy(arena); }
static void test(void *stack_pointer) { void *marker = ▮ mps_arena_t arena; mps_pool_t pool; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_ap_t ap; mps_addr_t p, q, unaligned; cdie(mps_arena_create_k(&arena, mps_arena_class_vm(), mps_args_none), "create arena"); mps_arena_park(arena); cdie(mps_thread_reg(&thread, arena), "register thread"); cdie(mps_root_create_thread(&root, arena, thread, marker), "create root"); cdie(mps_fmt_create_A(&format, arena, &fmtA), "create format"); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_FORMAT, format); cdie(mps_pool_create_k(&pool, arena, mps_class_ams(), args), "pool"); } MPS_ARGS_END(args); cdie(mps_ap_create(&ap, pool, mps_rank_exact()), "ap"); /* p is in the AMS pool */ p = allocone(ap, 0, NULL, NULL, sizeof(mycell)); /* q is in the AMS pool with unaligned exact reference to p */ unaligned = (void *)((char*)p + 1); q = allocone(ap, 1, p, unaligned, sizeof(mycell)); mps_arena_start_collect(arena); mps_arena_park(arena); /* Keep q (and thus p) alive during the collection. */ report("q", "%p", q); mps_ap_destroy(ap); mps_pool_destroy(pool); mps_fmt_destroy(format); mps_root_destroy(root); mps_thread_dereg(thread); mps_arena_destroy(arena); }
static void test(void) { mps_space_t space; mps_pool_t pool; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_ap_t ap; mps_addr_t p; cdie(mps_space_create(&space), "create space"); cdie(mps_thread_reg(&thread, space), "register thread"); cdie( mps_root_create_reg(&root, space, MPS_RANK_AMBIG, 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie( mps_fmt_create_A(&format, space, &fmtA), "create format"); formatcomments = 0; cdie( mps_pool_create(&pool, space, mps_class_amc(), format), "create pool"); cdie( mps_ap_create(&ap, pool, MPS_RANK_EXACT), "create ap"); do{ cdie( mps_reserve(&p, ap, (size_t) 64), "reserve"); } while (!mps_commit(ap, UNALIGNED, (size_t) 64)); }
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_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) { 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) { mycell *p, *q; int i; mps_res_t res; size_t lim0, avail0, lim1, avail1, commit1, lim2, avail2, commit2; size_t lim3, avail3, commit3, lim4, avail4, commit4; size_t lim5, avail5, commit5, lim6, avail6, commit6; cdie(mps_arena_create(&arena, mps_arena_class_vm(), ARENA_SIZE), "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 stack root"); cdie( mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie( mps_pool_create(&poolsnc, arena, mps_class_snc(), format), "create pool"); cdie( mps_ap_create(&apsnc, poolsnc, mps_rank_exact()), "create ap"); report("lim0", "%d", lim0 = mps_reservoir_limit(arena)); report("avail0", "%d", avail0 = mps_reservoir_available(arena)); mps_reservoir_limit_set(arena, (size_t) 0); mps_reservoir_limit_set(arena, (size_t) (5ul*1024*1024)); report("lim1", "%d", lim1 = mps_reservoir_limit(arena)); report("avail1", "%d", avail1 = mps_reservoir_available(arena)); report("commit1", "%d", commit1 = arena_committed_and_used(arena)); report("defecit1", "%d", lim1-avail1); mps_reservoir_limit_set(arena, (size_t) (1045)); report("lim2", "%d", lim2 = mps_reservoir_limit(arena)); report("avail2", "%d", avail2 = mps_reservoir_available(arena)); report("commit2", "%d", commit2 = arena_committed_and_used(arena)); report("defecit2", "%d", lim2-avail2); /* set commit limit to whatever is currently committed plus 1 MB */ die(mps_arena_commit_limit_set(arena, arena_committed_and_used(arena)+1024*1024), "commit limit set"); mps_reservoir_limit_set(arena, (size_t) (10ul*1024*1024)); report("lim3", "%d", lim3 = mps_reservoir_limit(arena)); report("avail3", "%d", avail3 = mps_reservoir_available(arena)); report("commit3", "%d", commit3 = arena_committed_and_used(arena)); report("defecit3", "%d", lim3-avail3); report("spill3", "%d", commit3-mps_arena_commit_limit(arena)); /* now raise it by 1/2 MB -- reservoir should grow */ die(mps_arena_commit_limit_set(arena, arena_committed_and_used(arena)+512*1024), "commit limit set"); report("lim4", "%d", lim4 = mps_reservoir_limit(arena)); report("avail4", "%d", avail4 = mps_reservoir_available(arena)); report("commit4", "%d", commit4 = arena_committed_and_used(arena)); report("grow4", "%d", avail4-avail3); report("spill4", "%d", commit4-mps_arena_commit_limit(arena)); /* try some allocation -- more than a small amount should fail */ i = -1; p = NULL; res = MPS_RES_OK; while (res == MPS_RES_OK) { res = allocrone(&q, apsnc, 10, mps_rank_exact()); if (res == MPS_RES_OK) { setref(q, 0, p); p = q; } i++; } report("allocfail", "%d", i); report_res("failres", res); /* available shouldn't have changed since before allocation */ report("lim5", "%d", lim5 = mps_reservoir_limit(arena)); report("avail5", "%d", avail5 = mps_reservoir_available(arena)); report("commit5", "%d", commit5 = arena_committed_and_used(arena)); report("grow5", "%d", avail5-avail4); report("spill5", "%d", commit5-mps_arena_commit_limit(arena)); /* try some allocation from reservoir -- not much should fail */ i = -1; res = MPS_RES_OK; while (res == MPS_RES_OK) { res = reservoir_allocrone(&q, apsnc, 10, mps_rank_exact()); if (res == MPS_RES_OK) { setref(q, 0, p); p = q; } i++; } report("allocfail2", "%d", i); report_res("failres2", res); /* available should have changed now */ report("lim6", "%d", lim6 = mps_reservoir_limit(arena)); report("avail6", "%d", avail6 = mps_reservoir_available(arena)); report("commit6", "%d", commit6 = arena_committed_and_used(arena)); report("spill6", "%d", commit6-mps_arena_commit_limit(arena)); report("shrink6", "%d", avail5-avail6); mps_root_destroy(root); comment("Destroyed root."); mps_ap_destroy(apsnc); comment("Destroyed ap."); mps_pool_destroy(poolsnc); comment("Destroyed pool."); mps_fmt_destroy(format); comment("Destroyed format."); mps_thread_dereg(thread); comment("Deregistered thread."); mps_arena_destroy(arena); comment("Destroyed arena."); }