boehm-gc/include/gc_nursery.h

   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 *);