/* ----------------------------------------------------------------------------
- Time-stamp: <Thu Feb 24 2000 21:31:41 Stardate: [-30]4409.48 hwloidl>
- $Id: FetchMe.hc,v 1.5 2000/03/31 03:09:37 hwloidl Exp $
+ Time-stamp: <Tue Mar 06 2001 17:01:46 Stardate: [-30]6288.54 hwloidl>
Entry code for a FETCH_ME closure
//@node Includes, Info tables
//@subsection Includes
+#include "Stg.h"
#include "Rts.h"
#include "RtsFlags.h"
#include "RtsUtils.h"
checkClosure() (using the same fcts for determining the size of the
closures would be a good idea; at least it would be a nice step towards
making this code bug free).
-
- About the difference between std and PAR in returning to the RTS:
- in PAR we call RTS functions from within the entry code (see also
- BLACKHOLE_entry and friends in StgMiscClosures.hc); therefore, we
- have to save the thread state before calling these functions ---
- this is done via SAVE_THREAD_STATE; we then just load the return
- code into R1 before jumping into the RTS --- this is done via
- THREAD_RETURN; so, in short we have something like
- SAVE_THREAD_STATE + THREAD_RETURN = BLOCK_NP
-
------------------------------------------------------------------------ */
//@node Info tables, Index, Includes
//@subsection Info tables
//@cindex FETCH_ME_info
-INFO_TABLE(FETCH_ME_info, FETCH_ME_entry, 0,2, FETCH_ME, const, EF_,0,0);
+INFO_TABLE(stg_FETCH_ME_info, stg_FETCH_ME_entry, 0,2, FETCH_ME,, EF_,"FETCH_ME","FETCH_ME");
//@cindex FETCH_ME_entry
-STGFUN(FETCH_ME_entry)
+STGFUN(stg_FETCH_ME_entry)
{
- /*
- Not needed any more since we call blockThread in the scheduler
- (via BLOCK_NP(1) which returns with BlockedOnGA
-
- extern globalAddr *rga_GLOBAL;
- extern globalAddr *lga_GLOBAL;
- extern globalAddr fmbqga_GLOBAL;
- extern StgClosure *p_GLOBAL;
- globalAddr *rga;
- globalAddr *lga;
- globalAddr fmbqga;
- StgClosure *p;
- */
-
FB_
- /*
- rga_GLOBAL = ((StgFetchMe *)R1.p)->ga;
- ASSERT(rga->payload.gc.gtid != mytid);
- */
+ TICK_ENT_BH();
+
ASSERT(((StgFetchMe *)R1.p)->ga->payload.gc.gtid != mytid);
/* Turn the FETCH_ME into a FETCH_ME_BQ, and place the current thread
* on the blocking queue.
*/
- // R1.cl->header.info = FETCH_ME_BQ_info;
- SET_INFO((StgClosure *)R1.cl, &FETCH_ME_BQ_info);
+ // ((StgFetchMeBlockingQueue *)R1.cl)->header.info = &FETCH_ME_BQ_info; // does the same as SET_INFO
+ SET_INFO((StgClosure *)R1.cl, &stg_FETCH_ME_BQ_info);
+ /* Remember GA as a global var (used in blockThread); NB: not thread safe! */
+ ASSERT(theGlobalFromGA.payload.gc.gtid == (GlobalTaskId)0);
+ theGlobalFromGA = *((StgFetchMe *)R1.p)->ga;
+
/* Put ourselves on the blocking queue for this black hole */
- // This is really, really BAD; tmp HACK to remember ga (checked in blockThread)
ASSERT(looks_like_ga(((StgFetchMe *)R1.p)->ga));
- CurrentTSO->link = (StgBlockingQueueElement *)((StgFetchMe *)R1.p)->ga; // END_BQ_QUEUE;
+ CurrentTSO->link = END_BQ_QUEUE;
((StgFetchMeBlockingQueue *)R1.cl)->blocking_queue = (StgBlockingQueueElement *)CurrentTSO;
/* jot down why and on what closure we are blocked */
CurrentTSO->why_blocked = BlockedOnGA;
CurrentTSO->block_info.closure = R1.cl;
+ /* closure is mutable since something has just been added to its BQ */
//recordMutable((StgMutClosure *)R1.cl);
- //p_GLOBAL = R1.cl;
/* sendFetch etc is now done in blockThread, which is called from the
scheduler -- HWL */
When the data arrives from the remote PE, all waiting threads are
woken up and the FETCH_ME_BQ is overwritten with the fetched data.
- FETCH_ME_BQ_entry is a copy of BLACKHOLE_BQ_entry -- HWL
+ FETCH_ME_BQ_entry is almost identical to BLACKHOLE_BQ_entry -- HWL
------------------------------------------------------------------------ */
-INFO_TABLE(FETCH_ME_BQ_info, FETCH_ME_BQ_entry,0,2,FETCH_ME_BQ,const,EF_,0,0);
+INFO_TABLE(stg_FETCH_ME_BQ_info, stg_FETCH_ME_BQ_entry,0,2,FETCH_ME_BQ,,EF_,"FETCH_ME_BQ","FETCH_ME_BQ");
//@cindex FETCH_ME_BQ_info
-STGFUN(FETCH_ME_BQ_entry)
+STGFUN(stg_FETCH_ME_BQ_entry)
{
FB_
TICK_ENT_BH();
/* Put ourselves on the blocking queue for this node */
- CurrentTSO->link = ((StgBlockingQueue *)R1.p)->blocking_queue;
- ((StgBlockingQueue *)R1.p)->blocking_queue = CurrentTSO;
+ CurrentTSO->link = (StgTSO*)((StgBlockingQueue *)R1.p)->blocking_queue;
+ ((StgBlockingQueue *)R1.p)->blocking_queue = (StgBlockingQueueElement *)CurrentTSO;
/* jot down why and on what closure we are blocked */
CurrentTSO->why_blocked = BlockedOnGA_NoSend;
computation. Thus, when updating the closure, the result has to be sent
to that PE. The relevant routines handling that are awakenBlockedQueue
and blockFetch (for putting BLOCKED_FETCH closure into a BQ).
-*/
+ ------------------------------------------------------------------------ */
//@cindex BLOCKED_FETCH_info
-INFO_TABLE(BLOCKED_FETCH_info, BLOCKED_FETCH_entry,0,2,BLOCKED_FETCH,const,EF_,0,0);
+INFO_TABLE(stg_BLOCKED_FETCH_info, stg_BLOCKED_FETCH_entry,0,2,BLOCKED_FETCH,,EF_,"BLOCKED_FETCH","BLOCKED_FETCH");
//@cindex BLOCKED_FETCH_entry
-STGFUN(BLOCKED_FETCH_entry)
+STGFUN(stg_BLOCKED_FETCH_entry)
{
FB_
/* see NON_ENTERABLE_ENTRY_CODE in StgMiscClosures.hc */
FE_
}
+
+/* ---------------------------------------------------------------------------
+ REMOTE_REF
+
+ A REMOTE_REF closure is generated whenever we wish to refer to a sticky
+ object on another PE.
+ ------------------------------------------------------------------------ */
+
+//@cindex REMOTE_REF_info
+INFO_TABLE(stg_REMOTE_REF_info, stg_REMOTE_REF_entry,0,2,REMOTE_REF,,EF_,"REMOTE_REF","REMOTE_REF");
+//@cindex REMOTE_REF_entry
+STGFUN(stg_REMOTE_REF_entry)
+{
+ FB_
+ /* see NON_ENTERABLE_ENTRY_CODE in StgMiscClosures.hc */
+ STGCALL2(fprintf,stderr,"REMOTE REF object entered!\n");
+ STGCALL1(shutdownHaskellAndExit, EXIT_FAILURE);
+ FE_
+}
+
#endif /* PAR */
//@node Index, , Info tables
projects / ghc-hetmet.git / blobdiff