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) { long int i; long int rsize; mps_message_t message; int inramp; mycell *r, *s; cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) 1024*1024*ARENALIMIT), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); cdie( mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie( mps_root_create_table(&root1, arena, mps_rank_exact(), 0, &objtab[0], TABSIZE), "create root table"); cdie( mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); cdie( mps_pool_create(&poolamc, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap"); mps_message_type_enable(arena, mps_message_type_collection_stats()); inramp = 0; for (i = 0; i < ITERATIONS; i++) { if (i % 10000 == 0) { comment("%ld of %ld", i, ITERATIONS); } alloc_back(); if (inramp) { s = allocone(apamc, 3, mps_rank_exact()); setref(r, 0, s); setref(s, 1, r); r = s; s = allocdumb(apamc, RAMPSIZE, mps_rank_exact()); setref(r, 2, s); rsize ++; if (ranint(LEAVERAMP) == 0) { r = allocone(apamc, 2, mps_rank_exact()); s = allocone(apamc, 2, mps_rank_exact()); #ifdef RAMP_INTERFACE mps_ap_alloc_pattern_end(apamc, mps_alloc_pattern_ramp_collect_all()); #endif #ifdef COLLECT_WORLD mps_arena_collect(arena); mps_arena_release(arena); #endif comment("ramp end, %ld objects", rsize); inramp = 0; } } else { if (ranint(ENTERRAMP) == 0) { #ifdef RAMP_INTERFACE mps_ap_alloc_pattern_begin(apamc, mps_alloc_pattern_ramp_collect_all()); #endif comment("ramp begin"); r = allocone(apamc, 3, mps_rank_exact()); inramp = 1; rsize = 0; } } if(mps_message_get(&message, arena, mps_message_type_collection_stats())) { unsigned long live, condemned, notCondemned; live = mps_message_collection_stats_live_size(arena, message); condemned = mps_message_collection_stats_condemned_size(arena, message); notCondemned = mps_message_collection_stats_not_condemned_size(arena, message); comment("Collection: live=%ld, condemned=%ld, not condemned = %ld", live, condemned, notCondemned); mps_message_discard(arena, message); } } mps_ap_destroy(apamc); comment("Destroyed ap."); mps_pool_destroy(poolamc); comment("Destroyed pool."); mps_fmt_destroy(format); comment("Destroyed format."); mps_chain_destroy(chain); comment("Destroyed chain."); mps_root_destroy(root1); mps_root_destroy(root); comment("Destroyed roots."); mps_thread_dereg(thread); comment("Deregistered thread."); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void *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(mps_arena_t arena, mps_class_t pool_class, size_t roots_count) { mps_fmt_t format; mps_chain_t chain; mps_root_t exactRoot, ambigRoot; unsigned long objs; size_t i; mps_word_t collections, rampSwitch; mps_alloc_pattern_t ramp = mps_alloc_pattern_ramp(); int ramping; mps_ap_t busy_ap; mps_addr_t busy_init; mps_pool_t pool; int described = 0; die(dylan_fmt(&format, arena), "fmt_create"); die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mps_pool_create(&pool, arena, pool_class, format, chain), "pool_create(amc)"); 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)"); /* create an ap, and leave it busy */ die(mps_reserve(&busy_init, busy_ap, 64), "mps_reserve busy"); collections = 0; rampSwitch = rampSIZE; die(mps_ap_alloc_pattern_begin(ap, ramp), "pattern begin (ap)"); die(mps_ap_alloc_pattern_begin(busy_ap, ramp), "pattern begin (busy_ap)"); ramping = 1; objs = 0; while (collections < collectionsCOUNT) { mps_word_t c; size_t r; c = mps_collections(arena); if (collections != c) { if (!described) { die(ArenaDescribe(arena, mps_lib_get_stdout(), 0), "ArenaDescribe"); described = TRUE; } collections = c; report(arena); printf("%lu objects (mps_collections says: %"PRIuLONGEST")\n", objs, (ulongest_t)c); /* test mps_arena_has_addr */ { size_t hitRatio; unsigned hitsWanted = 4; /* aim for 4 hits (on average) */ /* [Note: The for-loop condition used to be "i < 4 * hitRatio", * with "4" an unexplained naked constant. I have now labelled * it "hitsWanted", as I think that is the intent. RHSK] */ /* how many random addrs must we try, to hit the arena once? */ hitRatio = (0xfffffffful / mps_arena_committed(arena)); for (i = 0; i < hitsWanted * hitRatio ; i++) { /* An exact root maybe in the arena, so add a random 32-bit * offset to it. We may get no hits if it is objNULL. */ mps_addr_t p = (char *)exactRoots[rnd() % exactRootsCOUNT] + rnd()-0x80000000ul; if (mps_arena_has_addr(arena, p)) { printf("%p is in the arena\n", p); } } } for (i = 0; i < exactRootsCOUNT; ++i) cdie(exactRoots[i] == objNULL || (dylan_check(exactRoots[i]) && mps_arena_has_addr(arena, exactRoots[i])), "all roots check"); cdie(!mps_arena_has_addr(arena, NULL), "NULL in arena"); if (collections == collectionsCOUNT / 2) { unsigned long object_count = 0; mps_arena_park(arena); mps_arena_formatted_objects_walk(arena, test_stepper, &object_count, 0); mps_arena_release(arena); printf("stepped on %lu objects.\n", object_count); } if (collections == rampSwitch) { int begin_ramp = !ramping || /* Every other time, switch back immediately. */ (collections & 1); rampSwitch += rampSIZE; if (ramping) { die(mps_ap_alloc_pattern_end(ap, ramp), "pattern end (ap)"); die(mps_ap_alloc_pattern_end(busy_ap, ramp), "pattern end (busy_ap)"); ramping = 0; /* kill half of the roots */ for(i = 0; i < exactRootsCOUNT; i += 2) { if (exactRoots[i] != objNULL) { cdie(dylan_check(exactRoots[i]), "ramp kill check"); exactRoots[i] = objNULL; } } } if (begin_ramp) { die(mps_ap_alloc_pattern_begin(ap, ramp), "pattern rebegin (ap)"); die(mps_ap_alloc_pattern_begin(busy_ap, ramp), "pattern rebegin (busy_ap)"); ramping = 1; } } } 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(roots_count); if (exactRoots[(exactRootsCOUNT-1) - i] != objNULL) dylan_write(exactRoots[(exactRootsCOUNT-1) - i], exactRoots, exactRootsCOUNT); } else {
static void *test(void *arg, size_t s) { mps_arena_t arena; mps_fmt_t format; mps_chain_t chain; mps_root_t exactRoot, ambigRoot, singleRoot, fmtRoot; unsigned long i; /* Leave arena clamped until we have allocated this many objects. is 0 when arena has not been clamped. */ unsigned long clamp_until = 0; size_t j; mps_word_t collections; mps_pool_t mv; mps_addr_t alloced_obj; size_t asize = 32; /* size of alloced obj */ mps_addr_t obj; mps_ld_s ld; mps_alloc_pattern_t ramp = mps_alloc_pattern_ramp(); size_t rampCount = 0; mps_res_t res; arena = (mps_arena_t)arg; testlib_unused(s); die(dylan_fmt(&format, arena), "fmt_create"); die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mps_pool_create(&mv, arena, mps_class_mv(), 0x10000, 32, 0x10000), "pool_create(mv)"); pool_create_v_test(arena, format, chain); /* creates amc pool */ ap_create_v_test(amcpool); die(mps_ap_create(&ap, amcpool), "ap_create"); for(j = 0; j < exactRootsCOUNT; ++j) { exactRoots[j] = objNULL; } for(j = 0; j < ambigRootsCOUNT; ++j) { ambigRoots[j] = (mps_addr_t)rnd(); } die(mps_root_create_table_masked(&exactRoot, arena, MPS_RANK_EXACT, (mps_rm_t)0, &exactRoots[0], exactRootsCOUNT, (mps_word_t)1), "root_create_table(exact)"); die(mps_root_create_table(&ambigRoot, arena, MPS_RANK_AMBIG, (mps_rm_t)0, &ambigRoots[0], ambigRootsCOUNT), "root_create_table(ambig)"); obj = objNULL; die(mps_root_create(&singleRoot, arena, MPS_RANK_EXACT, (mps_rm_t)0, &root_single, &obj, 0), "root_create(single)"); /* test non-inlined reserve/commit */ obj = make_no_inline(); die(mps_alloc(&alloced_obj, mv, asize), "mps_alloc"); die(dylan_init(alloced_obj, asize, exactRoots, exactRootsCOUNT), "dylan_init(alloced_obj)"); die(mps_root_create_fmt(&fmtRoot, arena, MPS_RANK_EXACT, (mps_rm_t)0, dylan_fmt_A()->scan, alloced_obj, (mps_addr_t)(((char*)alloced_obj)+asize)), "root_create_fmt"); mps_ld_reset(&ld, arena); mps_ld_add(&ld, arena, obj); if (mps_ld_isstale(&ld, arena, obj)) { mps_ld_reset(&ld, arena); mps_ld_add(&ld, arena, obj); } collections = mps_collections(arena); for(i = 0; i < OBJECTS; ++i) { unsigned c; size_t r; c = mps_collections(arena); if(collections != c) { collections = c; printf("\nCollection %u, %lu objects.\n", c, i); for(r = 0; r < exactRootsCOUNT; ++r) { cdie(exactRoots[r] == objNULL || dylan_check(exactRoots[r]), "all roots check"); } if(collections == 1) { mps_arena_clamp(arena); clamp_until = i + 10000; } if(collections % 6 == 0) { mps_arena_expose(arena); mps_arena_release(arena); } if(collections % 6 == 3) { mps_arena_unsafe_expose_remember_protection(arena); mps_arena_unsafe_restore_protection(arena); mps_arena_release(arena); } if(collections % 6 == 4) { mps_arena_unsafe_expose_remember_protection(arena); mps_arena_release(arena); } if(collections % 3 == 2) { mps_arena_park(arena); mps_arena_release(arena); } } if(clamp_until && i >= clamp_until) { mps_arena_release(arena); clamp_until = 0; } if (rnd() % patternFREQ == 0) { switch(rnd() % 4) { case 0: case 1: die(mps_ap_alloc_pattern_begin(ap, ramp), "alloc_pattern_begin"); ++rampCount; break; case 2: res = mps_ap_alloc_pattern_end(ap, ramp); cdie(rampCount > 0 ? res == MPS_RES_OK : res == MPS_RES_FAIL, "alloc_pattern_end"); if (rampCount > 0) { --rampCount; } break; case 3: die(mps_ap_alloc_pattern_reset(ap), "alloc_pattern_reset"); rampCount = 0; break; } } if (rnd() & 1) { exactRoots[rnd() % exactRootsCOUNT] = make(); } else { ambigRoots[rnd() % ambigRootsCOUNT] = make(); } r = rnd() % exactRootsCOUNT; if (exactRoots[r] != objNULL) { cdie(dylan_check(exactRoots[r]), "random root check"); } } arena_commit_test(arena); reservoir_test(arena); alignmentTest(arena); die(mps_arena_collect(arena), "collect"); mps_free(mv, alloced_obj, 32); alloc_v_test(mv); mps_pool_destroy(mv); mps_ap_destroy(ap); mps_root_destroy(fmtRoot); mps_root_destroy(singleRoot); mps_root_destroy(exactRoot); mps_root_destroy(ambigRoot); mps_pool_destroy(amcpool); mps_chain_destroy(chain); mps_fmt_destroy(format); return NULL; }
static void *test(void *arg, size_t s) { mps_arena_t arena; mps_fmt_t format; mps_chain_t chain; mps_root_t exactRoot, ambigRoot; unsigned long objs; size_t i; mps_word_t collections, rampSwitch; mps_alloc_pattern_t ramp = mps_alloc_pattern_ramp(); int ramping; mps_ap_t busy_ap; mps_addr_t busy_init; arena = (mps_arena_t)arg; (void)s; /* unused */ 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)"); 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)"); /* create an ap, and leave it busy */ die(mps_reserve(&busy_init, busy_ap, 64), "mps_reserve busy"); collections = 0; rampSwitch = rampSIZE; die(mps_ap_alloc_pattern_begin(ap, ramp), "pattern begin (ap)"); die(mps_ap_alloc_pattern_begin(busy_ap, ramp), "pattern begin (busy_ap)"); ramping = 1; objs = 0; while (collections < collectionsCOUNT) { unsigned long c; size_t r; size_t hitRatio; c = mps_collections(arena); if (collections != c) { collections = c; printf("\nCollection %lu started, %lu objects.\n", c, objs); /* test mps_arena_has_addr */ hitRatio = ((size_t)-1 / mps_arena_committed(arena)); /* That's roughly how often a random addr should hit the arena. */ for (i = 0; i < 4 * hitRatio ; i++) { mps_addr_t p = rnd_addr(); if (mps_arena_has_addr(arena, p)) { printf("%p is in the arena\n", p); } } report(arena); for (i = 0; i < exactRootsCOUNT; ++i) cdie(exactRoots[i] == objNULL || (dylan_check(exactRoots[i]) && mps_arena_has_addr(arena, exactRoots[i])), "all roots check"); cdie(!mps_arena_has_addr(arena, NULL), "NULL in arena"); if (collections == collectionsCOUNT / 2) { unsigned long object_count = 0; mps_arena_park(arena); mps_arena_formatted_objects_walk(arena, test_stepper, &object_count, 0); mps_arena_release(arena); printf("stepped on %lu objects.\n", object_count); } if (collections == rampSwitch) { int begin_ramp = !ramping || /* Every other time, switch back immediately. */ (collections & 1); rampSwitch += rampSIZE; if (ramping) { die(mps_ap_alloc_pattern_end(ap, ramp), "pattern end (ap)"); die(mps_ap_alloc_pattern_end(busy_ap, ramp), "pattern end (busy_ap)"); ramping = 0; /* kill half of the roots */ for(i = 0; i < exactRootsCOUNT; i += 2) { if (exactRoots[i] != objNULL) { cdie(dylan_check(exactRoots[i]), "ramp kill check"); exactRoots[i] = objNULL; } } } if (begin_ramp) { die(mps_ap_alloc_pattern_begin(ap, ramp), "pattern rebegin (ap)"); die(mps_ap_alloc_pattern_begin(busy_ap, ramp), "pattern rebegin (busy_ap)"); ramping = 1; } } } 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(mps_arena_t arena, mps_pool_class_t pool_class, size_t roots_count) { mps_fmt_t format; mps_chain_t chain; mps_root_t exactRoot, ambigRoot, bogusRoot; unsigned long objs; size_t i; mps_word_t collections, rampSwitch; mps_alloc_pattern_t ramp = mps_alloc_pattern_ramp(); int ramping; mps_ap_t busy_ap; mps_addr_t busy_init; die(EnsureHeaderFormat(&format, arena), "fmt_create"); die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mps_pool_create(&pool, arena, pool_class, format, chain), "pool_create(amc)"); 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)"); die(mps_root_create_table(&bogusRoot, arena, mps_rank_ambig(), (mps_rm_t)0, &bogusRoots[0], bogusRootsCOUNT), "root_create_table(bogus)"); /* create an ap, and leave it busy */ die(mps_reserve(&busy_init, busy_ap, 64), "mps_reserve busy"); collections = 0; rampSwitch = rampSIZE; die(mps_ap_alloc_pattern_begin(ap, ramp), "pattern begin (ap)"); die(mps_ap_alloc_pattern_begin(busy_ap, ramp), "pattern begin (busy_ap)"); ramping = 1; objs = 0; while (collections < collectionsCOUNT) { mps_word_t c; size_t r; c = mps_collections(arena); if (collections != c) { collections = c; printf("\nCollection %"PRIuLONGEST", %lu objects.\n", (ulongest_t)c, objs); report(arena); for (r = 0; r < exactRootsCOUNT; ++r) { if (exactRoots[r] != objNULL) die(HeaderFormatCheck(exactRoots[r]), "wrapper check"); } if (collections == rampSwitch) { int begin_ramp = !ramping || /* Every other time, switch back immediately. */ (collections & 1); rampSwitch += rampSIZE; if (ramping) { die(mps_ap_alloc_pattern_end(ap, ramp), "pattern end (ap)"); die(mps_ap_alloc_pattern_end(busy_ap, ramp), "pattern end (busy_ap)"); ramping = 0; /* kill half of the roots */ for(i = 0; i < exactRootsCOUNT; i += 2) { if (exactRoots[i] != objNULL) { die(HeaderFormatCheck(exactRoots[i]), "ramp kill check"); exactRoots[i] = objNULL; } } } if (begin_ramp) { die(mps_ap_alloc_pattern_begin(ap, ramp), "pattern rebegin (ap)"); die(mps_ap_alloc_pattern_begin(busy_ap, ramp), "pattern rebegin (busy_ap)"); ramping = 1; } } /* fill bogusRoots with variations of a real pointer */ r = rnd() % exactRootsCOUNT; if (exactRoots[r] != objNULL) { char *p = (char*)exactRoots[r]; for(i = 0; i < bogusRootsCOUNT; ++i, ++p) bogusRoots[i] = (mps_addr_t)p; } } r = (size_t)rnd(); if (r & 1) { i = (r >> 1) % exactRootsCOUNT; if (exactRoots[i] != objNULL) die(HeaderFormatCheck(exactRoots[i]), "wrapper check"); exactRoots[i] = make(roots_count); if (exactRoots[(exactRootsCOUNT-1) - i] != objNULL) dylan_write(exactRoots[(exactRootsCOUNT-1) - i], exactRoots, exactRootsCOUNT); } else {
static void test(void) { mps_chain_t chain; long int i; long int rsize = 0; int inramp; mycell *r, *s; cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) 1024*1024*ARENALIMIT), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); cdie( mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie( mps_root_create_table(&root1, arena, mps_rank_exact(), 0, &objtab[0], TABSIZE), "create root table"); cdie(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain), "create pool(amc)"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap"); inramp = 0; r = NULL; /* r is always initialized, because inramp=0 at the start, but */ /* the compiler doesn't know this. */ for (i = 0; i < ITERATIONS; i++) { if (i % 10000 == 0) { comment("%ld of %ld", i, ITERATIONS); } alloc_back(); if (inramp) { s = allocone(apamc, 3, mps_rank_exact()); setref(r, 0, s); setref(s, 1, r); r = s; s = allocdumb(apamc, RAMPSIZE, mps_rank_exact()); setref(r, 2, s); rsize ++; if (ranint(LEAVERAMP) == 0) { r = allocone(apamc, 2, mps_rank_exact()); s = allocone(apamc, 2, mps_rank_exact()); #ifdef RAMP_INTERFACE mps_ap_alloc_pattern_end(apamc, mps_alloc_pattern_ramp()); #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); mps_pool_destroy(poolamc); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root1); mps_root_destroy(root); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }