static void test(void *stack_pointer) { mps_arena_t arena; mps_pool_t pool; mps_addr_t block[ITERATIONS]; unsigned i; MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_ARENA_SIZE, CHUNKSIZE); die(mps_arena_create_k(&arena, mps_arena_class_vm(), args), "arena_create"); } MPS_ARGS_END(args); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_SPARE, 0); die(mps_pool_create_k(&pool, arena, mps_class_mvff(), args), "pool_create"); } MPS_ARGS_END(args); check_chunks(arena, 1); for (i = 0; i < ITERATIONS; ++i) { die(mps_alloc(&block[i], pool, CHUNKSIZE), "mps_alloc"); check_chunks(arena, i + 2); } for (i = ITERATIONS; i > 0; --i) { mps_free(pool, block[i - 1], CHUNKSIZE); mps_arena_collect(arena); /* ensure ArenaCompact is called */ check_chunks(arena, i); } mps_pool_destroy(pool); mps_arena_destroy(arena); }
static void testInArena(mps_arena_class_t arena_class, mps_arg_s *arena_args, mps_pool_debug_option_s *options) { mps_arena_t arena; die(mps_arena_create_k(&arena, arena_class, arena_args), "mps_arena_create"); MPS_ARGS_BEGIN(args) { mps_align_t align = sizeof(void *) << (rnd() % 4); MPS_ARGS_ADD(args, MPS_KEY_ALIGN, align); MPS_ARGS_ADD(args, MPS_KEY_MVFF_ARENA_HIGH, TRUE); MPS_ARGS_ADD(args, MPS_KEY_MVFF_SLOT_HIGH, TRUE); MPS_ARGS_ADD(args, MPS_KEY_MVFF_FIRST_FIT, TRUE); MPS_ARGS_ADD(args, MPS_KEY_SPARE, rnd_double()); die(stress(arena, NULL, randomSize8, align, "MVFF", mps_class_mvff(), args), "stress MVFF"); } MPS_ARGS_END(args); MPS_ARGS_BEGIN(args) { mps_align_t align = sizeof(void *) << (rnd() % 4); MPS_ARGS_ADD(args, MPS_KEY_ALIGN, align); MPS_ARGS_ADD(args, MPS_KEY_MVFF_ARENA_HIGH, TRUE); MPS_ARGS_ADD(args, MPS_KEY_MVFF_SLOT_HIGH, TRUE); MPS_ARGS_ADD(args, MPS_KEY_MVFF_FIRST_FIT, TRUE); MPS_ARGS_ADD(args, MPS_KEY_SPARE, rnd_double()); MPS_ARGS_ADD(args, MPS_KEY_POOL_DEBUG_OPTIONS, options); die(stress(arena, options, randomSize8, align, "MVFF debug", mps_class_mvff_debug(), args), "stress MVFF debug"); } MPS_ARGS_END(args); MPS_ARGS_BEGIN(args) { mps_align_t align = (mps_align_t)1 << (rnd() % 6); MPS_ARGS_ADD(args, MPS_KEY_ALIGN, align); die(stress(arena, NULL, randomSize, align, "MV", mps_class_mv(), args), "stress MV"); } MPS_ARGS_END(args); MPS_ARGS_BEGIN(args) { mps_align_t align = (mps_align_t)1 << (rnd() % 6); MPS_ARGS_ADD(args, MPS_KEY_ALIGN, align); MPS_ARGS_ADD(args, MPS_KEY_POOL_DEBUG_OPTIONS, options); die(stress(arena, options, randomSize, align, "MV debug", mps_class_mv_debug(), args), "stress MV debug"); } MPS_ARGS_END(args); MPS_ARGS_BEGIN(args) { fixedSizeSize = 1 + rnd() % 64; MPS_ARGS_ADD(args, MPS_KEY_MFS_UNIT_SIZE, fixedSizeSize); MPS_ARGS_ADD(args, MPS_KEY_EXTEND_BY, 100000); die(stress(arena, NULL, fixedSize, MPS_PF_ALIGN, "MFS", mps_class_mfs(), args), "stress MFS"); } MPS_ARGS_END(args); /* Manual allocation should not cause any garbage collections. */ Insist(mps_collections(arena) == 0); mps_arena_destroy(arena); }
mps_res_t mps_arena_create_v(mps_arena_t *mps_arena_o, mps_arena_class_t arena_class, va_list varargs) { mps_arg_s args[MPS_ARGS_MAX]; AVERT(ArenaClass, arena_class); arena_class->varargs(args, varargs); return mps_arena_create_k(mps_arena_o, arena_class, args); }
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) { mps_arena_t arena; mps_pool_t pool; mps_addr_t p; die(mps_arena_create_k(&arena, mps_arena_class_vm(), mps_args_none), "arena_create"); die(mps_pool_create_k(&pool, arena, mps_class_mvff(), mps_args_none), "pool_create"); die(mps_alloc(&p, pool, 4096), "alloc"); die(mps_finalize(arena, &p), "finalize"); mps_pool_destroy(pool); mps_arena_destroy(arena); }
static void runArenaTest(size_t size, mps_bool_t failcase, mps_bool_t usefulFailcase) { mps_arena_t arena; MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_ARENA_SIZE, size); MPS_ARGS_ADD(args, MPS_KEY_ARENA_ZONED, FALSE); MPS_ARGS_ADD(args, MPS_KEY_COMMIT_LIMIT, size - chunkSize); die(mps_arena_create_k(&arena, mps_arena_class_vm(), args), "mps_arena_create"); } MPS_ARGS_END(args); testInArena(arena, failcase, usefulFailcase); 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); }
int main(int argc, char *argv[]) { mps_arena_t arena; testlib_init(argc, argv); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_ARENA_SIZE, testArenaSIZE); MPS_ARGS_ADD(args, MPS_KEY_ARENA_ZONED, FALSE); die(mps_arena_create_k(&arena, mps_arena_class_vm(), args), "mps_arena_create"); } MPS_ARGS_END(args); testInArena(arena); mps_arena_destroy(arena); printf("%s: Conclusion: Failed to find any defects.\n", argv[0]); return 0; }
static void test_in_arena(mps_arena_class_t arena_class, mps_arg_s *arena_args) { mps_arena_t arena; die(mps_arena_create_k(&arena, arena_class, arena_args), "mps_arena_create"); size_min = MPS_PF_ALIGN; size_mean = 42; size_max = 8192; MPS_ARGS_BEGIN(args) { mps_align_t align = sizeof(void *) << (rnd() % 4); MPS_ARGS_ADD(args, MPS_KEY_ALIGN, align); MPS_ARGS_ADD(args, MPS_KEY_MIN_SIZE, size_min); MPS_ARGS_ADD(args, MPS_KEY_MEAN_SIZE, size_mean); MPS_ARGS_ADD(args, MPS_KEY_MAX_SIZE, size_max); MPS_ARGS_ADD(args, MPS_KEY_MVT_RESERVE_DEPTH, TEST_SET_SIZE/2); MPS_ARGS_ADD(args, MPS_KEY_MVT_FRAG_LIMIT, 0.3); die(stress(arena, align, randomSize, mps_class_mvt(), args), "stress MVT"); } MPS_ARGS_END(args); mps_arena_destroy(arena); }
static void test(void) { mps_pool_t poolamc, poolawl, poolamcz; mps_thr_t thread; mps_root_t root0, root1; mps_fmt_t format; mps_chain_t chain; mps_ap_t apamc, apawl, apamcz; mycell *a, *b, *c, *d, *z; long int j; cdie(mps_arena_create_k(&arena, mps_arena_class_vm(), mps_args_none), "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"); cdie(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(&poolamcz, 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(&apamcz, poolamcz, 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(apamcz, 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; setref(a, 0, b); setref(a, 1, c); setref(c, 1, d); b = a; } /* throw them all away and collect everything */ a = NULL; b = NULL; c = NULL; d = NULL; mps_arena_collect(arena); while (mps_message_poll(arena)) { finalpoll(&z, FINAL_DISCARD); } /* How many are left? (Ideally, this would be 0 but there's no guarantee.) */ report("count1", "%i", final_count); /* now to test leaving messages open for a long time! */ for (j=0; j<1000; j++) { comment("%d of 1000", j+1); a = allocone(apamc, 10000, mps_rank_exact()); mps_finalize(arena, (mps_addr_t*)&a); final_count +=1; comment("finalize"); finalpoll(&z, FINAL_QUEUE); } comment("reregister"); for (j=0; j<500; j++) { comment("%d of 500", j+1); qpoll(&z, FINAL_REREGISTER); } b = a; z = a; for (j=0; j<1000; j++) { comment("%d of 1000", j+1); finalpoll(&z, FINAL_QUEUE); qpoll(&z, FINAL_STORE); a = allocone(apamc, 2, mps_rank_exact()); setref(z, 0, b); setref(a, 1, z); b = a; } for (j=0; j<1000; j++) { a = allocone(apamc, 2, mps_rank_exact()); qpoll(&z, FINAL_DISCARD); finalpoll(&z, FINAL_DISCARD); setref(a, 0, b); b = a; } /* Force old objects to be killed */ while (qmt() == 0) { qpoll(&z, FINAL_DISCARD); } mps_root_destroy(root0); mps_root_destroy(root1); comment("Destroyed roots."); mps_arena_collect(arena); comment("Collected arena."); while (mps_message_poll(arena)) { finalpoll(&z, FINAL_DISCARD); } report("count2", "%d", final_count); mps_arena_park(arena); mps_ap_destroy(apawl); mps_ap_destroy(apamc); mps_ap_destroy(apamcz); comment("Destroyed aps."); mps_pool_destroy(poolamc); mps_pool_destroy(poolawl); mps_pool_destroy(poolamcz); comment("Destroyed pools."); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }