-- Event Logging Common Definitions
*
- * Copyright (c) 2001 Ravenbrook Limited. See end of file for license.
+ * Copyright (c) 2001-2014 Ravenbrook Limited. See end of file for license.
* $Id$
*
* .sources: mps.design.telemetry
@@ -56,7 +56,8 @@ ENUM_DECLARE(EventKind)
enum EventDefinitionsEnum {
EVENT_LIST(EVENT_ENUM, X)
- EventEnumWarningSuppressor /* suppress comma-at-end-of-enum warning */
+ /* suppress comma-at-end-of-enum warning */
+ EventEnumWarningSuppressor = USHRT_MAX
};
@@ -89,7 +90,11 @@ typedef Word EventFW; /* word */
typedef unsigned EventFU; /* unsigned integer */
typedef char EventFS[EventStringLengthMAX + sizeof('\0')]; /* string */
typedef double EventFD; /* double */
-typedef int EventFB; /* boolean */
+/* EventFB must be unsigned (even though Bool is a typedef for int)
+ * because it used as the type of a bitfield with width 1, and we need
+ * the legals values of the field to be 0 and 1 (not 0 and -1 which
+ * would be the case for int : 1). */
+typedef unsigned EventFB; /* Boolean */
/* Event packing bitfield specifiers */
#define EventFP_BITFIELD
@@ -133,7 +138,7 @@ typedef union EventUnion {
/* C. COPYRIGHT AND LICENSE
*
- * Copyright (C) 2001-2002 Ravenbrook Limited
#include
-#include
-#include
+#include /* exit, EXIT_FAILURE, EXIT_SUCCESS */
+#include /* strcpy, strlen */
static const char *prog; /* program name */
static const char *logFileName = NULL;
@@ -106,15 +111,19 @@ static void parseArgs(int argc, char *argv[])
static void *tableAlloc(void *closure, size_t size)
{
- UNUSED(closure);
- return malloc(size);
+ mps_pool_t pool = closure;
+ mps_addr_t p;
+ mps_res_t res;
+ res = mps_alloc(&p, pool, size);
+ if (res != MPS_RES_OK)
+ everror("allocation failed: %d", res);
+ return p;
}
static void tableFree(void *closure, void *p, size_t size)
{
- UNUSED(closure);
- UNUSED(size);
- free(p);
+ mps_pool_t pool = closure;
+ mps_free(pool, p, size);
}
/* Printing routines */
@@ -171,7 +180,7 @@ static double parseDouble(char **pInOut)
#define MAX_STRING_LENGTH 1024
-char strBuf[MAX_STRING_LENGTH];
+static char strBuf[MAX_STRING_LENGTH];
static char *parseString(char **pInOut)
{
@@ -215,21 +224,21 @@ static Table internTable; /* dictionary of intern ids to strings */
static Table labelTable; /* dictionary of addrs to intern ids */
-static void createTables(void)
+static void createTables(mps_pool_t pool)
{
Res res;
/* MPS intern IDs are serials from zero up, so we can use -1
* and -2 as specials. */
res = TableCreate(&internTable,
(size_t)1<<4,
- tableAlloc, tableFree, NULL,
+ tableAlloc, tableFree, pool,
(Word)-1, (Word)-2);
if (res != ResOK)
everror("Couldn't make intern table.");
/* We assume that 0 and 1 are invalid as Addrs. */
res = TableCreate(&labelTable, (size_t)1<<7,
- tableAlloc, tableFree, NULL,
+ tableAlloc, tableFree, pool,
0, 1);
if (res != ResOK)
everror("Couldn't make label table.");
@@ -238,19 +247,19 @@ static void createTables(void)
/* recordIntern -- record an interned string in the table. a copy of
* the string from the parsed buffer into a newly-allocated block. */
-static void recordIntern(char *p)
+static void recordIntern(mps_pool_t pool, char *p)
{
ulongest_t stringId;
char *string;
- char *copy;
+ mps_addr_t copy;
size_t len;
Res res;
stringId = parseHex(&p);
string = parseString(&p);
len = strlen(string);
- copy = malloc(len+1);
- if (copy == NULL)
+ res = mps_alloc(©, pool, len + 1);
+ if (res != MPS_RES_OK)
everror("Couldn't allocate space for a string.");
(void)strcpy(copy, string);
res = TableDefine(internTable, (Word)stringId, (void *)copy);
@@ -258,12 +267,55 @@ static void recordIntern(char *p)
everror("Couldn't create an intern mapping.");
}
-/* recordLabel records a label (an association between an address and
- * a string ID). Note that the event log may have been generated on a
- * platform with addresses larger than Word on the current platform.
- * If that happens then we are scuppered because our Table code uses
- * Word as the key type: there's nothing we can do except detect this
- * bad case (see also the EventInit handling and warning code).
+/* Over time there may be multiple labels associated with an address,
+ * so we keep a list, recording for each label the clock when the
+ * association was made. This means that printAddr can select the
+ * label that was in force at the time of the event.
+ */
+
+typedef struct LabelStruct *Label;
+typedef struct LabelStruct {
+ ulongest_t clock; /* clock of this label */
+ ulongest_t id; /* string id of this label */
+} LabelStruct;
+
+typedef struct LabelListStruct *LabelList;
+typedef struct LabelListStruct {
+ size_t n; /* number of labels in array */
+ Label labels; /* labels, sorted in order by clock */
+} LabelListStruct;
+
+/* labelFind returns the index of the first entry in list with a clock
+ * value that's greater than 'clock', or list->n if there is no such
+ * label. The list is assumed to be sorted.
+ */
+
+static size_t labelFind(LabelList list, ulongest_t clock)
+{
+ size_t low = 0, high = list->n;
+ while (low < high) {
+ size_t mid = (low + high) / 2;
+ assert(NONNEGATIVE(mid) && mid < list->n);
+ if (list->labels[mid].clock > clock) {
+ high = mid;
+ } else {
+ low = mid + 1;
+ }
+ }
+ assert(NONNEGATIVE(low) && low <= list->n);
+ assert(low == list->n || list->labels[low].clock > clock);
+ return low;
+}
+
+/* recordLabel records a label: an association (made at the time given
+ * by 'clock') between an address and a string ID. These are encoded
+ * as two hexadecimal numbers in the string pointed to by 'p'.
+ *
+ * Note that the event log may have been generated on a platform with
+ * addresses larger than Word on the current platform. If that happens
+ * then we are scuppered because our Table code uses Word as the key
+ * type: there's nothing we can do except detect this bad case (see
+ * also the EventInit handling and warning code).
*
* We can and do handle the case where string IDs (which are Words on
* the MPS platform) are larger than void* on the current platform.
@@ -274,25 +326,50 @@ static void recordIntern(char *p)
* probably a bad idea and maybe doomed to failure.
*/
-static void recordLabel(char *p)
+static void recordLabel(mps_pool_t pool, ulongest_t clock, char *p)
{
ulongest_t address;
- ulongest_t *stringIdP;
+ LabelList list;
+ Label newlabels;
+ mps_addr_t tmp;
+ size_t pos;
Res res;
-
+
address = parseHex(&p);
if (address > (Word)-1) {
(void)printf("label address too large!");
return;
}
-
- stringIdP = malloc(sizeof(ulongest_t));
- if (stringIdP == NULL)
- everror("Can't allocate space for a string's ID");
- *stringIdP = parseHex(&p);
- res = TableDefine(labelTable, (Word)address, (void *)stringIdP);
+
+ if (TableLookup(&tmp, labelTable, address)) {
+ list = tmp;
+ } else {
+ /* First label for this address */
+ res = mps_alloc(&tmp, pool, sizeof(LabelListStruct));
+ if (res != MPS_RES_OK)
+ everror("Can't allocate space for a label list");
+ list = tmp;
+ list->n = 0;
+ res = TableDefine(labelTable, (Word)address, list);
+ if (res != ResOK)
+ everror("Couldn't create a label mapping.");
+ }
+
+ res = mps_alloc(&tmp, pool, sizeof(LabelStruct) * (list->n + 1));
if (res != ResOK)
- everror("Couldn't create an intern mapping.");
+ everror("Couldn't allocate space for list of labels.");
+ newlabels = tmp;
+
+ pos = labelFind(list, clock);
+ memcpy(newlabels, list->labels, sizeof(LabelStruct) * pos);
+ newlabels[pos].clock = clock;
+ newlabels[pos].id = parseHex(&p);
+ memcpy(newlabels + pos + 1, list->labels + pos,
+ sizeof(LabelStruct) * (list->n - pos));
+ if (list->n > 0)
+ mps_free(pool, list->labels, sizeof(LabelStruct) * list->n);
+ list->labels = newlabels;
+ ++ list->n;
}
/* output code */
@@ -308,20 +385,23 @@ static int hexWordWidth = (MPS_WORD_WIDTH+3)/4;
/* printAddr -- output a ulongest_t in hex, with the interned string
* if the value is in the label table */
-static void printAddr(ulongest_t addr, const char *ident)
+static void printAddr(ulongest_t clock, ulongest_t addr, const char *ident)
{
- ulongest_t label;
- void *alias;
+ void *tmp;
printf("%s:%0*" PRIXLONGEST, ident, hexWordWidth, addr);
- if (TableLookup(&alias, labelTable, addr)) {
- label = *(ulongest_t*)alias;
- putchar('[');
- if (TableLookup(&alias, internTable, label))
- printStr((char *)alias);
- else
- printf("unknown label %" PRIuLONGEST, label);
- putchar(']');
+ if (TableLookup(&tmp, labelTable, addr)) {
+ LabelList list = tmp;
+ size_t pos = labelFind(list, clock);
+ if (pos > 0) {
+ ulongest_t id = list->labels[pos - 1].id;
+ putchar('[');
+ if (TableLookup(&tmp, internTable, id))
+ printStr((char *)tmp);
+ else
+ printf("unknown label %" PRIXLONGEST, id);
+ putchar(']');
+ }
}
putchar(' ');
}
@@ -332,7 +412,7 @@ static void printAddr(ulongest_t addr, const char *ident)
#define processParamA(ident) \
val_hex = parseHex(&p); \
- printAddr(val_hex, #ident);
+ printAddr(clock, val_hex, #ident);
#define processParamP processParamA
#define processParamW processParamA
@@ -375,7 +455,7 @@ static const char *eventName[EventCodeMAX+EventCodeMAX];
/* readLog -- read and parse log. Returns the number of events written. */
-static void readLog(FILE *input)
+static void readLog(mps_pool_t pool, FILE *input)
{
int i;
@@ -415,9 +495,9 @@ static void readLog(FILE *input)
/* for a few particular codes, we do local processing. */
if (code == EventInternCode) {
- recordIntern(q);
+ recordIntern(pool, q);
} else if (code == EventLabelCode) {
- recordLabel(q);
+ recordLabel(pool, clock, q);
} else if (code == EventEventInitCode) {
ulongest_t major, median, minor, maxCode, maxNameLen, wordWidth, clocksPerSec;
major = parseHex(&q); /* EVENT_VERSION_MAJOR */
@@ -476,6 +556,9 @@ static void readLog(FILE *input)
int main(int argc, char *argv[])
{
+ mps_arena_t arena;
+ mps_pool_t pool;
+ mps_res_t res;
FILE *input;
parseArgs(argc, argv);
@@ -488,8 +571,20 @@ int main(int argc, char *argv[])
everror("unable to open %s", logFileName);
}
- createTables();
- readLog(input);
+ res = mps_arena_create_k(&arena, mps_arena_class_vm(), mps_args_none);
+ if (res != MPS_RES_OK)
+ everror("failed to create arena: %d", res);
+
+ res = mps_pool_create_k(&pool, arena, mps_class_mvff(), mps_args_none);
+ if (res != MPS_RES_OK)
+ everror("failed to create pool: %d", res);
+
+ createTables(pool);
+ readLog(pool, input);
+
+ mps_pool_destroy(pool);
+ mps_arena_destroy(arena);
+
(void)fclose(input);
return 0;
}
diff --git a/mps/code/exposet0.c b/mps/code/exposet0.c
index f471dd2a3bc..21f2567cbaa 100644
--- a/mps/code/exposet0.c
+++ b/mps/code/exposet0.c
@@ -72,12 +72,6 @@ static void report(mps_arena_t arena)
printf("not_condemned %"PRIuLONGEST"\n", (ulongest_t)not_condemned);
mps_message_discard(arena, message);
-
- if (condemned > (gen1SIZE + gen2SIZE + (size_t)128) * 1024)
- /* When condemned size is larger than could happen in a gen 2
- * collection (discounting ramps, natch), guess that was a dynamic
- * collection, and reset the commit limit, so it doesn't run out. */
- die(mps_arena_commit_limit_set(arena, 2 * testArenaSIZE), "set limit");
}
}
diff --git a/mps/code/fbmtest.c b/mps/code/fbmtest.c
index 9f3754b3496..231d02482a7 100644
--- a/mps/code/fbmtest.c
+++ b/mps/code/fbmtest.c
@@ -560,7 +560,7 @@ extern int main(int argc, char *argv[])
Align align;
testlib_init(argc, argv);
- align = (1 << rnd() % 4) * MPS_PF_ALIGN;
+ align = sizeof(void *) << (rnd() % 4);
NAllocateTried = NAllocateSucceeded = NDeallocateTried =
NDeallocateSucceeded = 0;
diff --git a/mps/code/finaltest.c b/mps/code/finaltest.c
index 02c1448d137..f449d7e1acf 100644
--- a/mps/code/finaltest.c
+++ b/mps/code/finaltest.c
@@ -6,6 +6,20 @@
*
* DESIGN
*
+ * .mode: This test has two modes.
+ *
+ * .mode.park: In this mode, we use the arena's default generation
+ * chain, leave the arena parked and call mps_arena_collect. This
+ * tests that the default generation chain works and that all segments
+ * get condemned via TraceStartCollectAll. (See job003771 item 4.)
+ *
+ * .mode.poll: In this mode, we use our own generation chain (with
+ * small generations), allocate into generation 1, unclamp the arena,
+ * and provoke collection by allocating. This tests that custom
+ * generation chains work, and that segments get condemned via
+ * TracePoll even if there is no allocation into generation 0 of the
+ * chain. (See job003771 item 5.)
+ *
* DEPENDENCIES
*
* This test uses the dylan object format, but the reliance on this
@@ -16,6 +30,7 @@
* This code was created by first copying
*/
+#include "mpm.h"
#include "testlib.h"
#include "mpslib.h"
#include "mps.h"
@@ -30,10 +45,15 @@
#include /* fflush, printf, stdout */
+enum {
+ ModePARK, /* .mode.park */
+ ModePOLL /* .mode.poll */
+};
+
#define testArenaSIZE ((size_t)16<<20)
#define rootCOUNT 20
-#define maxtreeDEPTH 10
+#define maxtreeDEPTH 9
#define collectionCOUNT 10
@@ -126,17 +146,21 @@ static mps_addr_t test_awl_find_dependent(mps_addr_t addr)
static void *root[rootCOUNT];
-static void test_trees(const char *name, mps_arena_t arena, mps_ap_t ap,
+static void test_trees(int mode, const char *name, mps_arena_t arena,
+ mps_ap_t ap,
mps_word_t (*make)(mps_word_t, mps_ap_t),
void (*reg)(mps_word_t, mps_arena_t))
{
size_t collections = 0;
size_t finals = 0;
size_t i;
+ int object_alloc;
object_count = 0;
printf("Making some %s finalized trees of objects.\n", name);
+ mps_arena_park(arena);
+
/* make some trees */
for(i = 0; i < rootCOUNT; ++i) {
root[i] = (void *)(*make)(maxtreeDEPTH, ap);
@@ -151,10 +175,23 @@ static void test_trees(const char *name, mps_arena_t arena, mps_ap_t ap,
while (finals < object_count && collections < collectionCOUNT) {
mps_word_t final_this_time = 0;
- printf("Collecting...");
- (void)fflush(stdout);
- die(mps_arena_collect(arena), "collect");
- printf(" Done.\n");
+ switch (mode) {
+ default:
+ case ModePARK:
+ printf("Collecting...");
+ (void)fflush(stdout);
+ die(mps_arena_collect(arena), "collect");
+ printf(" Done.\n");
+ break;
+ case ModePOLL:
+ mps_arena_release(arena);
+ printf("Allocating...");
+ (void)fflush(stdout);
+ object_alloc = 0;
+ while (object_alloc < 1000 && !mps_message_poll(arena))
+ (void)DYLAN_INT(object_alloc++);
+ break;
+ }
++ collections;
while (mps_message_poll(arena)) {
mps_message_t message;
@@ -167,12 +204,17 @@ static void test_trees(const char *name, mps_arena_t arena, mps_ap_t ap,
}
finals += final_this_time;
printf("%"PRIuLONGEST" objects finalized: total %"PRIuLONGEST
- " of %"PRIuLONGEST"\n", final_this_time, finals, object_count);
+ " of %"PRIuLONGEST"\n", (ulongest_t)final_this_time,
+ (ulongest_t)finals, (ulongest_t)object_count);
}
- cdie(finals == object_count, "Not all objects were finalized.");
+ if (finals != object_count)
+ error("Not all objects were finalized for %s in mode %s.",
+ BufferOfAP(ap)->pool->class->name,
+ mode == ModePOLL ? "POLL" : "PARK");
}
-static void *test(mps_arena_t arena, mps_class_t pool_class)
+static void test_pool(int mode, mps_arena_t arena, mps_chain_t chain,
+ mps_class_t pool_class)
{
mps_ap_t ap;
mps_fmt_t fmt;
@@ -181,10 +223,13 @@ static void *test(mps_arena_t arena, mps_class_t pool_class)
die(mps_fmt_create_A(&fmt, arena, dylan_fmt_A()), "fmt_create\n");
MPS_ARGS_BEGIN(args) {
- /* Allocate into generation 0 so that they get finalized quickly. */
- MPS_ARGS_ADD(args, MPS_KEY_GEN, 0);
MPS_ARGS_ADD(args, MPS_KEY_FORMAT, fmt);
- MPS_ARGS_ADD(args, MPS_KEY_AWL_FIND_DEPENDENT, test_awl_find_dependent);
+ if (mode == ModePOLL) {
+ MPS_ARGS_ADD(args, MPS_KEY_CHAIN, chain);
+ MPS_ARGS_ADD(args, MPS_KEY_GEN, 1);
+ }
+ if (pool_class == mps_class_awl())
+ 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\n");
} MPS_ARGS_END(args);
@@ -193,19 +238,25 @@ static void *test(mps_arena_t arena, mps_class_t pool_class)
"root_create\n");
die(mps_ap_create(&ap, pool, mps_rank_exact()), "ap_create\n");
- mps_message_type_enable(arena, mps_message_type_finalization());
-
- mps_arena_park(arena);
-
- test_trees("numbered", arena, ap, make_numbered_tree, register_numbered_tree);
- test_trees("indirect", arena, ap, make_indirect_tree, register_indirect_tree);
+ test_trees(mode, "numbered", arena, ap, make_numbered_tree,
+ register_numbered_tree);
+ test_trees(mode, "indirect", arena, ap, make_indirect_tree,
+ register_indirect_tree);
mps_ap_destroy(ap);
mps_root_destroy(mps_root);
mps_pool_destroy(pool);
mps_fmt_destroy(fmt);
+}
- return NULL;
+
+static void test_mode(int mode, mps_arena_t arena, mps_chain_t chain)
+{
+ test_pool(mode, arena, chain, mps_class_amc());
+ test_pool(mode, arena, chain, mps_class_amcz());
+ test_pool(mode, arena, chain, mps_class_ams());
+ /* test_pool(mode, arena, chain, mps_class_lo()); TODO: job003773 */
+ /* test_pool(mode, arena, chain, mps_class_awl()); TODO: job003772 */
}
@@ -213,19 +264,27 @@ int main(int argc, char *argv[])
{
mps_arena_t arena;
mps_thr_t thread;
+ mps_chain_t chain;
+ mps_gen_param_s params[2];
+ size_t gens = 2;
+ size_t i;
testlib_init(argc, argv);
die(mps_arena_create(&arena, mps_arena_class_vm(), testArenaSIZE),
"arena_create\n");
+ mps_message_type_enable(arena, mps_message_type_finalization());
die(mps_thread_reg(&thread, arena), "thread_reg\n");
+ for (i = 0; i < gens; ++i) {
+ params[i].mps_capacity = 1;
+ params[i].mps_mortality = 0.5;
+ }
+ die(mps_chain_create(&chain, arena, gens, params), "chain_create\n");
- test(arena, mps_class_amc());
- test(arena, mps_class_amcz());
- test(arena, mps_class_ams());
- test(arena, mps_class_awl());
- /* TODO: test(arena, mps_class_lo()); */
+ test_mode(ModePOLL, arena, chain);
+ test_mode(ModePARK, arena, NULL);
+ mps_chain_destroy(chain);
mps_thread_dereg(thread);
mps_arena_destroy(arena);
diff --git a/mps/code/fmtscheme.c b/mps/code/fmtscheme.c
index 5299c8f3525..11900130a71 100644
--- a/mps/code/fmtscheme.c
+++ b/mps/code/fmtscheme.c
@@ -12,14 +12,8 @@
/* special objects */
-obj_t obj_empty; /* (), the empty list */
-obj_t obj_eof; /* end of file */
-obj_t obj_error; /* error indicator */
-obj_t obj_true; /* #t, boolean true */
-obj_t obj_false; /* #f, boolean false */
-obj_t obj_undefined; /* undefined result indicator */
-obj_t obj_tail; /* tail recursion indicator */
-obj_t obj_deleted; /* deleted key in hashtable */
+static obj_t obj_true; /* #t, boolean true */
+static obj_t obj_false; /* #f, boolean false */
/* MPS globals */
diff --git a/mps/code/fotest.c b/mps/code/fotest.c
index 9dab6650ede..2e63d4e121b 100644
--- a/mps/code/fotest.c
+++ b/mps/code/fotest.c
@@ -171,7 +171,7 @@ int main(int argc, char *argv[])
die(mps_arena_create(&arena, mps_arena_class_vm(), testArenaSIZE),
"mps_arena_create");
- alignment = (1 << (rnd() % 4)) * MPS_PF_ALIGN;
+ alignment = sizeof(void *) << (rnd() % 4);
MPS_ARGS_BEGIN(args) {
MPS_ARGS_ADD(args, MPS_KEY_EXTEND_BY, (64 + rnd() % 64) * 1024);
MPS_ARGS_ADD(args, MPS_KEY_MEAN_SIZE, (1 + rnd() % 8) * 8);
@@ -190,7 +190,7 @@ int main(int argc, char *argv[])
die(mps_arena_create(&arena, mps_arena_class_vm(), testArenaSIZE),
"mps_arena_create");
- alignment = (1 << (rnd() % 4)) * MPS_PF_ALIGN;
+ alignment = sizeof(void *) << (rnd() % 4);
MPS_ARGS_BEGIN(args) {
MPS_ARGS_ADD(args, MPS_KEY_ALIGN, alignment);
MPS_ARGS_ADD(args, MPS_KEY_MIN_SIZE, (1 + rnd() % 4) * 4);
diff --git a/mps/code/gcbench.c b/mps/code/gcbench.c
index 80c68d7f711..2a18d1a7d10 100644
--- a/mps/code/gcbench.c
+++ b/mps/code/gcbench.c
@@ -318,8 +318,8 @@ int main(int argc, char *argv[]) {
double mort = 0.0;
cap = (size_t)strtoul(optarg, &p, 10);
switch(toupper(*p)) {
- case 'G': cap *= 1024; /* fall through */
- case 'M': cap *= 1024; /* fall through */
+ case 'G': cap <<= 20; p++; break;
+ case 'M': cap <<= 10; p++; break;
case 'K': p++; break;
default: cap = 0; break;
}
@@ -340,9 +340,9 @@ int main(int argc, char *argv[]) {
char *p;
arenasize = (unsigned)strtoul(optarg, &p, 10);
switch(toupper(*p)) {
- case 'G': arenasize *= 1024;
- case 'M': arenasize *= 1024;
- case 'K': arenasize *= 1024; break;
+ case 'G': arenasize <<= 30; break;
+ case 'M': arenasize <<= 20; break;
+ case 'K': arenasize <<= 10; break;
case '\0': break;
default:
fprintf(stderr, "Bad arena size %s\n", optarg);
diff --git a/mps/code/global.c b/mps/code/global.c
index 24cd0a81013..812f90dad3d 100644
--- a/mps/code/global.c
+++ b/mps/code/global.c
@@ -393,25 +393,7 @@ void GlobalsFinish(Globals arenaGlobals)
Arena arena;
Rank rank;
- /* Check that the tear-down is complete: that the client has
- * destroyed all data structures associated with the arena. We do
- * this *before* calling AVERT(Globals, arenaGlobals) because the
- * AVERT will crash if there are any remaining data structures, and
- * it is politer to assert than to crash. (The crash would happen
- * because by this point in the code the control pool has been
- * destroyed and so the address space containing all these rings has
- * potentially been unmapped, and so RingCheck dereferences a
- * pointer into that unmapped memory.) See job000652. */
arena = GlobalsArena(arenaGlobals);
- AVER(RingIsSingle(&arena->formatRing));
- AVER(RingIsSingle(&arena->chainRing));
- AVER(RingIsSingle(&arena->messageRing));
- AVER(RingIsSingle(&arena->threadRing));
- for(rank = 0; rank < RankLIMIT; ++rank)
- AVER(RingIsSingle(&arena->greyRing[rank]));
- AVER(RingIsSingle(&arenaGlobals->poolRing));
- AVER(RingIsSingle(&arenaGlobals->rootRing));
-
AVERT(Globals, arenaGlobals);
STATISTIC_STAT(EVENT2(ArenaWriteFaults, arena,
@@ -441,6 +423,7 @@ void GlobalsPrepareToDestroy(Globals arenaGlobals)
TraceId ti;
Trace trace;
Chain defaultChain;
+ Rank rank;
AVERT(Globals, arenaGlobals);
@@ -495,6 +478,31 @@ void GlobalsPrepareToDestroy(Globals arenaGlobals)
arena->finalPool = NULL;
PoolDestroy(pool);
}
+
+ /* Check that the tear-down is complete: that the client has
+ * destroyed all data structures associated with the arena. We do
+ * this here rather than in GlobalsFinish because by the time that
+ * is called, the control pool has been destroyed and so the address
+ * space containing all these rings has potentially been unmapped,
+ * and so RingCheck dereferences a pointer into that unmapped memory
+ * and we get a crash instead of an assertion. See job000652.
+ */
+ AVER(RingIsSingle(&arena->formatRing));
+ AVER(RingIsSingle(&arena->chainRing));
+ AVER(RingIsSingle(&arena->messageRing));
+ AVER(RingIsSingle(&arena->threadRing));
+ AVER(RingIsSingle(&arenaGlobals->rootRing));
+ for(rank = 0; rank < RankLIMIT; ++rank)
+ AVER(RingIsSingle(&arena->greyRing[rank]));
+
+ /* At this point the following pools still exist:
+ * 0. arena->freeCBSBlockPoolStruct
+ * 1. arena->reservoirStruct
+ * 2. arena->controlPoolStruct
+ * 3. arena->controlPoolStruct.blockPoolStruct
+ * 4. arena->controlPoolStruct.spanPoolStruct
+ */
+ AVER(RingLength(&arenaGlobals->poolRing) == 5);
}
@@ -595,6 +603,7 @@ void ArenaLeaveRecursive(Arena arena)
* version. The format is platform-specific. We won't necessarily
* publish this. */
+extern MutatorFaultContext mps_exception_info;
MutatorFaultContext mps_exception_info = NULL;
@@ -1101,7 +1110,7 @@ void ArenaSetEmergency(Arena arena, Bool emergency)
AVERT(Arena, arena);
AVERT(Bool, emergency);
- EVENT2(ArenaSetEmergency, arena, emergency);
+ EVENT2(ArenaSetEmergency, arena, BOOLOF(emergency));
arena->emergency = emergency;
}
diff --git a/mps/code/ll.gmk b/mps/code/ll.gmk
index dc2595c511f..55e4b6cff5d 100644
--- a/mps/code/ll.gmk
+++ b/mps/code/ll.gmk
@@ -10,17 +10,20 @@
# common makefile fragment () requires.
CC = clang
-CFLAGSDEBUG = -O -g3
+CFLAGSDEBUG = -O0 -g3
CFLAGSOPT = -O2 -g3
CFLAGSCOMPILER := \
-pedantic \
-Waggregate-return \
-Wall \
-Wcast-qual \
+ -Wconversion \
+ -Wduplicate-enum \
-Werror \
-Wextra \
-Winline \
-Wmissing-prototypes \
+ -Wmissing-variable-declarations \
-Wnested-externs \
-Wno-extended-offsetof \
-Wpointer-arith \
diff --git a/mps/code/lockcov.c b/mps/code/lockcov.c
index a7289dca9ce..75ded6f202a 100644
--- a/mps/code/lockcov.c
+++ b/mps/code/lockcov.c
@@ -4,21 +4,37 @@
* Copyright (c) 2001-2014 Ravenbrook Limited. See end of file for license.
*/
+#include "mps.h"
+#include "mpsavm.h"
+#include "mpscmfs.h"
#include "mpm.h"
#include "testlib.h"
#include "mpslib.h"
#include /* printf */
-#include /* free, malloc */
int main(int argc, char *argv[])
{
- Lock a = malloc(LockSize());
- Lock b = malloc(LockSize());
+ mps_arena_t arena;
+ mps_pool_t pool;
+ mps_addr_t p;
+ Lock a, b;
testlib_init(argc, argv);
+ die(mps_arena_create_k(&arena, mps_arena_class_vm(), mps_args_none),
+ "arena_create");
+ MPS_ARGS_BEGIN(args) {
+ MPS_ARGS_ADD(args, MPS_KEY_MFS_UNIT_SIZE, LockSize());
+ die(mps_pool_create_k(&pool, arena, mps_class_mfs(), args), "pool_create");
+ } MPS_ARGS_END(args);
+
+ die(mps_alloc(&p, pool, LockSize()), "alloc a");
+ a = p;
+ die(mps_alloc(&p, pool, LockSize()), "alloc b");
+ b = p;
+
Insist(a != NULL);
Insist(b != NULL);
@@ -46,8 +62,11 @@ int main(int argc, char *argv[])
LockReleaseMPM(a);
LockFinish(a);
LockReleaseGlobalRecursive();
- free(a);
- free(b);
+
+ mps_free(pool, a, LockSize());
+ mps_free(pool, b, LockSize());
+ mps_pool_destroy(pool);
+ mps_arena_destroy(arena);
printf("%s: Conclusion: Failed to find any defects.\n", argv[0]);
return 0;
diff --git a/mps/code/lockut.c b/mps/code/lockut.c
index ec22369bc13..e93bdea6815 100644
--- a/mps/code/lockut.c
+++ b/mps/code/lockut.c
@@ -4,18 +4,20 @@
* Copyright (c) 2001-2014 Ravenbrook Limited. See end of file for license.
*/
+#include "mps.h"
+#include "mpsavm.h"
+#include "mpscmfs.h"
#include "mpm.h"
#include "testlib.h"
#include "testthr.h"
#include /* printf */
-#include /* malloc */
#define nTHREADS 4
static Lock lock;
-unsigned long shared, tmp;
+static unsigned long shared, tmp;
static void incR(unsigned long i)
@@ -63,12 +65,23 @@ static void *thread0(void *p)
int main(int argc, char *argv[])
{
+ mps_arena_t arena;
+ mps_pool_t pool;
+ mps_addr_t p;
testthr_t t[10];
unsigned i;
testlib_init(argc, argv);
- lock = malloc(LockSize());
+ die(mps_arena_create_k(&arena, mps_arena_class_vm(), mps_args_none),
+ "arena_create");
+ MPS_ARGS_BEGIN(args) {
+ MPS_ARGS_ADD(args, MPS_KEY_MFS_UNIT_SIZE, LockSize());
+ die(mps_pool_create_k(&pool, arena, mps_class_mfs(), args), "pool_create");
+ } MPS_ARGS_END(args);
+
+ die(mps_alloc(&p, pool, LockSize()), "alloc");
+ lock = p;
Insist(lock != NULL);
LockInit(lock);
@@ -86,6 +99,10 @@ int main(int argc, char *argv[])
LockFinish(lock);
+ mps_free(pool, lock, LockSize());
+ mps_pool_destroy(pool);
+ mps_arena_destroy(arena);
+
printf("%s: Conclusion: Failed to find any defects.\n", argv[0]);
return 0;
}
diff --git a/mps/code/locus.c b/mps/code/locus.c
index a704c8b820b..6e6e22128b7 100644
--- a/mps/code/locus.c
+++ b/mps/code/locus.c
@@ -287,13 +287,21 @@ Res ChainAlloc(Seg *segReturn, Chain chain, Serial genNr, SegClass class,
double ChainDeferral(Chain chain)
{
+ double time = DBL_MAX;
+ size_t i;
+
AVERT(Chain, chain);
- if (chain->activeTraces != TraceSetEMPTY)
- return DBL_MAX;
- else
- return chain->gens[0].capacity * 1024.0
- - (double)GenDescNewSize(&chain->gens[0]);
+ if (chain->activeTraces == TraceSetEMPTY) {
+ for (i = 0; i < chain->genCount; ++i) {
+ double genTime = chain->gens[i].capacity * 1024.0
+ - (double)GenDescNewSize(&chain->gens[i]);
+ if (genTime < time)
+ time = genTime;
+ }
+ }
+
+ return time;
}
@@ -306,7 +314,7 @@ double ChainDeferral(Chain chain)
Res ChainCondemnAuto(double *mortalityReturn, Chain chain, Trace trace)
{
Res res;
- Serial topCondemnedGenSerial, currGenSerial;
+ size_t topCondemnedGen, i;
GenDesc gen;
ZoneSet condemnedSet = ZoneSetEMPTY;
Size condemnedSize = 0, survivorSize = 0, genNewSize, genTotalSize;
@@ -314,33 +322,39 @@ Res ChainCondemnAuto(double *mortalityReturn, Chain chain, Trace trace)
AVERT(Chain, chain);
AVERT(Trace, trace);
- /* Find lowest gen within its capacity, set topCondemnedGenSerial to the */
- /* preceeding one. */
- currGenSerial = 0;
- gen = &chain->gens[0];
- AVERT(GenDesc, gen);
- genNewSize = GenDescNewSize(gen);
- do { /* At this point, we've decided to collect currGenSerial. */
- topCondemnedGenSerial = currGenSerial;
+ /* Find the highest generation that's over capacity. We will condemn
+ * this and all lower generations in the chain. */
+ topCondemnedGen = chain->genCount;
+ for (;;) {
+ /* It's an error to call this function unless some generation is
+ * over capacity as reported by ChainDeferral. */
+ AVER(topCondemnedGen > 0);
+ if (topCondemnedGen == 0)
+ return ResFAIL;
+ -- topCondemnedGen;
+ gen = &chain->gens[topCondemnedGen];
+ AVERT(GenDesc, gen);
+ genNewSize = GenDescNewSize(gen);
+ if (genNewSize >= gen->capacity * (Size)1024)
+ break;
+ }
+
+ /* At this point, we've decided to condemn topCondemnedGen and all
+ * lower generations. */
+ for (i = 0; i <= topCondemnedGen; ++i) {
+ gen = &chain->gens[i];
+ AVERT(GenDesc, gen);
condemnedSet = ZoneSetUnion(condemnedSet, gen->zones);
genTotalSize = GenDescTotalSize(gen);
+ genNewSize = GenDescNewSize(gen);
condemnedSize += genTotalSize;
survivorSize += (Size)(genNewSize * (1.0 - gen->mortality))
/* predict survivors will survive again */
+ (genTotalSize - genNewSize);
-
- /* is there another one to consider? */
- currGenSerial += 1;
- if (currGenSerial >= chain->genCount)
- break; /* reached the top */
- gen = &chain->gens[currGenSerial];
- AVERT(GenDesc, gen);
- genNewSize = GenDescNewSize(gen);
- } while (genNewSize >= gen->capacity * (Size)1024);
+ }
AVER(condemnedSet != ZoneSetEMPTY || condemnedSize == 0);
- EVENT3(ChainCondemnAuto, chain, topCondemnedGenSerial, chain->genCount);
- UNUSED(topCondemnedGenSerial); /* only used for EVENT */
+ EVENT3(ChainCondemnAuto, chain, topCondemnedGen, chain->genCount);
/* Condemn everything in these zones. */
if (condemnedSet != ZoneSetEMPTY) {
@@ -354,41 +368,6 @@ Res ChainCondemnAuto(double *mortalityReturn, Chain chain, Trace trace)
}
-/* ChainCondemnAll -- condemn everything in the chain */
-
-Res ChainCondemnAll(Chain chain, Trace trace)
-{
- Ring node, nextNode;
- Bool haveWhiteSegs = FALSE;
- Res res;
-
- /* Condemn every segment in every pool using this chain. */
- /* Finds the pools by iterating over the PoolGens in gen 0. */
- RING_FOR(node, &chain->gens[0].locusRing, nextNode) {
- PoolGen nursery = RING_ELT(PoolGen, genRing, node);
- Pool pool = nursery->pool;
- Ring segNode, nextSegNode;
-
- AVERT(Pool, pool);
- AVER(PoolHasAttr(pool, AttrGC));
- RING_FOR(segNode, PoolSegRing(pool), nextSegNode) {
- Seg seg = SegOfPoolRing(segNode);
-
- res = TraceAddWhite(trace, seg);
- if (res != ResOK)
- goto failBegin;
- haveWhiteSegs = TRUE;
- }
- }
-
- return ResOK;
-
-failBegin:
- AVER(!haveWhiteSegs); /* Would leave white sets inconsistent. */
- return res;
-}
-
-
/* ChainStartGC -- called to notify start of GC for this chain */
void ChainStartGC(Chain chain, Trace trace)
@@ -416,9 +395,11 @@ void ChainEndGC(Chain chain, Trace trace)
Res PoolGenInit(PoolGen gen, Chain chain, Serial nr, Pool pool)
{
/* Can't check gen, because it's not been initialized. */
+ AVER(gen != NULL);
AVERT(Chain, chain);
AVER(nr <= chain->genCount);
AVERT(Pool, pool);
+ AVER(PoolHasAttr(pool, AttrGC));
gen->nr = nr;
gen->pool = pool;
diff --git a/mps/code/meter.h b/mps/code/meter.h
index 7a7f8266e87..f1731400e42 100644
--- a/mps/code/meter.h
+++ b/mps/code/meter.h
@@ -1,7 +1,7 @@
/* meter.h: METER INTERFACE
*
* $Id$
- * Copyright (c) 2001-2013 Ravenbrook Limited. See end of file for license.
+ * Copyright (c) 2001-2014 Ravenbrook Limited. See end of file for license.
*
* .sources: mps.design.metrics.
*
@@ -45,9 +45,12 @@ extern void MeterEmit(Meter meter);
#define METER_ACC(meter, delta) \
STATISTIC(MeterAccumulate(&(meter), delta))
#if defined(STATISTICS)
-#define METER_WRITE(meter, stream) MeterWrite(&(meter), stream)
+#define METER_WRITE(meter, stream) BEGIN \
+ Res _res = MeterWrite(&(meter), (stream)); \
+ if (_res != ResOK) return _res; \
+ END
#elif defined(STATISTICS_NONE)
-#define METER_WRITE(meter, stream) (ResOK)
+#define METER_WRITE(meter, stream) NOOP
#else
#error "No statistics configured."
#endif
@@ -59,7 +62,7 @@ extern void MeterEmit(Meter meter);
/* C. COPYRIGHT AND LICENSE
*
- * Copyright (C) 2001-2013 Ravenbrook Limited */
@@ -712,10 +714,10 @@ extern Addr (SegLimit)(Seg seg);
#define SegSummary(seg) (((GCSeg)(seg))->summary)
-#define SegSetPM(seg, mode) ((void)((seg)->pm = (mode)))
-#define SegSetSM(seg, mode) ((void)((seg)->sm = (mode)))
-#define SegSetDepth(seg, d) ((void)((seg)->depth = (d)))
-#define SegSetNailed(seg, ts) ((void)((seg)->nailed = (ts)))
+#define SegSetPM(seg, mode) ((void)((seg)->pm = BS_BITFIELD(Access, (mode))))
+#define SegSetSM(seg, mode) ((void)((seg)->sm = BS_BITFIELD(Access, (mode))))
+#define SegSetDepth(seg, d) ((void)((seg)->depth = BITFIELD(unsigned, (d), ShieldDepthWIDTH)))
+#define SegSetNailed(seg, ts) ((void)((seg)->nailed = BS_BITFIELD(Trace, (ts))))
/* Buffer Interface -- see */
@@ -927,8 +929,6 @@ extern void (ShieldFlush)(Arena arena);
extern void ProtSetup(void);
extern void ProtSet(Addr base, Addr limit, AccessSet mode);
-extern void ProtTramp(void **resultReturn, void *(*f)(void *, size_t),
- void *p, size_t s);
extern void ProtSync(Arena arena);
extern Bool ProtCanStepInstruction(MutatorFaultContext context);
extern Res ProtStepInstruction(MutatorFaultContext context);
diff --git a/mps/code/mpmst.h b/mps/code/mpmst.h
index 85e95a78ec1..5d38f3a3319 100644
--- a/mps/code/mpmst.h
+++ b/mps/code/mpmst.h
@@ -1,7 +1,7 @@
/* mpmst.h: MEMORY POOL MANAGER DATA STRUCTURES
*
* $Id$
- * Copyright (c) 2001-2013 Ravenbrook Limited. See end of file for license.
+ * Copyright (c) 2001-2014 Ravenbrook Limited. See end of file for license.
* Portions copyright (C) 2001 Global Graphics Software.
*
* .design: This header file crosses module boundaries. The relevant
@@ -275,8 +275,8 @@ typedef struct SegStruct { /* segment structure */
RingStruct poolRing; /* link in list of segs in pool */
Addr limit; /* limit of segment */
unsigned depth : ShieldDepthWIDTH; /* see */
- AccessSet pm : AccessSetWIDTH; /* protection mode, */
- AccessSet sm : AccessSetWIDTH; /* shield mode, */
+ AccessSet pm : AccessLIMIT; /* protection mode, */
+ AccessSet sm : AccessLIMIT; /* shield mode, */
TraceSet grey : TraceLIMIT; /* traces for which seg is grey */
TraceSet white : TraceLIMIT; /* traces for which seg is white */
TraceSet nailed : TraceLIMIT; /* traces for which seg has nailed objects */
@@ -738,7 +738,7 @@ typedef struct AllocPatternStruct {
/* C. COPYRIGHT AND LICENSE
*
- * Copyright (C) 2001-2013 Ravenbrook Limited */
#define AccessREAD ((AccessSet)(1<<0))
#define AccessWRITE ((AccessSet)(1<<1))
-#define AccessSetWIDTH (2)
+#define AccessLIMIT (2)
#define RefSetEMPTY BS_EMPTY(RefSet)
#define RefSetUNIV BS_UNIV(RefSet)
#define ZoneSetEMPTY BS_EMPTY(ZoneSet)
diff --git a/mps/code/mpsi.c b/mps/code/mpsi.c
index 3df0913df83..45ffff50166 100644
--- a/mps/code/mpsi.c
+++ b/mps/code/mpsi.c
@@ -1380,7 +1380,7 @@ void (mps_tramp)(void **r_o,
AVER(FUNCHECK(f));
/* Can't check p and s as they are interpreted by the client */
- ProtTramp(r_o, f, p, s);
+ *r_o = (*f)(p, s);
}
diff --git a/mps/code/mpsw3.h b/mps/code/mpsw3.h
deleted file mode 100644
index f32b7a09831..00000000000
--- a/mps/code/mpsw3.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/* mpsw3.h: RAVENBROOK MEMORY POOL SYSTEM C INTERFACE, WINDOWS PART
- *
- * $Id$
- * Copyright (c) 2001 Ravenbrook Limited. See end of file for license.
- *
- * .readership: customers, MPS developers.
- * .sources: .* */
Bool splinter; /* Saved splinter */
- Seg splinterSeg; /* Saved splinter seg */
Addr splinterBase; /* Saved splinter base */
Addr splinterLimit; /* Saved splinter size */
@@ -133,7 +132,7 @@ typedef struct MVTStruct
DEFINE_POOL_CLASS(MVTPoolClass, this)
{
- INHERIT_CLASS(this, AbstractSegBufPoolClass);
+ INHERIT_CLASS(this, AbstractBufferPoolClass);
this->name = "MVT";
this->size = sizeof(MVTStruct);
this->offset = offsetof(MVTStruct, poolStruct);
@@ -292,7 +291,6 @@ static Res MVTInit(Pool pool, ArgList args)
mvt->maxSize = maxSize;
mvt->fragLimit = fragLimit;
mvt->splinter = FALSE;
- mvt->splinterSeg = NULL;
mvt->splinterBase = (Addr)0;
mvt->splinterLimit = (Addr)0;
@@ -378,9 +376,7 @@ static Bool MVTCheck(MVT mvt)
if (mvt->splinter) {
CHECKL(AddrOffset(mvt->splinterBase, mvt->splinterLimit) >=
mvt->minSize);
- CHECKD(Seg, mvt->splinterSeg);
- CHECKL(mvt->splinterBase >= SegBase(mvt->splinterSeg));
- CHECKL(mvt->splinterLimit <= SegLimit(mvt->splinterSeg));
+ CHECKL(mvt->splinterBase < mvt->splinterLimit);
}
CHECKL(mvt->size == mvt->allocated + mvt->available +
mvt->unavailable);
@@ -951,7 +947,6 @@ static void MVTBufferEmpty(Pool pool, Buffer buffer,
}
mvt->splinter = TRUE;
- mvt->splinterSeg = BufferSeg(buffer);
mvt->splinterBase = base;
mvt->splinterLimit = limit;
}
@@ -998,8 +993,6 @@ static void MVTFree(Pool pool, Addr base, Size size)
AVER(mvt->size == mvt->allocated + mvt->available +
mvt->unavailable);
METER_ACC(mvt->exceptionReturns, SegSize(seg));
- if (SegBuffer(seg) != NULL)
- BufferDetach(SegBuffer(seg), MVT2Pool(mvt));
MVTSegFree(mvt, seg);
return;
}
@@ -1031,7 +1024,6 @@ static Res MVTDescribe(Pool pool, mps_lib_FILE *stream)
" availLimit: $U \n", (WriteFU)mvt->availLimit,
" abqOverflow: $S \n", mvt->abqOverflow?"TRUE":"FALSE",
" splinter: $S \n", mvt->splinter?"TRUE":"FALSE",
- " splinterSeg: $P \n", (WriteFP)mvt->splinterSeg,
" splinterBase: $A \n", (WriteFA)mvt->splinterBase,
" splinterLimit: $A \n", (WriteFU)mvt->splinterLimit,
" size: $U \n", (WriteFU)mvt->size,
@@ -1050,68 +1042,37 @@ static Res MVTDescribe(Pool pool, mps_lib_FILE *stream)
res = FreelistDescribe(MVTFreelist(mvt), stream);
if(res != ResOK) return res;
- res = METER_WRITE(mvt->segAllocs, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->segFrees, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->bufferFills, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->bufferEmpties, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->poolFrees, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->poolSize, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->poolAllocated, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->poolAvailable, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->poolUnavailable, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->poolUtilization, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->finds, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->overflows, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->underflows, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->refills, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->refillPushes, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->returns, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->perfectFits, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->firstFits, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->secondFits, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->failures, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->emergencyContingencies, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->fragLimitContingencies, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->contingencySearches, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->contingencyHardSearches, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->splinters, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->splintersUsed, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->splintersDropped, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->sawdust, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->exceptions, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->exceptionSplinters, stream);
- if (res != ResOK) return res;
- res = METER_WRITE(mvt->exceptionReturns, stream);
- if (res != ResOK) return res;
+ METER_WRITE(mvt->segAllocs, stream);
+ METER_WRITE(mvt->segFrees, stream);
+ METER_WRITE(mvt->bufferFills, stream);
+ METER_WRITE(mvt->bufferEmpties, stream);
+ METER_WRITE(mvt->poolFrees, stream);
+ METER_WRITE(mvt->poolSize, stream);
+ METER_WRITE(mvt->poolAllocated, stream);
+ METER_WRITE(mvt->poolAvailable, stream);
+ METER_WRITE(mvt->poolUnavailable, stream);
+ METER_WRITE(mvt->poolUtilization, stream);
+ METER_WRITE(mvt->finds, stream);
+ METER_WRITE(mvt->overflows, stream);
+ METER_WRITE(mvt->underflows, stream);
+ METER_WRITE(mvt->refills, stream);
+ METER_WRITE(mvt->refillPushes, stream);
+ METER_WRITE(mvt->returns, stream);
+ METER_WRITE(mvt->perfectFits, stream);
+ METER_WRITE(mvt->firstFits, stream);
+ METER_WRITE(mvt->secondFits, stream);
+ METER_WRITE(mvt->failures, stream);
+ METER_WRITE(mvt->emergencyContingencies, stream);
+ METER_WRITE(mvt->fragLimitContingencies, stream);
+ METER_WRITE(mvt->contingencySearches, stream);
+ METER_WRITE(mvt->contingencyHardSearches, stream);
+ METER_WRITE(mvt->splinters, stream);
+ METER_WRITE(mvt->splintersUsed, stream);
+ METER_WRITE(mvt->splintersDropped, stream);
+ METER_WRITE(mvt->sawdust, stream);
+ METER_WRITE(mvt->exceptions, stream);
+ METER_WRITE(mvt->exceptionSplinters, stream);
+ METER_WRITE(mvt->exceptionReturns, stream);
res = WriteF(stream, "}\n", NULL);
return res;
@@ -1189,7 +1150,7 @@ static Res MVTSegAlloc(Seg *segReturn, MVT mvt, Size size,
{
/* Can't use plain old SegClass here because we need to call
* SegBuffer() in MVTFree(). */
- Res res = SegAlloc(segReturn, GCSegClassGet(),
+ Res res = SegAlloc(segReturn, SegClassGet(),
SegPrefDefault(), size, MVT2Pool(mvt), withReservoirPermit,
argsNone);
@@ -1213,7 +1174,6 @@ static Res MVTSegAlloc(Seg *segReturn, MVT mvt, Size size,
*/
static void MVTSegFree(MVT mvt, Seg seg)
{
- Buffer buffer;
Size size;
size = SegSize(seg);
@@ -1223,16 +1183,6 @@ static void MVTSegFree(MVT mvt, Seg seg)
mvt->size -= size;
mvt->availLimit = mvt->size * mvt->fragLimit / 100;
AVER(mvt->size == mvt->allocated + mvt->available + mvt->unavailable);
-
- /* If the client program allocates the exactly the entire buffer then
- frees the allocated memory then we'll try to free the segment with
- the buffer still attached. It's safe, but we must detach the buffer
- first. See job003520 and job003672. */
- buffer = SegBuffer(seg);
- if (buffer != NULL) {
- AVER(BufferAP(buffer)->init == SegLimit(seg));
- BufferDetach(buffer, MVT2Pool(mvt));
- }
SegFree(seg);
METER_ACC(mvt->segFrees, size);
diff --git a/mps/code/poolmvff.c b/mps/code/poolmvff.c
index 201d2047104..4971550c76a 100644
--- a/mps/code/poolmvff.c
+++ b/mps/code/poolmvff.c
@@ -610,7 +610,7 @@ static Res MVFFInit(Pool pool, ArgList args)
mvff->sig = MVFFSig;
AVERT(MVFF, mvff);
EVENT8(PoolInitMVFF, pool, arena, extendBy, avgSize, align,
- slotHigh, arenaHigh, firstFit);
+ BOOLOF(slotHigh), BOOLOF(arenaHigh), BOOLOF(firstFit));
return ResOK;
failInit:
diff --git a/mps/code/prmci3li.c b/mps/code/prmci3li.c
index 6a36ae7db2b..5b5d150b8cc 100644
--- a/mps/code/prmci3li.c
+++ b/mps/code/prmci3li.c
@@ -36,27 +36,34 @@ SRCID(prmci3li, "$Id$");
MRef Prmci3AddressHoldingReg(MutatorFaultContext mfc, unsigned int regnum)
{
+ MRef gregs;
+
+ AVER(mfc != NULL);
AVER(NONNEGATIVE(regnum));
AVER(regnum <= 7);
+ AVER(mfc->ucontext != NULL);
+
+ /* TODO: The current arrangement of the fix operation (taking a Ref *)
+ forces us to pun these registers (actually `int` on LII3GC). We can
+ suppress the warning by casting through `void *` and this might make
+ it safe, but does it really? RB 2012-09-10 */
+ AVER(sizeof(void *) == sizeof(*mfc->ucontext->uc_mcontext.gregs));
+ gregs = (void *)mfc->ucontext->uc_mcontext.gregs;
/* .source.i486 */
/* .assume.regref */
/* The register numbers (REG_EAX etc.) are defined in
but only if _GNU_SOURCE is defined: see .feature.li in
config.h. */
- /* TODO: The current arrangement of the fix operation (taking a Ref *)
- forces us to pun these registers (actually `int` on LII3GC). We can
- suppress the warning my casting through `char *` and this might make
- it safe, but does it really? RB 2012-09-10 */
switch (regnum) {
- case 0: return (MRef)((char *)&mfc->ucontext->uc_mcontext.gregs[REG_EAX]);
- case 1: return (MRef)((char *)&mfc->ucontext->uc_mcontext.gregs[REG_ECX]);
- case 2: return (MRef)((char *)&mfc->ucontext->uc_mcontext.gregs[REG_EDX]);
- case 3: return (MRef)((char *)&mfc->ucontext->uc_mcontext.gregs[REG_EBX]);
- case 4: return (MRef)((char *)&mfc->ucontext->uc_mcontext.gregs[REG_ESP]);
- case 5: return (MRef)((char *)&mfc->ucontext->uc_mcontext.gregs[REG_EBP]);
- case 6: return (MRef)((char *)&mfc->ucontext->uc_mcontext.gregs[REG_ESI]);
- case 7: return (MRef)((char *)&mfc->ucontext->uc_mcontext.gregs[REG_EDI]);
+ case 0: return &gregs[REG_EAX];
+ case 1: return &gregs[REG_ECX];
+ case 2: return &gregs[REG_EDX];
+ case 3: return &gregs[REG_EBX];
+ case 4: return &gregs[REG_ESP];
+ case 5: return &gregs[REG_EBP];
+ case 6: return &gregs[REG_ESI];
+ case 7: return &gregs[REG_EDI];
default:
NOTREACHED;
return NULL; /* Avoids compiler warning. */
diff --git a/mps/code/prmci3xc.c b/mps/code/prmci3xc.c
index 786145fc084..eafeff61540 100644
--- a/mps/code/prmci3xc.c
+++ b/mps/code/prmci3xc.c
@@ -34,8 +34,13 @@ SRCID(prmci3li, "$Id$");
MRef Prmci3AddressHoldingReg(MutatorFaultContext mfc, unsigned int regnum)
{
+ THREAD_STATE_S *threadState;
+
+ AVER(mfc != NULL);
AVER(NONNEGATIVE(regnum));
AVER(regnum <= 7);
+ AVER(mfc->threadState != NULL);
+ threadState = mfc->threadState;
/* .source.i486 */
/* .assume.regref */
@@ -44,17 +49,17 @@ MRef Prmci3AddressHoldingReg(MutatorFaultContext mfc, unsigned int regnum)
config.h. */
/* TODO: The current arrangement of the fix operation (taking a Ref *)
forces us to pun these registers (actually `int` on LII3GC). We can
- suppress the warning my casting through `char *` and this might make
+ suppress the warning by casting through `void *` and this might make
it safe, but does it really? RB 2012-09-10 */
switch (regnum) {
- case 0: return (MRef)((char *)&mfc->threadState->__eax);
- case 1: return (MRef)((char *)&mfc->threadState->__ecx);
- case 2: return (MRef)((char *)&mfc->threadState->__edx);
- case 3: return (MRef)((char *)&mfc->threadState->__ebx);
- case 4: return (MRef)((char *)&mfc->threadState->__esp);
- case 5: return (MRef)((char *)&mfc->threadState->__ebp);
- case 6: return (MRef)((char *)&mfc->threadState->__esi);
- case 7: return (MRef)((char *)&mfc->threadState->__edi);
+ case 0: return (void *)&threadState->__eax;
+ case 1: return (void *)&threadState->__ecx;
+ case 2: return (void *)&threadState->__edx;
+ case 3: return (void *)&threadState->__ebx;
+ case 4: return (void *)&threadState->__esp;
+ case 5: return (void *)&threadState->__ebp;
+ case 6: return (void *)&threadState->__esi;
+ case 7: return (void *)&threadState->__edi;
default:
NOTREACHED;
return NULL; /* Avoids compiler warning. */
diff --git a/mps/code/prmci6li.c b/mps/code/prmci6li.c
index 2f8bf9afc62..c00c1359014 100644
--- a/mps/code/prmci6li.c
+++ b/mps/code/prmci6li.c
@@ -33,12 +33,19 @@ SRCID(prmci6li, "$Id$");
MRef Prmci6AddressHoldingReg(MutatorFaultContext mfc, unsigned int regnum)
{
- Word *gregs;
+ MRef gregs;
+ AVER(mfc != NULL);
AVER(NONNEGATIVE(regnum));
AVER(regnum <= 15);
+ AVER(mfc->ucontext != NULL);
- gregs = (Word *)&mfc->ucontext->uc_mcontext.gregs;
+ /* TODO: The current arrangement of the fix operation (taking a Ref *)
+ forces us to pun these registers (actually `int` on LII6GC). We can
+ suppress the warning by casting through `void *` and this might make
+ it safe, but does it really? RB 2012-09-10 */
+ AVER(sizeof(void *) == sizeof(*mfc->ucontext->uc_mcontext.gregs));
+ gregs = (void *)mfc->ucontext->uc_mcontext.gregs;
/* .assume.regref */
/* The register numbers (REG_RAX etc.) are defined in
diff --git a/mps/code/prmci6xc.c b/mps/code/prmci6xc.c
index 02ccb840b6c..131447cd0cc 100644
--- a/mps/code/prmci6xc.c
+++ b/mps/code/prmci6xc.c
@@ -31,33 +31,38 @@ SRCID(prmci6li, "$Id$");
MRef Prmci6AddressHoldingReg(MutatorFaultContext mfc, unsigned int regnum)
{
+ THREAD_STATE_S *threadState;
+
+ AVER(mfc != NULL);
AVER(NONNEGATIVE(regnum));
AVER(regnum <= 15);
+ AVER(mfc->threadState != NULL);
+ threadState = mfc->threadState;
/* .assume.regref */
/* The register numbers (REG_RAX etc.) are defined in
but only if _XOPEN_SOURCE is defined: see .feature.xc in
config.h. */
/* MRef (a Word *) is not compatible with pointers to the register
- types (actually a __uint64_t). To avoid aliasing optimization
- problems, The registers are cast through (char *) */
+ types (actually a __uint64_t). To avoid aliasing optimization
+ problems, the registers are cast through (void *). */
switch (regnum) {
- case 0: return (MRef)((char *)&mfc->threadState->__rax);
- case 1: return (MRef)((char *)&mfc->threadState->__rcx);
- case 2: return (MRef)((char *)&mfc->threadState->__rdx);
- case 3: return (MRef)((char *)&mfc->threadState->__rbx);
- case 4: return (MRef)((char *)&mfc->threadState->__rsp);
- case 5: return (MRef)((char *)&mfc->threadState->__rbp);
- case 6: return (MRef)((char *)&mfc->threadState->__rsi);
- case 7: return (MRef)((char *)&mfc->threadState->__rdi);
- case 8: return (MRef)((char *)&mfc->threadState->__r8);
- case 9: return (MRef)((char *)&mfc->threadState->__r9);
- case 10: return (MRef)((char *)&mfc->threadState->__r10);
- case 11: return (MRef)((char *)&mfc->threadState->__r11);
- case 12: return (MRef)((char *)&mfc->threadState->__r12);
- case 13: return (MRef)((char *)&mfc->threadState->__r13);
- case 14: return (MRef)((char *)&mfc->threadState->__r14);
- case 15: return (MRef)((char *)&mfc->threadState->__r15);
+ case 0: return (void *)&threadState->__rax;
+ case 1: return (void *)&threadState->__rcx;
+ case 2: return (void *)&threadState->__rdx;
+ case 3: return (void *)&threadState->__rbx;
+ case 4: return (void *)&threadState->__rsp;
+ case 5: return (void *)&threadState->__rbp;
+ case 6: return (void *)&threadState->__rsi;
+ case 7: return (void *)&threadState->__rdi;
+ case 8: return (void *)&threadState->__r8;
+ case 9: return (void *)&threadState->__r9;
+ case 10: return (void *)&threadState->__r10;
+ case 11: return (void *)&threadState->__r11;
+ case 12: return (void *)&threadState->__r12;
+ case 13: return (void *)&threadState->__r13;
+ case 14: return (void *)&threadState->__r14;
+ case 15: return (void *)&threadState->__r15;
default:
NOTREACHED;
return NULL; /* Avoids compiler warning. */
diff --git a/mps/code/protan.c b/mps/code/protan.c
index 86afa645e63..0e8abf8ac7e 100644
--- a/mps/code/protan.c
+++ b/mps/code/protan.c
@@ -1,7 +1,7 @@
/* protan.c: ANSI MEMORY PROTECTION
*
* $Id$
- * Copyright (c) 2001 Ravenbrook Limited. See end of file for license.
+ * Copyright (c) 2001-2014 Ravenbrook Limited. See end of file for license.
*
*
* DESIGN
@@ -63,22 +63,9 @@ void ProtSync(Arena arena)
}
-/* ProtTramp -- protection trampoline */
-
-void ProtTramp(void **rReturn, void *(*f)(void *, size_t),
- void *p, size_t s)
-{
- AVER(rReturn != NULL);
- AVER(FUNCHECK(f));
- /* Can't check p and s as they are interpreted by the client */
-
- *(rReturn) = (*(f))(p, s);
-}
-
-
/* C. COPYRIGHT AND LICENSE
*
- * Copyright (C) 2001-2002 Ravenbrook Limited ` so that we can improve
this documentation.
-``arenavm.c: BTIsResRange(vmChunk->pageTableMapped, 0, chunk->pageTablePages)``
+``sa.c: BTIsResRange(sa->mapped, 0, sa->length)``
The client program called :c:func:`mps_arena_destroy` without
having destroyed all pools in that arena first. (The assertion is
@@ -283,14 +283,6 @@ this documentation.
point` instead.
-``poolams.c: !AMS_IS_INVALID_COLOUR(seg, i)``
-
- The client program failed to :term:`fix` a reference to an object
- in an :ref:`pool-ams` pool, violating the :term:`tri-colour
- invariant` that the MPS depends on for the correctness of its
- :term:`incremental garbage collection`.
-
-
``poolams.c: AMS_ALLOCED(seg, i)``
The client program tried to :term:`fix` a :term:`reference` to a
diff --git a/mps/manual/source/topic/format.rst b/mps/manual/source/topic/format.rst
index 91ac7ae6462..b9bbdae61bb 100644
--- a/mps/manual/source/topic/format.rst
+++ b/mps/manual/source/topic/format.rst
@@ -468,22 +468,27 @@ Object format introspection
Each :term:`pool class` determines for which objects the stepper
function is called. Typically, all validly formatted objects are
- visited. During a :term:`trace` this will in general be only the
- :term:`black` objects, though the :ref:`pool-lo` pool, for
- example, will walk all objects since they are validly formatted
- whether they are black or :term:`white`. :term:`Padding objects`
- may be visited at the pool class's discretion: the :term:`client
- program` should handle this case.
-
- .. seealso::
-
- :ref:`topic-arena`.
+ visited. :term:`Padding objects` may be visited at the pool
+ class's discretion: the stepper function must handle this
+ case.
.. note::
This function is intended for heap analysis, tuning, and
debugging, not for frequent use in production.
+ .. warning::
+
+ If a garbage collection is currently in progress (that is, if
+ the arena is in the :term:`clamped ` or
+ :term:`unclamped state`), then only objects that are known to
+ be currently valid are visited.
+
+ For the most reliable results, ensure the arena is in the
+ :term:`parked state` by calling :c:func:`mps_arena_park`
+ before calling this function (and release it by calling
+ :c:func:`mps_arena_release` afterwards, if desired).
+
.. c:type:: void (*mps_formatted_objects_stepper_t)(mps_addr_t addr, mps_fmt_t fmt, mps_pool_t pool, void *p, size_t s)
@@ -515,10 +520,6 @@ Object format introspection
It must not access other memory managed by the MPS.
- .. seealso::
-
- :ref:`topic-arena`.
-
Obsolete interface
------------------
diff --git a/mps/manual/source/topic/telemetry.rst b/mps/manual/source/topic/telemetry.rst
index f33de3516ce..a665aaf4b07 100644
--- a/mps/manual/source/topic/telemetry.rst
+++ b/mps/manual/source/topic/telemetry.rst
@@ -110,7 +110,7 @@ The MPS writes the telemetry to the log in an encoded form for speed.
It can be decoded using the :ref:`mpseventcnv `
and :ref:`mpseventtxt ` programs::
- (gdb) shell mpseventcnv | mpseventtxt | sort > mpsio.txt
+ (gdb) shell mpseventcnv | sort | mpseventtxt > mpsio.txt
The ``sort`` is useful because the events are not necessarily written
to the telemetry file in time order, but each event starts with a
diff --git a/mps/procedure/release-build.rst b/mps/procedure/release-build.rst
index bdce60df4ca..ee65b5f645d 100644
--- a/mps/procedure/release-build.rst
+++ b/mps/procedure/release-build.rst
@@ -47,7 +47,7 @@ All relative paths are relative to
1.111.0), where *VERSION* is the number of the version you’re
releasing, and *N* is the first unused release number (starting at
zero). Look in the index of releases (``release/index.html``) for
- existing release numbers for your version::
+ existing release numbers for your version. ::
VERSION=A.BBB
RELEASE=$VERSION.N
@@ -111,7 +111,7 @@ Run the script ``tool/release``, passing the options:
* ``-P mps`` — project name
* ``-b BRANCH`` — branch to make the release from: for example ``version/1.113``
* ``-C CHANGELEVEL`` — changelevel at which to make the release
-* ``-d "DESCRIPTION"`` — changelevel at which to make the release
+* ``-d "DESCRIPTION"`` — description of the release
* ``-y`` — yes, really make the release
If omitted, the project and branch are deduced from the current
@@ -231,8 +231,6 @@ A. References
Ravenbrook Limited; 2008-10-16;
http://info.ravenbrook.com/mail/2008/10/16/13-08-20/0.txt
-.. [Sphinx] "Sphinx: Python document generator"; http://sphinx-doc.org/
-
B. Document History
-------------------
diff --git a/mps/test/function/122.c b/mps/test/function/122.c
index 6f1465289cb..4ba0c0c6090 100644
--- a/mps/test/function/122.c
+++ b/mps/test/function/122.c
@@ -133,7 +133,7 @@ static void test(void)
die(allocrdumb(&a[0], aplo, 64, mps_rank_exact()), "alloc");
die(allocrdumb(&a[1], apamc, 64, mps_rank_exact()), "alloc");
die(allocrdumb(&a[3], apawl, 64, mps_rank_exact()), "alloc");
- a[2] = (mycell *)((int)a[3] | 4);
+ a[2] = (mycell *)((mps_word_t)a[3] | 4);
die(allocrdumb(&b[0], aplo, 64, mps_rank_exact()), "alloc");
die(allocrdumb(&b[1], apamc, 64, mps_rank_exact()), "alloc");
diff --git a/mps/test/function/40.c b/mps/test/function/40.c
index c57f8c62ba5..5257e1fcfc1 100644
--- a/mps/test/function/40.c
+++ b/mps/test/function/40.c
@@ -66,7 +66,7 @@ static void test(void)
comment("%i of 10.", i);
UC;
z[i] = allocone(ap, 1, 1);
- if (i % 8 == 0) { z[i] = (mycell *) ((int)z[i] + 4); } /* error to scan this! */
+ if (i % 8 == 0) { z[i] = (mycell *) ((mps_word_t)z[i] + 4); } /* error to scan this! */
}
for (i=0; i<1000; i++) {
diff --git a/mps/test/testsets/passing b/mps/test/testsets/passing
index 64c72fe2982..fc00f37feb0 100644
--- a/mps/test/testsets/passing
+++ b/mps/test/testsets/passing
@@ -110,7 +110,7 @@ function/118.c
function/119.c
function/120.c
% function/121.c -- job003495
-% function/122.c -- job003496
+function/122.c
function/123.c
function/124.c
function/125.c
diff --git a/mps/tool/branch b/mps/tool/branch
index f60eccae235..5a3b4d8652d 100755
--- a/mps/tool/branch
+++ b/mps/tool/branch
@@ -46,10 +46,10 @@ CHILD_RE = r'(?:{}|{})$'.format(TASK_BRANCH_RE, VERSION_BRANCH_RE)
TASK_BRANCH_ENTRY = '''
- {child}{date}/{task}Changes
- {description}
- In development (diffs).
+ {desc_html}
+ Active (diffs).
'''
@@ -60,7 +60,7 @@ VERSION_BRANCH_ENTRY = '''
None.
{parent}/...@{changelevel}
- {description}
+ {desc_html}
base
@@ -154,13 +154,16 @@ def main(argv):
m = re.match(CHILD_RE, args.child)
if not m:
raise Error(fmt("Invalid child: {child}"))
- if args.customer != m.group(3):
+ if not args.task and args.customer != m.group(3):
raise Error(fmt("Customer mismatch between {parent} and {child}."))
args.date, args.task, _, args.version = m.groups()
if not args.description:
args.description = fmt("Branching {parent} to {child}.")
print(fmt("description={description}"))
+ args.desc_html = re.sub(r'\b(job\d{6})\b',
+ fmt(r'\1'),
+ args.description)
# Create the branch specification
args.branch = fmt('{project}/{child}')
diff --git a/mps/tool/p4-bisect b/mps/tool/p4-bisect
new file mode 100755
index 00000000000..2886d823c59
--- /dev/null
+++ b/mps/tool/p4-bisect
@@ -0,0 +1,176 @@
+#!/usr/bin/env python
+#
+#
+# Ravenbrook
+#