static void test(void) { mps_thr_t thread; size_t mins; cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*50)), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); mins = sizeof(int); dt(SEQ, 4096, 32, 64*1024, 8, 9, 5, 1000); dt(RANGAP, 64, 64, 64, 8, 128, 100, 100000); dt(DUMMY, 4096, 32, 64*1024, 8, 64, 1000, 1000000); dt(SEQ, 4096, 32, 64*1024, 8, 64, 1000, 1000000); dt(RAN, 4096, 32, 64*1024, 8, 64, 1000, 1000000); dt(SEQGAP, 4096, 32, 64*1024, 8, 64, 1000, 1000000); dt(RANGAP, 4096, 32, 64*1024, 8, 64, 1000, 1000000); dt(DUMMY, 4096, 1024, 64*1024, 100, 132, 1000, 1000000); dt(SEQ, 4096, 1024, 64*1024, 100, 132, 1000, 1000000); dt(RAN, 4096, 1024, 64*1024, 100, 132, 1000, 1000000); dt(SEQGAP, 4096, 1024, 64*1024, 100, 132, 1000, 1000000); dt(RANGAP, 4096, 1024, 64*1024, 100, 132, 1000, 1000000); dt(DUMMY, 128*1024, 64*1024, 6400*1024, mins, 128*1024, 100, 10000); dt(SEQ, 128*1024, 64*1024, 6400*1024, mins, 128*1024, 100, 10000); dt(RAN, 128*1024, 64*1024, 6400*1024, mins, 128*1024, 100, 10000); dt(SEQGAP, 128*1024, 64*1024, 6400*1024, mins, 128*1024, 100, 10000); dt(RANGAP, 128*1024, 64*1024, 6400*1024, mins, 128*1024, 100, 10000); mps_thread_dereg(thread); mps_arena_destroy(arena); }
static void test(void) { int i; mps_addr_t a; /* create an arena with chunk size of 2 M */ cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*20)), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); /* set the commit limit to 10MB */ report_res("commit0", mps_arena_commit_limit_set(arena, (size_t) (1024*1024*10))); /* create a pool */ cdie(mps_pool_create(&pool, arena, mps_class_mv(), (size_t) 64, (size_t) 64, (size_t) 64), "pool create"); for (i=0; i<200; i++) { report("count", "%i", i); die(mps_alloc(&a, pool, (size_t) 1024*1024), "alloc"); } mps_pool_destroy(pool); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
int main(int argc, char **argv) { mps_arena_t arena; mps_thr_t thread; mps_root_t reg_root; void *r; void *marker = ▮ randomize(argc, argv); die(mps_arena_create(&arena, mps_arena_class_vm(), TEST_ARENA_SIZE), "arena_create"); die(mps_thread_reg(&thread, arena), "thread_reg"); die(mps_root_create_reg(®_root, arena, MPS_RANK_AMBIG, (mps_rm_t)0, thread, &mps_stack_scan_ambig, marker, (size_t)0), "root_create_reg"); (mps_tramp)(&r, test, arena, 0); /* non-inlined trampoline */ mps_tramp(&r, test, arena, 0); mps_root_destroy(reg_root); mps_thread_dereg(thread); 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_thr_t thread; mps_pool_t pool; mps_addr_t a; char *c; cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*50)), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_POOL_DEBUG_OPTIONS, &debugOpts); die(mps_pool_create_k(&pool, arena, mps_class_mvff_debug(), args), "create MVFF pool"); } MPS_ARGS_END(args); die(mps_alloc(&a, pool, 64), "alloc a"); c = a; c -= 1; *c = 0; mps_pool_check_fenceposts(pool); comment("Fencepost check."); c += 67; *c = 0; mps_pool_check_fenceposts(pool); comment("Fencepost check."); mps_pool_destroy(pool); mps_thread_dereg(thread); mps_arena_destroy(arena); }
int main(int argc, char *argv[]) { mps_arena_t arena; mps_thr_t thread; testlib_init(argc, argv); die(mps_arena_create(&arena, mps_arena_class_vm(), testArenaSIZE), "arena_create"); die(mps_thread_reg(&thread, arena), "thread_reg"); test(arena, mps_class_amc()); test(arena, mps_class_amcz()); test(arena, mps_class_ams()); test(arena, mps_class_awl()); test(arena, mps_class_lo()); test(arena, mps_class_snc()); mps_thread_dereg(thread); mps_arena_destroy(arena); printf("%s: Conclusion: Failed to find any defects.\n", argv[0]); return 0; }
static void test(void) { mps_thr_t thread; mps_pool_t pool; mps_addr_t a; char * c; cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*50)), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); die(mps_pool_create(&pool, arena, mps_class_mvff_debug(), &debugOpts, (size_t)8192, (size_t)8, (mps_align_t)8, (mps_bool_t)0, (mps_bool_t)1, (mps_bool_t)0), "create MVFF pool"); die(mps_alloc(&a, pool, 63), "alloc a"); c = a; c += 63; *c = 0; mps_free(pool, a, 63); mps_pool_destroy(pool); mps_thread_dereg(thread); mps_arena_destroy(arena); }
static void test(void) { mps_arena_t arena; mps_pool_t pool; mps_pool_t pool1; mps_thr_t thread; mps_fmt_t format; mps_chain_t chain; int p; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); die(mps_thread_reg(&thread, arena), "register thread"); 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(&pool1, arena, mps_class_amc(), format, chain), "create pool"); for (p = 0; p < 10000; p++) { die(mmqa_pool_create_chain(&pool, arena, mps_class_amc(), format, chain), "create pool"); comment("%i", p); mps_pool_destroy(pool1); pool1=pool; } mps_pool_destroy(pool); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_thread_dereg(thread); mps_arena_destroy(arena); }
/* testscriptA -- create arena, thr, and tramp; call testscriptB */ static void testscriptA(const char *script) { mps_arena_t arena; mps_thr_t thr; mps_tramp_t trampFunction; trampDataStruct trampData; void *trampResult; printf("Script: \"%s\"\n Create arena etc.\n", script); /* arena */ die(mps_arena_create(&arena, mps_arena_class_vm(), testArenaSIZE), "arena_create"); mps_arena_clamp(arena); /* thr: used to stop/restart multiple threads */ die(mps_thread_reg(&thr, arena), "thread"); /* tramp: used for protection (barrier hits) */ /* call testscriptB! */ trampFunction = testscriptB; trampData.arena = arena; trampData.thr = thr; trampData.script = script; mps_tramp(&trampResult, trampFunction, &trampData, sizeof trampData); mps_thread_dereg(thr); mps_arena_destroy(arena); printf(" Destroy arena etc.\n\n"); }
static void test(void) { mps_thr_t thread; int spare, spare_total, commit, obj; /* create a VM arena of 100MB */ cdie(mps_arena_create(&arena,mps_arena_class_vmnz(),(size_t)(1024*1024*100)), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); report("failed", "no"); for (spare = SPARE_EMPTY; spare <= SPARE_MORE; spare++) { for (spare_total = spare; spare_total <= SPARE_MORE; spare_total++) { for (commit = COMMIT_EXACT; commit <= COMMIT_PLENTY; commit++) { for (obj = OBJ_SMALL; obj <= OBJ_BIG; obj++) { t_alloc(spare, spare_total, commit, obj); }}}} comment("Finishing off."); mps_thread_dereg(thread); comment("Deregistered thread."); mps_arena_destroy(arena); comment("Destroyed arena."); }
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) { mps_thr_t thread; mps_pool_t pool; mps_addr_t a, b; char *c; cdie(mps_arena_create(&arena, mps_arena_class_vmnz(), (size_t) (1024*1024*50)), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); die( mps_pool_create(&pool, arena, mps_class_mvff_debug(), &debugOpts, 8192, 8, 8, 0, 0, 1), "create MVFF pool"); die(mps_alloc(&a, pool, 64), "alloc a"); die(mps_alloc(&b, pool, 64), "alloc b"); c = a; c -= 1; *c = 0; mps_pool_check_fenceposts(pool); comment("Fencepost check."); c += 67; *c = 0; mps_pool_check_fenceposts(pool); comment("Fencepost check."); mps_pool_destroy(pool); mps_thread_dereg(thread); mps_arena_destroy(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) { 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) { 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_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); }
static void test(void) { mps_space_t space; mps_thr_t thread; cdie(mps_space_create(&space), "create space"); cdie(mps_thread_reg(&thread, space), "register thread"); mps_thread_dereg(thread); comment("Deregistered thread."); mps_thread_dereg(thread); comment("Deregistered thread again."); mps_space_destroy(space); comment("Destroyed space."); }
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_arena_t arena; mps_thr_t thread; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); mps_thread_dereg(thread); comment("Deregistered thread."); mps_thread_dereg(thread); comment("Deregistered thread again."); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void *stack_pointer) { mps_thr_t thread; mps_pool_t pool; unsigned int i; unsigned long nLarge; cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*50)), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); mps_arena_commit_limit_set(arena, COMLIMIT1); die(mps_pool_create(&pool, arena, mps_class_mvff(), (size_t)EXTENDBY, (size_t)8, (mps_align_t)MPS_PF_ALIGN, (mps_bool_t)0, (mps_bool_t)0, (mps_bool_t)1), "create MVFF pool"); for (i = 0; i < NSMALL; i++) { die(mps_alloc(&smallObjects[i], pool, SMALLSIZE), "small alloc failed"); } nLarge = 0; while (mps_alloc(&largeObjects[nLarge], pool, BIGSIZE) == MPS_RES_OK) { nLarge ++; } report("nLarge", "%lu", nLarge); for (i = 0; i < NSMALL; i += 2) { mps_free(pool, smallObjects[i], SMALLSIZE); } comment("Freed every other small object."); /* The CBS should be in emergency mode now. */ for (i = 0; i < nLarge; i += 2) { mps_free(pool, largeObjects[i], BIGSIZE); } comment("Freed every other large object."); /* Now there should be lots of big blocks on the CBS. */ mps_arena_commit_limit_set(arena, COMLIMIT2); comment("Raised the commit limit. Will attempt free and alloc."); mps_free(pool, largeObjects[1], BIGSIZE); die(mps_alloc(&largeObjects[0], pool, BIGSIZE), "alloc failed"); mps_pool_destroy(pool); mps_thread_dereg(thread); mps_arena_destroy(arena); }
static void test_main(void *marker, int interior, int stack) { mps_res_t res; mps_chain_t obj_chain; mps_fmt_t obj_fmt; mps_thr_t thread; mps_root_t reg_root = NULL; res = mps_arena_create_k(&scheme_arena, mps_arena_class_vm(), mps_args_none); if (res != MPS_RES_OK) error("Couldn't create arena"); res = mps_chain_create(&obj_chain, scheme_arena, sizeof(obj_gen_params) / sizeof(*obj_gen_params), obj_gen_params); if (res != MPS_RES_OK) error("Couldn't create obj chain"); scheme_fmt(&obj_fmt); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_CHAIN, obj_chain); MPS_ARGS_ADD(args, MPS_KEY_FORMAT, obj_fmt); MPS_ARGS_ADD(args, MPS_KEY_INTERIOR, interior); die(mps_pool_create_k(&obj_pool, scheme_arena, mps_class_amc(), args), "mps_pool_create_k"); } MPS_ARGS_END(args); res = mps_ap_create_k(&obj_ap, obj_pool, mps_args_none); if (res != MPS_RES_OK) error("Couldn't create obj allocation point"); res = mps_thread_reg(&thread, scheme_arena); if (res != MPS_RES_OK) error("Couldn't register thread"); if (stack) { res = mps_root_create_thread(®_root, scheme_arena, thread, marker); if (res != MPS_RES_OK) error("Couldn't create root"); } test_air(interior, stack); mps_arena_park(scheme_arena); if (stack) mps_root_destroy(reg_root); mps_thread_dereg(thread); mps_ap_destroy(obj_ap); mps_pool_destroy(obj_pool); mps_chain_destroy(obj_chain); mps_fmt_destroy(obj_fmt); mps_arena_destroy(scheme_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 *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) { 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"); */ allocone(ap, 0, NULL, NULL, 0x100); 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_arena_t arena; mps_thr_t thread; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); mps_thread_dereg(NULL); }
static void test(void) { mps_thr_t thread; size_t mins; mps_count_t dep, frag; cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*100)), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); mins = sizeof(int); dep = 10000; for (frag = 40; frag >= 5; frag = (frag >> 1)) { comment("Frag: %i", frag); dt(SEQ, 8, 8, 9, dep, frag, 8, 9, 5, 1000); dt(RANGAP, 64, 64, 64, dep, frag, 8, 128, 100, 100000); dt(DUMMY, 8, 32, 64, dep, frag, 8, 64, 1000, 1000000); dt(SEQ, 8, 32, 64, dep, frag, 8, 64, 1000, 1000000); dt(RAN, 8, 32, 64, dep, frag, 8, 64, 1000, 1000000); dt(SEQGAP, 8, 32, 64, dep, frag, 8, 64, 1000, 1000000); dt(RANGAP, 8, 32, 64, dep, frag, 8, 64, 1000, 1000000); dt(DUMMY, 100, 116, 132, dep, frag, 100, 132, 1000, 1000000); dt(SEQ, 100, 116, 132, dep, frag, 100, 132, 1000, 1000000); dt(RAN, 100, 116, 132, dep, frag, 100, 132, 1000, 1000000); dt(SEQGAP, 100, 116, 132, dep, frag, 100, 132, 1000, 1000000); dt(RANGAP, 100, 116, 132, dep, frag, 100, 132, 1000, 1000000); dt(DUMMY, mins, 60*1024, 120*1024, dep, frag, mins, 128*1024, 100, 10000); dt(SEQ, mins, 60*1024, 120*1024, dep, frag, mins, 128*1024, 100, 10000); dt(RAN, mins, 60*1024, 120*1024, dep, frag, mins, 128*1024, 100, 10000); dt(SEQGAP, mins, 60*1024, 120*1024, dep, frag, mins, 128*1024, 100, 10000); dt(RANGAP, mins, 60*1024, 120*1024, dep, frag, mins, 128*1024, 100, 10000); /* try again using exceptional obj for anything over 16K */ dt(DUMMY, mins, 8*1024, 16*1024, dep, frag, mins, 128*1024, 100, 10000); dt(SEQ, mins, 8*1024, 16*1024, dep, frag, mins, 128*1024, 100, 10000); dt(RAN, mins, 8*1024, 16*1024, dep, frag, mins, 128*1024, 100, 10000); dt(SEQGAP, mins, 8*1024, 16*1024, dep, frag, mins, 128*1024, 100, 10000); dt(RANGAP, mins, 8*1024, 16*1024, dep, frag, mins, 128*1024, 100, 10000); } mps_thread_dereg(thread); mps_arena_destroy(arena); }
/* start -- start routine for each thread */ static void *start(void *p) { gcthread_t thread = p; void *marker; RESMUST(mps_thread_reg(&thread->mps_thread, arena)); RESMUST(mps_root_create_thread(&thread->reg_root, arena, thread->mps_thread, &marker)); RESMUST(mps_ap_create_k(&thread->ap, pool, mps_args_none)); thread->fn(thread); mps_ap_destroy(thread->ap); mps_root_destroy(thread->reg_root); mps_thread_dereg(thread->mps_thread); return NULL; }
/* start -- start routine for each thread */ static void *start(void *p) { gcthread_t thread = p; void *marker; RESMUST(mps_thread_reg(&thread->mps_thread, arena)); RESMUST(mps_root_create_reg(&thread->reg_root, arena, mps_rank_ambig(), (mps_rm_t)0, thread->mps_thread, &mps_stack_scan_ambig, &marker, (size_t)0)); RESMUST(mps_ap_create_k(&thread->ap, pool, mps_args_none)); thread->fn(thread); mps_ap_destroy(thread->ap); mps_root_destroy(thread->reg_root); mps_thread_dereg(thread->mps_thread); return NULL; }