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_thr_t thread;
mps_pool_t pool;
mps_addr_t a;
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, 1, 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_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 runArenaTest(size_t size,
mps_bool_t failcase,
mps_bool_t usefulFailcase)
{
mps_arena_t arena;
die(mps_arena_create(&arena, mps_arena_class_vmnz(), size),
"mps_arena_create");
die(mps_arena_commit_limit_set(arena, size - chunkSize),
"mps_arena_commit_limit_set");
testInArena(arena, failcase, usefulFailcase);
mps_arena_destroy(arena);
}
int main(int argc, char *argv[])
{
mps_arena_t arena;
randomize(argc, argv);
mps_lib_assert_fail_install(assert_die);
die(mps_arena_create(&arena, mps_arena_class_vmnz(), testArenaSIZE),
"mps_arena_create");
testInArena(arena);
mps_arena_destroy(arena);
printf("%s: Conclusion: Failed to find any defects.\n", argv[0]);
return 0;
}
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_pool_t poolhi, poollo;
mps_thr_t thread;
unsigned long com0, com1;
/* create a VM arena of 30MB */
cdie(mps_arena_create(&arena, mps_arena_class_vmnz(), (size_t) (1024*1024*40)),
"create arena");
/* set the commit limit to 100MB, i.e. let the arena do the limiting */
mps_arena_commit_limit_set(arena, (size_t) (1024ul*1024ul*100ul));
cdie(mps_thread_reg(&thread, arena), "register thread");
cdie(
mps_pool_create(&poolhi, arena, mps_class_mvff(), MVFF_HI_PARMS),
"create high pool");
cdie(
mps_pool_create(&poollo, arena, mps_class_mvff(), MVFF_LO_PARMS),
"create low pool");
/* set the spare commit limit to something very big */
mps_arena_spare_commit_limit_set(arena, (size_t)-1);
/* allocate a jolly big object, clamp the commit limit down, leaving
64KB space, then free it */
die(mps_alloc(&objs[0], poollo, BIGSIZE), "alloc");
com0 = mps_arena_committed(arena);
mps_arena_commit_limit_set(arena, com0+(1024*64));
mps_free(poollo, objs[0], BIGSIZE);
com1 = mps_arena_committed(arena);
/* the free shouldn't have reduced the total amount committed */
report("reduce1", "%ld", com0-com1);
/* it should be possible to reallocate the object */
die(mps_alloc(&objs[0], poollo, BIGSIZE), "alloc lo");
mps_free(poollo, objs[0], BIGSIZE);
/* it should equally be possible to allocate an object in a different
segment (poolhi). This ought to flush the spare. */
die(mps_alloc(&objs[0], poolhi, BIGSIZE), "alloc hi");
mps_free(poolhi, objs[0], BIGSIZE);
comment("Finishing off.");
mps_pool_destroy(poolhi);
mps_pool_destroy(poollo);
comment("Destroyed pool.");
mps_thread_dereg(thread);
comment("Deregistered thread.");
mps_arena_destroy(arena);
comment("Destroyed arena.");
}
