summaryrefslogtreecommitdiff
path: root/nursery.h
diff options
context:
space:
mode:
Diffstat (limited to 'nursery.h')
-rwxr-xr-xnursery.h90
1 files changed, 90 insertions, 0 deletions
diff --git a/nursery.h b/nursery.h
new file mode 100755
index 0000000..d109ff0
--- /dev/null
+++ b/nursery.h
@@ -0,0 +1,90 @@
+
+/*
+ * Copyright (c) 1999 by Silicon Graphics. All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+/*
+ * THIS IMPLEMENTATION FOR THIS INTERFACE IS INCOMPLETE.
+ * NONE OF THIS HAS BEEN TESTED. DO NOT USE.
+ *
+ * Comments on the interface are appreciated, especially from
+ * potential users of the interface.
+ *
+ * This is a Bartlett style copying collector for young objects.
+ * We assume for now that all objects allocated through this
+ * mechanism have pointers only in the first BITMAP_BITS words.
+ * (On a 32-bit machine, BITMAP_BITS is 30.)
+ * Objects allocated in this manner should be rarely referenced
+ * by objects not allocated either through this interface, or through
+ * the typed allocation interface.
+ * If this interface is used, we assume that type information provided
+ * through either this or the typed allocation interface is valid
+ * in a stronger sense:
+ *
+ * 1) No pointers are stored in fields not marked as such.
+ * (Otherwise it is only necessary that objects referenced by
+ * fields marked as nonpointers are also reachable via another
+ * path.)
+ * 2) Values stored in pointer fields are either not addresses in
+ * the heap, or they really are pointers. In the latter case, it
+ * is acceptable to move the object they refer to, and to update
+ * the pointer.
+ *
+ * GC_free may not be invoked on objects allocated with GC_copying_malloc.
+ *
+ * No extra space is added to the end of objects allocated through this
+ * interface. If the client needs to maintain pointers past the
+ * end, the size should be explicitly padded.
+ *
+ * We assume that calls to this will usually be compiler generated.
+ * Hence the interface is allowed to be a bit ugly in return for speed.
+ */
+
+#include "gc_copy_descr.h"
+
+/* GC_copy_descr.h must define */
+/* GC_SIZE_FROM_DESCRIPTOR(descr) and */
+/* GC_BIT_MAP_FROM_DESCRIPTOR(descr). */
+/* It may either be the GC supplied version of the header file, or a */
+/* client specific one that derives the information from a client- */
+/* specific type descriptor. */
+
+typedef GC_PTR GC_copy_alloc_state;
+ /* Current allocator state. */
+ /* Multiple allocation states */
+ /* may be used for concurrent */
+ /* allocation, or to enhance */
+ /* locality. */
+ /* Should be treated as opaque. */
+
+/* Allocate a memory block of size given in the descriptor, and with */
+/* pointer layout given by the descriptor. The resulting block may not */
+/* be cleared, and should immediately be initialized by the client. */
+/* (A concurrent GC may see an uninitialized pointer field. If it */
+/* points outside the nursery, that's fine. If it points inside, it */
+/* may retain an object, and be relocated. But that's also fine, since */
+/* the new value will be immediately overwritten. */
+/* This variant acquires the allocation lock, and uses a default */
+/* global allocation state. */
+GC_PTR GC_copying_malloc(GC_copy_descriptor);
+
+/* A variant of the above that does no locking on the fast path, */
+/* and passes an explicit pointer to an allocation state. */
+/* The allocation state is updated. */
+/* There will eventually need to be a macro or inline function version */
+/* of this. */
+GC_PTR GC_copying_malloc2(GC_copy_descriptor, GC_copy_alloc_state *);
+
+/* Initialize an allocation state so that it can be used for */
+/* allocation. This implicitly reserves a small section of the */
+/* nursery for use with this allocator. */
+void GC_init_copy_alloc_state(GC_copy_alloc_state *);