X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fincludes%2FClosures.h;h=5f0b5709542fab2586fd4dacd9db4fd0c286ee75;hb=22584fda405fbf88eed7132d372ce2b404a96329;hp=85d87042605dd61e6a4a4480588608ad25eb6361;hpb=5fec2547a787bdf4a8867cd000b2816b81204d69;p=ghc-hetmet.git diff --git a/ghc/includes/Closures.h b/ghc/includes/Closures.h index 85d8704..5f0b570 100644 --- a/ghc/includes/Closures.h +++ b/ghc/includes/Closures.h @@ -1,5 +1,5 @@ /* ---------------------------------------------------------------------------- - * $Id: Closures.h,v 1.16 2000/01/18 12:36:38 simonmar Exp $ + * $Id: Closures.h,v 1.28 2001/10/03 13:57:42 simonmar Exp $ * * (c) The GHC Team, 1998-1999 * @@ -19,56 +19,26 @@ The profiling header -------------------------------------------------------------------------- */ -#ifdef PROFILING - typedef struct { CostCentreStack *ccs; } StgProfHeader; -#else /* !PROFILING */ - -typedef struct { - /* empty */ -} StgProfHeader; - -#endif /* PROFILING */ - /* ----------------------------------------------------------------------------- The parallel header -------------------------------------------------------------------------- */ -#ifdef PAR - typedef struct { /* StgWord ga; */ /* nope! global addresses are managed via a hash table */ } StgParHeader; -#else /* !PAR */ - -typedef struct { - /* empty */ -} StgParHeader; - -#endif /* PAR */ - /* ----------------------------------------------------------------------------- The GranSim header -------------------------------------------------------------------------- */ -#if defined(GRAN) - typedef struct { StgWord procs; /* bitmask indicating on which PEs this closure resides */ } StgGranHeader; -#else /* !GRAN */ - -typedef struct { - /* empty */ -} StgGranHeader; - -#endif /* GRAN */ - /* ----------------------------------------------------------------------------- The ticky-ticky header @@ -88,20 +58,10 @@ typedef struct { info tables to be @_Evacuate_1@ and @_Scavenge_1_0@. -------------------------------------------------------------------------- */ -#ifdef TICKY_TICKY - typedef struct { /* old: W_ updated; */ } StgTickyHeader; -#else /* !TICKY_TICKY */ - -typedef struct { - /* empty */ -} StgTickyHeader; - -#endif /* TICKY_TICKY */ - /* ----------------------------------------------------------------------------- The full fixed-size closure header @@ -137,10 +97,10 @@ typedef struct { /* All closures follow the generic format */ -typedef struct StgClosure_ { +struct StgClosure_ { StgHeader header; - struct StgClosure_ *payload[0]; -} StgClosure; + struct StgClosure_ *payload[FLEXIBLE_ARRAY]; +}; /* What a stroke of luck - all our mutable closures follow the same * basic layout, with the mutable link field as the second field after @@ -150,9 +110,9 @@ typedef struct StgClosure_ { typedef struct StgMutClosure_ { StgHeader header; - StgPtr *padding; + StgWord padding; struct StgMutClosure_ *mut_link; - struct StgClosure_ *payload[0]; + struct StgClosure_ *payload[FLEXIBLE_ARRAY]; } StgMutClosure; typedef struct { @@ -164,26 +124,17 @@ typedef struct { StgHeader header; StgWord n_args; StgClosure *fun; - StgPtr payload[0]; + StgClosure *payload[FLEXIBLE_ARRAY]; } StgPAP; typedef struct { StgHeader header; StgWord n_args; StgClosure *fun; - StgPtr payload[0]; + StgClosure *payload[FLEXIBLE_ARRAY]; } StgAP_UPD; typedef struct { - StgHeader header; - StgWord n_ptrs; - StgWord n_words; - StgWord n_instrs; - StgWord stgexpr; - StgPtr payload[0]; -} StgBCO; - -typedef struct { StgHeader header; StgClosure *indirectee; } StgInd; @@ -195,30 +146,23 @@ typedef struct { } StgIndOldGen; typedef struct { - StgHeader header; - StgClosure *indirectee; - StgClosure *static_link; -} StgIndStatic; - -typedef struct StgCAF_ { StgHeader header; - StgClosure *body; - StgMutClosure *mut_link; - StgClosure *value; - struct StgCAF_ *link; -} StgCAF; + StgClosure *indirectee; + StgClosure *static_link; + struct _StgInfoTable *saved_info; +} StgIndStatic; typedef struct { StgHeader header; StgWord words; - StgWord payload[0]; + StgWord payload[FLEXIBLE_ARRAY]; } StgArrWords; typedef struct { StgHeader header; StgWord ptrs; StgMutClosure *mut_link; /* mutable list */ - StgClosure *payload[0]; + StgClosure *payload[FLEXIBLE_ARRAY]; } StgMutArrPtrs; typedef struct { @@ -227,6 +171,23 @@ typedef struct { StgMutClosure *mut_link; } StgMutVar; +typedef struct { + StgHeader header; + StgArrWords *instrs; /* a pointer to an ArrWords */ + StgArrWords *literals; /* a pointer to an ArrWords */ + StgMutArrPtrs *ptrs; /* a pointer to a MutArrPtrs */ + StgArrWords *itbls; /* a pointer to an ArrWords */ +} StgBCO; + +/* + A collective typedef for all linkable stack frames i.e. + StgUpdateFrame, StgSeqFrame, StgCatchFrame +*/ +typedef struct _StgFrame { + StgHeader header; + struct _StgFrame *link; +} StgFrame; + typedef struct _StgUpdateFrame { StgHeader header; struct _StgUpdateFrame *link; @@ -296,7 +257,7 @@ typedef struct { const struct _StgInfoTable* info; StgWord liveness; StgWord ret_addr; - StgWord payload[0]; + StgWord payload[FLEXIBLE_ARRAY]; } StgRetDyn; /* Concurrent communication objects */ @@ -311,35 +272,40 @@ typedef struct { #if defined(PAR) || defined(GRAN) /* - StgBlockingQueueElement represents the types of closures that can be - found on a blocking queue: StgTSO, StgRBHSave, StgBlockedFetch. - (StgRBHSave can only appear at the end of a blocking queue). - Logically, this is a union type, but defining another struct with a common - layout is easier to handle in the code (same as for StgMutClosures). + StgBlockingQueueElement is a ``collective type'' representing the types + of closures that can be found on a blocking queue: StgTSO, StgRBHSave, + StgBlockedFetch. (StgRBHSave can only appear at the end of a blocking + queue). Logically, this is a union type, but defining another struct + with a common layout is easier to handle in the code (same as for + StgMutClosures). + Note that in the standard setup only StgTSOs can be on a blocking queue. + This is one of the main reasons for slightly different code in files + such as Schedule.c. */ typedef struct StgBlockingQueueElement_ { StgHeader header; - struct StgBlockingQueueElement_ *link; - StgMutClosure *mut_link; - struct StgClosure_ *payload[0]; + struct StgBlockingQueueElement_ *link; /* next elem in BQ */ + StgMutClosure *mut_link; /* next elem in mutable list */ + struct StgClosure_ *payload[FLEXIBLE_ARRAY];/* contents of the closure */ } StgBlockingQueueElement; +/* only difference to std code is type of the elem in the BQ */ typedef struct StgBlockingQueue_ { StgHeader header; - struct StgBlockingQueueElement_ *blocking_queue; - StgMutClosure *mut_link; + struct StgBlockingQueueElement_ *blocking_queue; /* start of the BQ */ + StgMutClosure *mut_link; /* next elem in mutable list */ } StgBlockingQueue; -/* this closure is hanging at the end of a blocking queue in (par setup only) */ +/* this closure is hanging at the end of a blocking queue in (see RBH.c) */ typedef struct StgRBHSave_ { StgHeader header; - StgPtr payload[0]; -} StgRBHSave; - + StgClosure *payload[FLEXIBLE_ARRAY]; /* 2 words ripped out of the guts of the */ +} StgRBHSave; /* closure holding the blocking queue */ + typedef struct StgRBH_ { - StgHeader header; - struct StgBlockingQueueElement_ *blocking_queue; - StgMutClosure *mut_link; + StgHeader header; + struct StgBlockingQueueElement_ *blocking_queue; /* start of the BQ */ + StgMutClosure *mut_link; /* next elem in mutable list */ } StgRBH; #else @@ -356,25 +322,30 @@ typedef struct StgBlockingQueue_ { /* global indirections aka FETCH_ME closures */ typedef struct StgFetchMe_ { StgHeader header; - globalAddr *ga; /* type globalAddr is abstract here */ - StgMutClosure *mut_link; + globalAddr *ga; /* ptr to unique id for a closure */ + StgMutClosure *mut_link; /* next elem in mutable list */ } StgFetchMe; /* same contents as an ordinary StgBlockingQueue */ typedef struct StgFetchMeBlockingQueue_ { StgHeader header; - struct StgBlockingQueueElement_ *blocking_queue; - StgMutClosure *mut_link; + struct StgBlockingQueueElement_ *blocking_queue; /* start of the BQ */ + StgMutClosure *mut_link; /* next elem in mutable list */ } StgFetchMeBlockingQueue; -/* entry in a blocking queue, indicating a request from a TSO on another PE */ +/* This is an entry in a blocking queue. It indicates a fetch request from a + TSO on another PE demanding the value of this closur. Note that a + StgBlockedFetch can only occur in a BQ. Once the node is evaluated and + updated with the result, the result will be sent back (the PE is encoded + in the globalAddr) and the StgBlockedFetch closure will be nuked. +*/ typedef struct StgBlockedFetch_ { StgHeader header; - struct StgBlockingQueueElement_ *link; - StgMutClosure *mut_link; - StgClosure *node; - globalAddr ga; -} StgBlockedFetch; + struct StgBlockingQueueElement_ *link; /* next elem in the BQ */ + StgMutClosure *mut_link; /* next elem in mutable list */ + StgClosure *node; /* node to fetch */ + globalAddr ga; /* where to send the result to */ +} StgBlockedFetch; /* NB: not just a ptr to a GA */ #endif #endif /* CLOSURES_H */