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_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) { 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 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 *stack_pointer) { mps_thr_t thread; mps_pool_t pool; unsigned int i; unsigned long nLarge; cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*50)), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); mps_arena_commit_limit_set(arena, COMLIMIT1); die(mps_pool_create(&pool, arena, mps_class_mvff(), (size_t)EXTENDBY, (size_t)8, (mps_align_t)MPS_PF_ALIGN, (mps_bool_t)0, (mps_bool_t)0, (mps_bool_t)1), "create MVFF pool"); for (i = 0; i < NSMALL; i++) { die(mps_alloc(&smallObjects[i], pool, SMALLSIZE), "small alloc failed"); } nLarge = 0; while (mps_alloc(&largeObjects[nLarge], pool, BIGSIZE) == MPS_RES_OK) { nLarge ++; } report("nLarge", "%lu", nLarge); for (i = 0; i < NSMALL; i += 2) { mps_free(pool, smallObjects[i], SMALLSIZE); } comment("Freed every other small object."); /* The CBS should be in emergency mode now. */ for (i = 0; i < nLarge; i += 2) { mps_free(pool, largeObjects[i], BIGSIZE); } comment("Freed every other large object."); /* Now there should be lots of big blocks on the CBS. */ mps_arena_commit_limit_set(arena, COMLIMIT2); comment("Raised the commit limit. Will attempt free and alloc."); mps_free(pool, largeObjects[1], BIGSIZE); die(mps_alloc(&largeObjects[0], pool, BIGSIZE), "alloc failed"); mps_pool_destroy(pool); mps_thread_dereg(thread); mps_arena_destroy(arena); }
static void test(void *stack_pointer) { 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"); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_POOL_DEBUG_OPTIONS, &debugOpts); die(mps_pool_create_k(&pool, arena, mps_class_mvff_debug(), args), "create MVFF pool"); } MPS_ARGS_END(args); die(mps_alloc(&a, pool, 64), "alloc a"); 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_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_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 *stack_pointer) { mps_pool_t pool = malloc(4096); mps_addr_t obj; cdie(mps_alloc(&obj, pool, 152), "allocate"); }
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 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) { 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) { 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 *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 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 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_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!"); }
/** Tries to reclaim as much of the reserve as is more valuable than the given cost. Returns success. */ static Bool mm_reserve_get(mm_cost_t limit) { mps_res_t res; HQASSERT( mm_reserve_level >= 0 && mm_reserve_level <= mm_reserve_numlevels, "mm_reserve_get: mm_reserve_level is invalid" ); while ( mm_reserve_level > 0 && mm_cost_less_than(limit, mm_reserve_table[mm_reserve_level-1].cost) ) { res = mps_alloc( & mm_reserve_table[mm_reserve_level - 1].ptr, mm_pool_reserve, (size_t)mm_reserve_table[mm_reserve_level - 1].size ); if ( res != MPS_RES_OK ) return FALSE; mm_reserve_level--; MM_LOG(( LOG_RG, "%u 0x%08x 0x%08x", mm_reserve_level + 1, (unsigned)mm_reserve_table[mm_reserve_level].ptr, mm_reserve_table[mm_reserve_level].size )); } if ( mm_reserve_level == 0 && mm_commit_limit == mm_commit_base ) { #if defined(DEBUG_BUILD) if ( debug_lowmemory_count > 0 ) --debug_lowmemory_count; else #endif mm_memory_is_low = FALSE; } return TRUE; }
static mps_addr_t allocObject(mps_pool_t pool, size_t size) { mps_addr_t addr; die(mps_alloc(&addr, pool, size), "Allocate Object"); return addr; }
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_arena_t arena; mps_pool_t pool; mps_addr_t q, r; 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"); die(mps_alloc(&q, pool, 1024*1024), "alloc"); for (p=0; p<2000; p++) { report("promise", "%i", p); die(mps_alloc(&r, pool, 1024*1024), "alloc"); mps_free(pool, q, 256*1024-8); q = (mps_addr_t) ((char *) r + 8); } }
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; 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 test(void *stack_pointer) { mps_arena_t arena; mps_pool_t pool; mps_addr_t obj; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_pool_create_k(&pool, arena, mps_class_mvff(), mps_args_none), "pool"); cdie(mps_alloc(&obj, pool, 152), "allocate"); mps_free(pool, obj, 512); 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_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 ps_write(int8 level, OBJECT *dest, OBJECT *src) { corecontext_t *corecontext = get_core_context() ; /* Save it if the array will survive the object being written into it. */ if (level < (theMark(*src) & SAVEMASK)) { void *p; saveRecord *sl; size_t saveIndex = NUMBERSAVES(corecontext->savelevel); die(mps_alloc(&p, savePool, sizeof(saveRecord)), "save alloc"); sl = (saveRecord *)p; sl->slot = dest; Copy( &sl->oldvalue, dest ); sl->next = saves[saveIndex]; saves[saveIndex] = sl; SETSLOTSAVED(*dest, FALSE, corecontext); } Copy(dest, src); }
static void test(void) { mps_space_t space; mps_pool_t pool; mps_fmt_t format; mps_fmt_A_s fmtA; mps_addr_t obj; cdie(mps_space_create(&space), "create space"); fmtA.align = (mps_align_t) 1; fmtA.scan = &zilch; fmtA.skip = &myskip; fmtA.copy = &zilch; fmtA.fwd = &zilch; fmtA.isfwd = &zilch; fmtA.pad = &zilch; cdie( mps_fmt_create_A(&format, space, &fmtA), "create format"); cdie( mps_pool_create(&pool, space, mps_class_lo(), format), "create pool"); cdie(mps_alloc(&obj, pool, 152), "allocate"); mps_free(pool, obj, 152); comment("Freed."); mps_free(pool, obj, 152); comment("Freed again."); mps_pool_destroy(pool); comment("Destroyed pool"); mps_space_destroy(space); comment("Destroyed space."); }
static mps_res_t allocMultiple(PoolStat stat) { mps_addr_t objects[contigAllocs]; int i; /* allocate a few objects, and record stats for them */ for (i = 0; i < contigAllocs; i++) { mps_addr_t obj; mps_res_t res = mps_alloc(&obj, stat->pool, stat->objSize); if (res != MPS_RES_OK) return res; recordNewObjectStat(stat, obj); objects[i] = obj; } /* free one of the objects, to make the test more interesting */ i = rnd() % contigAllocs; mps_free(stat->pool, objects[i], stat->objSize); recordFreedObjectStat(stat); return MPS_RES_OK; }