static void test(void)
{
mps_arena_t arena;
mps_pool_t pool;
mps_pool_t pool1;
size_t extendBy;
size_t avgSize;
size_t maxSize;
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 0");
cdie(
mps_pool_create(&pool1, arena, mps_class_mv(),
extendBy, avgSize, maxSize),
"create pool 1");
cdie(mps_alloc(&obj, pool, 152), "allocate in 0");
mps_free(pool, obj, 512);
comment("Freed in 1.");
}
static void test(void) {
mps_arena_t arena;
mps_pool_t pool;
mps_thr_t thread;
mps_fmt_t format;
mps_root_t root;
mps_addr_t q;
int p;
die(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create");
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_pool_create(&pool, arena, mps_class_mv(),
1024*32, 1024*16, 1024*256), "pool");
while (mps_alloc(&q, pool, 64*1024)==MPS_RES_OK);
p=0;
while (1) {
p++;
die(mps_fmt_create_A(&format, arena, &fmtA), "create format");
report("format", "%i", p);
}
asserts(1, "Unreachable!");
}
static void test(void)
{
mps_space_t space;
mps_pool_t pool;
size_t extendBy;
size_t avgSize;
size_t maxSize;
extendBy = (size_t) 4096;
avgSize = (size_t) 32;
maxSize = (size_t) 65536;
/* cdie(mps_space_create(&space), "create space");
*/
space=malloc(64);
cdie(
mps_pool_create(&pool, space, mps_class_mv(),
extendBy, avgSize, maxSize),
"create pool");
mps_pool_destroy(pool);
comment("Destroyed pool.");
mps_space_destroy(space);
comment("Destroyed space.");
}
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.");
}
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;
mps_thr_t thread;
mps_addr_t a,b;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena");
cdie(mps_thread_reg(&thread, arena), "register thread");
cdie(
mps_pool_create(
&pool, arena, mps_class_mv(),
(size_t) 4096, (size_t) 32, (size_t) 64*1024),
"create pool");
die(mps_alloc(&a, pool, 8),
"alloc a");
die(mps_alloc(&b, pool, 32),
"alloc b");
mps_free(pool, a, 9);
mps_pool_destroy(pool);
}
static void test(void)
{
mps_arena_t arena;
mps_pool_t pool;
size_t extendBy;
size_t avgSize;
size_t maxSize;
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");
mps_pool_destroy(pool);
comment("Destroyed pool");
cdie(mps_alloc(&obj, pool, 152), "allocate");
mps_arena_destroy(arena);
comment("Destroyed arena.");
}
static void test(void)
{
mps_space_t space;
mps_pool_t pool;
size_t extendBy;
size_t avgSize;
size_t maxSize;
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_alloc(&obj, pool, 152), "allocate");
cdie(mps_alloc(&obj, pool, 4), "alloc2");
mps_free(pool, obj, 512);
comment("Freed.");
mps_pool_destroy(pool);
comment("Destroyed pool");
mps_space_destroy(space);
comment("Destroyed space.");
}
static void alignmentTest(mps_arena_t arena)
{
mps_pool_t pool;
void *p;
int dummy = 0;
size_t j, size;
die(mps_pool_create(&pool, arena, mps_class_mv(), 0x1000, 1024, 16384),
"alignment pool create");
size = max(sizeof(double), sizeof(long));
#ifdef HAS_LONG_LONG
size = max(size, sizeof(long_long_t));
#endif
for(j = 0; j <= size + (size_t)1; ++j) {
die(mps_alloc(&p, pool, size + 1), "alignment alloc");
#define access(type, p) *(type*)(p) = (type)dummy; dummy += (int)*(type*)(p);
access(double, p);
access(long, p);
#ifdef HAS_LONG_LONG
access(long_long_t, p);
#endif
}
mps_pool_destroy(pool);
}
static void arena_commit_test(mps_arena_t arena)
{
mps_pool_t pool;
size_t committed;
size_t reserved;
size_t limit;
void *p;
mps_res_t res;
committed = mps_arena_committed(arena);
reserved = mps_arena_reserved(arena);
cdie(reserved >= committed, "reserved < committed");
die(mps_pool_create(&pool, arena, mps_class_mv(), 0x1000, 1024, 16384),
"commit pool create");
limit = mps_arena_commit_limit(arena);
die(mps_arena_commit_limit_set(arena, committed), "commit_limit_set before");
do {
res = mps_alloc(&p, pool, FILLER_OBJECT_SIZE);
} while (res == MPS_RES_OK);
die_expect(res, MPS_RES_COMMIT_LIMIT, "Commit limit allocation");
die(mps_arena_commit_limit_set(arena, limit), "commit_limit_set after");
res = mps_alloc(&p, pool, FILLER_OBJECT_SIZE);
die_expect(res, MPS_RES_OK, "Allocation failed after raising commit_limit");
mps_pool_destroy(pool);
}
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);
}
static void test(void) {
mps_arena_t arena;
mps_pool_t pool;
mps_addr_t q;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create");
cdie(mps_pool_create(&pool, arena, mps_class_mv(),
1024*32, 1024*16, 1024*256), "pool");
cdie(mps_alloc(&q, pool, (size_t) -1), "alloc");
mps_pool_destroy(pool);
mps_arena_destroy(arena);
}
static void test(void) {
mps_space_t space;
mps_pool_t pool;
mps_addr_t q;
cdie(mps_space_create(&space), "create");
cdie(mps_pool_create(&pool, space, mps_class_mv(),
1024*32, 1024*16, 1024*256), "pool");
cdie(mps_alloc(&q, pool, (size_t) -1), "alloc");
mps_pool_destroy(pool);
mps_space_destroy(space);
}
static void test(void)
{
mps_arena_t arena;
mps_pool_t pool;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena");
cdie(
mps_pool_create(
&pool, arena, mps_class_mv(),
(size_t) 32, (size_t) 0, (size_t) 32),
"create pool");
mps_pool_destroy(pool);
mps_arena_destroy(arena);
}
static void fillup(void)
{
size_t size;
mps_addr_t a;
char *b;
mps_pool_create(&poolmv, arena, mps_class_mv(), 64, 64, 64);
size=1024ul*1024ul;
while (size) {
while (mps_alloc(&a, poolmv, size)==MPS_RES_OK) {
for(b=a; b<(char *)a+size; b++) {
*b = 97;
}
}
size = size / 2;
}
}
static void test(void) {
mps_arena_t arena;
mps_pool_t pool;
mps_addr_t q;
int p;
die(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create");
die(mps_pool_create(&pool, arena, mps_class_mv(),
1024*32, 1024*16, 1024*256), "pool");
for (p=0; p<2000; p++) {
die(mps_alloc(&q, pool, 1024*1024), "alloc");
q = (mps_addr_t) ((char *) q + 8);
mps_free(pool, q, 256*1024-8);
report("promise", "%i", p);
}
}
static void test(void) {
mps_space_t space;
mps_pool_t pool;
mps_addr_t q;
int p;
die(mps_space_create(&space), "create");
die(mps_pool_create(&pool, space, mps_class_mv(),
1024*32, 1024*16, 1024*256), "pool");
for (p=0; p<2000; p++) {
die(mps_alloc(&q, pool, 1024*1024), "alloc");
q = (mps_addr_t) ((char *) q + 8);
mps_free(pool, q, 256*1024-8);
report("promise", "%i", p);
}
}
static void test(void)
{
mps_space_t space;
mps_pool_t pool;
mps_thr_t thread;
cdie(mps_space_create(&space), "create space");
cdie(mps_thread_reg(&thread, space), "register thread");
cdie(
mps_pool_create(
&pool, space, mps_class_mv(),
(size_t) 32, (size_t) 32, (size_t) 0),
"create pool");
mps_pool_destroy(pool);
}
static void test(void)
{
mps_arena_t arena;
mps_pool_t pool;
mps_thr_t thread;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena");
cdie(mps_thread_reg(&thread, arena), "register thread");
cdie(
mps_pool_create(
&pool, arena, mps_class_mv(),
(size_t) 0, (size_t) 32, (size_t) 32),
"create pool");
mps_pool_destroy(pool);
}
static void test(void)
{
mps_arena_t arena;
mps_pool_t pool;
mps_thr_t thread;
mps_addr_t a;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena");
cdie(mps_thread_reg(&thread, arena), "register thread");
cdie(
mps_pool_create(
&pool, arena, mps_class_mv(),
(size_t) 4096, (size_t) 32, (size_t) 64*1024),
"create pool");
die(mps_alloc(&a, pool, HIGHBIT_SIZE+8),
"allocation failed (correct)");
mps_pool_destroy(pool);
}
static void test(void)
{
mps_space_t space;
mps_pool_t pool;
mps_thr_t thread;
mps_addr_t a;
cdie(mps_space_create(&space), "create space");
cdie(mps_thread_reg(&thread, space), "register thread");
cdie(
mps_pool_create(
&pool, space, mps_class_mv(),
(size_t) 4096, (size_t) 32, (size_t) 64*1024),
"create pool");
die(mps_alloc(&a, pool, HIGHBIT_SIZE+8),
"allocation failed (correct)");
mps_pool_destroy(pool);
}
static void test(void)
{
mps_arena_t arena;
mps_pool_t pool;
mps_addr_t q;
int p;
die(mps_arena_create(&arena, mps_arena_class_vmnz(), VMNZSIZE), "create");
die(mps_arena_commit_limit_set(arena, VMNZSIZE), "commit limit");
die(mps_pool_create(&pool, arena, mps_class_mv(),
EXTENDBY, AVGSIZE, EXTENDBY),
"pool create");
for (p=0; p<ITERATE; p++) {
die(mps_alloc(&q, pool, PROMISE*1024), "alloc");
q = (mps_addr_t) ((char *) q + 8);
mps_free(pool, q, PROMISE*1024-8);
report("promise", "%i", p);
}
mps_pool_destroy(pool);
mps_arena_destroy(arena);
}
static void test(void)
{
mps_space_t space;
mps_pool_t pool;
mps_thr_t thread;
mps_addr_t a;
cdie(mps_space_create(&space), "create space");
cdie(mps_thread_reg(&thread, space), "register thread");
cdie(
mps_pool_create(
&pool, space, mps_class_mv(),
(size_t) 4096, (size_t) 32, (size_t) 64*1024),
"create pool");
die(mps_alloc(&a, pool, 8),
"alloc");
mps_free(pool, (mps_addr_t) ((char *)a+1), 8);
mps_pool_destroy(pool);
}
static void testInArena(mps_arena_t arena,
mps_bool_t failcase,
mps_bool_t usefulFailcase)
{
mps_pool_t lopool, hipool, temppool;
PoolStatStruct lostruct; /* stats about lopool */
PoolStatStruct histruct; /* stats about lopool */
PoolStatStruct tempstruct; /* stats about temppool */
PoolStat lostat = &lostruct;
PoolStat histat = &histruct;
PoolStat tempstat = &tempstruct;
int i;
die(mps_pool_create(&hipool, arena, mps_class_mvff(),
chunkSize, chunkSize, (size_t)1024,
TRUE, TRUE, TRUE),
"Create HI MFFV");
die(mps_pool_create(&lopool, arena, mps_class_mvff(),
chunkSize, chunkSize, (size_t)1024,
FALSE, FALSE, TRUE),
"Create LO MFFV");
die(mps_pool_create(&temppool, arena, mps_class_mv(),
chunkSize, chunkSize, chunkSize),
"Create TEMP");
if(failcase) {
if(usefulFailcase) {
/* describe a useful failure case */
} else {
/* describe a misleading failure case */
}
}
poolStatInit(lostat, lopool, chunkSize);
poolStatInit(histat, hipool, chunkSize);
poolStatInit(tempstat, temppool, chunkSize);
/* iterate, allocating objects */
for (i=0; i<iterationCount; ++i) {
mps_res_t res;
res = allocMultiple(lostat);
if (res != MPS_RES_OK)
break;
res = allocMultiple(histat);
if (res != MPS_RES_OK)
break;
res = allocMultiple(tempstat);
if (res != MPS_RES_OK)
break;
}
/* report results */
reportResults(lostat, "the low MVFF pool");
reportResults(histat, "the high MVFF pool");
reportResults(tempstat, "the temp pool");
mps_pool_destroy(hipool);
mps_pool_destroy(lopool);
mps_pool_destroy(temppool);
}
static void test(void) {
mps_pool_t poolmv, poolawl, poolamc;
mps_thr_t thread;
mps_root_t root0, root1, root2;
mps_addr_t p;
mps_chain_t chain;
mps_fmt_t format;
mps_ap_t apawl, apamc;
mps_addr_t base;
mps_addr_t *addr;
int i,j,merge,stale,prevstale;
mycell *held[AMBIGHOLD];
RC;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), 100*1024*1024),
"create arena");
cdie(mps_thread_reg(&thread, arena), "register thread");
base = &exfmt_root;
addr = base;
cdie(
mps_root_create_table(&root0, arena, mps_rank_ambig(), 0, addr, 1),
"create exfmt root");
cdie(
mps_root_create_table(&root2, arena, mps_rank_exact(), 0,
(mps_addr_t *)obj_table, MAXLDS),
"create table root");
cdie(
mps_root_create_reg(&root1, arena, mps_rank_ambig(), 0, thread,
mps_stack_scan_ambig, stackpointer, 0),
"create register and stack root");
cdie(
mps_fmt_create_A(&format, arena, &fmtA),
"create format");
cdie(
mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated),
"create awl pool");
cdie(
mps_pool_create(&poolmv, arena, mps_class_mv(), 0x4000, 128, 0x4000),
"create mv pool");
cdie(
mps_ap_create(&apawl, poolawl, mps_rank_exact()),
"create ap");
cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create");
cdie(
mps_pool_create(&poolamc, arena, mps_class_amc(), format, chain),
"create amc pool");
cdie(
mps_ap_create(&apamc, poolamc, mps_rank_exact()),
"create ap");
/* allocate MAXLDS objects, and make each LD depend on the corresponding
object
*/
for (i=0; i < MAXLDS; i++) {
mps_alloc(&p, poolmv, sizeof(mps_ld_s));
lds[i] = (mps_ld_t) p;
mps_alloc(&p, poolmv, sizeof(mps_ld_s));
ldm[i] = (mps_ld_t) p;
}
for (i=0; i < MAXLDS; i++) {
obj_table[i] = allocone(apamc, ranint(1000), mps_rank_exact());
mps_ld_reset(lds[i], arena);
mps_ld_add(lds[i], arena, (mps_addr_t) obj_table[i]);
addr_table[i] = obj_table[i];
}
for (merge = 1; merge <= MAXMERGE; merge++) {
comment("Merge %d", merge);
for (i=0; i < MAXLDS; i++) {
if (ranint(100) < BLATPERCENT) {
obj_table[i] = allocone(apamc, ranint(1000), mps_rank_exact());
mps_ld_reset(lds[i], arena);
mps_ld_add(lds[i], arena, (mps_addr_t) obj_table[i]);
addr_table[i] = obj_table[i];
}
}
mergelds(merge);
stale = 0;
prevstale = 0;
i = 0;
while (stale < MAXLDS) {
for (j = 0; j < AMBIGHOLD; j++) {
held[j] = obj_table[ranint(MAXLDS)];
}
i++;
stale = checklds(merge);
if (stale > prevstale) {
prevstale = stale;
comment("inc to %d at %d", stale, i);
}
for (j = 0; j < JUNK; j++) {
(void)allocdumb(apamc, ranint(1000), mps_rank_exact());
}
}
}
comment("held[0] = %p", held[0]); /* avoid warning about unused variable */
mps_arena_park(arena);
mps_ap_destroy(apawl);
mps_ap_destroy(apamc);
comment("Destroyed aps.");
mps_pool_destroy(poolmv);
mps_pool_destroy(poolamc);
mps_pool_destroy(poolawl);
comment("Destroyed pools.");
mps_fmt_destroy(format);
comment("Destroyed format.");
mps_chain_destroy(chain);
comment("Destroyed chain.");
mps_root_destroy(root0);
mps_root_destroy(root1);
mps_root_destroy(root2);
comment("Destroyed roots.");
mps_thread_dereg(thread);
comment("Deregistered thread.");
mps_arena_destroy(arena);
comment("Destroyed arena.");
}
static void test(void) {
mps_pool_t poolmv, poolawl, poolamc;
mps_thr_t thread;
mps_root_t root0, root1, root2;
mps_addr_t p;
mps_fmt_t format;
mps_ap_t apawl, apamc;
mycell *a, *b;
int i,j;
RC;
cdie(mps_space_create(&space), "create space");
cdie(mps_thread_reg(&thread, space), "register thread");
cdie(
mps_root_create_table(&root0, space, MPS_RANK_AMBIG, 0, &exfmt_root, 1),
"create exfmt root");
cdie(
mps_root_create_table(&root2, space, MPS_RANK_EXACT, 0,
(mps_addr_t *)obj_table, MAXLDS),
"create table root");
cdie(
mps_root_create_reg(&root1, space, MPS_RANK_AMBIG, 0, thread,
mps_stack_scan_ambig, stackpointer, 0),
"create register and stack root");
cdie(
mps_fmt_create_A(&format, space, &fmtA),
"create format");
cdie(
mps_pool_create(&poolawl, space, mps_class_awl(), format),
"create awl pool");
cdie(
mps_pool_create(&poolmv, space, mps_class_mv(), 0x4000, 128, 0x4000),
"create mv pool");
cdie(
mps_ap_create(&apawl, poolawl, MPS_RANK_EXACT),
"create ap");
cdie(
mps_pool_create(&poolamc, space, mps_class_amc(), format),
"create amc pool");
cdie(
mps_ap_create(&apamc, poolamc, MPS_RANK_EXACT),
"create ap");
/* first we'll use only pool classes MV and AWL. So LDs shouldn't
go stale at all.
*/
b = allocone(apawl, 5, MPS_RANK_EXACT);
for (i=0; i < MAXLDS; i++) {
comment("%d", i);
mps_alloc(&p, poolmv, sizeof(mps_ld_s));
a = allocone(apawl, 5, MPS_RANK_EXACT);
setref(a, 0, b);
b = a;
a = allocdumb(apamc, 256*1024, MPS_RANK_EXACT);
a = allocdumb(apawl, 256*1024, MPS_RANK_EXACT);
comment("alloc");
lds[i] = p;
mps_ld_reset(lds[i], space);
comment("reset");
if (i>0) {
mps_ld_add(lds[i], space, (mps_addr_t) b);
}
comment("add");
}
for (i=0; i < MAXLDS; i++) {
comment("%d", i);
asserts(mps_ld_isstale(lds[i], space, p) == 0,
"%d stale but shouldn't be", i);
}
/* allocate MAXLDS objects, and make each LD depend on the corresponding
object
*/
for (i=0; i < MAXLDS; i++) {
comment("%d", i);
obj_table[i] = allocone(apamc, ranint(100), MPS_RANK_EXACT);
mps_ld_add(lds[i], space, (mps_addr_t) obj_table[i]);
}
for (i=0; i < 1000; i++) {
comment("%d of 1000", i);
checklds();
for (j=0; j < 4; j++) {
a = allocdumb(apamc, 32*1024, MPS_RANK_EXACT);
}
}
mps_ap_destroy(apawl);
mps_ap_destroy(apamc);
comment("Destroyed aps.");
mps_pool_destroy(poolmv);
mps_pool_destroy(poolamc);
mps_pool_destroy(poolawl);
comment("Destroyed pools.");
mps_fmt_destroy(format);
comment("Destroyed format.");
mps_root_destroy(root0);
mps_root_destroy(root1);
mps_root_destroy(root2);
comment("Destroyed roots.");
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 poolmv, poolawl;
mps_thr_t thread;
mps_root_t root0, root1;
mps_addr_t p;
mps_ld_t lds[MAXLDS];
mps_fmt_t format;
mps_ap_t apawl;
mycell *a, *b;
int i;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t)1024*1024*30),
"create arena");
cdie(mps_thread_reg(&thread, arena), "register thread");
cdie(mps_root_create_table(&root0, arena, MPS_RANK_AMBIG, 0,
(mps_addr_t *)&exfmt_root, 1),
"create exfmt root");
cdie(mps_root_create_reg(&root1, arena, MPS_RANK_AMBIG, 0, thread,
mps_stack_scan_ambig, stackpointer, 0),
"create register and stack root");
cdie(mps_fmt_create_A(&format, arena, &fmtA),
"create format");
cdie(mps_pool_create(&poolawl, arena, mps_class_awl(), format),
"create awl pool");
cdie(mps_pool_create(&poolmv, arena, mps_class_mv(), 0x4000, 128, 0x4000),
"create mv pool");
cdie(mps_ap_create(&apawl, poolawl, MPS_RANK_EXACT),
"create ap");
b = allocone(apawl, 5, MPS_RANK_EXACT);
for (i=0; i < MAXLDS; i++) {
comment("%d", i);
mps_alloc(&p, poolmv, sizeof(mps_ld_s));
a = allocone(apawl, 5, MPS_RANK_EXACT);
setref(a, 0, b);
b = a;
a = allocdumb(apawl, 256*1024, MPS_RANK_EXACT);
comment("alloc");
lds[i] = p;
mps_ld_reset(lds[i], arena);
comment("reset");
if (i>0) {
mps_ld_add(lds[i], arena, (mps_addr_t) b);
}
comment("add");
}
for (i=0; i < MAXLDS; i++) {
comment("%d", i);
asserts(mps_ld_isstale(lds[i], arena, p) == 0,
"%d stale but shouldn't be", i);
}
mps_ap_destroy(apawl);
comment("Destroyed ap.");
mps_pool_destroy(poolmv);
mps_pool_destroy(poolawl);
comment("Destroyed pools.");
mps_fmt_destroy(format);
comment("Destroyed format.");
mps_root_destroy(root0);
mps_root_destroy(root1);
comment("Destroyed roots.");
mps_thread_dereg(thread);
comment("Deregistered thread.");
mps_arena_destroy(arena);
comment("Destroyed arena.");
}
static void test(void)
{
mps_pool_t poolmv, poolawl, poolamc;
mps_thr_t thread;
mps_root_t root0, root1, root2;
mps_addr_t p;
mps_fmt_t format;
mps_chain_t chain;
mps_ap_t apawl, apamc;
mycell *a, *b;
int i,j;
RC;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t)1024*1024*30),
"create arena");
cdie(mps_thread_reg(&thread, arena), "register thread");
cdie(mps_root_create_table(&root0, arena, mps_rank_ambig(), 0,
(mps_addr_t*)&exfmt_root, 1),
"create exfmt root");
cdie(mps_root_create_table(&root2, arena, mps_rank_exact(), 0,
(mps_addr_t *)obj_table, MAXLDS),
"create table root");
cdie(mps_root_create_reg(&root1, arena, mps_rank_ambig(), 0, thread,
mps_stack_scan_ambig, stackpointer, 0),
"create register and stack root");
cdie(mps_fmt_create_A(&format, arena, &fmtA),
"create format");
cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create");
cdie(mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated),
"create awl pool");
cdie(mps_pool_create(&poolmv, arena, mps_class_mv(), 0x4000, 128, 0x4000),
"create mv pool");
cdie(mps_ap_create(&apawl, poolawl, mps_rank_exact()),
"create ap");
/* First we'll use only pool classes MV and AWL. So LDs shouldn't */
/* go stale at all. */
b = allocone(apawl, 5, mps_rank_exact());
for (i=0; i < MAXLDS; i++) {
comment("%d", i);
mps_alloc(&p, poolmv, sizeof(mps_ld_s));
a = allocone(apawl, 5, mps_rank_exact());
setref(a, 0, b);
b = a;
a = allocdumb(apawl, 256*1024, mps_rank_exact());
comment("alloc");
lds[i] = p;
mps_ld_reset(lds[i], arena);
comment("reset");
if (i>0) {
mps_ld_add(lds[i], arena, (mps_addr_t) b);
}
comment("add");
}
for (i=0; i < MAXLDS; i++) {
comment("%d", i);
asserts(mps_ld_isstale(lds[i], arena, p) == 0,
"%d stale but shouldn't be", i);
}
/* Then use AMC, so object do move and LDs go stale. */
die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain),
"create pool");
cdie(
mps_ap_create(&apamc, poolamc, mps_rank_exact()),
"create ap");
/* Allocate MAXLDS objects, and make each LD depend on the corresponding */
/* object. */
for (i=0; i < MAXLDS; i++) {
comment("%d", i);
obj_table[i] = allocone(apamc, ranint(100), mps_rank_exact());
mps_ld_add(lds[i], arena, (mps_addr_t) obj_table[i]);
}
for (i=0; i < 1000; i++) {
comment("%d of 1000", i);
checklds();
for (j=0; j < 8; j++) {
a = allocdumb(apamc, 32*1024, mps_rank_exact());
}
}
mps_ap_destroy(apawl);
mps_ap_destroy(apamc);
mps_pool_destroy(poolmv);
mps_pool_destroy(poolamc);
mps_pool_destroy(poolawl);
comment("Destroyed pools.");
mps_chain_destroy(chain);
mps_fmt_destroy(format);
mps_root_destroy(root0);
mps_root_destroy(root1);
mps_root_destroy(root2);
comment("Destroyed roots.");
mps_thread_dereg(thread);
mps_arena_destroy(arena);
comment("Destroyed arena.");
}
static void dt(int kind,
size_t extendBy, size_t avgSize, size_t maxSize,
size_t mins, size_t maxs, int number, int iter)
{
mps_pool_t pool;
int i, hd;
clock_t time0, time1;
size_t size;
int secs;
asserts(number <= MAXNUMBER, "number too big");
time0 = clock();
asserts(time0 != -1, "processor time not available");
die(
mps_pool_create(&pool, arena, mps_class_mv(),
extendBy, avgSize, maxSize),
"create MV pool");
for(hd=0; hd<number; hd++)
{
size = ranrange(mins, maxs);
if ((ranint(2) && (kind & 2)) || (kind==DUMMY))
{
queue[hd].addr=NULL;
}
else
{
die(mps_alloc(&queue[hd].addr, pool, size), "alloc");
setobj(queue[hd].addr, size, (unsigned char) (hd%256));
queue[hd].size = size;
}
};
hd=-1;
for(i=0; i<iter; i++)
{
if (kind & 1) hd = ranint(number);
else {ranint(number); hd=(hd+1)%number;} /* call raninit anyway
to use same time */
if (queue[hd].addr != NULL)
{
asserts(chkobj(queue[hd].addr, queue[hd].size, (unsigned char) (hd%256)),
"corrupt at %x (%s: %x, %x, %x, %x, %x, %i, %i)",
queue[hd].addr,
tdesc[kind], (int) extendBy, (int) avgSize, (int) maxSize,
(int) mins, (int) maxs, number, iter);
mps_free(pool, queue[hd].addr, queue[hd].size);
}
size = ranrange(mins, maxs);
if ((ranint(2) && (kind & 2)) || (kind==DUMMY))
{
queue[hd].addr=NULL;
}
else
{
die(mps_alloc(&queue[hd].addr, pool, size),"alloc");
setobj(queue[hd].addr, size, (unsigned char) (hd%256));
queue[hd].size = size;
}
}
mps_pool_destroy(pool);
time1=clock();
secs=(int) 100*(time1-time0)/CLOCKS_PER_SEC;
comment("%s test (%x, %x, %x, %x, %x, %i, %i) in %i centisecs",
tdesc[kind], (int) extendBy, (int) avgSize, (int) maxSize,
(int) mins, (int) maxs, number, iter, secs);
}
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;
}
