X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fincludes%2FStorage.h;h=035088e26b3f3f410da18390a953e260e4497a90;hb=91b07216be1cb09230b7d1b417899ddea8620ff3;hp=7d6fa00c7a150c1c804b3f34e258f7d9c6263d22;hpb=e7c3f957fd36fd9f6369183b7a31e2a4a4c21b43;p=ghc-hetmet.git diff --git a/ghc/includes/Storage.h b/ghc/includes/Storage.h index 7d6fa00..035088e 100644 --- a/ghc/includes/Storage.h +++ b/ghc/includes/Storage.h @@ -10,6 +10,7 @@ #define STORAGE_H #include +#include "OSThreads.h" /* ----------------------------------------------------------------------------- * Generational GC @@ -50,23 +51,29 @@ * * ------------------------------------------------------------------------- */ -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 */ int is_compacted; /* compact this step? (old gen only) */ + /* During GC, if we are collecting this step, blocks and n_blocks + * are copied into the following two fields. After GC, these blocks + * are freed. */ + bdescr * old_blocks; /* bdescr of first from-space block */ + unsigned int n_old_blocks; /* number of blocks in from-space */ + /* temporary use during GC: */ StgPtr hp; /* next free locn in to-space */ StgPtr hpLim; /* end of current to-space block */ bdescr * hp_bd; /* bdescr of current to-space block */ - bdescr * to_blocks; /* bdescr of first to-space block */ - unsigned int n_to_blocks; /* number of blocks in to-space */ + StgPtr scavd_hp; /* ... same as above, but already */ + StgPtr scavd_hpLim; /* scavenged. */ bdescr * scan_bd; /* block currently being scanned */ StgPtr scan; /* scan pointer in current block */ bdescr * new_large_objects; /* large objects collected so far */ @@ -75,7 +82,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 */ @@ -138,6 +145,7 @@ extern void exitStorage(void); -------------------------------------------------------------------------- */ extern StgPtr allocate ( nat n ); +extern StgPtr allocateLocal ( Capability *cap, nat n ); extern StgPtr allocatePinned ( nat n ); extern lnat allocated_bytes ( void ); @@ -192,17 +200,18 @@ 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) +#endif + +#if defined(SMP) +#define ACQUIRE_SM_LOCK ACQUIRE_LOCK(&sm_mutex); +#define RELEASE_SM_LOCK RELEASE_LOCK(&sm_mutex); +#define ASSERT_SM_LOCK() ASSERT_LOCK_HELD(&sm_mutex); #else #define ACQUIRE_SM_LOCK #define RELEASE_SM_LOCK +#define ASSERT_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 +226,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,11 +246,30 @@ 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). */ +extern rtsBool keepCAFs; + +/* ----------------------------------------------------------------------------- + This is the write barrier for MUT_VARs, a.k.a. IORefs. A + MUT_VAR_CLEAN object is not on the mutable list; a MUT_VAR_DIRTY + is. When written to, a MUT_VAR_CLEAN turns into a MUT_VAR_DIRTY + and is put on the mutable list. + -------------------------------------------------------------------------- */ + +void dirty_MUT_VAR(StgClosure *p); /* ----------------------------------------------------------------------------- DEBUGGING predicates for pointers @@ -265,6 +302,9 @@ void revertCAFs( void ); 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; } @@ -275,7 +315,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 @@ -286,9 +326,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); } @@ -342,17 +390,18 @@ 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 -------------------------------------------------------------------------- */ -extern void threadPaused ( StgTSO * ); +extern void threadPaused ( Capability *cap, StgTSO * ); extern StgClosure * isAlive ( StgClosure *p ); extern void markCAFs ( evac_fn evac ); @@ -370,6 +419,7 @@ extern lnat calcNeeded ( void ); extern void memInventory(void); extern void checkSanity(void); extern nat countBlocks(bdescr *); +extern void checkNurserySanity( step *stp ); #endif #if defined(DEBUG) @@ -388,11 +438,11 @@ extern void newDynCAF(StgClosure *); extern void move_TSO(StgTSO *src, StgTSO *dest); extern StgTSO *relocate_stack(StgTSO *dest, ptrdiff_t diff); -extern StgClosure * RTS_VAR(static_objects); extern StgClosure * RTS_VAR(scavenged_static_objects); extern StgWeak * RTS_VAR(old_weak_ptr_list); extern StgWeak * RTS_VAR(weak_ptr_list); 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 */