From 17b682db453ddaeb0d4ab9ed5ecb91a236d65962 Mon Sep 17 00:00:00 2001 From: Richard Tucker Date: Tue, 2 Jun 1998 16:30:32 +0100 Subject: [PATCH] New unit new test Copied from Perforce Change: 19572 ServerID: perforce.ravenbrook.com --- mps/qa/function/83.c | 137 +++++++++++++++++++++++++++++++++++ mps/qa/function/87.c | 166 +++++++++++++++++++++++++++++++++++++++++++ mps/qa/function/88.c | 84 ++++++++++++++++++++++ mps/qa/function/89.c | 78 ++++++++++++++++++++ mps/qa/function/90.c | 116 ++++++++++++++++++++++++++++++ mps/qa/function/93.c | 97 +++++++++++++++++++++++++ mps/qa/function/98.c | 34 +++++++++ mps/qa/function/99.c | 124 ++++++++++++++++++++++++++++++++ 8 files changed, 836 insertions(+) create mode 100644 mps/qa/function/83.c create mode 100644 mps/qa/function/87.c create mode 100644 mps/qa/function/88.c create mode 100644 mps/qa/function/89.c create mode 100644 mps/qa/function/90.c create mode 100644 mps/qa/function/93.c create mode 100644 mps/qa/function/98.c create mode 100644 mps/qa/function/99.c diff --git a/mps/qa/function/83.c b/mps/qa/function/83.c new file mode 100644 index 00000000000..fd914b8d16a --- /dev/null +++ b/mps/qa/function/83.c @@ -0,0 +1,137 @@ +/* $HopeName$ +TEST_HEADER + summary = test for bug with segment summaries + language = c + link = testlib.o awlfmt.o +END_HEADER +*/ + +/* + +This bug, suggested by drj, turned out not to exist. The problem +would have occurred when a nailed, buffered segment was scanned, +and the summary would be wrongly set. But in fact all buffered +segments are scanned in their entirety anyway, so no problem +arises. + +*/ + +#include "testlib.h" +#include "mpscamc.h" +#include "mpscawl.h" +#include "awlfmt.h" + +void *stackpointer; + +mps_addr_t temp_root; + +static void test(void) +{ + mps_space_t space; + mps_pool_t pool1, pool2; + mps_thr_t thread; + mps_root_t root; + + mps_fmt_t format; + mps_ap_t ap1, ap2, ap; + + mycell *a, *b, *c, *d; + + int i; + + alloccomments = 1; + fixcomments = 1; + deathcomments = 1; + formatcomments = 1; + fixcomments = 1; + + cdie(mps_space_create(&space), "create space"); + + cdie(mps_thread_reg(&thread, space), "register thread"); + + cdie( + mps_root_create_table(&root, space, MPS_RANK_AMBIG, 0, &temp_root, 1), + "create temp root"); + + cdie( + mps_fmt_create_A(&format, space, &fmtA), + "create format"); + + cdie( + mps_pool_create(&pool1, space, mps_class_amc(), format), + "create pool"); + + cdie( + mps_pool_create(&pool2, space, mps_class_awl(), format), + "create pool"); + + cdie( + mps_ap_create(&ap1, pool1, MPS_RANK_EXACT), + "create ap"); + + cdie( + mps_ap_create(&ap2, pool2, MPS_RANK_EXACT), + "create ap"); + + ap=ap1; + + mps_arena_park(space); + + c = allocone(ap, 1, 1); + + for (i=0; i<20; i++) { + if (i==10) { + comment("b..."); + b = allocone(ap, 1, 1); + } + a = allocone(ap, 1, 1); + setref(a, 0, c); + if (i==10) { + comment("switch ap"); + ap = ap2; + } + d = allocone(ap, 1000, 1); + c = a; + } + setref(b, 0, c); + + temp_root = NULL; + + mps_arena_collect(space); + + mps_arena_release(space); + + report("d", "%p", d); + + + mps_ap_destroy(ap1); + mps_ap_destroy(ap2); + comment("Destroyed aps."); + + mps_pool_destroy(pool1); + mps_pool_destroy(pool2); + comment("Destroyed pools."); + + mps_fmt_destroy(format); + comment("Destroyed format."); + + mps_root_destroy(root); + comment("Destroyed root."); + + mps_thread_dereg(thread); + comment("Deregistered thread."); + + mps_space_destroy(space); + comment("Destroyed space."); + +} + +int main(void) +{ + void *m; + stackpointer=&m; /* hack to get stack pointer */ + + easy_tramp(test); + pass(); + return 0; +} diff --git a/mps/qa/function/87.c b/mps/qa/function/87.c new file mode 100644 index 00000000000..4eb1d53506c --- /dev/null +++ b/mps/qa/function/87.c @@ -0,0 +1,166 @@ +/* $HopeName$ +TEST_HEADER + summary = EPVM make sure objects are left intact + language = c + link = testlib.o epvmfmt.o +END_HEADER +*/ + +#include "testlib.h" +#include "mpscepvm.h" +#include "mpsavm.h" +#include "epvmfmt.h" + +#define MAX_SAVE 1000 +#define INIT_SAVE 12 + +void *stackpointer; + +#define MAXOBJS 5000 + +mps_addr_t addrs[MAXOBJS]; +size_t sizes[MAXOBJS] = {0}; +mps_epvm_save_level_t levels[MAXOBJS]; + +mps_pool_t pool1; + +mps_epvm_save_level_t lev1; + +mps_ap_t ap1s; + +static void myrestore(mps_epvm_save_level_t i) { + int j; + + comment("restore to %i", i); + + mps_epvm_restore(pool1, i); + for (j=0; j i) { + comment("free %i", j); + sizes[j] = (size_t) 0; + } + } +} + +static void mycheck(psobj *addr, size_t size) { + int i; + unsigned long ob, om, pb, pm; + + pb = (unsigned long) addr; + pm = pb+size; + + for (i=0; i= pm, + "overlapping objects: %p, %p", addr, addrs[i]); + } + } +} + +static void myalloc(int i) { + size_t s; + psobj *a; + + s = 8 * (ranint(50)+1); + a = allocepvm(ap1s, s); + + comment("alloc %i at %p level %i", i, a, lev1); + + mycheck(a, s); + + addrs[i] = a; + sizes[i] = s; + levels[i] = lev1; +} + +static void mysave() { + if (lev1 < MAX_SAVE) { + lev1++; + comment("save to %i", lev1); + mps_epvm_save(pool1); + } +} + +int myfindblank(int *ii) { + int j; + + for (j=0; j0 && ranint(100)!=0) { + lev1--; + } + myrestore(lev1); + if (lev1 == 0) { + mysave(); + } + } + if (ranint(100)<20) { + mysave(); + } + } + + mps_ap_destroy(ap1s); + mps_pool_destroy(pool1); + mps_fmt_destroy(format); + mps_root_destroy(root); + mps_thread_dereg(thread); + mps_arena_destroy(arena); + comment("Destroyed arena"); + +} + +int main(void) { + void *m; + stackpointer=&m; + + easy_tramp(test); + pass(); + return 0; +} + + + diff --git a/mps/qa/function/88.c b/mps/qa/function/88.c new file mode 100644 index 00000000000..2764f28a1dc --- /dev/null +++ b/mps/qa/function/88.c @@ -0,0 +1,84 @@ +/* $HopeName$ +TEST_HEADER + summary = EPVM allocate and collect_world + language = c + link = testlib.o epvmfmt.o +END_HEADER +*/ + +#include "testlib.h" +#include "mpscepvm.h" +#include "mpsavm.h" +#include "epvmfmt.h" + +#define MAX_SAVE 32 +#define INIT_SAVE 0 + +void *stackpointer; + +psobj *a[100]; + +static void test(void) +{ + mps_arena_t arena; + mps_thr_t thread; + mps_root_t root; + + mps_fmt_t format; + + mps_pool_t pool1; + mps_epvm_save_level_t lev1; + mps_ap_t ap1s; + + int i, j; + + alloccomments = 1; + +/* create an arena that can't grow beyond 64M */ + + cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*64)), + "create arena"); + + cdie(mps_thread_reg(&thread, arena), "register thread"); + + cdie(mps_root_create_table(&root, arena, MPS_RANK_AMBIG, 0, &a[0], 100), + "create root"); + + cdie(mps_fmt_create_A(&format, arena, &fmtepvm), "create format"); + + cdie(mps_pool_create(&pool1, arena, mps_class_epvm(), + format, MAX_SAVE, INIT_SAVE), "create pool1"); + + cdie(mps_ap_create(&ap1s, pool1, 0), "create ap1s"); + + lev1 = INIT_SAVE; + + for (i=0; i<10; i++) { + for (j=0; j<10000; j++) { + a[ranint(100)] = allocepvm(ap1s, (size_t) (8+8*ranint(16))); + } + mps_arena_collect(arena); + comment("collected %i", i); + } + + mps_ap_destroy(ap1s); + mps_pool_destroy(pool1); + mps_fmt_destroy(format); + mps_root_destroy(root); + mps_thread_dereg(thread); + mps_arena_destroy(arena); + comment("Destroyed arena"); + +} + +int main(void) { + void *m; + stackpointer=&m; + + easy_tramp(test); + pass(); + return 0; +} + + + diff --git a/mps/qa/function/89.c b/mps/qa/function/89.c new file mode 100644 index 00000000000..7e3252cfe1e --- /dev/null +++ b/mps/qa/function/89.c @@ -0,0 +1,78 @@ +/* $HopeName$ +TEST_HEADER + summary = EPVM allocate and epvm_collect + language = c + link = testlib.o epvmfmt.o +END_HEADER +*/ + +#include "testlib.h" +#include "mpscepvm.h" +#include "mpsavm.h" +#include "epvmfmt.h" + +#define MAX_SAVE 1000 +#define INIT_SAVE 12 + +void *stackpointer; + +static void test(void) +{ + mps_arena_t arena; + mps_thr_t thread; + mps_root_t root; + + mps_fmt_t format; + + mps_pool_t pool1; + mps_epvm_save_level_t lev1; + mps_ap_t ap1s; + + int i, j; + + psobj *a; + +/* create an arena that can't grow beyond 64M */ + + cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*64)), + "create arena"); + + cdie(mps_thread_reg(&thread, arena), "register thread"); + + cdie(mps_fmt_create_A(&format, arena, &fmtepvm), "create format"); + + cdie(mps_pool_create(&pool1, arena, mps_class_epvm(), + format, MAX_SAVE, INIT_SAVE), "create pool1"); + + cdie(mps_ap_create(&ap1s, pool1, 0), "create ap1s"); + + lev1 = INIT_SAVE; + + for (i=0; i<50; i++) { + for (j=0; j<3000; j++) { + a = allocepvm(ap1s, (size_t) (8+8*ranint(500))); + } + comment("collecting..."); + mps_epvm_collect(pool1); + } + + mps_ap_destroy(ap1s); + mps_pool_destroy(pool1); + mps_fmt_destroy(format); + mps_thread_dereg(thread); + mps_arena_destroy(arena); + comment("Destroyed arena"); + +} + +int main(void) { + void *m; + stackpointer=&m; + + easy_tramp(test); + pass(); + return 0; +} + + + diff --git a/mps/qa/function/90.c b/mps/qa/function/90.c new file mode 100644 index 00000000000..7d5d9f78f06 --- /dev/null +++ b/mps/qa/function/90.c @@ -0,0 +1,116 @@ +/* $HopeName$ +TEST_HEADER + summary = various EPVM functional tests + language = c + link = testlib.o epvmfmt.o +END_HEADER +*/ + +#include "testlib.h" +#include "mpscepvm.h" +#include "mpsavm.h" +#include "epvmfmt.h" + +#define MAX_SAVE 32 +#define INIT_SAVE 4 + +#define RT_SIZE 1000 + +void *stackpointer; + +static void test(void) +{ + mps_arena_t arena; + mps_thr_t thread; + mps_root_t root; + + mps_fmt_t format; + + mps_pool_t pool1; + mps_epvm_save_level_t lev1; + mps_ap_t ap1s, ap1p; + + unsigned int i, j, k; + + psobj *a[RT_SIZE], *b; + +/* create an arena that can't grow beyond 64M */ + + cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*64)), + "create arena"); + + cdie(mps_thread_reg(&thread, arena), "register thread"); + + cdie(mps_root_create_table(&root, arena, MPS_RANK_AMBIG, 0, &a[0], RT_SIZE), + "create root"); + + cdie(mps_fmt_create_A(&format, arena, &fmtepvm), "create format"); + + cdie(mps_pool_create(&pool1, arena, mps_class_epvm(), + format, MAX_SAVE, INIT_SAVE), "create pool1"); + + cdie(mps_ap_create(&ap1s, pool1, 0), "create ap1s"); + + cdie(mps_ap_create(&ap1p, pool1, 1), "create ap1p"); + + asserts(sizeof(unsigned char) == 1, "surprise! -- characters too big!"); + + for (k=0; k<20; k++) { + comment("%i of 20", k); + + comment("allocate string objects of various sizes"); + + for (i=0; i<256; i++) { + a[i] = allocepvm(ap1s, (size_t) (8+8*i)); + for (j=0; j<(8+i*8); j++) { + *((unsigned char *) a[i]+j) = i; + } + } + + comment("allocate psobjects pointing to strings"); + + for (i=0; i<256; i++) { + b = allocepvm(ap1p, (size_t) 8); + b->obj = a[i]; + b->size = i+1; + a[i] = b; + } + + comment("collect"); + + mps_epvm_collect(pool1); + + comment("check objects are ok"); + + for (i=0; i<256; i++) { + b = a[i]->obj; + asserts(a[i]->size == i+1, "object %i wrong size", i); + for (j=0; j<(8+i*8); j++) { + asserts(*((unsigned char *) b+j) == i, "object %i corrupt at %i", i, j); + } + } + comment("finished"); + } + + mps_ap_destroy(ap1s); + mps_ap_destroy(ap1p); + mps_pool_destroy(pool1); + mps_fmt_destroy(format); + mps_root_destroy(root); + mps_thread_dereg(thread); + mps_arena_destroy(arena); + comment("Destroyed arena"); + +} + +int main(void) { + void *m; + stackpointer=&m; + + easy_tramp(test); + pass(); + return 0; +} + + + diff --git a/mps/qa/function/93.c b/mps/qa/function/93.c new file mode 100644 index 00000000000..f1c115f7963 --- /dev/null +++ b/mps/qa/function/93.c @@ -0,0 +1,97 @@ +/* $HopeName$ +TEST_HEADER + summary = EPVM time allocations with checklevels + language = c + link = testlib.o epvmfmt.o +END_HEADER +*/ + +#include "testlib.h" +#include "mpscepvm.h" +#include "mpsavm.h" +#include "epvmfmt.h" +#include + +#define MAX_SAVE 1 +#define INIT_SAVE 0 + +void *stackpointer; + +mps_word_t CheckLevel; + +#define CheckNONE 0 +#define CheckSHALLOW 1 +#define CheckDEEP 2 + +static void timealloc(mps_pool_t pool, mps_ap_t ap, size_t size, int num, int step) { + int i, j; + clock_t t0, t1; + int secs; + psobj *a; + + mps_epvm_save(pool); + t0 = clock(); + for (j=0; j 10 +END_HEADER +*/ + +#include "testlib.h" +#include "mpsavm.h" + +static void test(void) +{ + mps_space_t space; + + int p; + + p=0; + + while (1) + { + die(mps_arena_create(&space, mps_arena_class_vm(), (size_t) (1024*1024*10)), "create"); + p = p+1; + report("space", "%i", p); + } +} + +int main(void) +{ + easy_tramp(test); + return 0; +} diff --git a/mps/qa/function/99.c b/mps/qa/function/99.c new file mode 100644 index 00000000000..f608e40b238 --- /dev/null +++ b/mps/qa/function/99.c @@ -0,0 +1,124 @@ +/* $HopeName$ +TEST_HEADER + summary = AMC and AMCZ performance + language = c + link = testlib.o fastfmt.o +END_HEADER +*/ + +#include "testlib.h" +#include "mpscawl.h" +#include "mpscamc.h" +#include "fastfmt.h" + +void *stackpointer; + +static void test(void) +{ + mps_space_t space; + mps_pool_t poolamc, poolamcz; + mps_thr_t thread; + mps_root_t root, root1; + + mps_fmt_t format; + mps_ap_t apamc, apamcz; + + mycell *a, *b, *c, *d, *e, *f, *g; + + int i; + int j; + + cdie(mps_space_create(&space), "create space"); + + cdie(mps_thread_reg(&thread, space), "register thread"); + + cdie( + mps_root_create_reg(&root, space, MPS_RANK_AMBIG, 0, thread, + mps_stack_scan_ambig, stackpointer, 0), + "create root"); + + cdie( + mps_root_create_table(&root1,space,MPS_RANK_AMBIG,0,&exfmt_root,1), + "create table root"); + + cdie( + mps_fmt_create_A(&format, space, &fmtA), + "create format"); + + cdie( + mps_pool_create(&poolamc, space, mps_class_amc(), format), + "create pool"); + + cdie( + mps_pool_create(&poolamcz, space, mps_class_amcz(), format), + "create pool"); + + cdie( + mps_ap_create(&apamcz, poolamcz, 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<100; j++) + { + comment("%i of 100.", j); + a = allocone(apamc, 5, MPS_RANK_EXACT); + b = a; + c = a; + d = a; + e = a; + f = a; + g = a; + + for (i=1; i<5000; i++) + { + c = allocone(apamc, 20, MPS_RANK_EXACT); + d = allocone(apamcz, 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_ap_destroy(apamcz); + mps_ap_destroy(apamc); + comment("Destroyed aps."); + + mps_pool_destroy(poolamc); + mps_pool_destroy(poolamcz); + comment("Destroyed pools."); + + mps_fmt_destroy(format); + comment("Destroyed format."); + + mps_root_destroy(root); + mps_root_destroy(root1); + comment("Destroyed roots."); + + mps_thread_dereg(thread); + comment("Deregistered thread."); + + mps_space_destroy(space); + comment("Destroyed space."); + +} + +int main(void) +{ + void *m; + stackpointer=&m; /* hack to get stack pointer */ + + easy_tramp(test); + pass(); + return 0; +}