2 % (c) Kevin Hammond, Parade/AQUA Projects, Glasgow University, February 15th. 1995
4 % This is for GUM only.
6 %************************************************************************
8 \section[Parallel.lh]{Definitions for parallel machines}
10 %************************************************************************
12 Multi-slurp protection:
18 This section contains definitions applicable only to programs compiled
19 to run on a parallel machine. Some of these things can probably be
20 ripped out now that we don't store GAs in closures, but beware that
21 this {\em might} break GranSim, so check first! KH
23 These basic definitions need to be around, one way or the other:
25 #define PAR_FIXED_HDR (GA_HDR_SIZE)
26 #define PAR_HDR_POSN AFTER_INFO_HDR
27 #define AFTER_PAR_HDR (PAR_HDR_POSN+PAR_FIXED_HDR)
29 #define SET_PAR_HDR(closure,ga) /* nothing */
30 #define SET_STATIC_PAR_HDR(closure) /* nothing */
35 # define MAX_PES 256 /* Maximum number of processors */
36 /* MAX_PES is enforced by SysMan, which does not
37 allow more than this many "processors".
38 This is important because PackGA [GlobAddr.lc]
39 **assumes** that a PE# can fit in 8+ bits.
42 extern I_ do_sp_profile;
44 extern P_ PendingFetches;
45 extern GLOBAL_TASK_ID *PEs;
47 extern rtsBool IAmMainThread, GlobalStopPending;
48 extern rtsBool fishing;
49 extern GLOBAL_TASK_ID SysManTask;
50 extern int seed; /*pseudo-random-number generator seed:*/
51 /*Initialised in ParInit*/
52 extern I_ threadId; /*Number of Threads that have existed on a PE*/
53 extern GLOBAL_TASK_ID mytid;
57 extern rtsBool InGlobalGC; /* Are we in the midst of performing global GC */
59 extern HashTable *pGAtoGALAtable;
60 extern HashTable *LAtoGALAtable;
61 extern GALA *freeIndirections;
62 extern GALA *liveIndirections;
63 extern GALA *freeGALAList;
64 extern GALA *liveRemoteGAs;
67 void RunParallelSystem PROTO((StgPtr program_closure));
68 void initParallelSystem(STG_NO_ARGS);
69 void SynchroniseSystem(STG_NO_ARGS);
71 void registerTask PROTO((GLOBAL_TASK_ID gtid));
72 globalAddr *LAGAlookup PROTO((P_ addr));
73 P_ GALAlookup PROTO((globalAddr *ga));
74 globalAddr *MakeGlobal PROTO((P_ addr, rtsBool preferred));
75 globalAddr *setRemoteGA PROTO((P_ addr, globalAddr *ga, rtsBool preferred));
76 void splitWeight PROTO((globalAddr *to, globalAddr *from));
77 globalAddr *addWeight PROTO((globalAddr *ga));
78 void initGAtables(STG_NO_ARGS);
79 W_ taskIDtoPE PROTO((GLOBAL_TASK_ID gtid));
80 void RebuildLAGAtable(STG_NO_ARGS);
82 void *lookupHashTable PROTO((HashTable *table, StgWord key));
83 void insertHashTable PROTO((HashTable *table, StgWord key, void *data));
84 void freeHashTable PROTO((HashTable *table, void (*freeDataFun) PROTO((void *data))));
85 HashTable *allocHashTable(STG_NO_ARGS);
86 void *removeHashTable PROTO((HashTable *table, StgWord key, void *data));
89 Redefining exit is more trouble than its worth, IMO -- SOF
91 extern void myexit PROTO((I_));
93 /* # define exit : error : Wrong exit! */
100 %************************************************************************
102 \subsection[anti-parallel-SM]{But if we're {\em not} compiling for a parallel system...}
104 %************************************************************************
106 Get this out of the way. These are all null definitions.
109 # if !(defined(GRAN) || defined(PAR))
111 # define GA_HDR_SIZE 0
112 # define GA(closure) /*nothing*/
114 # define SET_GA(closure,ga) /* nothing */
115 # define SET_STATIC_GA(closure) /* nothing */
116 # define SET_GRAN_HDR(closure,pe) /* nothing */
117 # define SET_STATIC_PROCS(closure) /* nothing */
119 # define SET_TASK_ACTIVITY(act) /* nothing */
125 # define GA_HDR_SIZE 1
127 # define PROCS_HDR_POSN PAR_HDR_POSN
128 # define PROCS_HDR_SIZE 1
130 /* Accessing components of the field */
131 # define PROCS(closure) (*((P_)(closure)+PROCS_HDR_POSN))
133 # define SET_PROCS(closure, procs) \
134 PROCS(closure) = (W_)(procs) /* Set closure's location */
135 # define SET_GRAN_HDR(closure,pe) SET_PROCS(closure,pe)
137 # define SET_STATIC_PROCS(closure) , (W_) (Everywhere)
139 # define SET_TASK_ACTIVITY(act) /* nothing */
143 %************************************************************************
145 \subsection[parallel-GAs]{Parallel-only part of fixed headers (global addresses)}
147 %************************************************************************
149 Definitions relating to the entire parallel-only fixed-header field.
151 On GUM, the global addresses for each local closure are stored in a separate
152 hash table, rather then with the closure in the heap. We call @getGA@ to
153 look up the global address associated with a local closure (0 is returned
154 for local closures that have no global address), and @setGA@ to store a new
155 global address for a local closure which did not previously have one.
160 # define GA_HDR_SIZE 0
162 # define GA(closure) getGA(closure)
164 # define SET_GA(closure, ga) setGA(closure,ga)
165 # define SET_STATIC_GA(closure)
166 # define SET_GRAN_HDR(closure,pe)
167 # define SET_STATIC_PROCS(closure)
169 # define MAX_GA_WEIGHT 0 /* Treat as 2^n */
171 W_ PackGA PROTO((W_, int));
172 /* There was a PACK_GA macro here; but we turned it into the PackGA
173 routine [GlobAddr.lc] (because it needs to do quite a bit of
174 paranoia checking. Phil & Will (95/08)
178 At the moment, there is no activity profiling for GUM. This may change.
182 # define SET_TASK_ACTIVITY(act)
186 %************************************************************************
188 \subsection[parallel-heap-objs]{Special parallel-only heap objects (`closures')}
190 %************************************************************************
192 % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
193 % NB: The following definitons are BOTH for GUM and GrAnSim -- HWL
194 % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
196 The rest of this file contains definitions for {\it GUM and GrAnSim}.
197 Although we don't create FetchMe nodes in GrAnSim (we simulate it by
198 bitmask twiddling) we use FetchMe_info when converting nodes into RBHs
199 (mainly to keep the code as close to GUM as possible). So, we define all
200 the FetchMe related stuff in GrAnSim, too. % -- HWL
202 %************************************************************************
204 \subsubsection[FETCHME-closures]{@FETCHME@ heap objects (`closures')}
206 %************************************************************************
208 FetchMes are pointers into the global heap. When evaluated, the value
209 they point to is read from the global heap.
211 A FetchMe closure has the form:
216 \begin{tabular}{||l|l||}\hline
217 \tr{FETCHME_info} & junk \\ \hline
223 The argument word is a pointer (outside of the heap) to a globalAddr structure...
224 in particular, the one corresponding to the object to be fetched. Note that
225 we can't just used the LAGA table, because weight-splitting may force us to
226 reassign a local GA to the @FetchMe@ so that we can give out new references.
228 A @FetchMe@ must have a valid @MUT_LINK@ field, because it may act as
229 a transition between an RBH on the OldMutables list and a BQ still on
230 the OldMutables list.
234 # define FETCHME_VHS IND_VHS
235 # define FETCHME_HS IND_HS
237 # define FETCHME_GA_LOCN FETCHME_HS
239 # define FETCHME_CLOSURE_SIZE(closure) IND_CLOSURE_SIZE(closure)
240 # define FETCHME_CLOSURE_NoPTRS(closure) 0L
241 # define FETCHME_CLOSURE_NoNONPTRS(closure) (IND_CLOSURE_SIZE(closure)-IND_VHS)
243 # define SET_FETCHME_HDR(closure,infolbl,cc,size,ptrs) \
244 { SET_FIXED_HDR(closure,FetchMe_info,<bogus CC>); \
245 SET_MUT_RESERVED_WORDS(closure); \
248 # define FETCHME_GA(closure) (((globalAddr **)(closure))[FETCHME_GA_LOCN])
250 EXTFUN(FetchMe_entry);
251 EXTDATA_RO(FetchMe_info);
255 %************************************************************************
257 \subsubsection[BlockedFetch-closures]{@BlockedFetch@ heap objects (`closures')}
259 %************************************************************************
261 @BlockedFetch@s are inbound fetch messages blocked on local closures.
262 They arise as entries in a local blocking queue when a fetch has been
263 received for a local black hole. When awakened, we look at their
264 contents to figure out where to send a resume.
266 A @BlockedFetch@ closure has the form:
271 \begin{tabular}{||l|l|l||}\hline
272 \tr{BF_info} & link & node & gtid & slot & weight \\ \hline
279 # define BF_VHS (GC_MUT_RESERVED_WORDS)
280 # define BF_HS (FIXED_HS + BF_VHS)
282 # define BF_LINK_LOCN (BF_HS)
283 # define BF_NODE_LOCN (BF_HS + 1)
284 # define BF_GTID_LOCN (BF_HS + 2)
285 # define BF_SLOT_LOCN (BF_HS + 3)
286 # define BF_WEIGHT_LOCN (BF_HS + 4)
288 # define BF_CLOSURE_NoPTRS(closure) 2
289 # define BF_CLOSURE_NoNONPTRS(closure) 3
291 # define BF_CLOSURE_SIZE(closure) (BF_VHS + 5)
293 # define BF_LINK(closure) (((PP_)closure)[BF_LINK_LOCN])
294 # define BF_NODE(closure) (((PP_)closure)[BF_NODE_LOCN])
295 # define BF_GTID(closure) (((P_)closure)[BF_GTID_LOCN])
296 # define BF_SLOT(closure) (((P_)closure)[BF_SLOT_LOCN])
297 # define BF_WEIGHT(closure) (((P_)closure)[BF_WEIGHT_LOCN])
299 # define BF_CLOSURE_PTR(closure, no) (((P_)(closure))[BF_HS + (no) - 1])
301 /* std start-filling-in macro: */
302 # define SET_BF_HDR(closure,infolbl,cc) \
303 { SET_FIXED_HDR(closure,infolbl,cc); \
304 SET_MUT_RESERVED_WORDS(closure); \
312 %************************************************************************
314 \subsubsection[FMBQ-closures]{@FMBQ@ (FetchMe with blocking queue) heap objects (`closures')}
316 %************************************************************************
318 FetchMe's with blocking queues are @Fetchme@ nodes which have been entered
319 (and therefore a fetch has been sent), but for which we have not yet received
320 a @Resume@ message. They look just like normal blocking queues, but have
321 a distinguished info pointer.
324 # define FMBQ_VHS BQ_VHS
325 # define FMBQ_HS BQ_HS
327 # define FMBQ_CLOSURE_SIZE(closure) BQ_CLOSURE_SIZE(closure)
328 # define FMBQ_CLOSURE_NoPTRS(closure) BQ_CLOSURE_NoPTRS(closure)
329 # define FMBQ_CLOSURE_NoNONPTRS(closure) BQ_CLOSURE_NoNONPTRS(closure)
330 # define FMBQ_CLOSURE_PTR(closure, no) BQ_CLOSURE_PTR(closure, no)
332 # define FMBQ_ENTRIES(closure) BQ_ENTRIES(closure)
333 # define FMBQ_LINK(closure) BQ_LINK(closure)
336 EXTDATA_RO(FMBQ_info);
339 %************************************************************************
341 \subsection[parallel-info-tables]{Special parallel-only info-table stuff}
343 %************************************************************************
345 %************************************************************************
347 \subsubsection[FETCHME_ITBL]{@FETCHME_ITBL@}
349 %************************************************************************
351 ToDo: delete FetchMe CAT (because we don't profile and parallelize at
352 the same time...) Even better...set things up so that we can profile
353 and parallelize at the same time!
357 # define FETCHME_ITBL(itbl_name,entry_code) \
358 CAT_DECLARE(FetchMe,INTERNAL_KIND,"FetchMe","<FetchMe>") \
359 EXTFUN(entry_code); \
360 EXTDATA_RO(MK_REP_LBL(FetchMe,,)); \
361 const W_ itbl_name[] = { \
363 ,(W_) INFO_OTHER_TAG \
364 ,(W_) MK_REP_REF(FetchMe,,) \
365 INCLUDE_PROFILING_INFO(FetchMe) \
368 # define FETCHME_RTBL() \
369 const W_ MK_REP_LBL(FetchMe,,)[] = { \
370 INCLUDE_TYPE_INFO(FETCHME) \
371 INCLUDE_SIZE_INFO(MIN_UPD_SIZE, 0L) \
373 INCLUDE_COPYING_INFO(_Evacuate_FetchMe,_Scavenge_FetchMe) \
374 INCLUDE_COMPACTING_INFO(_ScanLink_FetchMe,_PRStart_FetchMe,_ScanMove_FetchMe,_PRIn_Error) \
379 %************************************************************************
381 \subsubsection[BF_ITBL]{@BF_ITBL@}
383 %************************************************************************
385 The special info table used for thread state objects (BlockedFetchs).
390 CAT_DECLARE(BF,INTERNAL_KIND,"BlockedFetch","<BlockedFetch>") \
392 EXTDATA_RO(MK_REP_LBL(BF,,)); \
393 const W_ BF_info[] = { \
395 ,(W_) INFO_OTHER_TAG \
396 ,(W_) MK_REP_REF(BF,,) \
397 INCLUDE_PROFILING_INFO(BF) \
401 const W_ MK_REP_LBL(BF,,)[] = { \
402 INCLUDE_TYPE_INFO(BF) \
403 INCLUDE_SIZE_INFO(BF_CLOSURE_SIZE(dummy),BF_CLOSURE_NoPTRS(dummy)) \
405 INCLUDE_COPYING_INFO(_Evacuate_BF,_Scavenge_BF) \
406 INCLUDE_COMPACTING_INFO(_ScanLink_BF,_PRStart_BF,_ScanMove_BF,_PRIn_BF) \
411 %************************************************************************
413 \subsubsection[FMBQ_ITBL]{@FMBQ_ITBL@}
415 %************************************************************************
417 Special info-table for local blocking queues.
420 # define FMBQ_ITBL() \
421 CAT_DECLARE(FMBQ,INTERNAL_KIND,"FMBQ","<FMBQ>") \
422 EXTFUN(FMBQ_entry); \
423 EXTDATA_RO(MK_REP_LBL(FMBQ,,)); \
424 const W_ FMBQ_info[] = { \
426 ,(W_) INFO_OTHER_TAG \
427 ,(W_) MK_REP_REF(FMBQ,,) \
428 INCLUDE_PROFILING_INFO(FMBQ) \
431 # define FMBQ_RTBL() \
432 const W_ MK_REP_LBL(FMBQ,,)[] = { \
433 INCLUDE_TYPE_INFO(FMBQ) \
434 INCLUDE_SIZE_INFO(MIN_UPD_SIZE,INFO_UNUSED) \
436 INCLUDE_COPYING_INFO(_Evacuate_BQ,_Scavenge_BQ) \
437 SPEC_COMPACTING_INFO(_ScanLink_BQ,_PRStart_BQ,_ScanMove_BQ,_PRIn_BQ) \
442 %************************************************************************
444 \subsection[parallel-spark-pool-defs]{Parallel-only Spark pool definitions}
446 %************************************************************************
449 # define HAVE_SPARK ((PendingSparksHd[REQUIRED_POOL] < PendingSparksTl[REQUIRED_POOL]) \
450 || (PendingSparksHd[ADVISORY_POOL] < PendingSparksTl[ADVISORY_POOL]))
452 # define HAVE_WORK (RUNNING_THREAD || HAVE_SPARK)
453 # define RUNNING_THREAD (CurrentTSO != NULL)
456 %************************************************************************
458 \subsection[parallel-pack-defs]{Parallel-only Packing definitions}
460 %************************************************************************
463 Symbolic constants for the packing code.
465 This constant defines how many words of data we can pack into a single
466 packet in the parallel (GUM) system.
469 void InitPackBuffer(STG_NO_ARGS);
470 P_ PackTSO PROTO((P_ tso, W_ *size));
471 P_ PackStkO PROTO((P_ stko, W_ *size));
472 P_ AllocateHeap PROTO((W_ size)); /* Doesn't belong */
474 void InitClosureQueue (STG_NO_ARGS);
475 P_ DeQueueClosure(STG_NO_ARGS);
476 void QueueClosure PROTO((P_ closure));
477 rtsBool QueueEmpty(STG_NO_ARGS);
478 void PrintPacket PROTO((P_ buffer));
480 P_ get_closure_info PROTO((P_ closure, W_ *size, W_ *ptrs, W_ *nonptrs, W_ *vhs, char *type));
482 rtsBool isOffset PROTO((globalAddr *ga)),
483 isFixed PROTO((globalAddr *ga));
485 void doGlobalGC(STG_NO_ARGS);
487 P_ PackNearbyGraph PROTO((P_ closure,W_ *size));
488 P_ UnpackGraph PROTO((W_ *buffer, globalAddr **gamap, W_ *nGAs));
492 # define PACK_HEAP_REQUIRED \
493 ((RTSflags.ParFlags.packBufferSize - PACK_HDR_SIZE) / (PACK_GA_SIZE + _FHS) * (SPEC_HS + 2))
495 extern W_ *PackBuffer; /* size: can be set via option */
496 extern long *buffer; /* HWL_ */
497 extern W_ *freeBuffer; /* HWL_ */
498 extern W_ *packBuffer; /* HWL_ */
500 extern void InitPackBuffer(STG_NO_ARGS);
501 extern void InitMoreBuffers(STG_NO_ARGS);
502 extern void InitPendingGABuffer(W_ size);
503 extern void AllocClosureQueue(W_ size);
505 # define MAX_GAS (RTSflags.ParFlags.packBufferSize / PACK_GA_SIZE)
508 # define PACK_GA_SIZE 3 /* Size of a packed GA in words */
509 /* Size of a packed fetch-me in words */
510 # define PACK_FETCHME_SIZE (PACK_GA_SIZE + FIXED_HS)
512 # define PACK_HDR_SIZE 1 /* Words of header in a packet */
514 # define PACK_PLC_SIZE 2 /* Size of a packed PLC in words */
521 /* ToDo: Check which of the PAR routines are needed in GranSim -- HWL */
522 void InitPackBuffer(STG_NO_ARGS);
523 P_ AllocateHeap PROTO((W_ size)); /* Doesn't belong */
524 P_ PackNearbyGraph PROTO((P_ closure, P_ tso, W_ *packbuffersize));
525 P_ PackOneNode PROTO((P_ closure, P_ tso, W_ *packbuffersize));
526 P_ UnpackGraph PROTO((P_ buffer));
528 void InitClosureQueue (STG_NO_ARGS);
529 P_ DeQueueClosure(STG_NO_ARGS);
530 void QueueClosure PROTO((P_ closure));
531 rtsBool QueueEmpty(STG_NO_ARGS);
532 void PrintPacket PROTO((P_ buffer));
534 P_ get_closure_info PROTO((P_ closure, W_ *size, W_ *ptrs, W_ *nonptrs, W_ *vhs, char *type));
536 /* These are needed in the packing code to get the size of the packet
537 right. The closures itself are never built in GrAnSim. */
538 # define FETCHME_VHS IND_VHS
539 # define FETCHME_HS IND_HS
541 # define FETCHME_GA_LOCN FETCHME_HS
543 # define FETCHME_CLOSURE_SIZE(closure) IND_CLOSURE_SIZE(closure)
544 # define FETCHME_CLOSURE_NoPTRS(closure) 0L
545 # define FETCHME_CLOSURE_NoNONPTRS(closure) (IND_CLOSURE_SIZE(closure)-IND_VHS)
547 # define MAX_GAS (RTSflags.GranFlags.packBufferSize / PACK_GA_SIZE)
548 # define PACK_GA_SIZE 3 /* Size of a packed GA in words */
549 /* Size of a packed fetch-me in words */
550 # define PACK_FETCHME_SIZE (PACK_GA_SIZE + FIXED_HS)
551 # define PACK_HDR_SIZE 4 /* Words of header in a packet */
553 # define PACK_HEAP_REQUIRED \
554 ((RTSflags.GranFlags.packBufferSize - PACK_HDR_SIZE) / (PACK_GA_SIZE \
555 + _FHS) * (SPEC_HS + 2))
557 # define PACK_FLAG_LOCN 0
558 # define PACK_TSO_LOCN 1
559 # define PACK_UNPACKED_SIZE_LOCN 2
560 # define PACK_SIZE_LOCN 3
561 # define MAGIC_PACK_FLAG 0xfabc
564 #endif /* Parallel_H */