Return to gc_nursery.h CVS log

Up to [local] / OpenXM_contrib / gc / include

Annotation of OpenXM_contrib/gc/include/gc_nursery.h, Revision 1.1

1.1     ! maekawa     1:
        !             2: /*
        !             3:  * Copyright (c) 1999 by Silicon Graphics.  All rights reserved.
        !             4:  *
        !             5:  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
        !             6:  * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
        !             7:  *
        !             8:  * Permission is hereby granted to use or copy this program
        !             9:  * for any purpose,  provided the above notices are retained on all copies.
        !            10:  * Permission to modify the code and to distribute modified code is granted,
        !            11:  * provided the above notices are retained, and a notice that the code was
        !            12:  * modified is included with the above copyright notice.
        !            13:  */
        !            14:
        !            15: /*
        !            16:  * THIS IMPLEMENTATION FOR THIS INTERFACE IS INCOMPLETE.
        !            17:  * NONE OF THIS HAS BEEN TESTED.  DO NOT USE.
        !            18:  *
        !            19:  * Comments on the interface are appreciated, especially from
        !            20:  * potential users of the interface.
        !            21:  *
        !            22:  * This is a Bartlett style copying collector for young objects.
        !            23:  * We assume for now that all objects allocated through this
        !            24:  * mechanism have pointers only in the first BITMAP_BITS words.
        !            25:  * (On a 32-bit machine, BITMAP_BITS is 30.)
        !            26:  * Objects allocated in this manner should be rarely referenced
        !            27:  * by objects not allocated either through this interface, or through
        !            28:  * the typed allocation interface.
        !            29:  * If this interface is used, we assume that type information provided
        !            30:  * through either this or the typed allocation interface is valid
        !            31:  * in a stronger sense:
        !            32:  *
        !            33:  * 1) No pointers are stored in fields not marked as such.
        !            34:  *    (Otherwise it is only necessary that objects referenced by
        !            35:  *    fields marked as nonpointers are also reachable via another
        !            36:  *    path.)
        !            37:  * 2) Values stored in pointer fields are either not addresses in
        !            38:  *    the heap, or they really are pointers.  In the latter case, it
        !            39:  *    is acceptable to move the object they refer to, and to update
        !            40:  *    the pointer.
        !            41:  *
        !            42:  * GC_free may not be invoked on objects allocated with GC_copying_malloc.
        !            43:  *
        !            44:  * No extra space is added to the end of objects allocated through this
        !            45:  * interface.  If the client needs to maintain pointers past the
        !            46:  * end, the size should be explicitly padded.
        !            47:  *
        !            48:  * We assume that calls to this will usually be compiler generated.
        !            49:  * Hence the interface is allowed to be a bit ugly in return for speed.
        !            50:  */
        !            51:
        !            52: #include "gc_copy_descr.h"
        !            53:
        !            54: /* GC_copy_descr.h must define                                         */
        !            55: /* GC_SIZE_FROM_DESCRIPTOR(descr) and                                  */
        !            56: /* GC_BIT_MAP_FROM_DESCRIPTOR(descr).                                  */
        !            57: /* It may either be the GC supplied version of the header file, or a   */
        !            58: /* client specific one that derives the information from a client-     */
        !            59: /* specific type descriptor.                                           */
        !            60:
        !            61: typedef GC_PTR GC_copy_alloc_state;
        !            62:                                /* Current allocator state.     */
        !            63:                                /* Multiple allocation states   */
        !            64:                                /* may be used for concurrent   */
        !            65:                                /* allocation, or to enhance    */
        !            66:                                /* locality.                    */
        !            67:                                /* Should be treated as opaque. */
        !            68:
        !            69: /* Allocate a memory block of size given in the descriptor, and with   */
        !            70: /* pointer layout given by the descriptor.  The resulting block may not        */
        !            71: /* be cleared, and should immediately be initialized by the client.    */
        !            72: /* (A concurrent GC may see an uninitialized pointer field.  If it     */
        !            73: /* points outside the nursery, that's fine.  If it points inside, it   */
        !            74: /* may retain an object, and be relocated.  But that's also fine, since        */
        !            75: /* the new value will be immediately overwritten.                      */
        !            76: /* This variant acquires the allocation lock, and uses a default       */
        !            77: /* global allocation state.                                            */
        !            78: GC_PTR GC_copying_malloc(GC_copy_descriptor);
        !            79:
        !            80: /* A variant of the above that does no locking on the fast path,       */
        !            81: /* and passes an explicit pointer to an allocation state.              */
        !            82: /* The allocation state is updated.                                    */
        !            83: /* There will eventually need to be a macro or inline function version */
        !            84: /* of this.                                                            */
        !            85: GC_PTR GC_copying_malloc2(GC_copy_descriptor, GC_copy_alloc_state *);
        !            86:
        !            87: /* Initialize an allocation state so that it can be used for   */
        !            88: /* allocation.  This implicitly reserves a small section of the        */
        !            89: /* nursery for use with this allocator.                                */
        !            90: void GC_init_copy_alloc_state(GC_copy_alloc_state *);