rts/sm/Storage.h

   1 /* -----------------------------------------------------------------------------
   2  *
   3  * (c) The GHC Team, 1998-2009
   4  *
   5  * External Storage Manger Interface
   6  *
   7  * ---------------------------------------------------------------------------*/
   8
   9 #ifndef SM_STORAGE_H
  10 #define SM_STORAGE_H
  11
  12 /* -----------------------------------------------------------------------------
  13    Initialisation / De-initialisation
  14    -------------------------------------------------------------------------- */
  15
  16 void initStorage(void);
  17 void exitStorage(void);
  18 void freeStorage(void);
  19
  20 /* -----------------------------------------------------------------------------
  21    Storage manager state
  22    -------------------------------------------------------------------------- */
  23
  24 extern bdescr * pinned_object_block;
  25
  26 extern nat alloc_blocks;
  27 extern nat alloc_blocks_lim;
  28
  29 INLINE_HEADER rtsBool
  30 doYouWantToGC( void )
  31 {
  32   return (alloc_blocks >= alloc_blocks_lim);
  33 }
  34
  35 /* for splitting blocks groups in two */
  36 bdescr * splitLargeBlock (bdescr *bd, nat blocks);
  37
  38 /* -----------------------------------------------------------------------------
  39    Generational garbage collection support
  40
  41    recordMutable(StgPtr p)       Informs the garbage collector that a
  42                                  previously immutable object has
  43                                  become (permanently) mutable.  Used
  44                                  by thawArray and similar.
  45
  46    updateWithIndirection(p1,p2)  Updates the object at p1 with an
  47                                  indirection pointing to p2.  This is
  48                                  normally called for objects in an old
  49                                  generation (>0) when they are updated.
  50
  51    updateWithPermIndirection(p1,p2)  As above but uses a permanent indir.
  52
  53    -------------------------------------------------------------------------- */
  54
  55 /*
  56  * Storage manager mutex
  57  */
  58 #if defined(THREADED_RTS)
  59 extern Mutex sm_mutex;
  60 #endif
  61
  62 #if defined(THREADED_RTS)
  63 #define ACQUIRE_SM_LOCK   ACQUIRE_LOCK(&sm_mutex);
  64 #define RELEASE_SM_LOCK   RELEASE_LOCK(&sm_mutex);
  65 #define ASSERT_SM_LOCK()  ASSERT_LOCK_HELD(&sm_mutex);
  66 #else
  67 #define ACQUIRE_SM_LOCK
  68 #define RELEASE_SM_LOCK
  69 #define ASSERT_SM_LOCK()
  70 #endif
  71
  72 INLINE_HEADER void
  73 recordMutableGen(StgClosure *p, nat gen_no)
  74 {
  75     bdescr *bd;
  76
  77     bd = generations[gen_no].mut_list;
  78     if (bd->free >= bd->start + BLOCK_SIZE_W) {
  79         bdescr *new_bd;
  80         new_bd = allocBlock();
  81         new_bd->link = bd;
  82         bd = new_bd;
  83         generations[gen_no].mut_list = bd;
  84     }
  85     *bd->free++ = (StgWord)p;
  86
  87 }
  88
  89 INLINE_HEADER void
  90 recordMutableGenLock(StgClosure *p, nat gen_no)
  91 {
  92     ACQUIRE_SM_LOCK;
  93     recordMutableGen(p,gen_no);
  94     RELEASE_SM_LOCK;
  95 }
  96
  97 INLINE_HEADER void
  98 recordMutable(StgClosure *p)
  99 {
 100     bdescr *bd;
 101     ASSERT(closure_MUTABLE(p));
 102     bd = Bdescr((P_)p);
 103     if (bd->gen_no > 0) recordMutableGen(p, bd->gen_no);
 104 }
 105
 106 INLINE_HEADER void
 107 recordMutableLock(StgClosure *p)
 108 {
 109     ACQUIRE_SM_LOCK;
 110     recordMutable(p);
 111     RELEASE_SM_LOCK;
 112 }
 113
 114 /* -----------------------------------------------------------------------------
 115    This is the write barrier for MUT_VARs, a.k.a. IORefs.  A
 116    MUT_VAR_CLEAN object is not on the mutable list; a MUT_VAR_DIRTY
 117    is.  When written to, a MUT_VAR_CLEAN turns into a MUT_VAR_DIRTY
 118    and is put on the mutable list.
 119    -------------------------------------------------------------------------- */
 120
 121 void dirty_MUT_VAR(StgRegTable *reg, StgClosure *p);
 122
 123 /* -----------------------------------------------------------------------------
 124    Similarly, the write barrier for MVARs
 125    -------------------------------------------------------------------------- */
 126
 127 void dirty_MVAR(StgRegTable *reg, StgClosure *p);
 128
 129 /* -----------------------------------------------------------------------------
 130    Nursery manipulation
 131    -------------------------------------------------------------------------- */
 132
 133 void     resetNurseries       ( void );
 134 void     resizeNurseries      ( nat blocks );
 135 void     resizeNurseriesFixed ( nat blocks );
 136 lnat     countNurseryBlocks   ( void );
 137
 138 /* -----------------------------------------------------------------------------
 139    Stats 'n' DEBUG stuff
 140    -------------------------------------------------------------------------- */
 141
 142 extern ullong total_allocated;
 143
 144 lnat    calcAllocated  (void);
 145 lnat    calcLiveBlocks (void);
 146 lnat    calcLiveWords  (void);
 147 lnat    countOccupied  (bdescr *bd);
 148 lnat    calcNeeded     (void);
 149 HsInt64 getAllocations (void);
 150
 151 #if defined(DEBUG)
 152 void    memInventory       (rtsBool show);
 153 void    checkSanity        (void);
 154 nat     countBlocks        (bdescr *);
 155 void    checkNurserySanity (step *stp);
 156 #endif
 157
 158 /* ----------------------------------------------------------------------------
 159    Storage manager internal APIs and globals
 160    ------------------------------------------------------------------------- */
 161
 162 #define END_OF_STATIC_LIST ((StgClosure*)1)
 163
 164 void move_TSO  (StgTSO *src, StgTSO *dest);
 165
 166 extern StgClosure * caf_list;
 167 extern StgClosure * revertible_caf_list;
 168
 169 #endif /* SM_STORAGE_H */