static void test(void) { mps_arena_t arena; mps_pool_t poolamc1; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_chain_t chain; mps_ap_t ap1; mycell *a, *b; int i; int j; RC; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); 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_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&poolamc1, arena, mps_class_amc(), format, chain), "create pool(1)"); cdie( mps_ap_create(&ap1, poolamc1, mps_rank_exact()), "create ap"); for (j = 1; j < 100; j++) { comment("%i of 100.", j); for (i = 1; i < 10000; i++) { UC; a = allocone(ap1, 2, 1); b = allocone(ap1, 2, 1); setref(a, 0, b); setref(b, 0, a); UC; } DC; DMC; } mps_ap_destroy(ap1); mps_pool_destroy(poolamc1); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_arena_t arena; mps_pool_t pool; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_chain_t chain; int h; mycell *p, *q, *r; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); 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_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); cdie(mmqa_pool_create_chain(&pool, arena, mps_class_amc(), format, chain), "create pool"); cdie(mps_ap_create(&ap, pool, mps_rank_exact()), "create ap"); r = allocone(ap, 1000); for (h = 0; h < 10000; h++) { if (h % 10 == 0) { report("iter", "%i", h); } q = allocone(ap, 1000); p = allocone(ap, 1000); setref(p, 1, q); r = allocone(ap, 1000); setref(q, 50, r); setref(r, 1, p); } mps_ap_destroy(ap); mps_pool_destroy(pool); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
void freemem64(BOOL isglobal) { double *p1; int allocsz; if (nextsize == 0) { return; } /* We have to reduce stack size */ if (isglobal == TRUE) { gssize = nextsize; } else { ssize = nextsize; movegstack(); } /* Add 2 for internal stack */ allocsz = ssize + gssize + 2 + SKIPSIZE; p1 = (double*)REALLOC(ref, sizeof(double) * allocsz); if (p1 != NULL) { setref(p1, allocsz); } nextsize = 0; }
bool FUNCREF::execute(void) { VMREGTYPE pref= 0; bool result= (getMachine().pop(pref) && setref((VPREFERENCE)pref)); return result; }
bool FUNCREFPCTARGET::execute(void) { bool result= false; static VPVIEWMASTER viewmaster= 0; VPREFERENCE target= 0; result= ((viewmaster || getMachine().ReadMem((VPVOID)reltolinear(MASTER2_IMAGE),&viewmaster,sizeof(viewmaster))) && getMachine().ReadMem((VPVOID)&viewmaster->target,&target,sizeof(target)) && setref(target)); return result; }
FileBase* FileTable::create_as(const id_type& id, int type) { if (is_readonly()) throw OSException(EROFS); if (m_opened.find(id) != m_opened.end() || m_closed.find(id) != m_closed.end()) throw OSException(EEXIST); std::shared_ptr<FileStream> data_fd, meta_fd; std::tie(data_fd, meta_fd) = m_fio->create(id); auto fb = btree_make_file_from_type( type, data_fd, meta_fd, m_master_key, id, is_auth_enabled(), m_block_size, m_iv_size); m_opened.emplace(id, fb); fb->setref(1); return fb.get(); }
FileBase* FileTable::open_as(const id_type& id, int type) { auto it = m_opened.find(id); if (it != m_opened.end()) { if (it->second->type() != type) throw OSException(FileBase::error_number_for_not(type)); it->second->incref(); return it->second.get(); } it = m_closed.find(id); if (it != m_closed.end()) { if (it->second->type() != type) { m_closed.erase(it); } else { auto fb = it->second; m_opened.emplace(*it); m_closed.erase(it); fb->setref(1); return fb.get(); } } std::shared_ptr<FileStream> data_fd, meta_fd; std::tie(data_fd, meta_fd) = m_fio->open(id); auto fb = btree_make_file_from_type( type, data_fd, meta_fd, m_master_key, id, is_auth_enabled(), m_block_size, m_iv_size); m_opened.emplace(id, fb); fb->setref(1); return fb.get(); }
static void test(void) { mps_arena_t arena; mps_pool_t poolamc; mps_thr_t thread; mps_root_t root, root2, root3, root4, root5, root6, root7, root1; mps_fmt_t format; mps_chain_t chain; mps_ap_t apamc; typedef mycell * myroot; myroot a, b, c, d, e, f, g; int i; int j; RC; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); die(mps_thread_reg(&thread, arena), "register thread"); cdie( mps_root_create_table(&root1, arena, mps_rank_exact(), 0, (mps_addr_t*)&a, 1), "root"); cdie( mps_root_create_table(&root2, arena, mps_rank_exact(), 0, (mps_addr_t*)&b, 1), "root"); cdie( mps_root_create_table(&root3, arena, mps_rank_exact(), 0, (mps_addr_t*)&c, 1), "root"); cdie( mps_root_create_table(&root4, arena, mps_rank_exact(), 0, (mps_addr_t*)&d, 1), "root"); cdie( mps_root_create_table(&root5, arena, mps_rank_exact(), 0, (mps_addr_t*)&e, 1), "root"); cdie( mps_root_create_table(&root6, arena, mps_rank_exact(), 0, (mps_addr_t*)&f, 1), "root"); cdie( mps_root_create_table(&root7, arena, mps_rank_exact(), 0, (mps_addr_t*)&g, 1), "root"); cdie( mps_root_create_table(&root, arena, mps_rank_exact(), 0, &exfmt_root, 1), "create exfmt root"); die(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); 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"); comment("parking..."); mps_arena_park(arena); b = allocone(apamc, 1, 1); for (j=1; j<10; j++) { comment("%i of 10.", j); a = allocone(apamc, 5, 1); cutoff_id = getid(a); b = a; c = a; d = a; e = a; f = a; g = a; for (i=1; i<1000; i++) { c = allocone(apamc, 1000, 1); if (ranint(8) == 0) d = c; if (ranint(8) == 0) e = c; if (ranint(8) == 0) f = c; if (ranint(8) == 0) g = c; setref(c, 0, b); setref(c, 1, d); setref(c, 2, e); setref(c, 3, f); setref(c, 4, g); b = c; } for (i=1; i<1000; i++) { c = allocone(apamc, 1000, 1); if (ranint(8) == 0) d = c; if (ranint(8) == 0) e = c; if (ranint(8) == 0) f = c; if (ranint(8) == 0) g = c; setref(c, 0, b); setref(c, 1, d); setref(c, 2, e); setref(c, 3, f); setref(c, 4, g); b = c; } a = c; b = c; d = c; e = c; f = c; g = c; exfmt_root = c; mps_arena_collect(arena); comment(" reserved: %lu", (unsigned long) mps_arena_reserved(arena)); comment("committed: %lu", (unsigned long) mps_arena_committed(arena)); comment("calling amc_apply:"); checkfrom(c); appcount = 0; apppadcount = 0; junk_size = 0; mps_amc_apply(poolamc, &test_apply, NULL, MAGICSIZE); comment("finished amc_apply"); report("junksize", "%lu", (unsigned long) junk_size); report("appcount", "%ld", appcount); report("apppadcount", "%ld", apppadcount); RC; } mps_arena_release(arena); comment("released."); mps_arena_park(arena); mps_ap_destroy(apamc); mps_pool_destroy(poolamc); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_root_destroy(root1); mps_root_destroy(root2); mps_root_destroy(root3); mps_root_destroy(root4); mps_root_destroy(root5); mps_root_destroy(root6); mps_root_destroy(root7); comment("Destroyed roots."); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_arena_t arena; mps_pool_t poolamc, poolawl; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_chain_t chain; mps_ap_t apamc, apawl; mycell *a, *b, *c; int i; alloccomments = 1; fixcomments = 1; deathcomments = 1; formatcomments = 1; fixcomments = 1; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); 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_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated), "create pool"); cdie( mps_ap_create(&apawl, poolawl, mps_rank_exact()), "create ap"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap"); a = allocone(apawl, 1, 1); b = allocone(apawl, 1, 1); c = allocone(apawl, 1000, 1); setref(b, 0, c); setref(c, 0, b); for(i=0; i<1000; i++) { b = allocdumb(apamc, 0x400*1024, 0); if (i % 50 == 0) comment("%d of 1000.", i); } mps_ap_destroy(apawl); mps_ap_destroy(apamc); comment("Destroyed aps."); mps_pool_destroy(poolamc); mps_pool_destroy(poolawl); comment("Destroyed pools."); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_arena_t arena; mps_pool_t poolamc, poolawl; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_chain_t chain; mps_ap_t apamc, apawl, apweak; mycell *a, *b; RC; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); 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_fmt_create_A(&format, arena, &fmtA), "create format"); die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain), "create pool(amc)"); cdie(mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated), "create pool(awl)"); cdie(mps_ap_create(&apweak, poolawl, mps_rank_weak()), "create ap(weak)"); cdie(mps_ap_create(&apawl, poolawl, mps_rank_exact()), "create ap(awl)"); cdie(mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap(amc)"); b = allocone(apamc, 1, mps_rank_exact()); a = allocone(apweak, 1, mps_rank_weak()); mps_ap_destroy(apawl); mps_ap_destroy(apamc); mps_ap_destroy(apweak); comment("Destroyed aps."); /* buffered segments aren't condemned! */ setref(a, 0, b); mps_arena_collect(arena); asserts(getref(a, 0) == b, "Reference changed or was splatted."); mps_pool_destroy(poolamc); mps_pool_destroy(poolawl); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { long int i; long int rsize; int inramp; mycell *r1, *r2, *s1, *s2; cdie(mps_arena_create(&arena1, mps_arena_class_vm(), (size_t) 1024*1024*ARENALIMIT), "create arena"); cdie(mps_arena_create(&arena2, mps_arena_class_vm(), (size_t) 1024*1024*ARENALIMIT), "create arena"); cdie(mps_thread_reg(&thread1, arena1), "register thread"); cdie(mps_thread_reg(&thread2, arena2), "register thread"); cdie( mps_root_create_reg(&root1, arena1, mps_rank_ambig(), 0, thread1, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie( mps_root_create_reg(&root2, arena2, mps_rank_ambig(), 0, thread2, mps_stack_scan_ambig, stackpointer, 0), "create root"); cdie( mps_root_create_table(&root1a, arena1, mps_rank_exact(), 0, &objtab1[0], TABSIZE), "create root table"); cdie( mps_root_create_table(&root2a, arena2, mps_rank_exact(), 0, &objtab2[0], TABSIZE), "create root table"); cdie( mps_fmt_create_A(&format1, arena1, &fmtA), "create format"); cdie( mps_fmt_create_A(&format2, arena2, &fmtA), "create format"); cdie( mps_pool_create(&poolamc1, arena1, mps_class_amc(), format1), "create pool"); cdie( mps_pool_create(&poolamc2, arena2, mps_class_amc(), format2), "create pool"); cdie( mps_ap_create(&apamc1, poolamc1, mps_rank_exact()), "create ap"); cdie( mps_ap_create(&apamc2, poolamc2, mps_rank_exact()), "create ap"); inramp = 0; for (i = 0; i < ITERATIONS; i++) { if (i % 10000 == 0) { comment("%ld of %ld", i, ITERATIONS); } alloc_back(); if (inramp) { s1 = allocone(apamc1, 3, mps_rank_exact()); s2 = allocone(apamc2, 3, mps_rank_exact()); setref(r1, 0, s1); setref(r2, 0, s2); setref(s1, 1, r1); setref(s2, 1, r2); r1 = s1; r2 = s2; s1 = allocdumb(apamc1, RAMPSIZE, mps_rank_exact()); s2 = allocdumb(apamc2, RAMPSIZE, mps_rank_exact()); setref(r1, 2, s1); setref(r2, 2, s2); rsize ++; if (ranint(LEAVERAMP) == 0) { r1 = allocone(apamc1, 2, mps_rank_exact()); r2 = allocone(apamc2, 2, mps_rank_exact()); s1 = allocone(apamc1, 2, mps_rank_exact()); s2 = allocone(apamc2, 2, mps_rank_exact()); #ifdef RAMP_INTERFACE mps_ap_alloc_pattern_end(apamc1, mps_alloc_pattern_ramp()); mps_ap_alloc_pattern_end(apamc2, mps_alloc_pattern_ramp()); #endif #ifdef COLLECT_WORLD mps_arena_collect(arena1); mps_arena_collect(arena2); mps_arena_release(arena1); mps_arena_release(arena2); #endif comment("ramp end, %ld objects", rsize); inramp = 0; } } else { if (ranint(ENTERRAMP) == 0) { #ifdef RAMP_INTERFACE mps_ap_alloc_pattern_begin(apamc1, mps_alloc_pattern_ramp()); mps_ap_alloc_pattern_begin(apamc2, mps_alloc_pattern_ramp()); #endif comment("ramp begin"); r1 = allocone(apamc1, 3, mps_rank_exact()); r2 = allocone(apamc2, 3, mps_rank_exact()); inramp = 1; rsize = 0; } } } mps_ap_destroy(apamc1); mps_ap_destroy(apamc2); comment("Destroyed ap."); mps_pool_destroy(poolamc1); mps_pool_destroy(poolamc2); comment("Destroyed pool."); mps_fmt_destroy(format1); mps_fmt_destroy(format2); comment("Destroyed format."); mps_root_destroy(root1); mps_root_destroy(root1a); mps_root_destroy(root2); mps_root_destroy(root2a); comment("Destroyed roots."); mps_thread_dereg(thread1); mps_thread_dereg(thread2); comment("Deregistered thread."); mps_arena_destroy(arena1); mps_arena_destroy(arena2); comment("Destroyed arena."); }
static void test(void) { mps_arena_t arena; mps_pool_t pool; mps_thr_t thread; mps_root_t root, root1; mps_fmt_t format; mps_chain_t chain; mps_ap_t ap; mycell *a[3]; int i,j,k; clock_t time0, time1; formatcomments = 1; 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(&root, arena, mps_rank_ambig(), 0, (mps_addr_t*)&a[0], 3), "create table root"); cdie(mps_root_create_table(&root1, arena, mps_rank_ambig(), 0, (mps_addr_t *)&exfmt_root, 1), "exfmt root"); cdie(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&pool, arena, mps_class_amc(), format, chain), "create pool"); cdie(mps_ap_create(&ap, pool, mps_rank_exact()), "create ap"); time0 = clock(); asserts(time0 != -1, "processor time not available"); for (k=0; k<100; k++) { for (j=0; j<100; j++) { a[0] = allocone(ap, 50, mps_rank_exact()); a[1] = a[0]; for (i=1; i<100; i++) { a[2] = allocone(ap, 50, mps_rank_exact()); setref(a[1], 0, a[2]); a[1] = a[2]; } } time1 = clock(); comment("%d: %i", k, (int) (100*(time1-time0)/CLOCKS_PER_SEC)); time0 = time1; } mps_ap_destroy(ap); mps_pool_destroy(pool); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_root_destroy(root1); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void *stack_pointer) { long int i; long int rsize = 0; int inramp; mycell *r = NULL, *s; cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) 1024*1024*ARENALIMIT), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); cdie(mps_root_create_thread(&root, arena, thread, stack_pointer), "thread root"); cdie( mps_root_create_table(&root1, arena, mps_rank_exact(), 0, &objtab[0], TABSIZE), "create root table"); cdie( mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); cdie( mps_pool_create(&poolamc, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap"); inramp = 0; for (i = 0; i < ITERATIONS; i++) { if (i * 10 % ITERATIONS == 0) { comment("%ld of %ld", i, ITERATIONS); } alloc_back(); if (inramp) { s = allocone(apamc, 3, mps_rank_exact()); setref(r, 0, s); setref(s, 1, r); r = s; s = allocdumb(apamc, RAMPSIZE, mps_rank_exact()); setref(r, 2, s); rsize ++; if (ranint(LEAVERAMP) == 0) { r = allocone(apamc, 2, mps_rank_exact()); s = allocone(apamc, 2, mps_rank_exact()); #ifdef RAMP_INTERFACE mps_ap_alloc_pattern_end(apamc, mps_alloc_pattern_ramp()); #endif #ifdef COLLECT_WORLD mps_arena_collect(arena); mps_arena_release(arena); #endif comment("ramp end, %ld objects", rsize); inramp = 0; } } else { if (ranint(ENTERRAMP) == 0) { #ifdef RAMP_INTERFACE mps_ap_alloc_pattern_begin(apamc, mps_alloc_pattern_ramp()); #endif comment("ramp begin"); r = allocone(apamc, 3, mps_rank_exact()); inramp = 1; rsize = 0; } } } mps_arena_park(arena); mps_ap_destroy(apamc); comment("Destroyed ap."); mps_pool_destroy(poolamc); comment("Destroyed pool."); mps_fmt_destroy(format); comment("Destroyed format."); mps_chain_destroy(chain); comment("Destroyed chain."); mps_root_destroy(root1); mps_root_destroy(root); comment("Destroyed roots."); mps_thread_dereg(thread); comment("Deregistered thread."); mps_arena_destroy(arena); comment("Destroyed arena."); }
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; mycell *cells; int h,i,j,k,l; mycell *p[NAPS]; mycell *pobj; size_t bytes; size_t alignment; mps_addr_t q; int nextid = 0x1000000; /* turn on comments about copying and scanning */ formatcomments = BLAH; fixcomments = BLAH; 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"); for (i=0; i<NAPS; i++) { die(mps_ap_create(&ap[i], pool, mps_rank_exact()), "create ap"); ap_state[i] = 0; } cells = allocone(ap[0], NCELLS); /* ap_state can have the following values: 0 before reserve 1 after reverse 2 after init 3 after I=A 0 after commit */ for(h=0; h<100; h++) { comment("%i of 100", h); comment("%i collections", (int) mps_collections(arena)); for(j=0; j<1000; j++) { i = ranint(NAPS); switch (ap_state[i]) { case 0: nrefs[i] = NUMREFS; bytes = offsetof(struct data, ref)+nrefs[i]*sizeof(struct refitem); alignment = MPS_PF_ALIGN; bytes = (bytes+alignment-1)&~(alignment-1); s[i] = bytes; die(mps_reserve(&q, ap[i], s[i]), "reserve: "); p[i] = q; p[i]->data.tag = 0xD033E2A6; p[i]->data.id = nextid; ap_state[i] = 1; commentif(BLAH, "%i: reserve %li at %p", i, nextid, q); nextid +=1; break; case 1: commentif(BLAH, "%i: init %li", i, p[i]->data.id); p[i]->data.tag = MCdata; p[i]->data.numrefs = nrefs[i]; p[i]->data.size = s[i]; ap_state[i] = 2; for (k=0; k<nrefs[i]; k++) { if PNULL { p[i]->data.ref[k].addr = NULL; p[i]->data.ref[k].id = 0; } else { l = ranint(NCELLS); pobj = getref(cells, l); p[i]->data.ref[k].addr = pobj; p[i]->data.ref[k].id = (pobj==NULL ? 0 : pobj->data.id); } commentif(BLAH, " ref %i -> %li", k, p[i]->data.ref[k].id); } break; case 2: commentif(BLAH, "%i: begin commit %li", i, p[i]->data.id); ap[i]->init = ap[i]->alloc; ap_state[i] = 3; break; case 3: case 4: case 5: case 6: case 7: case 8: case 9: ap_state[i]+=1; break; case 10: commentif(BLAH, "%i: end commit %li", i, p[i]->data.id); q=p[i]; if (ap[i]->limit != 0 || mps_ap_trip(ap[i], p[i], s[i])) { l = ranint(NCELLS); setref(cells, l, q); commentif(BLAH, "%i -> %i", i, l); } ap_state[i] = 0; break; } } checkfrom(cells); }
static void test(void) { long int i; long int rsize; mps_message_t message; int inramp; mycell *r, *s; cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) 1024*1024*ARENALIMIT), "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_root_create_table(&root1, arena, mps_rank_exact(), 0, &objtab[0], TABSIZE), "create root table"); cdie( mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); cdie( mps_pool_create(&poolamc, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap"); mps_message_type_enable(arena, mps_message_type_collection_stats()); inramp = 0; for (i = 0; i < ITERATIONS; i++) { if (i % 10000 == 0) { comment("%ld of %ld", i, ITERATIONS); } alloc_back(); if (inramp) { s = allocone(apamc, 3, mps_rank_exact()); setref(r, 0, s); setref(s, 1, r); r = s; s = allocdumb(apamc, RAMPSIZE, mps_rank_exact()); setref(r, 2, s); rsize ++; if (ranint(LEAVERAMP) == 0) { r = allocone(apamc, 2, mps_rank_exact()); s = allocone(apamc, 2, mps_rank_exact()); #ifdef RAMP_INTERFACE mps_ap_alloc_pattern_end(apamc, mps_alloc_pattern_ramp_collect_all()); #endif #ifdef COLLECT_WORLD mps_arena_collect(arena); mps_arena_release(arena); #endif comment("ramp end, %ld objects", rsize); inramp = 0; } } else { if (ranint(ENTERRAMP) == 0) { #ifdef RAMP_INTERFACE mps_ap_alloc_pattern_begin(apamc, mps_alloc_pattern_ramp_collect_all()); #endif comment("ramp begin"); r = allocone(apamc, 3, mps_rank_exact()); inramp = 1; rsize = 0; } } if(mps_message_get(&message, arena, mps_message_type_collection_stats())) { unsigned long live, condemned, notCondemned; live = mps_message_collection_stats_live_size(arena, message); condemned = mps_message_collection_stats_condemned_size(arena, message); notCondemned = mps_message_collection_stats_not_condemned_size(arena, message); comment("Collection: live=%ld, condemned=%ld, not condemned = %ld", live, condemned, notCondemned); mps_message_discard(arena, message); } } mps_ap_destroy(apamc); comment("Destroyed ap."); mps_pool_destroy(poolamc); comment("Destroyed pool."); mps_fmt_destroy(format); comment("Destroyed format."); mps_chain_destroy(chain); comment("Destroyed chain."); mps_root_destroy(root1); mps_root_destroy(root); comment("Destroyed roots."); mps_thread_dereg(thread); comment("Deregistered thread."); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { int i; mps_ap_t ap, sap; mps_arena_t arena; mps_fmt_t format; mps_chain_t chain; mps_pool_t pool, spool; mps_thr_t thread; mps_frame_t frame1; mycell *p, *q; size_t com, com1, com2; formatcomments=1; alloccomments=1; fixcomments=1; /* create an arena (no particular size limit) */ cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t)ARENA_SIZE), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); /* because we know objects in the stack pool don't move, */ /* we can do without roots. Hooray! */ cdie(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&pool, arena, mps_class_amc(), format, chain), "create pool(amc)"); cdie(mps_ap_create(&ap, pool, mps_rank_exact()), "create ap(amc)"); cdie(mps_pool_create(&spool, arena, mps_class_snc(), format), "create SNC pool"); cdie(mps_ap_create(&sap, spool, mps_rank_exact()), "create ap"); /* push, alloc, check object is scanned */ com = arena_committed_and_used(arena); report("com", "%ld", com); cdie(mps_ap_frame_push(&frame1, sap), "push"); p = allocone(sap, 2, mps_rank_exact()); q = allocdumb(ap, BIGSIZE, mps_rank_exact()); setref(p, 0, q); q = allocdumb(ap, SMALLSIZE, mps_rank_exact()); report("com", "%ld", arena_committed_and_used(arena)); comment("collect..."); mps_arena_collect(arena); com1 = arena_committed_and_used(arena); mps_arena_release(arena); report("com", "%ld", com1); report("inc1", "%d", (com1-com)/BIGSIZE); /* pop, check object isn't scanned */ cdie(mps_ap_frame_pop(sap, frame1), "pop"); comment("collect..."); mps_arena_collect(arena); com1 = arena_committed_and_used(arena); mps_arena_release(arena); report("com", "%ld", com1); report("inc2", "%ld", (com1-com)/BIGSIZE); /* check initial frame is scanned */ p = allocone(sap, 2, mps_rank_exact()); q = allocdumb(ap, BIGSIZE, mps_rank_exact()); setref(p, 1, q); q = allocdumb(ap, SMALLSIZE, mps_rank_exact()); mps_arena_collect(arena); com2 = arena_committed_and_used(arena); mps_arena_release(arena); report("inc3", "%ld", (com2-com1)/BIGSIZE); /* even in ordinary collection */ for (i=0; i < 500; i++) { q = allocdumb(ap, BIGSIZE, mps_rank_exact()); } q = allocdumb(ap, SMALLSIZE, mps_rank_exact()); mps_arena_collect(arena); com2 = arena_committed_and_used(arena); mps_arena_release(arena); report("inc4", "%ld", (com2-com1)/BIGSIZE); mps_ap_destroy(ap); mps_ap_destroy(sap); mps_pool_destroy(pool); mps_pool_destroy(spool); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_arena_t arena; mps_pool_t poolamc, poolawl; mps_thr_t thread; mps_root_t root, root1; mps_fmt_t format; mps_chain_t chain; mps_ap_t apamc, apawl; size_t size0, size1; mycell *a, *b, *c, *d, *e, *f, *g; int i; int j; RC; deathcomments = 0; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); 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"); cdie( mps_root_create_table(&root1, arena, mps_rank_ambig(), 0, &exfmt_root, 1), "create exfmt root"); die(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated), "create pool"); cdie( mps_ap_create(&apawl, poolawl, mps_rank_weak()), "create ap"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap"); b = allocone(apamc, 1, 1); for (j=1; j<10; j++) { comment("%i of 10.", j); a = allocone(apawl, 5, 1); setref(b, 0, a); b = a; c = a; d = a; e = a; f = a; g = a; for (i=1; i<1000; i++) { if (i%100 == 0) { comment(" %i", i); } if (ranint(2)) { c = allocone(apamc, 1000, 1); } else { c = allocone(apawl, 1000, 1); } if (ranint(8) == 0) d = c; if (ranint(8) == 0) e = c; if (ranint(8) == 0) f = c; if (ranint(8) == 0) g = c; setref(b, 0, c); setref(c, 1, d); setref(c, 2, e); setref(c, 3, f); setref(c, 4, g); b = c; } if (j==3) { DC; comment("...collecting:"); RC; size0 = arena_committed_and_used(arena); mps_arena_collect(arena); size1 = arena_committed_and_used(arena); report("sizebefore0", "%lu", (unsigned long) size0); report("sizeafter0", "%lu", (unsigned long) size1); report("diff0", "%lu", (unsigned long) size0-size1); DC; mps_arena_release(arena); comment("...released"); } DC; comment("clamping..."); mps_arena_park(arena); RC; for (i=1; i<1000; i++) { if (i%100 == 0) { comment(" %i", i); } if (ranint(2)) { c = allocone(apamc, 1000, 1); } else { c = allocone(apawl, 1000, 1); } if (ranint(8) == 0) d = c; if (ranint(8) == 0) e = c; if (ranint(8) == 0) f = c; if (ranint(8) == 0) g = c; setref(b, 0, c); setref(c, 1, d); setref(c, 2, e); setref(c, 3, f); setref(c, 4, g); b = c; } asserts(counters[COPY_COUNT]==0, "Eppur si muove!"); DC; if (j==9) { comment("collecting..."); size0 = arena_committed_and_used(arena); mps_arena_collect(arena); size1 = arena_committed_and_used(arena); report("sizebefore1", "%lu", (unsigned long) size0); report("sizeafter1", "%lu", (unsigned long) size1); report("diff1", "%lu", (unsigned long) size0-size1); DC; } mps_arena_release(arena); comment("released."); RC; } mps_ap_destroy(apawl); mps_ap_destroy(apamc); mps_pool_destroy(poolamc); mps_pool_destroy(poolawl); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_root_destroy(root1); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_arena_t arena; mps_pool_t pool; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_ap_t ap; mycell *a, *b, *c, *d, *e, *f, *g; int i; int j; RC; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); 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"); cdie(mps_fmt_create_A(&format, arena, &fmtA), "create format"); die(mps_pool_create(&pool, arena, mps_class_awl(), format), "create pool"); cdie(mps_ap_create(&ap, pool, MPS_RANK_EXACT), "create ap"); for (j = 1; j < 100; j++) { comment("%i of 100.", j); UC; a = allocone(ap, 5, 1); b = a; c = a; d = a; e = a; f = a; g = a; for (i = 1; i < 100; i++) { UC; c = allocone(ap, 1000, 1); if (ranint(8) == 0) d = c; if (ranint(8) == 0) e = c; if (ranint(8) == 0) f = c; if (ranint(8) == 0) g = c; UC; setref(b, 0, c); UC; setref(c, 1, d); UC; setref(c, 2, e); UC; setref(c, 3, f); UC; setref(c, 4, g); UC; b = c; } } DC; DMC; checkfrom(a); mps_ap_destroy(ap); mps_pool_destroy(pool); mps_fmt_destroy(format); mps_root_destroy(root); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_arena_t arena; mps_pool_t poolamc, poollo; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_chain_t chain; mps_ap_t apamc, aplo; mycell *a[100]; int i; int j; int k,z; alloccomments = 1; formatcomments = 1; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); 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_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain), "create pool(amc)"); die(mps_pool_create(&poollo, arena, mps_class_lo(), format), "create pool(lo)"); cdie( mps_ap_create(&aplo, poollo, mps_rank_exact()), "create ap"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap"); for(i=0; i<100; i++) { a[i] = allocone(aplo, 6, 1); } for(i=0; i<10000; i++) { j = ranint(100); comment("New object %i", j); a[j] = allocone(aplo, 5+ranint(50), 1); k = ranint(50); z = ranint(5); comment("setting %i (%p) %i", k, a[k], z); setref(a[k], z, a[j]); (void)allocdumb(apamc, 0x400*64, 0); } mps_arena_park(arena); mps_ap_destroy(aplo); mps_ap_destroy(apamc); comment("Destroyed aps."); mps_pool_destroy(poolamc); mps_pool_destroy(poollo); comment("Destroyed pools."); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_pool_t pool; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_chain_t chain; mps_ap_t ap, ap2; mycell *a, *b; mps_res_t res; int i; /* create an arena that can't grow beyond 30 M */ cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*40)), "create arena"); mps_arena_commit_limit_set(arena, (size_t) (1024*1024*30)); 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"); die(mmqa_pool_create_chain(&pool, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_ap_create(&ap, pool, mps_rank_exact()), "create ap"); /* allocate until full */ i = 0; b = NULL; while (allocrone(&a, ap, 128, mps_rank_exact()) == MPS_RES_OK) { i++; setref(a, 0, b); b = a; } comment("%d objs allocated.", i); report("committed", "%ld", mps_arena_committed(arena)); /* try to allocate 10 times */ cdie(mps_ap_create(&ap2, pool, mps_rank_exact()), "create second ap"); mps_ap_destroy(ap); for (i = 0; i < 10; i++) { res = allocrone(&a, ap2, 128, mps_rank_exact()); report("predie", "%s", err_text(res)); } /* now let everything die, and try to allocate 10 times */ mps_root_destroy(root); for (i = 0; i < 10; i++) { res = allocrone(&a, ap2, 128, mps_rank_exact()); report("postdie", "%s", err_text(res)); } mps_ap_destroy(ap2); mps_pool_destroy(pool); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { int i = 0, f = 0; mps_ap_t sap; mps_arena_t arena; mps_fmt_t format; mps_pool_t spool; mps_thr_t thread; mps_frame_t frames[MAXFRAMES]; int nobj[MAXFRAMES+1]; 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 and pop stack frames, and allocate objects in them at random. Parameters ensure that max allocation can't get too high. */ for (i=0; i < ITERATIONS; i++) { switch (ranint(12)) { case 1: case 2: case 3: case 4: case 5: if (f < MAXFRAMES) { die(mps_ap_frame_push(&frames[f], sap), "push"); comment("push %i", f); f++; nobj[f] = 0; } break; case 6: case 7: case 8: case 9: case 10: if (nobj[f] < MAXLEVOBJS) { p = allocone(sap, 16, mps_rank_exact()); setref(p, 0, NULL); nobj[f]++; } break; case 11: if (f>0) { f -= 1+ranint(1+ranint(f)); /* new f is in [0, old f) */ die(mps_ap_frame_pop(sap, frames[f]), "pop"); comment("pop %i", f); } break; } } mps_arena_park(arena); 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 *stack_pointer) { mps_arena_t arena; mps_pool_t pool; mps_thr_t thread; mps_root_t root, root1; mps_fmt_t format; mps_chain_t chain; mps_ap_t ap; mycell *a, *b; int j; /* create an arena that can't grow beyond 1 Mb */ cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*1)), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); cdie(mps_root_create_thread(&root, arena, thread, stack_pointer), "thread root"); cdie(mps_root_create_table(&root1, arena, mps_rank_ambig(), 0, (mps_addr_t*)&exfmt_root, 1), "create table root"); cdie(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&pool, arena, mps_class_amc(), format, chain), "create pool"); cdie(mps_ap_create(&ap, pool, mps_rank_exact()), "create ap"); comment("ready"); b = allocone(ap, 2, mps_rank_exact()); /* allocate lots of little objects */ for (;;) { comment("reserved %ld, committed %ld", mps_arena_reserved(arena), mps_arena_committed(arena)); if (mps_arena_committed(arena) > 1024ul*1024ul*10) { break; } for (j=0; j<10000; j++) { a = allocone(ap, 2, mps_rank_exact()); setref(a, 0, b); b = a; a = allocone(ap, 1, mps_rank_exact()); setref(b, 1, a); } mps_arena_collect(arena); mps_arena_release(arena); } mps_arena_park(arena); mps_ap_destroy(ap); mps_pool_destroy(pool); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_root_destroy(root1); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_arena_t arena; mps_pool_t poolamc, poolawl; mps_thr_t thread; mps_root_t root, root1, root2; mps_fmt_t format; mps_chain_t chain; mps_ap_t apamc, apawl; mycell *a[3]; int j; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); die(mps_thread_reg(&thread, arena), "register thread"); die(mps_root_create_table(&root, arena, mps_rank_exact(), 0, (mps_addr_t*)&a[0], 2), "create table root"); cdie( mps_root_create_table(&root2, arena, mps_rank_ambig(), 0, (mps_addr_t*)&a[2], 1), "ambig table root"); cdie( mps_root_create_table(&root1, arena, mps_rank_ambig(), 0, &exfmt_root, 1), "create exfmt root"); die(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated), "create pool"); cdie( mps_ap_create(&apawl, poolawl, mps_rank_exact()), "create ap"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap"); a[1] = allocone(apawl, 2, 1); a[0] = allocone(apawl, 2, 1); a[2] = allocone(apamc, 2, 1); setref(a[0], 0, a[2]); mps_ap_destroy(apawl); comment("Destroyed awl ap"); for(j=0; j<100; j++) { allocdumb(apamc, 1024*256, 1); } mps_ap_destroy(apamc); comment("Destroyed amc ap."); mps_root_destroy(root1); mps_root_destroy(root2); comment("Destroyed ambiguous roots."); a[1] = a[0]; comment("Now to try arena_collect:"); mps_arena_collect(arena); mps_pool_destroy(poolamc); mps_pool_destroy(poolawl); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
static void test(void) { mps_arena_t arena; mps_pool_t poolamc, poolawl; mps_thr_t thread; mps_root_t root, root1; mps_chain_t chain; mps_fmt_t format; mps_ap_t apamc, apawl; mycell *a, *b, *c, *d, *e, *f, *g; int i; int j; 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_root_create_table(&root1,arena,mps_rank_ambig(),0,&exfmt_root,1), "create table 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(&poolamc, arena, mps_class_awl(), format, chain), "create pool"); cdie( mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated), "create pool"); cdie( mps_ap_create(&apawl, poolawl, mps_rank_exact()), "create ap"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap"); b = allocone(apamc, 1, mps_rank_exact()); for (j=1; j<=ITERATIONS; j++) { comment("%i of %i.", j, ITERATIONS); a = allocone(apamc, 5, mps_rank_exact()); b = a; c = a; d = a; e = a; f = a; g = a; for (i=1; i<=1000; i++) { c = allocone(apamc, 20, mps_rank_exact()); d = allocone(apawl, 20, mps_rank_exact()); if (ranint(8) == 0) e = c; if (ranint(8) == 0) f = c; if (ranint(8) == 0) g = c; setref(b, 0, c); setref(c, 1, d); setref(c, 2, e); setref(c, 3, f); setref(c, 4, g); b = c; } } mps_arena_park(arena); mps_ap_destroy(apawl); mps_ap_destroy(apamc); comment("Destroyed aps."); 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(root); 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 pool; mps_thr_t thread; mps_root_t root, root1; mps_fmt_t format; mps_chain_t chain; mps_ap_t ap; mycell *a, *b; mps_addr_t base, *addr; mps_res_t res; int j; /* create an arena that can't grow beyond 30 M */ cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*30)), "create arena"); die(mps_arena_commit_limit_set(arena, (size_t) (1024*1024*30)), "limit"); 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"); base = &exfmt_root; addr = base; cdie( mps_root_create_table(&root1,arena,mps_rank_ambig(),0,addr,1), "create table root"); cdie(mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&pool, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_ap_create(&ap, pool, mps_rank_exact()), "create ap"); /* allocate 16 M of (live) stuff */ b = allocone(ap, 2, mps_rank_exact()); for (j=0; j<160; j++) { a = allocone(ap, 2, mps_rank_exact()); setref(a, 0, b); b = allocdumb(ap, 1024*100, mps_rank_exact()); setref(a, 1, b); b = a; } comment("created 16M of live objects"); fillup(); comment("try to make collect by allocating another 1G..."); empty(); for (j=0; j<1000*1024; j++) { res=allocrdumb(&a, ap, 1024, mps_rank_exact()); if (res == MPS_RES_OK) { comment("%i ok", j); } else { break; } } comment("collect world..."); for (j=0; j<10; j++) { mps_arena_collect(arena); } mps_arena_park(arena); mps_ap_destroy(ap); mps_pool_destroy(pool); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_root_destroy(root1); mps_thread_dereg(thread); mps_arena_destroy(arena); comment("Destroyed arena."); }
int scimem64(int *ptr, int newsize, BOOL isglobal) { double *p1; int othersize, oldsize, allocsz; if (newsize++ < 0) /* Add 1 for alignment problems */ { return 0; } if (isglobal == TRUE) { othersize = ssize; oldsize = gssize; } else { othersize = gssize; oldsize = ssize; } /* The real work for reducing stack size is done after the relocation, * when freemem/freegmem is called. Right now, just return */ if (newsize < oldsize) { nextsize = newsize; if (isglobal == TRUE) { *ptr = ssize + 2 + SKIPSIZE; } else { *ptr = 2 + SKIPSIZE; } return 0; } /* Add 2 for internal stack */ allocsz = newsize + othersize + 2 + SKIPSIZE; p1 = (double*)REALLOC(ref, sizeof(double) * allocsz); if (p1 != NULL) { setref(p1, allocsz); if (isglobal == TRUE) { *ptr = ssize + 2 + SKIPSIZE; gssize = newsize; } else { *ptr = 2 + SKIPSIZE; ssize = newsize; movegstack(); } } else { if (ref == NULL) { sciprint(_("No space to allocate Scilab stack.\n")); exit(EXIT_FAILURE); } *ptr = 0; } return 0; }
static void test(void) { mps_arena_t arena; mps_pool_t poolamc; mps_thr_t thread; mps_root_t root; mps_fmt_t format; mps_chain_t chain; mps_ap_t apamc, apawl; mycell *a, *b, *c, *d, *e, *f, *g; int i; int j; RC; cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena"); 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_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain), "create pool(amc)"); cdie( mps_ap_create(&apawl, poolamc, mps_rank_exact()), "create ap"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap(amc)"); b = allocone(apamc, 1, 1); for (j = 1; j < 100; j++) { comment("%i of 100.", j); UC; a = allocone(apamc, 5, 1); b = a; c = a; d = a; e = a; f = a; g = a; for (i = 1; i < 5000; i++) { UC; c = allocone(apamc, 20, 1); d = allocone(apawl, 20, 1); if (ranint(8) == 0) e = c; if (ranint(8) == 0) f = c; if (ranint(8) == 0) g = c; UC; setref(b, 0, c); UC; setref(c, 1, d); UC; setref(c, 2, e); UC; setref(c, 3, f); UC; setref(c, 4, g); UC; b = c; } DC; DMC; } mps_ap_destroy(apawl); mps_ap_destroy(apamc); mps_pool_destroy(poolamc); mps_chain_destroy(chain); mps_fmt_destroy(format); mps_root_destroy(root); mps_thread_dereg(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 test(void) { mycell *p, *q; int i; mps_res_t res; size_t lim0, avail0, lim1, avail1, commit1, lim2, avail2, commit2; size_t lim3, avail3, commit3, lim4, avail4, commit4; size_t lim5, avail5, commit5, lim6, avail6, commit6; cdie(mps_arena_create(&arena, mps_arena_class_vm(), ARENA_SIZE), "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 stack root"); cdie( mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie( mps_pool_create(&poolsnc, arena, mps_class_snc(), format), "create pool"); cdie( mps_ap_create(&apsnc, poolsnc, mps_rank_exact()), "create ap"); report("lim0", "%d", lim0 = mps_reservoir_limit(arena)); report("avail0", "%d", avail0 = mps_reservoir_available(arena)); mps_reservoir_limit_set(arena, (size_t) 0); mps_reservoir_limit_set(arena, (size_t) (5ul*1024*1024)); report("lim1", "%d", lim1 = mps_reservoir_limit(arena)); report("avail1", "%d", avail1 = mps_reservoir_available(arena)); report("commit1", "%d", commit1 = arena_committed_and_used(arena)); report("defecit1", "%d", lim1-avail1); mps_reservoir_limit_set(arena, (size_t) (1045)); report("lim2", "%d", lim2 = mps_reservoir_limit(arena)); report("avail2", "%d", avail2 = mps_reservoir_available(arena)); report("commit2", "%d", commit2 = arena_committed_and_used(arena)); report("defecit2", "%d", lim2-avail2); /* set commit limit to whatever is currently committed plus 1 MB */ die(mps_arena_commit_limit_set(arena, arena_committed_and_used(arena)+1024*1024), "commit limit set"); mps_reservoir_limit_set(arena, (size_t) (10ul*1024*1024)); report("lim3", "%d", lim3 = mps_reservoir_limit(arena)); report("avail3", "%d", avail3 = mps_reservoir_available(arena)); report("commit3", "%d", commit3 = arena_committed_and_used(arena)); report("defecit3", "%d", lim3-avail3); report("spill3", "%d", commit3-mps_arena_commit_limit(arena)); /* now raise it by 1/2 MB -- reservoir should grow */ die(mps_arena_commit_limit_set(arena, arena_committed_and_used(arena)+512*1024), "commit limit set"); report("lim4", "%d", lim4 = mps_reservoir_limit(arena)); report("avail4", "%d", avail4 = mps_reservoir_available(arena)); report("commit4", "%d", commit4 = arena_committed_and_used(arena)); report("grow4", "%d", avail4-avail3); report("spill4", "%d", commit4-mps_arena_commit_limit(arena)); /* try some allocation -- more than a small amount should fail */ i = -1; p = NULL; res = MPS_RES_OK; while (res == MPS_RES_OK) { res = allocrone(&q, apsnc, 10, mps_rank_exact()); if (res == MPS_RES_OK) { setref(q, 0, p); p = q; } i++; } report("allocfail", "%d", i); report_res("failres", res); /* available shouldn't have changed since before allocation */ report("lim5", "%d", lim5 = mps_reservoir_limit(arena)); report("avail5", "%d", avail5 = mps_reservoir_available(arena)); report("commit5", "%d", commit5 = arena_committed_and_used(arena)); report("grow5", "%d", avail5-avail4); report("spill5", "%d", commit5-mps_arena_commit_limit(arena)); /* try some allocation from reservoir -- not much should fail */ i = -1; res = MPS_RES_OK; while (res == MPS_RES_OK) { res = reservoir_allocrone(&q, apsnc, 10, mps_rank_exact()); if (res == MPS_RES_OK) { setref(q, 0, p); p = q; } i++; } report("allocfail2", "%d", i); report_res("failres2", res); /* available should have changed now */ report("lim6", "%d", lim6 = mps_reservoir_limit(arena)); report("avail6", "%d", avail6 = mps_reservoir_available(arena)); report("commit6", "%d", commit6 = arena_committed_and_used(arena)); report("spill6", "%d", commit6-mps_arena_commit_limit(arena)); report("shrink6", "%d", avail5-avail6); mps_root_destroy(root); comment("Destroyed root."); mps_ap_destroy(apsnc); comment("Destroyed ap."); mps_pool_destroy(poolsnc); 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 *stack_pointer) { mps_arena_t arena; mps_pool_t poolamc, poolawl; mps_thr_t thread; mps_root_t root, rootb; mps_addr_t base; mps_addr_t *addr; mps_chain_t chain; mps_fmt_t format; mps_ap_t apamc, apawl; mps_word_t i, c; cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (60ul*1024*1024)), "create arena"); cdie(mps_thread_reg(&thread, arena), "register thread"); base = &b; addr = base; cdie(mps_root_create_table(&root, arena, mps_rank_ambig(), 0, addr, 1), "creat root"); base = &exfmt_root; addr = base; cdie(mps_root_create_table(&rootb, arena, mps_rank_ambig(), 0, addr, 1), "create root b"); cdie( mps_fmt_create_A(&format, arena, &fmtA), "create format"); cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); cdie( mps_pool_create(&poolamc, arena, mps_class_amc(), format, chain), "create pool"); cdie( mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated), "create pool"); cdie( mps_ap_create(&apawl, poolawl, mps_rank_weak()), "create ap"); cdie( mps_ap_create(&apamc, poolamc, mps_rank_exact()), "create ap"); formatcomments = 0; b = allocone(apamc, 1024, mps_rank_exact()); c = mps_collections(arena); for (i=1; i<100; i++) { comment("%i of 100.", i); while (mps_collections(arena) == c) { a = allocone(apamc, 1024, mps_rank_exact()); if (ranint(5)) { setref(a, 0, b); } b = a; } c = mps_collections(arena); a = allocone(apawl, 1, mps_rank_weak()); a->data.id = 0; setref(a, 0, b); } mps_arena_park(arena); mps_ap_destroy(apawl); mps_ap_destroy(apamc); comment("Destroyed aps."); 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(root); mps_root_destroy(rootb); comment("Destroyed roots."); mps_thread_dereg(thread); comment("Deregistered thread."); mps_arena_destroy(arena); comment("Destroyed arena."); }