ghc/includes/Parallel.lh

   1 %
   2 % (c) Kevin Hammond, Parade/AQUA Projects, Glasgow University, February 15th. 1995
   3 %
   4 %     This is for GUM only.
   5 %
   6 %************************************************************************
   7 %*                                                                      *
   8 \section[Parallel.lh]{Definitions for parallel machines}
   9 %*                                                                      *
  10 %************************************************************************
  11
  12 Multi-slurp protection:
  13 \begin{code}
  14 #ifndef Parallel_H
  15 #define Parallel_H
  16 \end{code}
  17
  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
  22
  23 These basic definitions need to be around, one way or the other:
  24 \begin{code}
  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)
  28
  29 #define SET_PAR_HDR(closure,ga)         /* nothing */
  30 #define SET_STATIC_PAR_HDR(closure)     /* nothing */
  31 \end{code}
  32
  33 \begin{code}
  34 # ifdef PAR
  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.
  40         */
  41
  42 extern I_ do_sp_profile;
  43
  44 extern P_ PendingFetches;
  45 extern GLOBAL_TASK_ID *PEs;
  46
  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;
  54
  55 extern int  nPEs;
  56
  57 extern rtsBool InGlobalGC;      /* Are we in the midst of performing global GC */
  58
  59 extern HashTable *pGAtoGALAtable;
  60 extern HashTable *LAtoGALAtable;
  61 extern GALA *freeIndirections;
  62 extern GALA *liveIndirections;
  63 extern GALA *freeGALAList;
  64 extern GALA *liveRemoteGAs;
  65 extern int thisPE;
  66
  67 void RunParallelSystem PROTO((StgPtr program_closure));
  68 void initParallelSystem(STG_NO_ARGS);
  69 void SynchroniseSystem(STG_NO_ARGS);
  70
  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);
  81
  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));
  87
  88 extern void myexit PROTO((I_));
  89 #  define EXIT myexit
  90 #  define exit : error : Wrong exit!
  91 # else
  92 #  define EXIT exit
  93 # endif
  94
  95 \end{code}
  96
  97 %************************************************************************
  98 %*                                                                      *
  99 \subsection[anti-parallel-SM]{But if we're {\em not} compiling for a parallel system...}
 100 %*                                                                      *
 101 %************************************************************************
 102
 103 Get this out of the way.  These are all null definitions.
 104
 105 \begin{code}
 106 # if !(defined(GRAN) || defined(PAR))
 107
 108 #  define GA_HDR_SIZE                   0
 109 #  define       GA(closure)                     /*nothing*/
 110
 111 #  define SET_GA(closure,ga)            /* nothing */
 112 #  define SET_STATIC_GA(closure)                /* nothing */
 113 #  define SET_GRAN_HDR(closure,pe)        /* nothing */
 114 #  define SET_STATIC_PROCS(closure)     /* nothing */
 115
 116 #  define SET_TASK_ACTIVITY(act)                /* nothing */
 117
 118 # else
 119 # ifdef GRAN
 120
 121 #  define GA_HDR_SIZE                   1
 122
 123 #  define PROCS_HDR_POSN                PAR_HDR_POSN
 124 #  define PROCS_HDR_SIZE                1
 125
 126 /* Accessing components of the field */
 127 #  define       PROCS(closure)          (*((P_)(closure)+PROCS_HDR_POSN))
 128
 129 #  define SET_PROCS(closure, procs) \
 130         PROCS(closure) = (W_)(procs)    /* Set closure's location */
 131 #  define SET_GRAN_HDR(closure,pe)      SET_PROCS(closure,pe)
 132
 133 #  if defined(GRAN_TNG)
 134 #   define SET_STATIC_PROCS(closure)    , (W_) (Everywhere)
 135 #  else
 136 #   define SET_STATIC_PROCS(closure)    , (W_) (MainPE)
 137 #  endif   /* GRAN_TNG */
 138
 139 #  define SET_TASK_ACTIVITY(act)        /* nothing */
 140 \end{code}
 141
 142 %************************************************************************
 143 %*                                                                      *
 144 \subsection[parallel-GAs]{Parallel-only part of fixed headers (global addresses)}
 145 %*                                                                      *
 146 %************************************************************************
 147
 148 Definitions relating to the entire parallel-only fixed-header field.
 149
 150 On GUM, the global addresses for each local closure are stored in a separate
 151 hash table, rather then with the closure in the heap.  We call @getGA@ to
 152 look up the global address associated with a local closure (0 is returned
 153 for local closures that have no global address), and @setGA@ to store a new
 154 global address for a local closure which did not previously have one.
 155
 156 \begin{code}
 157 # else /* it must be PARallel (to end of file) */
 158
 159 #  define GA_HDR_SIZE                   0
 160
 161 #  define GA(closure)                   getGA(closure)
 162
 163 #  define SET_GA(closure, ga)             setGA(closure,ga)
 164 #  define SET_STATIC_GA(closure)
 165 #  define SET_GRAN_HDR(closure,pe)
 166 #  define SET_STATIC_PROCS(closure)
 167
 168 #  define MAX_GA_WEIGHT                 0       /* Treat as 2^n */
 169
 170 W_ PackGA PROTO((W_, int));
 171    /* There was a PACK_GA macro here; but we turned it into the PackGA
 172       routine [GlobAddr.lc] (because it needs to do quite a bit of
 173       paranoia checking.  Phil & Will (95/08)
 174    */
 175 \end{code}
 176
 177 At the moment, there is no activity profiling for GUM.  This may change.
 178
 179 \begin{code}
 180
 181 #  define SET_TASK_ACTIVITY(act)
 182
 183 \end{code}
 184
 185 %************************************************************************
 186 %*                                                                      *
 187 \subsection[parallel-heap-objs]{Special parallel-only heap objects (`closures')}
 188 %*                                                                      *
 189 %************************************************************************
 190
 191 % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 192 % NB: The following definitons are BOTH for GUM and GrAnSim -- HWL
 193 % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 194
 195 The rest of  this  file contains definitions  for  {\it  GUM  and GrAnSim}.
 196 Although  we don't  create FetchMe   nodes in  GrAnSim  (we  simulate it by
 197 bitmask  twiddling)  we use FetchMe_info   when converting  nodes into RBHs
 198 (mainly  to keep the code as  close to GUM as  possible). So, we define all
 199 the FetchMe related stuff in GrAnSim, too. % -- HWL
 200
 201 %************************************************************************
 202 %*                                                                      *
 203 \subsubsection[FETCHME-closures]{@FETCHME@ heap objects (`closures')}
 204 %*                                                                      *
 205 %************************************************************************
 206
 207 FetchMes are pointers into the global heap.  When evaluated, the value
 208 they point to is read from the global heap.
 209
 210 A FetchMe closure has the form:
 211
 212 \begin{onlylatex}
 213 \begin{center}
 214 \end{onlylatex}
 215 \begin{tabular}{||l|l||}\hline
 216 \tr{FETCHME_info} & junk \\ \hline
 217 \end{tabular}
 218 \begin{onlylatex}
 219 \end{center}
 220 \end{onlylatex}
 221
 222 The argument word is a pointer (outside of the heap) to a globalAddr structure...
 223 in particular, the one corresponding to the object to be fetched.  Note that
 224 we can't just used the LAGA table, because weight-splitting may force us to
 225 reassign a local GA to the @FetchMe@ so that we can give out new references.
 226
 227 A @FetchMe@ must have a valid @MUT_LINK@ field, because it may act as
 228 a transition between an RBH on the OldMutables list and a BQ still on
 229 the OldMutables list.
 230
 231
 232 \begin{code}
 233 #  define FETCHME_VHS                           IND_VHS
 234 #  define FETCHME_HS                            IND_HS
 235
 236 #  define FETCHME_GA_LOCN                       FETCHME_HS
 237
 238 #  define FETCHME_CLOSURE_SIZE(closure)         IND_CLOSURE_SIZE(closure)
 239 #  define FETCHME_CLOSURE_NoPTRS(closure)               0L
 240 #  define FETCHME_CLOSURE_NoNONPTRS(closure)    (IND_CLOSURE_SIZE(closure)-IND_VHS)
 241
 242 #  define SET_FETCHME_HDR(closure,infolbl,cc,size,ptrs) \
 243 { SET_FIXED_HDR(closure,FetchMe_info,<bogus CC>);       \
 244   SET_MUT_RESERVED_WORDS(closure);                      \
 245 }
 246
 247 #  define FETCHME_GA(closure)           (((globalAddr **)(closure))[FETCHME_GA_LOCN])
 248
 249 EXTFUN(FetchMe_entry);
 250 EXTDATA_RO(FetchMe_info);
 251
 252 \end{code}
 253
 254 %************************************************************************
 255 %*                                                                      *
 256 \subsubsection[BlockedFetch-closures]{@BlockedFetch@ heap objects (`closures')}
 257 %*                                                                      *
 258 %************************************************************************
 259
 260 @BlockedFetch@s are inbound fetch messages blocked on local closures.
 261 They arise as entries in a local blocking queue when a fetch has been
 262 received for a local black hole.  When awakened, we look at their
 263 contents to figure out where to send a resume.
 264
 265 A @BlockedFetch@ closure has the form:
 266
 267 \begin{onlylatex}
 268 \begin{center}
 269 \end{onlylatex}
 270 \begin{tabular}{||l|l|l||}\hline
 271 \tr{BF_info} & link & node & gtid & slot & weight \\ \hline
 272 \end{tabular}
 273 \begin{onlylatex}
 274 \end{center}
 275 \end{onlylatex}
 276
 277 \begin{code}
 278 #  define BF_VHS                            (GC_MUT_RESERVED_WORDS)
 279 #  define BF_HS                     (FIXED_HS + BF_VHS)
 280
 281 #  define BF_LINK_LOCN              (BF_HS)
 282 #  define BF_NODE_LOCN              (BF_HS + 1)
 283 #  define BF_GTID_LOCN              (BF_HS + 2)
 284 #  define BF_SLOT_LOCN              (BF_HS + 3)
 285 #  define BF_WEIGHT_LOCN                    (BF_HS + 4)
 286
 287 #  define BF_CLOSURE_NoPTRS(closure)    2
 288 #  define BF_CLOSURE_NoNONPTRS(closure) 3
 289
 290 #  define BF_CLOSURE_SIZE(closure)    (BF_VHS + 5)
 291
 292 #  define BF_LINK(closure)          (((PP_)closure)[BF_LINK_LOCN])
 293 #  define BF_NODE(closure)          (((PP_)closure)[BF_NODE_LOCN])
 294 #  define BF_GTID(closure)          (((P_)closure)[BF_GTID_LOCN])
 295 #  define BF_SLOT(closure)          (((P_)closure)[BF_SLOT_LOCN])
 296 #  define BF_WEIGHT(closure)        (((P_)closure)[BF_WEIGHT_LOCN])
 297
 298 #  define BF_CLOSURE_PTR(closure, no) (((P_)(closure))[BF_HS + (no) - 1])
 299
 300 /* std start-filling-in macro: */
 301 #  define SET_BF_HDR(closure,infolbl,cc)        \
 302 { SET_FIXED_HDR(closure,infolbl,cc);            \
 303   SET_MUT_RESERVED_WORDS(closure);              \
 304 }
 305
 306 EXTFUN(BF_entry);
 307 EXTDATA_RO(BF_info);
 308
 309 \end{code}
 310
 311 %************************************************************************
 312 %*                                                                      *
 313 \subsubsection[FMBQ-closures]{@FMBQ@ (FetchMe with blocking queue) heap objects (`closures')}
 314 %*                                                                      *
 315 %************************************************************************
 316
 317 FetchMe's with blocking queues are @Fetchme@ nodes which have been entered
 318 (and therefore a fetch has been sent), but for which we have not yet received
 319 a @Resume@ message.  They look just like normal blocking queues, but have
 320 a distinguished info pointer.
 321
 322 \begin{code}
 323 #  define FMBQ_VHS                      BQ_VHS
 324 #  define FMBQ_HS                               BQ_HS
 325
 326 #  define FMBQ_CLOSURE_SIZE(closure)    BQ_CLOSURE_SIZE(closure)
 327 #  define FMBQ_CLOSURE_NoPTRS(closure)  BQ_CLOSURE_NoPTRS(closure)
 328 #  define FMBQ_CLOSURE_NoNONPTRS(closure)       BQ_CLOSURE_NoNONPTRS(closure)
 329 #  define FMBQ_CLOSURE_PTR(closure, no) BQ_CLOSURE_PTR(closure, no)
 330
 331 #  define FMBQ_ENTRIES(closure)         BQ_ENTRIES(closure)
 332 #  define FMBQ_LINK(closure)            BQ_LINK(closure)
 333
 334 EXTFUN(FMBQ_entry);
 335 EXTDATA_RO(FMBQ_info);
 336 \end{code}
 337
 338 %************************************************************************
 339 %*                                                                      *
 340 \subsection[parallel-info-tables]{Special parallel-only info-table stuff}
 341 %*                                                                      *
 342 %************************************************************************
 343
 344 %************************************************************************
 345 %*                                                                      *
 346 \subsubsection[FETCHME_ITBL]{@FETCHME_ITBL@}
 347 %*                                                                      *
 348 %************************************************************************
 349
 350 ToDo: delete FetchMe CAT (because we don't profile and parallelize at
 351 the same time...)  Even better...set things up so that we can profile
 352 and parallelize at the same time!
 353
 354 \begin{code}
 355
 356 #  define FETCHME_ITBL(itbl_name,entry_code)                    \
 357     CAT_DECLARE(FetchMe,INTERNAL_KIND,"FetchMe","<FetchMe>")    \
 358     EXTFUN(entry_code);                                         \
 359     EXTDATA_RO(MK_REP_LBL(FetchMe,,));                          \
 360     const W_ itbl_name[] = {                                    \
 361         (W_) entry_code                                         \
 362         ,(W_) INFO_OTHER_TAG                                    \
 363         ,(W_) MK_REP_REF(FetchMe,,)                             \
 364         INCLUDE_PROFILING_INFO(FetchMe)                         \
 365     }
 366
 367 #  define FETCHME_RTBL()                                        \
 368     const W_ MK_REP_LBL(FetchMe,,)[] = {                        \
 369         INCLUDE_TYPE_INFO(FETCHME)                              \
 370         INCLUDE_SIZE_INFO(MIN_UPD_SIZE, 0L)                     \
 371         INCLUDE_PAR_INFO                                        \
 372         INCLUDE_COPYING_INFO(_Evacuate_FetchMe,_Scavenge_FetchMe) \
 373         INCLUDE_COMPACTING_INFO(_ScanLink_FetchMe,_PRStart_FetchMe,_ScanMove_FetchMe,_PRIn_Error) \
 374     }
 375
 376 \end{code}
 377
 378 %************************************************************************
 379 %*                                                                      *
 380 \subsubsection[BF_ITBL]{@BF_ITBL@}
 381 %*                                                                      *
 382 %************************************************************************
 383
 384 The special info table used for thread state objects (BlockedFetchs).
 385
 386 \begin{code}
 387
 388 #  define BF_ITBL()                                 \
 389     CAT_DECLARE(BF,INTERNAL_KIND,"BlockedFetch","<BlockedFetch>")    \
 390     EXTFUN(BF_entry);                       \
 391     EXTDATA_RO(MK_REP_LBL(BF,,));                   \
 392     const W_ BF_info[] = {                  \
 393         (W_) BF_entry                       \
 394         ,(W_) INFO_OTHER_TAG                        \
 395         ,(W_) MK_REP_REF(BF,,)              \
 396         INCLUDE_PROFILING_INFO(BF)          \
 397         }
 398
 399 #  define BF_RTBL() \
 400     const W_ MK_REP_LBL(BF,,)[] = { \
 401         INCLUDE_TYPE_INFO(BF)                           \
 402         INCLUDE_SIZE_INFO(BF_CLOSURE_SIZE(dummy),BF_CLOSURE_NoPTRS(dummy))      \
 403         INCLUDE_PAR_INFO                                        \
 404         INCLUDE_COPYING_INFO(_Evacuate_BF,_Scavenge_BF)         \
 405         INCLUDE_COMPACTING_INFO(_ScanLink_BF,_PRStart_BF,_ScanMove_BF,_PRIn_BF) \
 406         }
 407
 408 \end{code}
 409
 410 %************************************************************************
 411 %*                                                                      *
 412 \subsubsection[FMBQ_ITBL]{@FMBQ_ITBL@}
 413 %*                                                                      *
 414 %************************************************************************
 415
 416 Special info-table for local blocking queues.
 417
 418 \begin{code}
 419 #  define FMBQ_ITBL()                           \
 420     CAT_DECLARE(FMBQ,INTERNAL_KIND,"FMBQ","<FMBQ>")     \
 421     EXTFUN(FMBQ_entry);                         \
 422     EXTDATA_RO(MK_REP_LBL(FMBQ,,));             \
 423     const W_ FMBQ_info[] = {                    \
 424         (W_) FMBQ_entry                         \
 425         ,(W_) INFO_OTHER_TAG                    \
 426         ,(W_) MK_REP_REF(FMBQ,,)                \
 427         INCLUDE_PROFILING_INFO(FMBQ)            \
 428     }
 429
 430 #  define FMBQ_RTBL() \
 431     const W_ MK_REP_LBL(FMBQ,,)[] = {                           \
 432         INCLUDE_TYPE_INFO(FMBQ)                                 \
 433         INCLUDE_SIZE_INFO(MIN_UPD_SIZE,INFO_UNUSED)             \
 434         INCLUDE_PAR_INFO                                        \
 435         INCLUDE_COPYING_INFO(_Evacuate_BQ,_Scavenge_BQ)         \
 436         SPEC_COMPACTING_INFO(_ScanLink_BQ,_PRStart_BQ,_ScanMove_BQ,_PRIn_BQ) \
 437     }
 438
 439 \end{code}
 440
 441 %************************************************************************
 442 %*                                                                      *
 443 \subsection[parallel-spark-pool-defs]{Parallel-only Spark pool definitions}
 444 %*                                                                      *
 445 %************************************************************************
 446
 447 \begin{code}
 448 #  ifdef GRAN
 449 #   define HAVE_SPARK ((PendingSparksHd[REQUIRED_POOL] != Nil_closure) ||       \
 450                     (PendingSparksHd[ADVISORY_POOL] != Nil_closure))
 451 #  else
 452 #   define HAVE_SPARK ((PendingSparksHd[REQUIRED_POOL] < PendingSparksTl[REQUIRED_POOL]) \
 453                 ||  (PendingSparksHd[ADVISORY_POOL] < PendingSparksTl[ADVISORY_POOL]))
 454 #  endif
 455
 456 #  define HAVE_WORK     (RUNNING_THREAD || HAVE_SPARK)
 457 #  define RUNNING_THREAD  (CurrentTSO != NULL)
 458 \end{code}
 459
 460 %************************************************************************
 461 %*                                                                      *
 462 \subsection[parallel-pack-defs]{Parallel-only Packing definitions}
 463 %*                                                                      *
 464 %************************************************************************
 465
 466
 467 Symbolic constants for the packing code.
 468
 469 This constant defines how many words of data we can pack into a single
 470 packet in the parallel (GUM) system.
 471
 472 \begin{code}
 473 #  ifdef PAR
 474 void    InitPackBuffer(STG_NO_ARGS);
 475 P_      PackNearbyGraph PROTO((P_ closure,W_ *size));
 476 P_      PackTSO PROTO((P_ tso, W_ *size));
 477 P_      PackStkO PROTO((P_ stko, W_ *size));
 478 P_      AllocateHeap PROTO((W_ size)); /* Doesn't belong */
 479
 480 P_      get_closure_info PROTO((P_ closure, W_ *size, W_ *ptrs, W_ *nonptrs, W_ *vhs));
 481
 482 rtsBool isOffset PROTO((globalAddr *ga)),
 483         isFixed PROTO((globalAddr *ga));
 484
 485 void    InitClosureQueue (STG_NO_ARGS);
 486 P_      DeQueueClosure(STG_NO_ARGS);
 487 void    QueueClosure PROTO((P_ closure));
 488 rtsBool QueueEmpty(STG_NO_ARGS);
 489 void    PrintPacket PROTO((P_ buffer));
 490 void    doGlobalGC(STG_NO_ARGS);
 491
 492 P_ UnpackGraph PROTO((W_ *buffer, globalAddr **gamap, W_ *nGAs));
 493 #  endif
 494
 495 \end{code}
 496
 497 \begin{code}
 498 #  define PACK_HEAP_REQUIRED  \
 499     ((RTSflags.ParFlags.packBufferSize - PACK_HDR_SIZE) / (PACK_GA_SIZE + _FHS) * (SPEC_HS + 2))
 500
 501 extern W_      *PackBuffer;      /* size: can be set via option */
 502 extern long *buffer;             /* HWL_ */
 503 extern W_ *freeBuffer;           /* HWL_ */
 504 extern W_ *packBuffer;           /* HWL_ */
 505
 506 extern void    InitPackBuffer(STG_NO_ARGS);
 507 extern void    InitMoreBuffers(STG_NO_ARGS);
 508 extern void    InitPendingGABuffer(W_ size);
 509 extern void    AllocClosureQueue(W_ size);
 510
 511 #  define MAX_GAS       (RTSflags.ParFlags.packBufferSize / PACK_GA_SIZE)
 512
 513
 514 #  define PACK_GA_SIZE  3       /* Size of a packed GA in words */
 515                                 /* Size of a packed fetch-me in words */
 516 #  define PACK_FETCHME_SIZE (PACK_GA_SIZE + FIXED_HS)
 517
 518 #  define PACK_HDR_SIZE 1       /* Words of header in a packet */
 519
 520 #  define PACK_PLC_SIZE 2       /* Size of a packed PLC in words */
 521
 522 \end{code}
 523 End multi-slurp protection:
 524 \begin{code}
 525 # endif /* yes, it is PARallel */
 526 #endif /* it was GRAN or PARallel */
 527
 528 #endif /* Parallel_H */
 529 \end{code}