X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fincludes%2FClosures.h;h=5f4eada7e1350c62f8b1c8a7de0fea94adf30ba3;hb=ac476ed9a8786f58f1bbc5132a017a63eb9b0c3e;hp=35578270461f3e7e7e9ace2deb39d2dd8d595102;hpb=612755bd52b4d422de179f4c0ca30b8afea336c1;p=ghc-hetmet.git diff --git a/ghc/includes/Closures.h b/ghc/includes/Closures.h index 3557827..5f4eada 100644 --- a/ghc/includes/Closures.h +++ b/ghc/includes/Closures.h @@ -1,5 +1,7 @@ /* ---------------------------------------------------------------------------- - * $Id: Closures.h,v 1.6 1999/02/05 12:41:31 sof Exp $ + * $Id: Closures.h,v 1.17 2000/03/31 03:09:35 hwloidl Exp $ + * + * (c) The GHC Team, 1998-1999 * * Closures * @@ -35,21 +37,39 @@ typedef struct { The parallel header -------------------------------------------------------------------------- */ -#ifdef GRAN +#ifdef PAR typedef struct { - W_ procs; -} StgGranHeader; + /* StgWord ga; */ /* nope! global addresses are managed via a hash table */ +} StgParHeader; #else /* !PAR */ typedef struct { /* empty */ -} StgGranHeader; +} 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 Comment from old Ticky.h: @@ -68,19 +88,19 @@ typedef struct { info tables to be @_Evacuate_1@ and @_Scavenge_1_0@. -------------------------------------------------------------------------- */ -#ifdef TICKY +#ifdef TICKY_TICKY typedef struct { - W_ updated; + /* old: W_ updated; */ } StgTickyHeader; -#else /* !TICKY */ +#else /* !TICKY_TICKY */ typedef struct { /* empty */ } StgTickyHeader; -#endif /* TICKY */ +#endif /* TICKY_TICKY */ /* ----------------------------------------------------------------------------- The full fixed-size closure header @@ -94,10 +114,13 @@ typedef struct { #ifdef PROFILING StgProfHeader prof; #endif +#ifdef PAR + StgParHeader par; +#endif #ifdef GRAN - StgGranHeader par; + StgGranHeader gran; #endif -#ifdef TICKY +#ifdef TICKY_TICKY StgTickyHeader ticky; #endif } StgHeader; @@ -156,6 +179,7 @@ typedef struct { StgWord n_ptrs; StgWord n_words; StgWord n_instrs; + StgWord stgexpr; StgPtr payload[0]; } StgBCO; @@ -177,20 +201,15 @@ typedef struct { } StgIndStatic; typedef struct StgCAF_ { - StgHeader header; - StgClosure *body; - StgClosure *value; + StgHeader header; + StgClosure *body; + StgMutClosure *mut_link; + StgClosure *value; struct StgCAF_ *link; } StgCAF; typedef struct { StgHeader header; - struct StgTSO_ *blocking_queue; - StgMutClosure *mut_link; -} StgBlockingQueue; - -typedef struct { - StgHeader header; StgWord words; StgWord payload[0]; } StgArrWords; @@ -208,6 +227,15 @@ typedef struct { StgMutClosure *mut_link; } StgMutVar; +/* + 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; @@ -222,6 +250,7 @@ typedef struct { typedef struct { StgHeader header; struct _StgUpdateFrame *link; + StgInt exceptions_blocked; StgClosure *handler; } StgCatchFrame; @@ -253,22 +282,27 @@ typedef struct _StgStableName { StgHeader header; StgWord sn; } StgStableName; - + typedef struct _StgWeak { /* Weak v */ StgHeader header; StgClosure *key; StgClosure *value; /* v */ - StgClosure *finaliser; + StgClosure *finalizer; struct _StgWeak *link; } StgWeak; +typedef struct _StgDeadWeak { /* Weak v */ + StgHeader header; + struct _StgWeak *link; +} StgDeadWeak; + /* Dynamic stack frames - these have a liveness mask in the object * itself, rather than in the info table. Useful for generic heap * check code. */ typedef struct { - StgHeader header; + const struct _StgInfoTable* info; StgWord liveness; StgWord ret_addr; StgWord payload[0]; @@ -284,12 +318,82 @@ typedef struct { StgClosure* value; } StgMVar; -/* Parallel FETCH_ME closures */ -#ifdef PAR -typedef struct { +#if defined(PAR) || defined(GRAN) +/* + 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; /* next elem in BQ */ + StgMutClosure *mut_link; /* next elem in mutable list */ + struct StgClosure_ *payload[0];/* 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; /* 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 (see RBH.c) */ +typedef struct StgRBHSave_ { StgHeader header; - void *ga; /* type globalAddr is abstract here */ + StgPtr payload[0]; /* 2 words ripped out of the guts of the */ +} StgRBHSave; /* closure holding the blocking queue */ + +typedef struct StgRBH_ { + StgHeader header; + struct StgBlockingQueueElement_ *blocking_queue; /* start of the BQ */ + StgMutClosure *mut_link; /* next elem in mutable list */ +} StgRBH; + +#else + +typedef struct StgBlockingQueue_ { + StgHeader header; + struct StgTSO_ *blocking_queue; + StgMutClosure *mut_link; +} StgBlockingQueue; + +#endif + +#if defined(PAR) +/* global indirections aka FETCH_ME closures */ +typedef struct StgFetchMe_ { + StgHeader header; + 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; /* start of the BQ */ + StgMutClosure *mut_link; /* next elem in mutable list */ +} StgFetchMeBlockingQueue; + +/* 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; /* 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 */