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."); }
/* v serves two purposes: * A pseudo stack base for the stack root. * Pointer to a guff structure, which packages some values needed * (arena and thr mostly) */ static void *setup(void *v, size_t s) { struct guff_s *guff; mps_arena_t arena; mps_pool_t leafpool; mps_pool_t tablepool; mps_fmt_t dylanfmt; mps_fmt_t dylanweakfmt; mps_ap_t leafap, exactap, weakap, bogusap; mps_root_t stack; mps_thr_t thr; guff = (struct guff_s *)v; (void)s; arena = guff->arena; thr = guff->thr; die(mps_root_create_reg(&stack, arena, MPS_RANK_AMBIG, 0, thr, mps_stack_scan_ambig, v, 0), "Root Create\n"); die(mps_fmt_create_A(&dylanfmt, arena, dylan_fmt_A()), "Format Create\n"); die(mps_fmt_create_A(&dylanweakfmt, arena, dylan_fmt_A_weak()), "Format Create (weak)\n"); die(mps_pool_create(&leafpool, arena, mps_class_lo(), dylanfmt), "Leaf Pool Create\n"); die(mps_pool_create(&tablepool, arena, mps_class_awl(), dylanweakfmt, dylan_weak_dependent), "Table Pool Create\n"); die(mps_ap_create(&leafap, leafpool, MPS_RANK_EXACT), "Leaf AP Create\n"); die(mps_ap_create(&exactap, tablepool, MPS_RANK_EXACT), "Exact AP Create\n"); die(mps_ap_create(&weakap, tablepool, MPS_RANK_WEAK), "Weak AP Create\n"); die(mps_ap_create(&bogusap, tablepool, MPS_RANK_EXACT), "Bogus AP Create\n"); test(leafap, exactap, weakap, bogusap); mps_ap_destroy(bogusap); mps_ap_destroy(weakap); mps_ap_destroy(exactap); mps_ap_destroy(leafap); mps_pool_destroy(tablepool); mps_pool_destroy(leafpool); mps_fmt_destroy(dylanweakfmt); mps_fmt_destroy(dylanfmt); mps_root_destroy(stack); return NULL; }
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 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 init(void) { size_t i; 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)"); 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)"); }
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"); formatcomments = 0; 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, UNALIGNED, mps_rank_exact()), "create ap"); }
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 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_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_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_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 test(void *stack_pointer) { mps_arena_t arena; mps_pool_t pool; mps_fmt_t format; mps_ap_t ap; mps_addr_t obj; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_fmt_create_k(&format, arena, mps_args_none), "create format"); cdie(mps_pool_create(&pool, arena, mps_class_lo(), format), "create pool"); cdie(mps_ap_create(&ap, pool), "create ap"); cdie(mps_reserve(&obj, ap, 256), "reserve"); (void)mps_commit(ap, &obj, 256); mps_free(pool, obj, 256); comment("Freed."); mps_free(pool, obj, 256); comment("Freed again."); mps_pool_destroy(pool); comment("Destroyed pool"); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_space_t space; mps_pool_t pool; mps_thr_t thread; size_t mysize; mps_addr_t a; cdie(mps_space_create(&space), "create space"); cdie(mps_thread_reg(&thread, space), "register thread"); mysize = 8; cdie( mps_pool_create( &pool, space, mps_class_mfs(), (size_t) 8, mysize), "create pool"); mps_alloc(&a, pool, mysize); mps_free(pool, NULL, mysize); mps_pool_destroy(pool); }
static int dllskin_meminit(SWSTART *start) { int32 i ; mps_arena_t dllskin_arena = NULL ; /* Spy on the memory configuration tags to find the arena */ for ( i = 0 ; dllskin_arena == NULL && start[i].tag != SWEndTag ; ++i ) { switch ( start[i].tag ) { case SWMemoryTag: dllskin_arena = ((SWSTART_MEMORY *)start[i].value.pointer_value)->arena; break ; case SWMemCfgTag: dllskin_arena = ((SWSTART_MEMCFG *)start[i].value.pointer_value)->arena; break ; } } if ( dllskin_arena != NULL ) { mps_res_t res = mps_pool_create(&dllskin_pool, dllskin_arena, mps_class_mvff(), (size_t)65536, (size_t)32, (size_t)8, EPDR_LIKE); if ( res == MPS_RES_OK ) { mps_word_t label = mps_telemetry_intern("DLLskin pool"); mps_telemetry_label((mps_addr_t)dllskin_pool, label); } else { SecurityExit(1, (uint8 *)"Unicode memory pool initialisation failed"); return FALSE ; } } return TRUE ; }
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 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; 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"); formatcomments = 0; cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); cdie( mps_pool_create(&pool, arena, mps_class_amc(), format, chain), "create pool"); mps_pool_destroy(UNALIGNED); }
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) { mps_space_t space; mps_pool_t pool; mps_thr_t thread; size_t mysize; mps_addr_t a; cdie(mps_space_create(&space), "create space"); cdie(mps_thread_reg(&thread, space), "register thread"); mysize = 16; cdie( mps_pool_create( &pool, space, mps_class_mfs(), mysize, mysize), "create pool"); cdie(mps_alloc(&a, pool, mysize), "alloc"); mps_free(pool, (mps_addr_t) ((char *)a+8), mysize); error("free"); 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_arena_t arena; mps_pool_t pool; mps_thr_t thread; size_t mysize; mps_addr_t a; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); mysize = 8; cdie( mps_pool_create( &pool, arena, mps_class_mfs(), (size_t) 8, mysize), "create pool"); mps_alloc(&a, pool, mysize); mps_free(NULL, a, mysize); mps_pool_destroy(pool); }
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 *stack_pointer) { mps_arena_t arena; mps_pool_t pool; mps_thr_t thread; size_t mysize; mps_addr_t a; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); mysize = 16; cdie( mps_pool_create( &pool, arena, mps_class_mfs(), mysize, mysize), "create pool"); cdie(mps_alloc(&a, pool, mysize), "alloc"); mps_free(pool, (mps_addr_t) ((char *)a+8), mysize); mps_pool_destroy(pool); }
static void test(void *stack_pointer) { mps_arena_t arena; mps_pool_t pool; mps_fmt_t format; mps_ap_t ap; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_fmt_create_k(&format, arena, mps_args_none), "create format"); cdie(mps_pool_create(&pool, arena, mps_class_lo(), format), "create pool"); mps_pool_destroy(pool); comment("Destroyed pool."); cdie(mps_ap_create(&ap, pool, mps_rank_exact()), "create ap"); mps_ap_destroy(ap); comment("Destroyed ap."); mps_fmt_destroy(format); comment("Destroyed format."); mps_arena_destroy(arena); comment("Destroyed 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."); }
static void test(void) { mps_space_t space; mps_pool_t pool; mps_thr_t thread; mps_root_t root; mps_fmt_t format; 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"); formatcomments = 0; adie( mps_pool_create(&pool, NULL, mps_class_amc(), format), "create pool"); }
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 *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."); }
int main(void) { mps_arena_t arena; mps_pool_t pool; mps_fmt_t format; mps_ap_t ap; mps_addr_t p; mps_root_t root; locv_fmt.align = sizeof(void *); /* .fmt.align.delayed */ die(mps_arena_create(&arena, mps_arena_class_vm(), testArenaSIZE), "mps_arena_create"); die(mps_root_create_table(&root, arena, mps_rank_exact(), (mps_rm_t)0, roots, (sizeof(roots)/sizeof(*roots))), "RootCreate"); die(mps_fmt_create_A(&format, arena, &locv_fmt), "FormatCreate"); die(mps_pool_create(&pool, arena, mps_class_lo(), format), "LOCreate"); die(mps_ap_create(&ap, pool, mps_rank_exact()), "APCreate"); die(mps_reserve(&p, ap, sizeof(void *)), "mps_reserve min"); *(mps_word_t *)p = sizeof(void *); cdie(mps_commit(ap, p, sizeof(void *)), "commit min"); die(mps_reserve(&roots[1], ap, 2*sizeof(void *)), "mps_reserve 2*min"); p = roots[1]; *(mps_word_t *)p = 2*sizeof(void *); cdie(mps_commit(ap, p, 2*sizeof(void *)), "commit 2*min"); die(mps_reserve(&p, ap, (size_t)4096), "mps_reserve 4096"); *(mps_word_t *)p = 4096; cdie(mps_commit(ap, p, (size_t)4096), "commit 4096"); die(mps_reserve(&p, ap, sizeof(void *)), "mps_reserve last"); *(mps_word_t *)p = sizeof(void *); cdie(mps_commit(ap, p, sizeof(void *)), "commit last"); { size_t count = 0; mps_arena_formatted_objects_walk(arena, stepper, &count, 0); cdie(count == 4, "walk 4 objects"); } mps_ap_destroy(ap); mps_pool_destroy(pool); mps_fmt_destroy(format); mps_root_destroy(root); mps_arena_destroy(arena); fflush(stdout); /* synchronize */ fprintf(stderr, "\nConclusion: Failed to find any defects.\n"); return 0; }