[project @ 2005-04-28 15:28:05 by simonmar]

[ghc-hetmet.git] / ghc / includes / Storage.h

diff --git a/ghc/includes/Storage.h b/ghc/includes/Storage.h
index 7108bc6..a8a6d24 100644 (file)
--- a/ghc/includes/Storage.h
+++ b/ghc/includes/Storage.h
@@ -10,6 +10,7 @@
 #define STORAGE_H
 
 #include <stddef.h>
+#include "OSThreads.h"
 
 /* -----------------------------------------------------------------------------
  * Generational GC
@@ -50,12 +51,12 @@
  *
  * ------------------------------------------------------------------------- */
 
-typedef struct _step {
+typedef struct step_ {
   unsigned int         no;             /* step number */
   bdescr *             blocks;         /* blocks in this step */
   unsigned int         n_blocks;       /* number of blocks */
-  struct _step *       to;             /* destination step for live objects */
-  struct _generation * gen;            /* generation this step belongs to */
+  struct step_ *       to;             /* destination step for live objects */
+  struct generation_ * gen;            /* generation this step belongs to */
   unsigned int         gen_no;          /* generation number (cached) */
   bdescr *             large_objects;  /* large objects (doubly linked) */
   unsigned int         n_large_blocks;  /* no. of blocks used by large objs */
@@ -75,7 +76,7 @@ typedef struct _step {
   bdescr *     bitmap;                 /* bitmap for compacting collection */
 } step;
 
-typedef struct _generation {
+typedef struct generation_ {
   unsigned int   no;                   /* generation number */
   step *         steps;                        /* steps */
   unsigned int   n_steps;              /* number of steps */
@@ -192,17 +193,13 @@ extern void GarbageCollect(void (*get_roots)(evac_fn),rtsBool force_major_gc);
  */
 #if defined(SMP)
 extern Mutex sm_mutex;
-#define ACQUIRE_SM_LOCK   ACQUIRE_LOCK(&sm_mutex)
-#define RELEASE_SM_LOCK   RELEASE_LOCK(&sm_mutex)
+#define ACQUIRE_SM_LOCK   ACQUIRE_LOCK(&sm_mutex);
+#define RELEASE_SM_LOCK   RELEASE_LOCK(&sm_mutex);
 #else
 #define ACQUIRE_SM_LOCK
 #define RELEASE_SM_LOCK
 #endif
 
-/* ToDo: shouldn't recordMutable acquire some
- * kind of lock in the SMP case?  Or do we need per-processor
- * mutable lists?
- */
 INLINE_HEADER void
 recordMutableGen(StgClosure *p, generation *gen)
 {
@@ -217,6 +214,15 @@ recordMutableGen(StgClosure *p, generation *gen)
        gen->mut_list = bd;
     }
     *bd->free++ = (StgWord)p;
+
+}
+
+INLINE_HEADER void
+recordMutableGenLock(StgClosure *p, generation *gen)
+{
+    ACQUIRE_SM_LOCK;
+    recordMutableGen(p,gen);
+    RELEASE_SM_LOCK;
 }
 
 INLINE_HEADER void
@@ -228,14 +234,20 @@ recordMutable(StgClosure *p)
     if (bd->gen_no > 0) recordMutableGen(p, &RTS_DEREF(generations)[bd->gen_no]);
 }
 
+INLINE_HEADER void
+recordMutableLock(StgClosure *p)
+{
+    ACQUIRE_SM_LOCK;
+    recordMutable(p);
+    RELEASE_SM_LOCK;
+}
+
 /* -----------------------------------------------------------------------------
    The CAF table - used to let us revert CAFs in GHCi
    -------------------------------------------------------------------------- */
 
-void revertCAFs( void );
-
-    // set to disable CAF garbage collection in GHCi.
-    // (needed when dynamic libraries are used).
+/* set to disable CAF garbage collection in GHCi. */
+/* (needed when dynamic libraries are used). */
 extern rtsBool keepCAFs;
 
 /* -----------------------------------------------------------------------------
@@ -269,6 +281,9 @@ extern rtsBool keepCAFs;
 INLINE_HEADER StgOffset PAP_sizeW   ( nat n_args )
 { return sizeofW(StgPAP) + n_args; }
 
+INLINE_HEADER StgOffset AP_sizeW   ( nat n_args )
+{ return sizeofW(StgAP) + n_args; }
+
 INLINE_HEADER StgOffset AP_STACK_sizeW ( nat size )
 { return sizeofW(StgAP_STACK) + size; }
 
@@ -279,7 +294,7 @@ INLINE_HEADER StgOffset THUNK_SELECTOR_sizeW ( void )
 { return stg_max(sizeofW(StgHeader)+MIN_UPD_SIZE, sizeofW(StgSelector)); }
 
 INLINE_HEADER StgOffset BLACKHOLE_sizeW ( void )
-{ return stg_max(sizeofW(StgHeader)+MIN_UPD_SIZE, sizeofW(StgBlockingQueue)); }
+{ return sizeofW(StgHeader)+MIN_UPD_SIZE; }
 
 /* --------------------------------------------------------------------------
    Sizes of closures
@@ -290,9 +305,17 @@ INLINE_HEADER StgOffset sizeW_fromITBL( const StgInfoTable* itbl )
        + sizeofW(StgPtr)  * itbl->layout.payload.ptrs 
        + sizeofW(StgWord) * itbl->layout.payload.nptrs; }
 
+INLINE_HEADER StgOffset thunk_sizeW_fromITBL( const StgInfoTable* itbl ) 
+{ return sizeofW(StgThunk) 
+       + sizeofW(StgPtr)  * itbl->layout.payload.ptrs 
+       + sizeofW(StgWord) * itbl->layout.payload.nptrs; }
+
 INLINE_HEADER StgOffset ap_stack_sizeW( StgAP_STACK* x )
 { return AP_STACK_sizeW(x->size); }
 
+INLINE_HEADER StgOffset ap_sizeW( StgAP* x )
+{ return AP_sizeW(x->n_args); }
+
 INLINE_HEADER StgOffset pap_sizeW( StgPAP* x )
 { return PAP_sizeW(x->n_args); }
 
@@ -346,11 +369,12 @@ INLINE_HEADER StgWord stack_frame_sizeW( StgClosure *frame )
    Nursery manipulation
    -------------------------------------------------------------------------- */
 
-extern void     allocNurseries ( void );
-extern void     resetNurseries ( void );
-extern bdescr * allocNursery   ( bdescr *last_bd, nat blocks );
-extern void     resizeNursery  ( nat blocks );
-extern void     tidyAllocateLists ( void );
+extern void     allocNurseries       ( void );
+extern void     resetNurseries       ( void );
+extern void     resizeNurseries      ( nat blocks );
+extern void     resizeNurseriesFixed ( nat blocks );
+extern void     tidyAllocateLists    ( void );
+extern lnat     countNurseryBlocks   ( void );
 
 /* -----------------------------------------------------------------------------
    Functions from GC.c 
@@ -400,4 +424,4 @@ extern StgClosure * RTS_VAR(caf_list);
 extern StgClosure * RTS_VAR(revertible_caf_list);
 extern StgTSO     * RTS_VAR(resurrected_threads);
 
-#endif // STORAGE_H
+#endif /* STORAGE_H */