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 *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_pool(mps_pool_class_t pool_class, mps_arg_s args[], mps_bool_t haveAmbiguous) { mps_pool_t pool; mps_root_t exactRoot, ambigRoot = NULL; size_t lastStep = 0, i, r; unsigned long objs; mps_ap_t busy_ap; mps_addr_t busy_init; die(mps_pool_create_k(&pool, arena, pool_class, args), "pool_create"); 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; if (haveAmbiguous) 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)"); if (haveAmbiguous) 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"); die(PoolDescribe(pool, mps_lib_get_stdout(), 0), "PoolDescribe"); objs = 0; totalSize = 0; while(totalSize < totalSizeMAX) { if (totalSize > lastStep + totalSizeSTEP) { lastStep = totalSize; printf("\nSize %"PRIuLONGEST" bytes, %lu objects.\n", (ulongest_t)totalSize, objs); (void)fflush(stdout); for(i = 0; i < exactRootsCOUNT; ++i) cdie(exactRoots[i] == objNULL || dylan_check(exactRoots[i]), "all roots check"); } r = (size_t)rnd(); if (!haveAmbiguous || (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_main(void *marker, int interior, int stack) { mps_res_t res; mps_chain_t obj_chain; mps_fmt_t obj_fmt; mps_thr_t thread; mps_root_t reg_root = NULL; res = mps_arena_create_k(&scheme_arena, mps_arena_class_vm(), mps_args_none); if (res != MPS_RES_OK) error("Couldn't create arena"); res = mps_chain_create(&obj_chain, scheme_arena, sizeof(obj_gen_params) / sizeof(*obj_gen_params), obj_gen_params); if (res != MPS_RES_OK) error("Couldn't create obj chain"); scheme_fmt(&obj_fmt); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_CHAIN, obj_chain); MPS_ARGS_ADD(args, MPS_KEY_FORMAT, obj_fmt); MPS_ARGS_ADD(args, MPS_KEY_INTERIOR, interior); die(mps_pool_create_k(&obj_pool, scheme_arena, mps_class_amc(), args), "mps_pool_create_k"); } MPS_ARGS_END(args); res = mps_ap_create_k(&obj_ap, obj_pool, mps_args_none); if (res != MPS_RES_OK) error("Couldn't create obj allocation point"); res = mps_thread_reg(&thread, scheme_arena); if (res != MPS_RES_OK) error("Couldn't register thread"); if (stack) { res = mps_root_create_thread(®_root, scheme_arena, thread, marker); if (res != MPS_RES_OK) error("Couldn't create root"); } test_air(interior, stack); mps_arena_park(scheme_arena); if (stack) mps_root_destroy(reg_root); mps_thread_dereg(thread); mps_ap_destroy(obj_ap); mps_pool_destroy(obj_pool); mps_chain_destroy(obj_chain); mps_fmt_destroy(obj_fmt); mps_arena_destroy(scheme_arena); }
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 test(void *stack_pointer) { void *marker = ▮ mps_arena_t arena; mps_pool_t pool; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_ap_t ap; mps_addr_t p, q, unaligned; cdie(mps_arena_create_k(&arena, mps_arena_class_vm(), mps_args_none), "create arena"); mps_arena_park(arena); cdie(mps_thread_reg(&thread, arena), "register thread"); cdie(mps_root_create_thread(&root, arena, thread, marker), "create root"); cdie(mps_fmt_create_A(&format, arena, &fmtA), "create format"); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_FORMAT, format); cdie(mps_pool_create_k(&pool, arena, mps_class_ams(), args), "pool"); } MPS_ARGS_END(args); cdie(mps_ap_create(&ap, pool, mps_rank_exact()), "ap"); /* p is in the AMS pool */ p = allocone(ap, 0, NULL, NULL, sizeof(mycell)); /* q is in the AMS pool with unaligned exact reference to p */ unaligned = (void *)((char*)p + 1); q = allocone(ap, 1, p, unaligned, sizeof(mycell)); mps_arena_start_collect(arena); mps_arena_park(arena); /* Keep q (and thus p) alive during the collection. */ report("q", "%p", q); mps_ap_destroy(ap); mps_pool_destroy(pool); mps_fmt_destroy(format); mps_root_destroy(root); mps_thread_dereg(thread); mps_arena_destroy(arena); }
static void test(void) { mps_arena_t arena; mps_pool_t pool; mps_fmt_t format; mps_ap_t ap; mps_addr_t p; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_fmt_create_k(&format, arena, mps_args_none), "create format"); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_FORMAT, format); cdie(mps_pool_create_k(&pool, arena, mps_class_ams(), args), "create pool"); } MPS_ARGS_END(args); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_RANK, mps_rank_weak()); cdie(mps_ap_create_k(&ap, pool, args), "create ap"); } MPS_ARGS_END(args); do { cdie(mps_reserve(&p, ap, 0x100), "Reserve: "); } while (!mps_commit(ap, p, 0x100)); comment("Committed."); mps_ap_destroy(ap); comment("Destroyed ap."); mps_pool_destroy(pool); comment("Destroyed pool."); mps_fmt_destroy(format); comment("Destroyed format."); mps_arena_destroy(arena); comment("Destroyed 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_k(&pool, arena, mps_class_mv_debug(), mps_args_none), "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 *stack_pointer) { mps_arena_t arena; mps_pool_t poolMVFF, poolAMC; mps_thr_t thread; mps_fmt_t format; mps_chain_t chain; mps_ap_t ap; mps_res_t r; mycell *a; mps_addr_t p; int i; int s1, s2, s3; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); die(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); formatcomments = 0; die(mmqa_pool_create_chain(&poolAMC, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_ap_create(&ap, poolAMC, mps_rank_exact()), "create ap"); comment("Sizes in megabytes:"); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_EXTEND_BY, EXTEND_BY); MPS_ARGS_ADD(args, MPS_KEY_MEAN_SIZE, MEAN_SIZE); cdie(mps_pool_create_k(&poolMVFF, arena, mps_class_mvff(), args), "create MVFF pool"); } MPS_ARGS_END(args); i = 0; while ((r=mps_alloc(&p, poolMVFF, 1024*1024)) == 0) i++; report("refuse1", "%s", err_text(r)); report("size1", "%i", i); s1 = i; mps_pool_destroy(poolMVFF); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_EXTEND_BY, EXTEND_BY); MPS_ARGS_ADD(args, MPS_KEY_MEAN_SIZE, MEAN_SIZE); cdie(mps_pool_create_k(&poolMVFF, arena, mps_class_mvff(), args), "create MVFF pool"); } MPS_ARGS_END(args); i = 0; while ((r=mps_alloc(&p, poolMVFF, 1024*1024)) == 0) i++; report("refuse2", "%s", err_text(r)); report("size2", "%i", i); s2 = i; mps_pool_destroy(poolMVFF); a = allocdumb(ap, 1024*1024*30); /* allocate 30 M object */ MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_EXTEND_BY, EXTEND_BY); MPS_ARGS_ADD(args, MPS_KEY_MEAN_SIZE, MEAN_SIZE); cdie(mps_pool_create_k(&poolMVFF, arena, mps_class_mvff(), args), "create MVFF pool"); } MPS_ARGS_END(args); i=0; while ((r=mps_alloc(&p, poolMVFF, 1024*1024)) == 0) i++; report("refuse3", "%s", err_text(r)); report("size3", "%i", i); s3 = i; report("diff12", "%i", s1-s2); report("diff23", "%i", s2-s3); for(i = 0; i < 10; i++) { r = mps_alloc(&p, poolMVFF, 1024*1024); report("refuse4", "%s", err_text(r)); } mps_arena_park(arena); mps_pool_destroy(poolMVFF); mps_ap_destroy(ap); mps_pool_destroy(poolAMC); comment("Destroyed pool."); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static mps_res_t stress(mps_arena_t arena, mps_pool_debug_option_s *options, size_t (*size)(size_t i), mps_align_t align, const char *name, mps_pool_class_t pool_class, mps_arg_s *args) { mps_res_t res; mps_pool_t pool; size_t i, k; int *ps[testSetSIZE]; size_t ss[testSetSIZE]; size_t allocated = 0; /* Total allocated memory */ size_t debugOverhead = options ? 2 * alignUp(options->fence_size, align) : 0; printf("Pool class %s, alignment %u\n", name, (unsigned)align); res = mps_pool_create_k(&pool, arena, pool_class, args); if (res != MPS_RES_OK) return res; /* allocate a load of objects */ for (i=0; i<testSetSIZE; ++i) { mps_addr_t obj; ss[i] = (*size)(i); res = mps_alloc(&obj, pool, ss[i]); if (res != MPS_RES_OK) return res; ps[i] = obj; allocated += alignUp(ss[i], align) + debugOverhead; if (ss[i] >= sizeof(ps[i])) *ps[i] = 1; /* Write something, so it gets swap. */ check_allocated_size(pool, allocated); } mps_pool_check_fenceposts(pool); for (k=0; k<testLOOPS; ++k) { /* shuffle all the objects */ for (i=0; i<testSetSIZE; ++i) { size_t j = rnd()%(testSetSIZE-i); void *tp; size_t ts; tp = ps[j]; ts = ss[j]; ps[j] = ps[i]; ss[j] = ss[i]; ps[i] = tp; ss[i] = ts; } /* free half of the objects */ /* upper half, as when allocating them again we want smaller objects */ /* see randomSize() */ for (i=testSetSIZE/2; i<testSetSIZE; ++i) { mps_free(pool, (mps_addr_t)ps[i], ss[i]); /* if (i == testSetSIZE/2) */ /* PoolDescribe((Pool)pool, mps_lib_stdout); */ Insist(alignUp(ss[i], align) + debugOverhead <= allocated); allocated -= alignUp(ss[i], align) + debugOverhead; } /* allocate some new objects */ for (i=testSetSIZE/2; i<testSetSIZE; ++i) { mps_addr_t obj; ss[i] = (*size)(i); res = mps_alloc(&obj, pool, ss[i]); if (res != MPS_RES_OK) return res; ps[i] = obj; allocated += alignUp(ss[i], align) + debugOverhead; } check_allocated_size(pool, allocated); } die(PoolDescribe(pool, mps_lib_get_stdout(), 0), "PoolDescribe"); mps_pool_destroy(pool); return MPS_RES_OK; }
static void *test(void *arg, size_t s) { mps_arena_t arena; mps_fmt_t format; mps_root_t exactRoot, ambigRoot; size_t lastStep = 0, i, r; unsigned long objs; mps_ap_t busy_ap; mps_addr_t busy_init; const char *indent = " "; mps_chain_t chain; static mps_gen_param_s genParam = {1024, 0.2}; arena = (mps_arena_t)arg; (void)s; /* unused */ die(mps_fmt_create_A(&format, arena, dylan_fmt_A()), "fmt_create"); die(mps_chain_create(&chain, arena, 1, &genParam), "chain_create"); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_FORMAT, format); MPS_ARGS_ADD(args, MPS_KEY_CHAIN, chain); MPS_ARGS_ADD(args, MPS_KEY_GEN, 0); die(mps_pool_create_k(&pool, arena, mps_class_amst(), args), "pool_create(amst)"); } MPS_ARGS_END(args); 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)"); puts(indent); /* create an ap, and leave it busy */ die(mps_reserve(&busy_init, busy_ap, 64), "mps_reserve busy"); objs = 0; while(totalSize < totalSizeMAX) { if (totalSize > lastStep + totalSizeSTEP) { lastStep = totalSize; printf("\nSize %"PRIuLONGEST" bytes, %"PRIuLONGEST" objects.\n", (ulongest_t)totalSize, (ulongest_t)objs); printf("%s", indent); (void)fflush(stdout); for(i = 0; i < exactRootsCOUNT; ++i) cdie(exactRoots[i] == objNULL || dylan_check(exactRoots[i]), "all roots check"); } 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 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_k(&temppool, arena, mps_class_mvff(), mps_args_none), "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(mps_arena_t arena, mps_class_t pool_class) { mps_chain_t chain; mps_fmt_t format; mps_pool_t pool; mps_root_t exactRoot; size_t i; unsigned long objs; struct stepper_data sdStruct, *sd; die(dylan_fmt(&format, arena), "fmt_create"); die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_FORMAT, format); MPS_ARGS_ADD(args, MPS_KEY_CHAIN, chain); MPS_ARGS_ADD(args, MPS_KEY_AWL_FIND_DEPENDENT, test_awl_find_dependent); die(mps_pool_create_k(&pool, arena, pool_class, args), "pool_create"); } MPS_ARGS_END(args); die(mps_ap_create(&ap, pool, mps_rank_exact()), "ap_create"); for(i = 0; i < exactRootsCOUNT; ++i) exactRoots[i] = objNULL; 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)"); objs = 0; while(objs < objCOUNT) { size_t r; r = objs; i = r % 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); ++objs; } sd = &sdStruct; sd->arena = arena; sd->expect_pool = pool; sd->expect_fmt = format; sd->count = 0; mps_arena_formatted_objects_walk(arena, stepper, sd, sizeof *sd); /* Note: stepper finds more than we expect, due to pad objects */ /* printf("stepper found %ld objs\n", sd->count); */ mps_ap_destroy(ap); mps_root_destroy(exactRoot); mps_pool_destroy(pool); mps_chain_destroy(chain); mps_fmt_destroy(format); return NULL; }
static mps_res_t stress(mps_arena_t arena, mps_align_t align, size_t (*size)(unsigned long i), mps_pool_class_t pool_class, mps_arg_s args[]) { mps_res_t res; mps_ap_t ap; unsigned long i, k; int *ps[TEST_SET_SIZE]; size_t ss[TEST_SET_SIZE]; res = mps_pool_create_k(&pool, arena, pool_class, args); if (res != MPS_RES_OK) return res; die(mps_ap_create(&ap, pool, mps_rank_exact()), "BufferCreate"); /* allocate a load of objects */ for(i=0; i<TEST_SET_SIZE; ++i) { mps_addr_t obj; ss[i] = (*size)(i); res = make(&obj, ap, ss[i], align); if (res != MPS_RES_OK) { ss[i] = 0; } else { ps[i]= obj; *ps[i] = 1; /* Write something, so it gets swap. */ } if (verbose) { if (i && i%4==0) putchar('\n'); printf("%"PRIwWORD PRIXLONGEST" %6"PRIXLONGEST" ", (ulongest_t)ps[i], (ulongest_t)ss[i]); } if (i == 100) { PoolDescribe(pool, mps_lib_get_stdout(), 0); } } if (verbose) { putchar('\n'); } for (k=0; k<TEST_LOOPS; ++k) { unsigned long x = rnd()%(TEST_SET_SIZE-1); /* shuffle all the objects */ for(i=0; i<TEST_SET_SIZE; ++i) { unsigned long j = rnd()%(TEST_SET_SIZE-i); void *tp; size_t ts; tp = ps[j]; ts = ss[j]; ps[j] = ps[i]; ss[j] = ss[i]; ps[i] = tp; ss[i] = ts; } /* free some of the objects */ for(i=x; i<TEST_SET_SIZE; ++i) { if (ss[i] > 0) { mps_free(pool, (mps_addr_t)ps[i], ss[i]); ss[i] = 0; } } /* allocate some new objects */ for(i=x; i<TEST_SET_SIZE; ++i) { mps_addr_t obj; size_t s = (*size)(i); res = make(&obj, ap, s, align); if(res != MPS_RES_OK) break; ps[i] = obj; ss[i] = s; if (verbose) { if (i && i%4==0) putchar('\n'); printf("%"PRIwWORD PRIXLONGEST" %6"PRIXLONGEST" ", (ulongest_t)ps[i], (ulongest_t)ss[i]); } } if (verbose) putchar('\n'); } mps_ap_destroy(ap); mps_pool_destroy(pool); return MPS_RES_OK; }
pool = NULL; watch(dj, name); } /* Wrap a call to a dj benchmark that requires MPS setup */ static void arena_wrap(dj_t dj, mps_pool_class_t pool_class, const char *name) { MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_ARENA_SIZE, arena_size); MPS_ARGS_ADD(args, MPS_KEY_ARENA_GRAIN_SIZE, arena_grain_size); MPS_ARGS_ADD(args, MPS_KEY_ARENA_ZONED, zoned); DJMUST(mps_arena_create_k(&arena, mps_arena_class_vm(), args)); } MPS_ARGS_END(args); DJMUST(mps_pool_create_k(&pool, arena, pool_class, mps_args_none)); watch(dj, name); mps_pool_destroy(pool); mps_arena_destroy(arena); } /* Command-line options definitions. See getopt_long(3). */ static struct option longopts[] = { {"help", no_argument, NULL, 'h'}, {"nthreads", required_argument, NULL, 't'}, {"niter", required_argument, NULL, 'i'}, {"npass", required_argument, NULL, 'p'}, {"nblocks", required_argument, NULL, 'b'}, {"sshift", required_argument, NULL, 's'},
static void test(mps_arena_t arena, mps_pool_class_t pool_class) { mps_chain_t chain; mps_fmt_t format; mps_pool_t pool; mps_root_t exactRoot; size_t i; size_t totalSize, freeSize, allocSize, bufferSize; unsigned long objs; struct stepper_data sdStruct, *sd; PoolClass class; die(dylan_fmt(&format, arena), "fmt_create"); die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_FORMAT, format); MPS_ARGS_ADD(args, MPS_KEY_CHAIN, chain); die(mps_pool_create_k(&pool, arena, pool_class, args), "pool_create"); } MPS_ARGS_END(args); die(mps_ap_create(&ap, pool, mps_rank_exact()), "ap_create"); for(i = 0; i < exactRootsCOUNT; ++i) exactRoots[i] = objNULL; 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)"); objs = 0; while(objs < objCOUNT) { size_t r; r = objs; i = r % 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); ++objs; } mps_arena_park(arena); sd = &sdStruct; sd->arena = arena; sd->expect_pool = pool; sd->expect_fmt = format; sd->count = 0; sd->objSize = 0; sd->padSize = 0; mps_arena_formatted_objects_walk(arena, stepper, sd, sizeof *sd); Insist(sd->count == objs); totalSize = mps_pool_total_size(pool); freeSize = mps_pool_free_size(pool); allocSize = totalSize - freeSize; bufferSize = AddrOffset(ap->init, ap->limit); class = ClassOfPoly(Pool, pool); printf("%s: obj=%lu pad=%lu total=%lu free=%lu alloc=%lu buffer=%lu\n", ClassName(class), (unsigned long)sd->objSize, (unsigned long)sd->padSize, (unsigned long)totalSize, (unsigned long)freeSize, (unsigned long)allocSize, (unsigned long)bufferSize); Insist(sd->objSize + sd->padSize + bufferSize == allocSize); mps_ap_destroy(ap); mps_root_destroy(exactRoot); mps_pool_destroy(pool); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_arena_release(arena); }
static void t_alloc(int spare, int spare_total, int commit, int obj_size) { size_t size, hisize, comsize, comlimit; size_t spsize = 0, losize = 0; /* stop warnings */ mps_res_t res, res_expected; if (obj_size == OBJ_SMALL) size = SMALL_SIZE; else size = BIG_SIZE; switch (spare_total) { case SPARE_EMPTY: spsize = 0; break; case SPARE_LESS: if (size > DIFF_SIZE) { spsize = size-DIFF_SIZE; } else { spsize = 0; } break; case SPARE_EXACT: spsize = size; break; case SPARE_MORE: spsize = size+DIFF_SIZE; break; default: error("Illegal spare.\n"); break; } switch (spare) { case SPARE_EMPTY: losize = 0; break; case SPARE_LESS: if (size > DIFF_SIZE) { losize = size-DIFF_SIZE; } else { losize = 0; } break; case SPARE_EXACT: losize = size; break; case SPARE_MORE: losize = size+DIFF_SIZE; break; } if (losize > spsize) { losize = spsize; hisize = 0; } else { hisize = spsize-losize; } /* turn off commit limit for a moment */ mps_arena_commit_limit_set(arena, HUGE); /* create low and high pools */ MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_EXTEND_BY, EXTEND); MPS_ARGS_ADD(args, MPS_KEY_MEAN_SIZE, AVGSIZE); MPS_ARGS_ADD(args, MPS_KEY_MVFF_ARENA_HIGH, 1); MPS_ARGS_ADD(args, MPS_KEY_MVFF_SLOT_HIGH, 1); MPS_ARGS_ADD(args, MPS_KEY_MVFF_FIRST_FIT, 0); MPS_ARGS_ADD(args, MPS_KEY_SPARE, 0.0); die(mps_pool_create_k(&poolhi, arena, mps_class_mvff(), args), "create high pool"); } MPS_ARGS_END(args); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_EXTEND_BY, EXTEND); MPS_ARGS_ADD(args, MPS_KEY_MEAN_SIZE, AVGSIZE); MPS_ARGS_ADD(args, MPS_KEY_MVFF_ARENA_HIGH, 0); MPS_ARGS_ADD(args, MPS_KEY_MVFF_SLOT_HIGH, 0); MPS_ARGS_ADD(args, MPS_KEY_MVFF_FIRST_FIT, 1); MPS_ARGS_ADD(args, MPS_KEY_SPARE, 0.0); die(mps_pool_create_k(&poollo, arena, mps_class_mvff(), args), "create low pool"); } MPS_ARGS_END(args); /* flush hysteresis fund, then set limit */ mps_arena_spare_set(arena, SPARE_ZERO); mps_arena_spare_set(arena, SPARE_LIMIT); /* allocate something in each pool (to reduce risk of subsidiary allocation being needed later) */ die(mps_alloc(&objlo, poollo, EXTEND), "low alloc"); mps_free(poollo, objlo, EXTEND); die(mps_alloc(&objhi, poolhi, EXTEND), "high alloc"); mps_free(poolhi, objhi, EXTEND); /* set up spare committed the way we want it */ if (losize>0) { die(mps_alloc(&objlo, poollo, losize), "low setup"); mps_free(poollo, objlo, losize); } if (hisize>0) { die(mps_alloc(&objhi, poolhi, hisize), "high setup"); mps_free(poolhi, objhi, hisize); } /* spare is now set up correctly */ /* now we need to set the commit limit correctly */ comsize = arena_committed_and_used(arena); /* allow for 1/16th memory overhead in setting commit limit */ if (commit == COMMIT_EXACT) { comlimit = comsize+size+(size/16); } else if (commit == COMMIT_NOCHANGE) { comlimit = mps_arena_committed(arena); } else if (commit == COMMIT_PLENTY) { comlimit = HUGE; } else /* commit == COMMIT_LITTLE */ { if (size > DIFF_SIZE) { comlimit = comsize+size+(size/16)+DIFF_SIZE; } else { comlimit = comsize+size+(size/16); } } die(mps_arena_commit_limit_set(arena, comlimit), "commit limit set"); res = mps_alloc(&objlo, poollo, size); asserts(comlimit >= comsize, "comlimit was less than comsize!"); if (size <= (comlimit-comsize)) { res_expected = MPS_RES_OK; } else { res_expected = MPS_RES_COMMIT_LIMIT; } if (res != res_expected) { comment("hisize=%lu losize=%lu\n" "comsize=%lu comlimit=%lu\n" "Expected %s. Got %s", (unsigned long)hisize, (unsigned long)losize, (unsigned long)comsize, (unsigned long)comlimit, err_text(res_expected), err_text(res)); report("failed", "yes"); } mps_pool_destroy(poollo); mps_pool_destroy(poolhi); }
static void dt(int kind, size_t extendBy, size_t avgSize, unsigned long mins, unsigned long maxs, int number, int iter) { mps_pool_t pool; int i, hd; clock_t time0, time1; size_t size; double secs; asserts(number <= MAXNUMBER, "number too big"); time0 = clock(); asserts(time0 != -1, "processor time not available"); MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_EXTEND_BY, extendBy); MPS_ARGS_ADD(args, MPS_KEY_MEAN_SIZE, avgSize); cdie(mps_pool_create_k(&pool, arena, mps_class_mvff(), args), "pool"); } MPS_ARGS_END(args); 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, %lx, %lx, %i, %i)", queue[hd].addr, tdesc[kind], (int) extendBy, (int) avgSize, mins, 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=(time1-time0)/(double)CLOCKS_PER_SEC; comment("%s test (%x, %x, %lx, %lx, %i, %i) in %.2f s", tdesc[kind], (int) extendBy, (int) avgSize, mins, maxs, number, iter, secs); }