ghc/rts/RtsFlags.c

   1 /* -----------------------------------------------------------------------------
   2  * $Id: RtsFlags.c,v 1.32 2000/10/06 15:35:09 simonmar Exp $
   3  *
   4  * (c) The AQUA Project, Glasgow University, 1994-1997
   5  * (c) The GHC Team, 1998-1999
   6  *
   7  * Functions for parsing the argument list.
   8  *
   9  * ---------------------------------------------------------------------------*/
  10
  11 //@menu
  12 //* Includes::
  13 //* Constants::
  14 //* Static function decls::
  15 //* Command-line option parsing routines::
  16 //* GranSim specific options::
  17 //* Aux fcts::
  18 //@end menu
  19 //*/
  20
  21 //@node Includes, Constants
  22 //@subsection Includes
  23
  24 #include "Rts.h"
  25 #include "RtsFlags.h"
  26 #include "RtsUtils.h"
  27 #include "BlockAlloc.h"
  28 #include "Itimer.h"             /* CS_MIN_MILLISECS */
  29 #include "Profiling.h"
  30
  31 #if defined(PROFILING)
  32 #include "Itimer.h"
  33 #endif
  34
  35 #ifdef HAVE_CTYPE_H
  36 #include <ctype.h>
  37 #endif
  38
  39 extern struct RTS_FLAGS RtsFlags;
  40
  41 /*
  42  * Split argument lists
  43  */
  44 int     prog_argc; /* an "int" so as to match normal "argc" */
  45 char  **prog_argv = NULL;
  46 int     rts_argc;  /* ditto */
  47 char   *rts_argv[MAX_RTS_ARGS];
  48
  49 //@node Constants, Static function decls, Includes
  50 //@subsection Constants
  51
  52 /*
  53  * constants, used later
  54  */
  55 #define RTS 1
  56 #define PGM 0
  57
  58 char *debug_opts_strs[] = {
  59   "DEBUG (-D1): scheduler\n",
  60   "DEBUG (-D2): evaluator\n",
  61   "DEBUG (-D4): codegen\n",
  62   "DEBUG (-D8): weak\n",
  63   "DEBUG (-D16): gccafs\n",
  64   "DEBUG (-D32): gc\n",
  65   "DEBUG (-D64): block\n",
  66   "DEBUG (-D128): sanity\n",
  67   "DEBUG (-D256): stable\n",
  68   "DEBUG (-D512): prof\n",
  69   "DEBUG (-D1024): gran\n",
  70   "DEBUG (-D2048): par\n",
  71   "DEBUG (-D4096): linker\n"
  72 };
  73
  74 char *debug_opts_prefix[] = {
  75   "_-", /* scheduler */
  76   "_.", /* evaluator */
  77   "_,", /* codegen */
  78   "_;", /* weak */
  79   "_~", /* gccafs */
  80   "_@", /* gc */
  81   "_#", /* block */
  82   "_&", /* sanity */
  83   "_:", /* stable */
  84   "_!", /* prof */
  85   "_=", /* gran */
  86   "_=" /* par */
  87   "_*" /* linker */
  88 };
  89
  90 #if defined(GRAN)
  91
  92 char *gran_debug_opts_strs[] = {
  93   "DEBUG (-bDe, -bD1): event_trace; printing event trace.\n",
  94   "DEBUG (-bDE, -bD2): event_stats; printing event statistics.\n",
  95   "DEBUG (-bDb, -bD4): bq; check blocking queues\n",
  96   "DEBUG (-bDG, -bD8): pack; routines for (un-)packing graph structures.\n",
  97   "DEBUG (-bDq, -bD16): checkSparkQ; check consistency of the spark queues.\n",
  98   "DEBUG (-bDf, -bD32): thunkStealing; print forwarding of fetches.\n",
  99   "DEBUG (-bDr, -bD64): randomSteal; stealing sparks/threads from random PEs.\n",
 100   "DEBUG (-bDF, -bD128): findWork; searching spark-pools (local & remote), thread queues for work.\n",
 101   "DEBUG (-bDu, -bD256): unused; currently unused flag.\n",
 102   "DEBUG (-bDS, -bD512): pri; priority sparking or scheduling.\n",
 103   "DEBUG (-bD:, -bD1024): checkLight; check GranSim-Light setup.\n",
 104   "DEBUG (-bDo, -bD2048): sortedQ; check whether spark/thread queues are sorted.\n",
 105   "DEBUG (-bDz, -bD4096): blockOnFetch; check for blocked on fetch.\n",
 106   "DEBUG (-bDP, -bD8192): packBuffer; routines handling pack buffer (GranSim internal!).\n",
 107   "DEBUG (-bDt, -bD16384): blockOnFetch_sanity; check for TSO asleep on fetch.\n",
 108 };
 109
 110 /* one character codes for the available debug options */
 111 char gran_debug_opts_flags[] = {
 112   'e', 'E', 'b', 'G', 'q', 'f', 'r', 'F', 'u', 'S', ':', 'o', 'z', 'P', 't'
 113 };
 114
 115 /* prefix strings printed with the debug messages of the corresponding type */
 116 char *gran_debug_opts_prefix[] = {
 117   "", /* event_trace */
 118   "", /* event_stats */
 119   "##", /* bq */
 120   "**", /* pack */
 121   "^^", /* checkSparkQ */
 122   "==", /* thunkStealing */
 123   "^^", /* randomSteal */
 124   "+-", /* findWork */
 125   "", /* unused */
 126   "++", /* pri */
 127   "::", /* checkLight */
 128   "##", /* sortedQ */
 129   "", /* blockOnFetch */
 130   "", /* packBuffer */
 131   "" /* blockOnFetch_sanity */
 132 };
 133
 134 #elif defined(PAR)
 135
 136 char *par_debug_opts_strs[] = {
 137   "DEBUG (-qDv, -qD1): verbose; be generally verbose with parallel related stuff.\n",
 138   "DEBUG (-qDt, -qD2): trace; trace messages.\n",
 139   "DEBUG (-qDs, -qD4): schedule; scheduling of parallel threads.\n",
 140   "DEBUG (-qDe, -qD8): free; free messages.\n",
 141   "DEBUG (-qDr, -qD16): resume; resume messages.\n",
 142   "DEBUG (-qDw, -qD32): weight; print weights and distrib GC stuff.\n",
 143   "DEBUG (-qDF, -qD64): fetch; fetch messages.\n",
 144   // "DEBUG (-qDa, -qD128): ack; ack messages.\n",
 145   "DEBUG (-qDf, -qD128): fish; fish messages.\n",
 146   //"DEBUG (-qDo, -qD512): forward; forwarding messages to other PEs.\n",
 147   "DEBUG (-qDl, -qD256): tables; print internal LAGA etc tables.\n",
 148   "DEBUG (-qDo, -qD512): packet; packets and graph structures when packing.\n",
 149   "DEBUG (-qDp, -qD1024): pack; packing and unpacking graphs.\n"
 150 };
 151
 152 /* one character codes for the available debug options */
 153 char par_debug_opts_flags[] = {
 154   'v', 't', 's', 'e', 'r', 'w', 'F', 'f', 'l', 'o', 'p'
 155 };
 156
 157 /* prefix strings printed with the debug messages of the corresponding type */
 158 char *par_debug_opts_prefix[] = {
 159   "  ", /* verbose */
 160   "..", /* trace */
 161   "--", /* schedule */
 162   "!!", /* free */
 163   "[]", /* resume */
 164   ";;", /* weight */
 165   "%%", /* fetch */
 166   //",,", /* ack */
 167   "$$", /* fish */
 168   "", /* tables */
 169   "**", /* packet */
 170   "**" /* pack */
 171 };
 172
 173 #endif /* PAR */
 174
 175 //@node Static function decls, Command-line option parsing routines, Constants
 176 //@subsection Static function decls
 177
 178 /* -----------------------------------------------------------------------------
 179    Static function decls
 180    -------------------------------------------------------------------------- */
 181
 182 static FILE *           /* return NULL on error */
 183 open_stats_file (
 184     I_ arg,
 185     int argc, char *argv[],
 186     int rts_argc, char *rts_argv[],
 187     const char *FILENAME_FMT);
 188
 189 static I_ decode(const char *s);
 190 static void bad_option(const char *s);
 191
 192 #if defined(GRAN)
 193 static void enable_GranSimLight(void);
 194 static void process_gran_option(int arg, int *rts_argc, char *rts_argv[], rtsBool *error);
 195 static void set_GranSim_debug_options(nat n);
 196 static void help_GranSim_debug_options(nat n);
 197 #elif defined(PAR)
 198 static void process_par_option(int arg, int *rts_argc, char *rts_argv[], rtsBool *error);
 199 static void set_par_debug_options(nat n);
 200 static void help_par_debug_options(nat n);
 201 #endif
 202 #if defined(DEBUG)
 203 static void set_debug_options(nat n);
 204 static void help_debug_options(nat n);
 205 #endif
 206
 207 //@node Command-line option parsing routines, GranSim specific options, Static function decls
 208 //@subsection Command-line option parsing routines
 209
 210 /* -----------------------------------------------------------------------------
 211  * Command-line option parsing routines.
 212  * ---------------------------------------------------------------------------*/
 213
 214 void initRtsFlagsDefaults(void)
 215 {
 216     RtsFlags.GcFlags.statsFile          = NULL;
 217     RtsFlags.GcFlags.giveStats          = NO_GC_STATS;
 218
 219     RtsFlags.GcFlags.maxStkSize         = (1024 * 1024) / sizeof(W_);
 220     RtsFlags.GcFlags.initialStkSize     = 1024 / sizeof(W_);
 221
 222     RtsFlags.GcFlags.minAllocAreaSize   = (256 * 1024)        / BLOCK_SIZE;
 223     RtsFlags.GcFlags.minOldGenSize      = (1024 * 1024)       / BLOCK_SIZE;
 224     RtsFlags.GcFlags.maxHeapSize        = (64  * 1024 * 1024) / BLOCK_SIZE;
 225     RtsFlags.GcFlags.heapSizeSuggestion = 0;    /* none */
 226     RtsFlags.GcFlags.pcFreeHeap         = 3;    /* 3% */
 227     RtsFlags.GcFlags.oldGenFactor       = 2;
 228     RtsFlags.GcFlags.generations        = 2;
 229     RtsFlags.GcFlags.steps              = 2;
 230
 231     RtsFlags.GcFlags.squeezeUpdFrames   = rtsTrue;
 232
 233 #if defined(PROFILING) || defined(PAR)
 234     RtsFlags.CcFlags.doCostCentres      = 0;
 235 #endif /* PROFILING or PAR */
 236
 237 #ifdef PROFILING
 238     RtsFlags.ProfFlags.doHeapProfile = rtsFalse;
 239     RtsFlags.ProfFlags.showCCSOnException = rtsFalse;
 240 #elif defined(DEBUG)
 241     RtsFlags.ProfFlags.doHeapProfile = rtsFalse;
 242 #endif
 243
 244     RtsFlags.ConcFlags.ctxtSwitchTime   = CS_MIN_MILLISECS;  /* In milliseconds */
 245
 246 #ifdef SMP
 247     RtsFlags.ParFlags.nNodes            = 1;
 248 #endif
 249
 250 #ifdef PAR
 251     RtsFlags.ParFlags.ParStats.Full       = rtsFalse;
 252     RtsFlags.ParFlags.ParStats.Binary     = rtsFalse;
 253     RtsFlags.ParFlags.ParStats.Sparks     = rtsFalse;
 254     RtsFlags.ParFlags.ParStats.Heap       = rtsFalse;
 255     RtsFlags.ParFlags.ParStats.NewLogfile = rtsFalse;
 256     RtsFlags.ParFlags.ParStats.Global     = rtsFalse;
 257
 258     RtsFlags.ParFlags.outputDisabled    = rtsFalse;
 259     RtsFlags.ParFlags.packBufferSize    = 1024;
 260
 261     RtsFlags.ParFlags.maxThreads        = 1024;
 262     RtsFlags.ParFlags.maxFishes        = MAX_FISHES;
 263     RtsFlags.ParFlags.fishDelay         = FISH_DELAY;
 264 #endif
 265
 266 #if defined(PAR) || defined(SMP)
 267     RtsFlags.ParFlags.maxLocalSparks    = 4096;
 268 #endif /* PAR || SMP */
 269
 270 #if defined(GRAN)
 271     /* ToDo: check defaults for GranSim and GUM */
 272     RtsFlags.GcFlags.maxStkSize         = (1024 * 1024) / sizeof(W_);
 273     RtsFlags.GcFlags.initialStkSize     = 1024 / sizeof(W_);
 274
 275     RtsFlags.GranFlags.maxThreads       = 65536; // refers to mandatory threads
 276     RtsFlags.GranFlags.GranSimStats.Full        = rtsFalse;
 277     RtsFlags.GranFlags.GranSimStats.Suppressed  = rtsFalse;
 278     RtsFlags.GranFlags.GranSimStats.Binary      = rtsFalse;
 279     RtsFlags.GranFlags.GranSimStats.Sparks      = rtsFalse;
 280     RtsFlags.GranFlags.GranSimStats.Heap        = rtsFalse;
 281     RtsFlags.GranFlags.GranSimStats.NewLogfile  = rtsFalse;
 282     RtsFlags.GranFlags.GranSimStats.Global      = rtsFalse;
 283
 284     RtsFlags.GranFlags.packBufferSize   = 1024;
 285     RtsFlags.GranFlags.packBufferSize_internal = GRANSIM_DEFAULT_PACK_BUFFER_SIZE;
 286
 287     RtsFlags.GranFlags.proc         = MAX_PROC;
 288     RtsFlags.GranFlags.Fishing      = rtsFalse;
 289     RtsFlags.GranFlags.maxFishes   = MAX_FISHES;
 290     RtsFlags.GranFlags.time_slice   = GRAN_TIME_SLICE;
 291     RtsFlags.GranFlags.Light        = rtsFalse;
 292
 293     RtsFlags.GranFlags.Costs.latency =             LATENCY;
 294     RtsFlags.GranFlags.Costs.additional_latency =  ADDITIONAL_LATENCY;
 295     RtsFlags.GranFlags.Costs.fetchtime =           FETCHTIME;
 296     RtsFlags.GranFlags.Costs.lunblocktime =        LOCALUNBLOCKTIME;
 297     RtsFlags.GranFlags.Costs.gunblocktime =        GLOBALUNBLOCKTIME;
 298     RtsFlags.GranFlags.Costs.mpacktime =           MSGPACKTIME;
 299     RtsFlags.GranFlags.Costs.munpacktime =         MSGUNPACKTIME;
 300     RtsFlags.GranFlags.Costs.mtidytime =           MSGTIDYTIME;
 301
 302     RtsFlags.GranFlags.Costs.threadcreatetime =         THREADCREATETIME;
 303     RtsFlags.GranFlags.Costs.threadqueuetime =          THREADQUEUETIME;
 304     RtsFlags.GranFlags.Costs.threaddescheduletime =     THREADDESCHEDULETIME;
 305     RtsFlags.GranFlags.Costs.threadscheduletime =       THREADSCHEDULETIME;
 306     RtsFlags.GranFlags.Costs.threadcontextswitchtime =  THREADCONTEXTSWITCHTIME;
 307
 308     RtsFlags.GranFlags.Costs.arith_cost =         ARITH_COST;
 309     RtsFlags.GranFlags.Costs.branch_cost =        BRANCH_COST;
 310     RtsFlags.GranFlags.Costs.load_cost =          LOAD_COST;
 311     RtsFlags.GranFlags.Costs.store_cost =         STORE_COST;
 312     RtsFlags.GranFlags.Costs.float_cost =         FLOAT_COST;
 313
 314     RtsFlags.GranFlags.Costs.heapalloc_cost =     HEAPALLOC_COST;
 315
 316     RtsFlags.GranFlags.Costs.pri_spark_overhead = PRI_SPARK_OVERHEAD;
 317     RtsFlags.GranFlags.Costs.pri_sched_overhead = PRI_SCHED_OVERHEAD;
 318
 319     RtsFlags.GranFlags.DoFairSchedule           = rtsFalse;
 320     RtsFlags.GranFlags.DoAsyncFetch             = rtsFalse;
 321     RtsFlags.GranFlags.DoStealThreadsFirst      = rtsFalse;
 322     RtsFlags.GranFlags.DoAlwaysCreateThreads    = rtsFalse;
 323     RtsFlags.GranFlags.DoBulkFetching           = rtsFalse;
 324     RtsFlags.GranFlags.DoThreadMigration        = rtsFalse;
 325     RtsFlags.GranFlags.FetchStrategy            = 2;
 326     RtsFlags.GranFlags.PreferSparksOfLocalNodes = rtsFalse;
 327     RtsFlags.GranFlags.DoPrioritySparking       = rtsFalse;
 328     RtsFlags.GranFlags.DoPriorityScheduling     = rtsFalse;
 329     RtsFlags.GranFlags.SparkPriority            = 0;
 330     RtsFlags.GranFlags.SparkPriority2           = 0;
 331     RtsFlags.GranFlags.RandomPriorities         = rtsFalse;
 332     RtsFlags.GranFlags.InversePriorities        = rtsFalse;
 333     RtsFlags.GranFlags.IgnorePriorities         = rtsFalse;
 334     RtsFlags.GranFlags.ThunksToPack             = 0;
 335     RtsFlags.GranFlags.RandomSteal              = rtsTrue;
 336 #endif
 337
 338 #ifdef TICKY_TICKY
 339     RtsFlags.TickyFlags.showTickyStats   = rtsFalse;
 340     RtsFlags.TickyFlags.tickyFile        = NULL;
 341 #endif
 342 }
 343
 344 static const char *
 345 usage_text[] = {
 346 "",
 347 "Usage: <prog> <args> [+RTS <rtsopts> | -RTS <args>] ... --RTS <args>",
 348 "",
 349 "   +RTS    Indicates run time system options follow",
 350 "   -RTS    Indicates program arguments follow",
 351 "  --RTS    Indicates that ALL subsequent arguments will be given to the",
 352 "           program (including any of these RTS flags)",
 353 "",
 354 "The following run time system options are available:",
 355 "",
 356 "  -? -f    Prints this message and exits; the program is not executed",
 357 "",
 358 "  -K<size> Sets the maximum stack size (default 1M)  Egs: -K32k   -K512k",
 359 "  -k<size> Sets the initial thread stack size (default 1k)  Egs: -K4k   -K2m",
 360 "",
 361 "  -A<size> Sets the minimum allocation area size (default 256k) Egs: -A1m -A10k",
 362 "  -M<size> Sets the maximum heap size (default 64M)  Egs: -M256k -M1G",
 363 "  -H<size> Sets the minimum heap size (default 0M)   Egs: -H24m  -H1G",
 364 "  -m<n>%   Minimum % of heap which must be available (default 3%)",
 365 "  -G<n>    Number of generations (default: 2)",
 366 "  -T<n>    Number of steps in younger generations (default: 2)",
 367 "  -s<file> Summary GC statistics   (default file: <program>.stat)",
 368 "  -S<file> Detailed GC statistics  (with -Sstderr going to stderr)",
 369 "",
 370 "",
 371 "  -Z       Don't squeeze out update frames on stack overflow",
 372 "  -B       Sound the bell at the start of each garbage collection",
 373 #if defined(PROFILING) || defined(PAR)
 374 "",
 375 "  -px      Time/allocation profile (XML)  (output file <program>.prof)",
 376 "  -p<sort> Time/allocation profile        (output file <program>.prof)",
 377 "             sort: T = time (default), A = alloc, C = cost centre label",
 378 "  -P<sort> More detailed Time/Allocation profile"
 379 # if defined(PROFILING)
 380 "",
 381 "  -hx            Heap residency profile (XML)  (output file <program>.prof)",
 382 "  -h<break-down> Heap residency profile (text) (output file <program>.prof)",
 383 "     break-down: C = cost centre stack (default), M = module",
 384 "                 D = closure description, Y = type description",
 385 "",
 386 "  -xc      Show current cost centre stack on raising an exception",
 387 # endif
 388 #endif /* PROFILING or PAR */
 389 #if !defined(PROFILING) && defined(DEBUG)
 390 "",
 391 "  -h<break-down> Debugging Heap residency profile",
 392 "                 (output file <program>.hp)",
 393 "     break-down: L = closure label (default)",
 394 "                 T = closure type (constructor, thunk etc.)",
 395 #endif
 396 "",
 397 #if defined(TICKY_TICKY)
 398 "  -r<file>  Produce reduction profiling statistics (with -rstderr for stderr)",
 399 "",
 400 #endif
 401 #if defined(PAR)
 402 "  -N<n>     Use <n> PVMish processors in parallel (default: 2)",
 403 /* NB: the -N<n> is implemented by the driver!! */
 404 #endif
 405 "  -C<secs>  Context-switch interval in seconds",
 406 "                (0 or no argument means switch as often as possible)",
 407 "                the default is .02 sec; resolution is .02 sec",
 408 #if defined(SMP)
 409 "  -N<n>     Use <n> OS threads (default: 1)",
 410 #endif
 411 #if defined(SMP) || defined(PAR)
 412 "  -e<size>  Size of spark pools (default 100)",
 413 #endif
 414 #if defined(PAR)
 415 "  -t<num>   Set maximum number of advisory threads per PE (default 32)",
 416 "  -qP       Enable activity profile (output files in ~/<program>*.gr)",
 417 "  -qQ<size> Set pack-buffer size (default: 1024)",
 418 "  -qd       Turn on PVM-ish debugging",
 419 "  -qO       Disable output for performance measurement",
 420 #endif
 421 #if defined(SMP) || defined(PAR)
 422 "  -e<n>     Maximum number of outstanding local sparks (default: 4096)",
 423 #endif
 424 #if defined(PAR)
 425 "  -d        Turn on PVM-ish debugging",
 426 "  -O        Disable output for performance measurement",
 427 #endif /* PAR */
 428 #if defined(GRAN)  /* ToDo: fill in decent Docu here */
 429 "  -b...     All GranSim options start with -b; see GranSim User's Guide for details",
 430 #endif
 431 "",
 432 "Other RTS options may be available for programs compiled a different way.",
 433 "The GHC User's Guide has full details.",
 434 "",
 435 0
 436 };
 437
 438 static __inline__ rtsBool
 439 strequal(const char *a, const char * b)
 440 {
 441     return(strcmp(a, b) == 0);
 442 }
 443
 444 void
 445 setupRtsFlags(int *argc, char *argv[], int *rts_argc, char *rts_argv[])
 446 {
 447     rtsBool error = rtsFalse;
 448     I_ mode;
 449     I_ arg, total_arg;
 450     char *last_slash;
 451
 452     /* Remove directory from argv[0] -- default files in current directory */
 453
 454     if ((last_slash = (char *) strrchr(argv[0], '/')) != NULL)
 455         strcpy(argv[0], last_slash+1);
 456
 457     /* Split arguments (argv) into PGM (argv) and RTS (rts_argv) parts */
 458     /*   argv[0] must be PGM argument -- leave in argv                 */
 459
 460     total_arg = *argc;
 461     arg = 1;
 462
 463     *argc = 1;
 464     *rts_argc = 0;
 465
 466     for (mode = PGM; arg < total_arg && ! strequal("--RTS", argv[arg]); arg++) {
 467         if (strequal("+RTS", argv[arg])) {
 468             mode = RTS;
 469         }
 470         else if (strequal("-RTS", argv[arg])) {
 471             mode = PGM;
 472         }
 473         else if (mode == RTS && *rts_argc < MAX_RTS_ARGS-1) {
 474             rts_argv[(*rts_argc)++] = argv[arg];
 475         }
 476         else if (mode == PGM) {
 477             argv[(*argc)++] = argv[arg];
 478         }
 479         else {
 480           barf("too many RTS arguments (max %d)", MAX_RTS_ARGS-1);
 481         }
 482     }
 483     if (arg < total_arg) {
 484         /* arg must be --RTS; process remaining program arguments */
 485         while (++arg < total_arg) {
 486             argv[(*argc)++] = argv[arg];
 487         }
 488     }
 489     argv[*argc] = (char *) 0;
 490     rts_argv[*rts_argc] = (char *) 0;
 491
 492     /* Process RTS (rts_argv) part: mainly to determine statsfile */
 493
 494     for (arg = 0; arg < *rts_argc; arg++) {
 495         if (rts_argv[arg][0] != '-') {
 496             fflush(stdout);
 497             prog_belch("unexpected RTS argument: %s", rts_argv[arg]);
 498             error = rtsTrue;
 499
 500         } else {
 501             switch(rts_argv[arg][1]) {
 502
 503               /* process: general args, then PROFILING-only ones,
 504                  then CONCURRENT-only, PARallel-only, GRAN-only,
 505                  TICKY-only (same order as defined in RtsFlags.lh);
 506                  within those groups, mostly in case-insensitive
 507                  alphabetical order.
 508                  Final group is x*, which allows for more options.
 509               */
 510
 511 #ifdef TICKY_TICKY
 512 # define TICKY_BUILD_ONLY(x) x
 513 #else
 514 # define TICKY_BUILD_ONLY(x) \
 515 prog_belch("GHC not built for: ticky-ticky stats"); \
 516 error = rtsTrue;
 517 #endif
 518
 519 #if defined(PROFILING)
 520 # define COST_CENTRE_USING_BUILD_ONLY(x) x
 521 #else
 522 # define COST_CENTRE_USING_BUILD_ONLY(x) \
 523 prog_belch("GHC not built for: -prof or -parallel"); \
 524 error = rtsTrue;
 525 #endif
 526
 527 #ifdef PROFILING
 528 # define PROFILING_BUILD_ONLY(x)   x
 529 #else
 530 # define PROFILING_BUILD_ONLY(x) \
 531 prog_belch("GHC not built for: -prof"); \
 532 error = rtsTrue;
 533 #endif
 534
 535 #ifdef SMP
 536 # define SMP_BUILD_ONLY(x)      x
 537 #else
 538 # define SMP_BUILD_ONLY(x) \
 539 prog_belch("GHC not built for: -parallel"); \
 540 error = rtsTrue;
 541 #endif
 542
 543 #ifdef PAR
 544 # define PAR_BUILD_ONLY(x)      x
 545 #else
 546 # define PAR_BUILD_ONLY(x) \
 547 prog_belch("GHC not built for: -parallel"); \
 548 error = rtsTrue;
 549 #endif
 550
 551 #if defined(SMP) || defined(PAR)
 552 # define PAR_OR_SMP_BUILD_ONLY(x)      x
 553 #else
 554 # define PAR_OR_SMP_BUILD_ONLY(x) \
 555 prog_belch("GHC not built for: -parallel or -smp"); \
 556 error = rtsTrue;
 557 #endif
 558
 559 #ifdef GRAN
 560 # define GRAN_BUILD_ONLY(x)     x
 561 #else
 562 # define GRAN_BUILD_ONLY(x) \
 563 prog_belch("GHC not built for: -gransim"); \
 564 error = rtsTrue;
 565 #endif
 566
 567               /* =========== GENERAL ========================== */
 568               case '?':
 569               case 'f':
 570                 error = rtsTrue;
 571                 break;
 572
 573               case 'A':
 574                 RtsFlags.GcFlags.minAllocAreaSize
 575                   = decode(rts_argv[arg]+2) / BLOCK_SIZE;
 576                 if (RtsFlags.GcFlags.minAllocAreaSize <= 0) {
 577                   bad_option(rts_argv[arg]);
 578                 }
 579                 break;
 580
 581               case 'B':
 582                 RtsFlags.GcFlags.ringBell = rtsTrue;
 583                 break;
 584
 585               case 'F':
 586                 RtsFlags.GcFlags.oldGenFactor = atof(rts_argv[arg]+2);
 587
 588                 if (RtsFlags.GcFlags.oldGenFactor < 0)
 589                   bad_option( rts_argv[arg] );
 590                 break;
 591
 592 #ifdef DEBUG
 593               case 'D':
 594                 if (isdigit(rts_argv[arg][2])) {/* Set all debugging options in one */
 595                 /* hack warning: interpret the flags as a binary number */
 596                   nat n = decode(rts_argv[arg]+2);
 597                   set_debug_options(n);
 598                 }
 599                 break;
 600 #endif
 601
 602               case 'K':
 603                 RtsFlags.GcFlags.maxStkSize =
 604                   decode(rts_argv[arg]+2) / sizeof(W_);
 605
 606                 if (RtsFlags.GcFlags.maxStkSize == 0)
 607                   bad_option( rts_argv[arg] );
 608                 break;
 609
 610               case 'k':
 611                 RtsFlags.GcFlags.initialStkSize =
 612                   decode(rts_argv[arg]+2) / sizeof(W_);
 613
 614                 if (RtsFlags.GcFlags.initialStkSize == 0)
 615                   bad_option( rts_argv[arg] );
 616                 break;
 617
 618               case 'M':
 619                 RtsFlags.GcFlags.maxHeapSize =
 620                   decode(rts_argv[arg]+2) / BLOCK_SIZE;
 621                 /* user give size in *bytes* but "maxHeapSize" is in *blocks* */
 622
 623                 if (RtsFlags.GcFlags.maxHeapSize <= 0) {
 624                   bad_option(rts_argv[arg]);
 625                 }
 626                 break;
 627
 628               case 'm':
 629                 RtsFlags.GcFlags.pcFreeHeap = atof(rts_argv[arg]+2);
 630
 631                 if (RtsFlags.GcFlags.pcFreeHeap < 0 ||
 632                     RtsFlags.GcFlags.pcFreeHeap > 100)
 633                   bad_option( rts_argv[arg] );
 634                 break;
 635
 636               case 'G':
 637                 RtsFlags.GcFlags.generations = decode(rts_argv[arg]+2);
 638                 if (RtsFlags.GcFlags.generations < 1) {
 639                   bad_option(rts_argv[arg]);
 640                 }
 641                 break;
 642
 643               case 'T':
 644                 RtsFlags.GcFlags.steps = decode(rts_argv[arg]+2);
 645                 if (RtsFlags.GcFlags.steps < 1) {
 646                   bad_option(rts_argv[arg]);
 647                 }
 648                 break;
 649
 650               case 'H':
 651                 RtsFlags.GcFlags.heapSizeSuggestion =
 652                   decode(rts_argv[arg]+2) / BLOCK_SIZE;
 653
 654                 if (RtsFlags.GcFlags.heapSizeSuggestion <= 0) {
 655                   bad_option(rts_argv[arg]);
 656                 }
 657                 break;
 658
 659               case 'S':
 660                 RtsFlags.GcFlags.giveStats ++;
 661
 662               case 's':
 663                 RtsFlags.GcFlags.giveStats ++;
 664 #ifdef PAR
 665                 /* Opening all those files would almost certainly fail... */
 666                 RtsFlags.ParFlags.ParStats.Full = rtsTrue;
 667                 RtsFlags.GcFlags.statsFile = stderr; /* temporary; ToDo: rm */
 668 #else
 669                 RtsFlags.GcFlags.statsFile
 670                   = open_stats_file(arg, *argc, argv,
 671                         *rts_argc, rts_argv, STAT_FILENAME_FMT);
 672
 673                 if (RtsFlags.GcFlags.statsFile == NULL) error = rtsTrue;
 674 #endif
 675                 break;
 676
 677               case 'Z':
 678                 RtsFlags.GcFlags.squeezeUpdFrames = rtsFalse;
 679                 break;
 680
 681               /* =========== PROFILING ========================== */
 682
 683               case 'P': /* detailed cost centre profiling (time/alloc) */
 684                 COST_CENTRE_USING_BUILD_ONLY(
 685                 RtsFlags.CcFlags.doCostCentres = COST_CENTRES_VERBOSE;
 686                 )
 687               case 'p': /* cost centre profiling (time/alloc) */
 688                 COST_CENTRE_USING_BUILD_ONLY(
 689                 switch (rts_argv[arg][2]) {
 690                   case 'x':
 691                     RtsFlags.CcFlags.doCostCentres = COST_CENTRES_XML;
 692                     break;
 693                   default:
 694                     RtsFlags.CcFlags.doCostCentres = COST_CENTRES_SUMMARY;
 695                     break;
 696                 }
 697                 ) break;
 698
 699               case 'h': /* serial heap profile */
 700 #if !defined(PROFILING) && defined(DEBUG)
 701                 switch (rts_argv[arg][2]) {
 702                   case '\0':
 703                   case 'L':
 704                     RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_INFOPTR;
 705                     break;
 706                   case 'T':
 707                     RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_CLOSURE_TYPE;
 708                     break;
 709                   default:
 710                     prog_belch("invalid heap profile option: %s",rts_argv[arg]);
 711                     error = rtsTrue;
 712                 }
 713 #else
 714                 PROFILING_BUILD_ONLY(
 715                 switch (rts_argv[arg][2]) {
 716                   case '\0':
 717                   case CCchar:
 718                     RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_CCS;
 719                     break;
 720                   case MODchar:
 721                     RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_MOD;
 722                     break;
 723                   case DESCRchar:
 724                     RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_DESCR;
 725                     break;
 726                   case TYPEchar:
 727                     RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_TYPE;
 728                     break;
 729                   default:
 730                     prog_belch("invalid heap profile option: %s",rts_argv[arg]);
 731                     error = rtsTrue;
 732                 }
 733                 )
 734 #endif
 735                 break;
 736
 737               /* =========== CONCURRENT ========================= */
 738               case 'C': /* context switch interval */
 739                 if (rts_argv[arg][2] == '\0')
 740                     RtsFlags.ConcFlags.ctxtSwitchTime = 0;
 741                 else {
 742                     I_ cst; /* tmp */
 743
 744                     /* Convert to milliseconds */
 745                     cst = (I_) ((atof(rts_argv[arg]+2) * 1000));
 746                     cst = (cst / CS_MIN_MILLISECS) * CS_MIN_MILLISECS;
 747                     if (cst != 0 && cst < CS_MIN_MILLISECS)
 748                         cst = CS_MIN_MILLISECS;
 749
 750                     RtsFlags.ConcFlags.ctxtSwitchTime = cst;
 751                 }
 752                 break;
 753
 754 #ifdef SMP
 755               case 'N':
 756                 SMP_BUILD_ONLY(
 757                 if (rts_argv[arg][2] != '\0') {
 758                     RtsFlags.ParFlags.nNodes
 759                       = strtol(rts_argv[arg]+2, (char **) NULL, 10);
 760                     if (RtsFlags.ParFlags.nNodes <= 0) {
 761                       prog_belch("bad value for -N");
 762                       error = rtsTrue;
 763                     }
 764                 }
 765                 ) break;
 766 #endif
 767               /* =========== PARALLEL =========================== */
 768               case 'e':
 769                 PAR_OR_SMP_BUILD_ONLY(
 770                 if (rts_argv[arg][2] != '\0') {
 771                     RtsFlags.ParFlags.maxLocalSparks
 772                       = strtol(rts_argv[arg]+2, (char **) NULL, 10);
 773                     if (RtsFlags.ParFlags.maxLocalSparks <= 0) {
 774                       prog_belch("bad value for -e");
 775                       error = rtsTrue;
 776                     }
 777                 }
 778                 ) break;
 779
 780               case 'q':
 781                 PAR_BUILD_ONLY(
 782                 process_par_option(arg, rts_argc, rts_argv, &error);
 783                 ) break;
 784
 785               /* =========== GRAN =============================== */
 786
 787               case 'b':
 788                 GRAN_BUILD_ONLY(
 789                 process_gran_option(arg, rts_argc, rts_argv, &error);
 790                 ) break;
 791
 792               /* =========== TICKY ============================== */
 793
 794               case 'r': /* Basic profiling stats */
 795                 TICKY_BUILD_ONLY(
 796
 797                 RtsFlags.TickyFlags.showTickyStats = rtsTrue;
 798                 RtsFlags.TickyFlags.tickyFile
 799                   = open_stats_file(arg, *argc, argv,
 800                         *rts_argc, rts_argv, TICKY_FILENAME_FMT);
 801
 802                 if (RtsFlags.TickyFlags.tickyFile == NULL) error = rtsTrue;
 803                 ) break;
 804
 805               /* =========== EXTENDED OPTIONS =================== */
 806
 807               case 'x': /* Extend the argument space */
 808                 switch(rts_argv[arg][2]) {
 809                   case '\0':
 810                     prog_belch("incomplete RTS option: %s",rts_argv[arg]);
 811                     error = rtsTrue;
 812                     break;
 813
 814                   case 'c': /* Debugging tool: show current cost centre on an exception */
 815                     PROFILING_BUILD_ONLY(
 816                     RtsFlags.ProfFlags.showCCSOnException = rtsTrue;
 817                     ) break;
 818
 819                   /* The option prefix '-xx' is reserved for future extension.  KSW 1999-11. */
 820
 821                   default:
 822                     prog_belch("unknown RTS option: %s",rts_argv[arg]);
 823                     error = rtsTrue;
 824                     break;
 825                 }
 826                 break;  /* defensive programming */
 827
 828               /* =========== OH DEAR ============================ */
 829               default:
 830                 prog_belch("unknown RTS option: %s",rts_argv[arg]);
 831                 error = rtsTrue;
 832                 break;
 833             }
 834         }
 835     }
 836     if (error) {
 837         const char **p;
 838
 839         fflush(stdout);
 840         for (p = usage_text; *p; p++)
 841             belch("%s", *p);
 842         stg_exit(EXIT_FAILURE);
 843     }
 844 }
 845
 846 #if defined(GRAN)
 847
 848 //@node GranSim specific options, Aux fcts, Command-line option parsing routines
 849 //@subsection GranSim specific options
 850
 851 static void
 852 enable_GranSimLight(void) {
 853
 854     fprintf(stderr,"GrAnSim Light enabled (infinite number of processors;  0 communication costs)\n");
 855     RtsFlags.GranFlags.Light=rtsTrue;
 856     RtsFlags.GranFlags.Costs.latency =
 857         RtsFlags.GranFlags.Costs.fetchtime =
 858         RtsFlags.GranFlags.Costs.additional_latency =
 859         RtsFlags.GranFlags.Costs.gunblocktime =
 860         RtsFlags.GranFlags.Costs.lunblocktime =
 861         RtsFlags.GranFlags.Costs.threadcreatetime =
 862         RtsFlags.GranFlags.Costs.threadqueuetime =
 863         RtsFlags.GranFlags.Costs.threadscheduletime =
 864         RtsFlags.GranFlags.Costs.threaddescheduletime =
 865         RtsFlags.GranFlags.Costs.threadcontextswitchtime = 0;
 866
 867     RtsFlags.GranFlags.Costs.mpacktime =
 868         RtsFlags.GranFlags.Costs.munpacktime = 0;
 869
 870     RtsFlags.GranFlags.DoFairSchedule = rtsTrue;
 871     RtsFlags.GranFlags.DoAsyncFetch = rtsFalse;
 872     RtsFlags.GranFlags.DoAlwaysCreateThreads = rtsTrue;
 873     /* FetchStrategy is irrelevant in GrAnSim-Light */
 874
 875     /* GrAnSim Light often creates an abundance of parallel threads,
 876        each with its own stack etc. Therefore, it's in general a good
 877        idea to use small stack chunks (use the -o<size> option to
 878        increase it again).
 879     */
 880     // RtsFlags.ConcFlags.stkChunkSize = 100;
 881
 882     RtsFlags.GranFlags.proc = 1;
 883 }
 884
 885 static void
 886 process_gran_option(int arg, int *rts_argc, char *rts_argv[], rtsBool *error)
 887 {
 888     if (rts_argv[arg][1] != 'b') /* All GranSim options start with -b */
 889       return;
 890
 891     /* or a ridiculously idealised simulator */
 892     if(strcmp((rts_argv[arg]+2),"oring")==0) {
 893       RtsFlags.GranFlags.Costs.latency =
 894         RtsFlags.GranFlags.Costs.fetchtime =
 895         RtsFlags.GranFlags.Costs.additional_latency =
 896         RtsFlags.GranFlags.Costs.gunblocktime =
 897         RtsFlags.GranFlags.Costs.lunblocktime =
 898         RtsFlags.GranFlags.Costs.threadcreatetime =
 899         RtsFlags.GranFlags.Costs.threadqueuetime =
 900         RtsFlags.GranFlags.Costs.threadscheduletime =
 901         RtsFlags.GranFlags.Costs.threaddescheduletime =
 902         RtsFlags.GranFlags.Costs.threadcontextswitchtime = 0;
 903
 904       RtsFlags.GranFlags.Costs.mpacktime =
 905         RtsFlags.GranFlags.Costs.munpacktime = 0;
 906
 907       RtsFlags.GranFlags.Costs.arith_cost =
 908         RtsFlags.GranFlags.Costs.float_cost =
 909         RtsFlags.GranFlags.Costs.load_cost =
 910         RtsFlags.GranFlags.Costs.store_cost =
 911         RtsFlags.GranFlags.Costs.branch_cost = 0;
 912
 913       RtsFlags.GranFlags.Costs.heapalloc_cost = 1;
 914
 915       /* ++RtsFlags.GranFlags.DoFairSchedule; */
 916       RtsFlags.GranFlags.DoStealThreadsFirst = rtsTrue;        /* -bZ */
 917       RtsFlags.GranFlags.DoThreadMigration   = rtsTrue;        /* -bM */
 918       RtsFlags.GranFlags.GranSimStats.Full   = rtsTrue;        /* -bP */
 919       return;
 920     }
 921
 922       /* or a somewhat idealised simulator */
 923       if(strcmp((rts_argv[arg]+2),"onzo")==0) {
 924         RtsFlags.GranFlags.Costs.latency =
 925         RtsFlags.GranFlags.Costs.fetchtime =
 926         RtsFlags.GranFlags.Costs.additional_latency =
 927         RtsFlags.GranFlags.Costs.gunblocktime =
 928         RtsFlags.GranFlags.Costs.lunblocktime =
 929         RtsFlags.GranFlags.Costs.threadcreatetime =
 930         RtsFlags.GranFlags.Costs.threadqueuetime =
 931         RtsFlags.GranFlags.Costs.threadscheduletime =
 932         RtsFlags.GranFlags.Costs.threaddescheduletime =
 933         RtsFlags.GranFlags.Costs.threadcontextswitchtime = 0;
 934
 935         RtsFlags.GranFlags.Costs.mpacktime =
 936         RtsFlags.GranFlags.Costs.munpacktime = 0;
 937
 938         RtsFlags.GranFlags.Costs.heapalloc_cost = 1;
 939
 940         /* RtsFlags.GranFlags.DoFairSchedule  = rtsTrue; */       /* -b-R */
 941         /* RtsFlags.GranFlags.DoStealThreadsFirst = rtsTrue; */   /* -b-T */
 942         RtsFlags.GranFlags.DoAsyncFetch = rtsTrue;         /* -bZ */
 943         RtsFlags.GranFlags.DoThreadMigration  = rtsTrue;          /* -bM */
 944         RtsFlags.GranFlags.GranSimStats.Full  = rtsTrue;          /* -bP */
 945 #  if defined(GRAN_CHECK) && defined(GRAN)
 946         RtsFlags.GranFlags.Debug.event_stats = rtsTrue; /* print event statistics   */
 947 #  endif
 948         return;
 949       }
 950
 951       /* Communication and task creation cost parameters */
 952       switch(rts_argv[arg][2]) {
 953         case '.':
 954           IgnoreYields = rtsTrue; // HWL HACK
 955           break;
 956
 957         case ':':
 958           enable_GranSimLight();       /* set flags for GrAnSim-Light mode */
 959           break;
 960
 961         case 'l':
 962           if (rts_argv[arg][3] != '\0')
 963             {
 964               RtsFlags.GranFlags.Costs.gunblocktime =
 965               RtsFlags.GranFlags.Costs.latency = decode(rts_argv[arg]+3);
 966               RtsFlags.GranFlags.Costs.fetchtime = 2*RtsFlags.GranFlags.Costs.latency;
 967             }
 968           else
 969             RtsFlags.GranFlags.Costs.latency = LATENCY;
 970           break;
 971
 972         case 'a':
 973           if (rts_argv[arg][3] != '\0')
 974             RtsFlags.GranFlags.Costs.additional_latency = decode(rts_argv[arg]+3);
 975           else
 976             RtsFlags.GranFlags.Costs.additional_latency = ADDITIONAL_LATENCY;
 977           break;
 978
 979         case 'm':
 980           if (rts_argv[arg][3] != '\0')
 981             RtsFlags.GranFlags.Costs.mpacktime = decode(rts_argv[arg]+3);
 982           else
 983             RtsFlags.GranFlags.Costs.mpacktime = MSGPACKTIME;
 984           break;
 985
 986         case 'x':
 987           if (rts_argv[arg][3] != '\0')
 988             RtsFlags.GranFlags.Costs.mtidytime = decode(rts_argv[arg]+3);
 989           else
 990             RtsFlags.GranFlags.Costs.mtidytime = 0;
 991           break;
 992
 993         case 'r':
 994           if (rts_argv[arg][3] != '\0')
 995             RtsFlags.GranFlags.Costs.munpacktime = decode(rts_argv[arg]+3);
 996           else
 997             RtsFlags.GranFlags.Costs.munpacktime = MSGUNPACKTIME;
 998           break;
 999
1000         case 'g':
1001           if (rts_argv[arg][3] != '\0')
1002             RtsFlags.GranFlags.Costs.fetchtime = decode(rts_argv[arg]+3);
1003           else
1004             RtsFlags.GranFlags.Costs.fetchtime = FETCHTIME;
1005           break;
1006
1007         case 'n':
1008           if (rts_argv[arg][3] != '\0')
1009             RtsFlags.GranFlags.Costs.gunblocktime = decode(rts_argv[arg]+3);
1010           else
1011             RtsFlags.GranFlags.Costs.gunblocktime = GLOBALUNBLOCKTIME;
1012           break;
1013
1014         case 'u':
1015           if (rts_argv[arg][3] != '\0')
1016             RtsFlags.GranFlags.Costs.lunblocktime = decode(rts_argv[arg]+3);
1017           else
1018             RtsFlags.GranFlags.Costs.lunblocktime = LOCALUNBLOCKTIME;
1019           break;
1020
1021         /* Thread-related metrics */
1022         case 't':
1023           if (rts_argv[arg][3] != '\0')
1024             RtsFlags.GranFlags.Costs.threadcreatetime = decode(rts_argv[arg]+3);
1025           else
1026             RtsFlags.GranFlags.Costs.threadcreatetime = THREADCREATETIME;
1027           break;
1028
1029         case 'q':
1030           if (rts_argv[arg][3] != '\0')
1031             RtsFlags.GranFlags.Costs.threadqueuetime = decode(rts_argv[arg]+3);
1032           else
1033             RtsFlags.GranFlags.Costs.threadqueuetime = THREADQUEUETIME;
1034           break;
1035
1036         case 'c':
1037           if (rts_argv[arg][3] != '\0')
1038             RtsFlags.GranFlags.Costs.threadscheduletime = decode(rts_argv[arg]+3);
1039           else
1040             RtsFlags.GranFlags.Costs.threadscheduletime = THREADSCHEDULETIME;
1041
1042           RtsFlags.GranFlags.Costs.threadcontextswitchtime = RtsFlags.GranFlags.Costs.threadscheduletime
1043             + RtsFlags.GranFlags.Costs.threaddescheduletime;
1044           break;
1045
1046         case 'd':
1047           if (rts_argv[arg][3] != '\0')
1048             RtsFlags.GranFlags.Costs.threaddescheduletime = decode(rts_argv[arg]+3);
1049           else
1050             RtsFlags.GranFlags.Costs.threaddescheduletime = THREADDESCHEDULETIME;
1051
1052           RtsFlags.GranFlags.Costs.threadcontextswitchtime = RtsFlags.GranFlags.Costs.threadscheduletime
1053             + RtsFlags.GranFlags.Costs.threaddescheduletime;
1054           break;
1055
1056         /* Instruction Cost Metrics */
1057         case 'A':
1058           if (rts_argv[arg][3] != '\0')
1059             RtsFlags.GranFlags.Costs.arith_cost = decode(rts_argv[arg]+3);
1060           else
1061             RtsFlags.GranFlags.Costs.arith_cost = ARITH_COST;
1062           break;
1063
1064         case 'F':
1065           if (rts_argv[arg][3] != '\0')
1066             RtsFlags.GranFlags.Costs.float_cost = decode(rts_argv[arg]+3);
1067           else
1068             RtsFlags.GranFlags.Costs.float_cost = FLOAT_COST;
1069           break;
1070
1071         case 'B':
1072           if (rts_argv[arg][3] != '\0')
1073             RtsFlags.GranFlags.Costs.branch_cost = decode(rts_argv[arg]+3);
1074           else
1075             RtsFlags.GranFlags.Costs.branch_cost = BRANCH_COST;
1076           break;
1077
1078         case 'L':
1079           if (rts_argv[arg][3] != '\0')
1080             RtsFlags.GranFlags.Costs.load_cost = decode(rts_argv[arg]+3);
1081           else
1082             RtsFlags.GranFlags.Costs.load_cost = LOAD_COST;
1083           break;
1084
1085         case 'S':
1086           if (rts_argv[arg][3] != '\0')
1087             RtsFlags.GranFlags.Costs.store_cost = decode(rts_argv[arg]+3);
1088           else
1089             RtsFlags.GranFlags.Costs.store_cost = STORE_COST;
1090           break;
1091
1092         case 'H':
1093           if (rts_argv[arg][3] != '\0')
1094             RtsFlags.GranFlags.Costs.heapalloc_cost = decode(rts_argv[arg]+3);
1095           else
1096             RtsFlags.GranFlags.Costs.heapalloc_cost = 0;
1097           break;
1098
1099         case 'y':
1100           RtsFlags.GranFlags.DoAsyncFetch = rtsTrue;
1101           if (rts_argv[arg][3] != '\0')
1102             RtsFlags.GranFlags.FetchStrategy = decode(rts_argv[arg]+3);
1103           else
1104             RtsFlags.GranFlags.FetchStrategy = 2;
1105           if (RtsFlags.GranFlags.FetchStrategy == 0)
1106             RtsFlags.GranFlags.DoAsyncFetch = rtsFalse;
1107           break;
1108
1109         case 'K':   /* sort overhead (per elem in spark list) */
1110           if (rts_argv[arg][3] != '\0')
1111             RtsFlags.GranFlags.Costs.pri_spark_overhead = decode(rts_argv[arg]+3);
1112           else
1113             RtsFlags.GranFlags.Costs.pri_spark_overhead = PRI_SPARK_OVERHEAD;
1114           fprintf(stderr,"Overhead for pri spark: %d (per elem).\n",
1115                          RtsFlags.GranFlags.Costs.pri_spark_overhead);
1116           break;
1117
1118         case 'O':  /* sort overhead (per elem in spark list) */
1119           if (rts_argv[arg][3] != '\0')
1120             RtsFlags.GranFlags.Costs.pri_sched_overhead = decode(rts_argv[arg]+3);
1121           else
1122             RtsFlags.GranFlags.Costs.pri_sched_overhead = PRI_SCHED_OVERHEAD;
1123           fprintf(stderr,"Overhead for pri sched: %d (per elem).\n",
1124                        RtsFlags.GranFlags.Costs.pri_sched_overhead);
1125           break;
1126
1127         /* General Parameters */
1128         case 'p':
1129           if (rts_argv[arg][3] != '\0')
1130             {
1131               RtsFlags.GranFlags.proc = decode(rts_argv[arg]+3);
1132               if (RtsFlags.GranFlags.proc==0) {
1133                   enable_GranSimLight(); /* set flags for GrAnSim-Light mode */
1134               } else if (RtsFlags.GranFlags.proc > MAX_PROC ||
1135                          RtsFlags.GranFlags.proc < 1)
1136                 {
1137                   fprintf(stderr,"setupRtsFlags: no more than %u processors
1138 allowed\n",
1139                           MAX_PROC);
1140                   *error = rtsTrue;
1141                 }
1142             }
1143           else
1144             RtsFlags.GranFlags.proc = MAX_PROC;
1145           break;
1146
1147         case 'f':
1148           RtsFlags.GranFlags.Fishing = rtsTrue;
1149           if (rts_argv[arg][3] != '\0')
1150             RtsFlags.GranFlags.maxFishes = decode(rts_argv[arg]+3);
1151           else
1152             RtsFlags.GranFlags.maxFishes = MAX_FISHES;
1153           break;
1154
1155         case 'w':
1156           if (rts_argv[arg][3] != '\0')
1157             RtsFlags.GranFlags.time_slice = decode(rts_argv[arg]+3);
1158           else
1159             RtsFlags.GranFlags.time_slice = GRAN_TIME_SLICE;
1160           break;
1161
1162         case 'C':
1163           RtsFlags.GranFlags.DoAlwaysCreateThreads=rtsTrue;
1164           RtsFlags.GranFlags.DoThreadMigration=rtsTrue;
1165           break;
1166
1167         case 'G':
1168           fprintf(stderr,"Bulk fetching enabled.\n");
1169           RtsFlags.GranFlags.DoBulkFetching=rtsTrue;
1170           break;
1171
1172         case 'M':
1173           fprintf(stderr,"Thread migration enabled.\n");
1174           RtsFlags.GranFlags.DoThreadMigration=rtsTrue;
1175           break;
1176
1177         case 'R':
1178           fprintf(stderr,"Fair Scheduling enabled.\n");
1179           RtsFlags.GranFlags.DoFairSchedule=rtsTrue;
1180           break;
1181
1182         case 'I':
1183           fprintf(stderr,"Priority Scheduling enabled.\n");
1184           RtsFlags.GranFlags.DoPriorityScheduling=rtsTrue;
1185           break;
1186
1187         case 'T':
1188           RtsFlags.GranFlags.DoStealThreadsFirst=rtsTrue;
1189           RtsFlags.GranFlags.DoThreadMigration=rtsTrue;
1190           break;
1191
1192         case 'Z':
1193           RtsFlags.GranFlags.DoAsyncFetch=rtsTrue;
1194           break;
1195
1196 /*          case 'z': */
1197 /*        RtsFlags.GranFlags.SimplifiedFetch=rtsTrue; */
1198 /*        break; */
1199
1200         case 'N':
1201           RtsFlags.GranFlags.PreferSparksOfLocalNodes=rtsTrue;
1202           break;
1203
1204         case 'b':
1205           RtsFlags.GranFlags.GranSimStats.Binary=rtsTrue;
1206           break;
1207
1208         case 'P':
1209           /* format is -bP<c> where <c> is one char describing kind of profile */
1210           RtsFlags.GranFlags.GranSimStats.Full = rtsTrue;
1211           switch(rts_argv[arg][3]) {
1212           case '\0': break; // nothing special, just an ordinary profile
1213           case '0': RtsFlags.GranFlags.GranSimStats.Suppressed = rtsTrue;
1214             break;
1215           case 'b': RtsFlags.GranFlags.GranSimStats.Binary = rtsTrue;
1216             break;
1217           case 's': RtsFlags.GranFlags.GranSimStats.Sparks = rtsTrue;
1218             break;
1219           case 'h': RtsFlags.GranFlags.GranSimStats.Heap = rtsTrue;
1220             break;
1221           case 'n': RtsFlags.GranFlags.GranSimStats.NewLogfile = rtsTrue;
1222             break;
1223           case 'g': RtsFlags.GranFlags.GranSimStats.Global = rtsTrue;
1224             break;
1225           default: barf("Unknown option -bP%c", rts_argv[arg][3]);
1226           }
1227           break;
1228
1229         case 's':
1230           RtsFlags.GranFlags.GranSimStats.Sparks=rtsTrue;
1231           break;
1232
1233         case 'h':
1234           RtsFlags.GranFlags.GranSimStats.Heap=rtsTrue;
1235           break;
1236
1237         case 'Y':   /* syntax: -bY<n>[,<n>]  n ... pos int */
1238           if (rts_argv[arg][3] != '\0') {
1239             char *arg0, *tmp;
1240
1241             arg0 = rts_argv[arg]+3;
1242             if ((tmp = strstr(arg0,","))==NULL) {
1243               RtsFlags.GranFlags.SparkPriority = decode(arg0);
1244               fprintf(stderr,"SparkPriority: %u.\n",RtsFlags.GranFlags.SparkPriority);
1245             } else {
1246               *(tmp++) = '\0';
1247               RtsFlags.GranFlags.SparkPriority = decode(arg0);
1248               RtsFlags.GranFlags.SparkPriority2 = decode(tmp);
1249               fprintf(stderr,"SparkPriority: %u.\n",
1250                       RtsFlags.GranFlags.SparkPriority);
1251               fprintf(stderr,"SparkPriority2:%u.\n",
1252                       RtsFlags.GranFlags.SparkPriority2);
1253               if (RtsFlags.GranFlags.SparkPriority2 <
1254                   RtsFlags.GranFlags.SparkPriority) {
1255                 fprintf(stderr,"WARNING: 2nd pri < main pri (%u<%u); 2nd pri has no effect\n",
1256                         RtsFlags.GranFlags.SparkPriority2,
1257                         RtsFlags.GranFlags.SparkPriority);
1258               }
1259             }
1260           } else {
1261             /* plain pri spark is now invoked with -bX
1262                RtsFlags.GranFlags.DoPrioritySparking = 1;
1263                fprintf(stderr,"PrioritySparking.\n");
1264             */
1265           }
1266           break;
1267
1268         case 'Q':
1269           if (rts_argv[arg][3] != '\0') {
1270             RtsFlags.GranFlags.ThunksToPack = decode(rts_argv[arg]+3);
1271           } else {
1272             RtsFlags.GranFlags.ThunksToPack = 1;
1273           }
1274           fprintf(stderr,"Thunks To Pack in one packet: %u.\n",
1275                   RtsFlags.GranFlags.ThunksToPack);
1276           break;
1277
1278         case 'e':
1279           RtsFlags.GranFlags.RandomSteal = rtsFalse;
1280           fprintf(stderr,"Deterministic mode (no random stealing)\n");
1281                       break;
1282
1283           /* The following class of options contains eXperimental */
1284           /* features in connection with exploiting granularity */
1285           /* information. I.e. if -bY is chosen these options */
1286           /* tell the RTS what to do with the supplied info --HWL */
1287
1288         case 'W':
1289           if (rts_argv[arg][3] != '\0') {
1290             RtsFlags.GranFlags.packBufferSize_internal = decode(rts_argv[arg]+3);
1291           } else {
1292             RtsFlags.GranFlags.packBufferSize_internal = GRANSIM_DEFAULT_PACK_BUFFER_SIZE;
1293           }
1294           fprintf(stderr,"Size of GranSim internal pack buffer: %u.\n",
1295                   RtsFlags.GranFlags.packBufferSize_internal);
1296           break;
1297
1298         case 'X':
1299           switch(rts_argv[arg][3]) {
1300
1301             case '\0':
1302               RtsFlags.GranFlags.DoPrioritySparking = 1;
1303               fprintf(stderr,"Priority Sparking with Normal Priorities.\n");
1304               RtsFlags.GranFlags.InversePriorities = rtsFalse;
1305               RtsFlags.GranFlags.RandomPriorities = rtsFalse;
1306               RtsFlags.GranFlags.IgnorePriorities = rtsFalse;
1307               break;
1308
1309             case 'I':
1310               RtsFlags.GranFlags.DoPrioritySparking = 1;
1311               fprintf(stderr,"Priority Sparking with Inverse Priorities.\n");
1312               RtsFlags.GranFlags.InversePriorities++;
1313               break;
1314
1315             case 'R':
1316               RtsFlags.GranFlags.DoPrioritySparking = 1;
1317               fprintf(stderr,"Priority Sparking with Random Priorities.\n");
1318               RtsFlags.GranFlags.RandomPriorities++;
1319               break;
1320
1321             case 'N':
1322               RtsFlags.GranFlags.DoPrioritySparking = 1;
1323               fprintf(stderr,"Priority Sparking with No Priorities.\n");
1324               RtsFlags.GranFlags.IgnorePriorities++;
1325               break;
1326
1327             default:
1328               bad_option( rts_argv[arg] );
1329               break;
1330           }
1331           break;
1332
1333         case '-':
1334           switch(rts_argv[arg][3]) {
1335
1336             case 'C':
1337               RtsFlags.GranFlags.DoAlwaysCreateThreads=rtsFalse;
1338               RtsFlags.GranFlags.DoThreadMigration=rtsFalse;
1339               break;
1340
1341             case 'G':
1342               RtsFlags.GranFlags.DoBulkFetching=rtsFalse;
1343               break;
1344
1345             case 'M':
1346               RtsFlags.GranFlags.DoThreadMigration=rtsFalse;
1347               break;
1348
1349             case 'R':
1350               RtsFlags.GranFlags.DoFairSchedule=rtsFalse;
1351               break;
1352
1353             case 'T':
1354               RtsFlags.GranFlags.DoStealThreadsFirst=rtsFalse;
1355               RtsFlags.GranFlags.DoThreadMigration=rtsFalse;
1356               break;
1357
1358             case 'Z':
1359               RtsFlags.GranFlags.DoAsyncFetch=rtsFalse;
1360               break;
1361
1362             case 'N':
1363               RtsFlags.GranFlags.PreferSparksOfLocalNodes=rtsFalse;
1364                          break;
1365
1366             case 'P':
1367               RtsFlags.GranFlags.GranSimStats.Suppressed=rtsTrue;
1368               break;
1369
1370             case 's':
1371               RtsFlags.GranFlags.GranSimStats.Sparks=rtsFalse;
1372               break;
1373
1374             case 'h':
1375               RtsFlags.GranFlags.GranSimStats.Heap=rtsFalse;
1376               break;
1377
1378             case 'b':
1379               RtsFlags.GranFlags.GranSimStats.Binary=rtsFalse;
1380               break;
1381
1382             case 'X':
1383               RtsFlags.GranFlags.DoPrioritySparking = rtsFalse;
1384               break;
1385
1386             case 'Y':
1387               RtsFlags.GranFlags.DoPrioritySparking = rtsFalse;
1388               RtsFlags.GranFlags.SparkPriority = rtsFalse;
1389               break;
1390
1391             case 'I':
1392               RtsFlags.GranFlags.DoPriorityScheduling = rtsFalse;
1393               break;
1394
1395             case 'e':
1396               RtsFlags.GranFlags.RandomSteal = rtsFalse;
1397               break;
1398
1399             default:
1400               bad_option( rts_argv[arg] );
1401               break;
1402           }
1403           break;
1404
1405 #  if defined(GRAN_CHECK) && defined(GRAN)
1406         case 'D':
1407           switch(rts_argv[arg][3]) {
1408             case 'Q':    /* Set pack buffer size (same as 'Q' in GUM) */
1409               if (rts_argv[arg][4] != '\0') {
1410                 RtsFlags.GranFlags.packBufferSize = decode(rts_argv[arg]+4);
1411                 fprintf(stderr,"Pack buffer size: %d\n",
1412                         RtsFlags.GranFlags.packBufferSize);
1413               } else {
1414                 fprintf(stderr, "setupRtsFlags: missing size of PackBuffer (for -Q)\n");
1415                 *error = rtsTrue;
1416               }
1417               break;
1418
1419           default:
1420               if (isdigit(rts_argv[arg][3])) {/* Set all debugging options in one */
1421                 /* hack warning: interpret the flags as a binary number */
1422                 nat n = decode(rts_argv[arg]+3);
1423                 set_GranSim_debug_options(n);
1424               } else {
1425                 nat i;
1426                 for (i=0; i<=MAX_GRAN_DEBUG_OPTION; i++)
1427                   if (rts_argv[arg][3] == gran_debug_opts_flags[i])
1428                     break;
1429
1430                 if (i==MAX_GRAN_DEBUG_OPTION+1) {
1431                   fprintf(stderr, "Valid GranSim debug options are:\n");
1432                   help_GranSim_debug_options(MAX_GRAN_DEBUG_MASK);
1433                   bad_option( rts_argv[arg] );
1434                 } else { // flag found; now set it
1435                   set_GranSim_debug_options(GRAN_DEBUG_MASK(i));  // 2^i
1436                 }
1437               }
1438               break;
1439
1440 #if 0
1441             case 'e':       /* event trace; also -bD1 */
1442               fprintf(stderr,"DEBUG: event_trace; printing event trace.\n");
1443               RtsFlags.GranFlags.Debug.event_trace = rtsTrue;
1444               /* RtsFlags.GranFlags.event_trace=rtsTrue; */
1445               break;
1446
1447             case 'E':       /* event statistics; also -bD2 */
1448               fprintf(stderr,"DEBUG: event_stats; printing event statistics.\n");
1449               RtsFlags.GranFlags.Debug.event_stats = rtsTrue;
1450               /* RtsFlags.GranFlags.Debug |= 0x20; print event statistics   */
1451               break;
1452
1453             case 'f':       /* thunkStealing; also -bD4 */
1454               fprintf(stderr,"DEBUG: thunkStealing; printing forwarding of FETCHNODES.\n");
1455               RtsFlags.GranFlags.Debug.thunkStealing = rtsTrue;
1456               /* RtsFlags.GranFlags.Debug |= 0x2;  print fwd messages */
1457               break;
1458
1459             case 'z':       /* blockOnFetch; also -bD8 */
1460               fprintf(stderr,"DEBUG: blockOnFetch; check for blocked on fetch.\n");
1461               RtsFlags.GranFlags.Debug.blockOnFetch = rtsTrue;
1462               /* RtsFlags.GranFlags.Debug |= 0x4; debug non-reschedule-on-fetch */
1463               break;
1464
1465             case 't':       /* blockOnFetch_sanity; also -bD16 */
1466               fprintf(stderr,"DEBUG: blockOnFetch_sanity; check for TSO asleep on fetch.\n");
1467               RtsFlags.GranFlags.Debug.blockOnFetch_sanity = rtsTrue;
1468               /* RtsFlags.GranFlags.Debug |= 0x10; debug TSO asleep for fetch  */
1469               break;
1470
1471             case 'S':       /* priSpark; also -bD32 */
1472               fprintf(stderr,"DEBUG: priSpark; priority sparking.\n");
1473               RtsFlags.GranFlags.Debug.priSpark = rtsTrue;
1474               break;
1475
1476             case 's':       /* priSched; also -bD64 */
1477               fprintf(stderr,"DEBUG: priSched; priority scheduling.\n");
1478               RtsFlags.GranFlags.Debug.priSched = rtsTrue;
1479               break;
1480
1481             case 'F':       /* findWork; also -bD128 */
1482               fprintf(stderr,"DEBUG: findWork; searching spark-pools (local & remote), thread queues for work.\n");
1483               RtsFlags.GranFlags.Debug.findWork = rtsTrue;
1484               break;
1485
1486             case 'g':       /* globalBlock; also -bD256 */
1487               fprintf(stderr,"DEBUG: globalBlock; blocking on remote closures (FETCHMEs etc in GUM).\n");
1488               RtsFlags.GranFlags.Debug.globalBlock = rtsTrue;
1489               break;
1490
1491             case 'G':       /* pack; also -bD512 */
1492               fprintf(stderr,"DEBUG: pack; routines for (un-)packing graph structures.\n");
1493               RtsFlags.GranFlags.Debug.pack = rtsTrue;
1494               break;
1495
1496             case 'P':       /* packBuffer; also -bD1024 */
1497               fprintf(stderr,"DEBUG: packBuffer; routines handling pack buffer (GranSim internal!).\n");
1498               RtsFlags.GranFlags.Debug.packBuffer = rtsTrue;
1499               break;
1500
1501             case 'o':       /* sortedQ; also -bD2048 */
1502               fprintf(stderr,"DEBUG: sortedQ; check whether spark/thread queues are sorted.\n");
1503               RtsFlags.GranFlags.Debug.sortedQ = rtsTrue;
1504               break;
1505
1506             case 'r':       /* randomSteal; also -bD4096 */
1507               fprintf(stderr,"DEBUG: randomSteal; stealing sparks/threads from random PEs.\n");
1508               RtsFlags.GranFlags.Debug.randomSteal = rtsTrue;
1509               break;
1510
1511             case 'q':       /* checkSparkQ; also -bD8192 */
1512               fprintf(stderr,"DEBUG: checkSparkQ; check consistency of the spark queues.\n");
1513               RtsFlags.GranFlags.Debug.checkSparkQ = rtsTrue;
1514               break;
1515
1516             case ':':       /* checkLight; also -bD16384 */
1517               fprintf(stderr,"DEBUG: checkLight; check GranSim-Light setup.\n");
1518               RtsFlags.GranFlags.Debug.checkLight = rtsTrue;
1519               break;
1520
1521             case 'b':       /* bq; also -bD32768 */
1522               fprintf(stderr,"DEBUG: bq; check blocking queues\n");
1523               RtsFlags.GranFlags.Debug.bq = rtsTrue;
1524               break;
1525
1526             case 'd':       /* all options turned on */
1527               fprintf(stderr,"DEBUG: all options turned on.\n");
1528               set_GranSim_debug_options(MAX_GRAN_DEBUG_MASK);
1529               /* RtsFlags.GranFlags.Debug |= 0x40; */
1530               break;
1531
1532 /*          case '\0': */
1533 /*            RtsFlags.GranFlags.Debug = 1; */
1534 /*            break; */
1535 #endif
1536
1537           }
1538           break;
1539 #  endif  /* GRAN_CHECK */
1540       default:
1541         bad_option( rts_argv[arg] );
1542         break;
1543       }
1544 }
1545
1546 /*
1547   Interpret n as a binary number masking GranSim debug options and set the
1548   correxponding option. See gran_debug_opts_strs for explanations of the flags.
1549 */
1550 static void
1551 set_GranSim_debug_options(nat n) {
1552   nat i;
1553
1554   for (i=0; i<=MAX_GRAN_DEBUG_OPTION; i++)
1555     if ((n>>i)&1) {
1556       fprintf(stderr, gran_debug_opts_strs[i]);
1557       switch (i) {
1558         case 0: RtsFlags.GranFlags.Debug.event_trace   = rtsTrue;  break;
1559         case 1: RtsFlags.GranFlags.Debug.event_stats   = rtsTrue;  break;
1560         case 2: RtsFlags.GranFlags.Debug.bq            = rtsTrue;  break;
1561         case 3: RtsFlags.GranFlags.Debug.pack          = rtsTrue;  break;
1562         case 4: RtsFlags.GranFlags.Debug.checkSparkQ   = rtsTrue;  break;
1563         case 5: RtsFlags.GranFlags.Debug.thunkStealing = rtsTrue;  break;
1564         case 6: RtsFlags.GranFlags.Debug.randomSteal   = rtsTrue;  break;
1565         case 7: RtsFlags.GranFlags.Debug.findWork      = rtsTrue;  break;
1566         case 8: RtsFlags.GranFlags.Debug.unused        = rtsTrue;  break;
1567         case 9: RtsFlags.GranFlags.Debug.pri           = rtsTrue;  break;
1568         case 10: RtsFlags.GranFlags.Debug.checkLight   = rtsTrue;  break;
1569         case 11: RtsFlags.GranFlags.Debug.sortedQ      = rtsTrue;  break;
1570         case 12: RtsFlags.GranFlags.Debug.blockOnFetch = rtsTrue;  break;
1571         case 13: RtsFlags.GranFlags.Debug.packBuffer   = rtsTrue;  break;
1572         case 14: RtsFlags.GranFlags.Debug.blockOnFetch_sanity = rtsTrue;  break;
1573         default: barf("set_GranSim_debug_options: only %d debug options expected");
1574       } /* switch */
1575     } /* if */
1576 }
1577
1578 /*
1579   Print one line explanation for each of the GranSim debug options specified
1580   in the bitmask n.
1581 */
1582 static void
1583 help_GranSim_debug_options(nat n) {
1584   nat i;
1585
1586   for (i=0; i<=MAX_GRAN_DEBUG_OPTION; i++)
1587     if ((n>>i)&1)
1588       fprintf(stderr, gran_debug_opts_strs[i]);
1589 }
1590
1591 # elif defined(PAR)
1592
1593 static void
1594 process_par_option(int arg, int *rts_argc, char *rts_argv[], rtsBool *error)
1595 {
1596   if (rts_argv[arg][1] != 'q') /* All GUM options start with -q */
1597     return;
1598
1599   /* Communication and task creation cost parameters */
1600   switch(rts_argv[arg][2]) {
1601   case 'e':  /* -qe<n>  ... allow <n> local sparks */
1602     if (rts_argv[arg][3] != '\0') { /* otherwise, stick w/ the default */
1603       RtsFlags.ParFlags.maxLocalSparks
1604         = strtol(rts_argv[arg]+3, (char **) NULL, 10);
1605
1606       if (RtsFlags.ParFlags.maxLocalSparks <= 0) {
1607         belch("setupRtsFlags: bad value for -e\n");
1608         *error = rtsTrue;
1609       }
1610     }
1611     IF_PAR_DEBUG(verbose,
1612                  belch("-qe<n>: max %d local sparks",
1613                        RtsFlags.ParFlags.maxLocalSparks));
1614     break;
1615
1616   case 't':
1617     if (rts_argv[arg][3] != '\0') {
1618       RtsFlags.ParFlags.maxThreads
1619         = strtol(rts_argv[arg]+3, (char **) NULL, 10);
1620     } else {
1621       belch("setupRtsFlags: missing size for -qt\n");
1622       *error = rtsTrue;
1623     }
1624     IF_PAR_DEBUG(verbose,
1625                  belch("-qt<n>: max %d threads",
1626                        RtsFlags.ParFlags.maxThreads));
1627     break;
1628
1629   case 'f':
1630     if (rts_argv[arg][3] != '\0')
1631       RtsFlags.ParFlags.maxFishes = decode(rts_argv[arg]+3);
1632     else
1633       RtsFlags.ParFlags.maxFishes = MAX_FISHES;
1634     break;
1635     IF_PAR_DEBUG(verbose,
1636                  belch("-qf<n>: max %d fishes sent out at one time",
1637                        RtsFlags.ParFlags.maxFishes));
1638     break;
1639
1640
1641   case 'd':
1642     if (rts_argv[arg][3] != '\0') {
1643       RtsFlags.ParFlags.fishDelay
1644         = strtol(rts_argv[arg]+3, (char **) NULL, 10);
1645     } else {
1646       belch("setupRtsFlags: missing fish delay time for -qd\n");
1647       *error = rtsTrue;
1648     }
1649     IF_PAR_DEBUG(verbose,
1650                  belch("-qd<n>: fish delay time %d",
1651                        RtsFlags.ParFlags.fishDelay));
1652     break;
1653
1654   case 'O':
1655     RtsFlags.ParFlags.outputDisabled = rtsTrue;
1656     IF_PAR_DEBUG(verbose,
1657                  belch("-qO: output disabled"));
1658     break;
1659
1660   case 'P': /* -qP for writing a log file */
1661     RtsFlags.ParFlags.ParStats.Full = rtsTrue;
1662     /* same encoding as in GranSim after -bP */
1663     switch(rts_argv[arg][3]) {
1664     case '\0': break; // nothing special, just an ordinary profile
1665       //case '0': RtsFlags.ParFlags.ParStats.Suppressed = rtsTrue;
1666       //  break;
1667     case 'b': RtsFlags.ParFlags.ParStats.Binary = rtsTrue;
1668       break;
1669     case 's': RtsFlags.ParFlags.ParStats.Sparks = rtsTrue;
1670       break;
1671       //case 'h': RtsFlags.parFlags.ParStats.Heap = rtsTrue;
1672       //  break;
1673     case 'n': RtsFlags.ParFlags.ParStats.NewLogfile = rtsTrue;
1674       break;
1675     case 'g': RtsFlags.ParFlags.ParStats.Global = rtsTrue;
1676       break;
1677     default: barf("Unknown option -qP%c", rts_argv[arg][2]);
1678     }
1679     IF_PAR_DEBUG(verbose,
1680                  belch("(-qP) writing to log-file (RtsFlags.ParFlags.ParStats.Full=%s)",
1681                        (RtsFlags.ParFlags.ParStats.Full ? "rtsTrue" : "rtsFalse")));
1682     break;
1683
1684   case 'Q': /* -qQ<n> ... set pack buffer size to <n> */
1685     if (rts_argv[arg][3] != '\0') {
1686       RtsFlags.ParFlags.packBufferSize = decode(rts_argv[arg]+3);
1687     } else {
1688       belch("setupRtsFlags: missing size of PackBuffer (for -Q)\n");
1689       error = rtsTrue;
1690     }
1691     IF_PAR_DEBUG(verbose,
1692                  belch("-qQ<n>: pack buffer size set to %d",
1693                        RtsFlags.ParFlags.packBufferSize));
1694     break;
1695
1696 # if defined(DEBUG)
1697   case 'w':
1698     if (rts_argv[arg][3] != '\0') {
1699       RtsFlags.ParFlags.wait
1700         = strtol(rts_argv[arg]+3, (char **) NULL, 10);
1701     } else {
1702       RtsFlags.ParFlags.wait = 1000;
1703     }
1704     IF_PAR_DEBUG(verbose,
1705                  belch("-qw<n>: length of wait loop after synchr before reduction: %d",
1706                        RtsFlags.ParFlags.wait));
1707     break;
1708
1709   case 'D':  /* -qD ... all the debugging options */
1710     if (isdigit(rts_argv[arg][3])) {/* Set all debugging options in one */
1711       /* hack warning: interpret the flags as a binary number */
1712       nat n = decode(rts_argv[arg]+3);
1713       set_par_debug_options(n);
1714     } else {
1715       nat i;
1716       for (i=0; i<=MAX_PAR_DEBUG_OPTION; i++)
1717         if (rts_argv[arg][3] == par_debug_opts_flags[i])
1718           break;
1719
1720       if (i==MAX_PAR_DEBUG_OPTION+1) {
1721         fprintf(stderr, "Valid GUM debug options are:\n");
1722         help_par_debug_options(MAX_PAR_DEBUG_MASK);
1723         bad_option( rts_argv[arg] );
1724       } else { // flag found; now set it
1725         set_par_debug_options(PAR_DEBUG_MASK(i));  // 2^i
1726       }
1727     }
1728     break;
1729 # endif
1730   default:
1731     belch("Unknown option -q%c", rts_argv[arg][2]);
1732     break;
1733   } /* switch */
1734 }
1735
1736 /*
1737   Interpret n as a binary number masking Par debug options and set the
1738   correxponding option. See par_debug_opts_strs for explanations of the flags.
1739 */
1740 static void
1741 set_par_debug_options(nat n) {
1742   nat i;
1743
1744   for (i=0; i<=MAX_PAR_DEBUG_OPTION; i++)
1745     if ((n>>i)&1) {
1746       fprintf(stderr, par_debug_opts_strs[i]);
1747       switch (i) {
1748         case 0: RtsFlags.ParFlags.Debug.verbose       = rtsTrue;  break;
1749         case 1: RtsFlags.ParFlags.Debug.trace         = rtsTrue;  break;
1750         case 2: RtsFlags.ParFlags.Debug.schedule      = rtsTrue;  break;
1751         case 3: RtsFlags.ParFlags.Debug.free          = rtsTrue;  break;
1752         case 4: RtsFlags.ParFlags.Debug.resume        = rtsTrue;  break;
1753         case 5: RtsFlags.ParFlags.Debug.weight        = rtsTrue;  break;
1754         case 6: RtsFlags.ParFlags.Debug.fetch         = rtsTrue;  break;
1755           //case 7: RtsFlags.ParFlags.Debug.ack           = rtsTrue;  break;
1756         case 7: RtsFlags.ParFlags.Debug.fish          = rtsTrue;  break;
1757         case 8: RtsFlags.ParFlags.Debug.tables        = rtsTrue;  break;
1758         case 9: RtsFlags.ParFlags.Debug.packet        = rtsTrue;  break;
1759         case 10: RtsFlags.ParFlags.Debug.pack          = rtsTrue;  break;
1760         default: barf("set_par_debug_options: only %d debug options expected");
1761       } /* switch */
1762     } /* if */
1763 }
1764
1765 /*
1766   Print one line explanation for each of the GranSim debug options specified
1767   in the bitmask n.
1768 */
1769 static void
1770 help_par_debug_options(nat n) {
1771   nat i;
1772
1773   for (i=0; i<=MAX_PAR_DEBUG_OPTION; i++)
1774     if ((n>>i)&1)
1775       fprintf(stderr, par_debug_opts_strs[i]);
1776 }
1777
1778 #endif /* PAR */
1779
1780 #ifdef DEBUG
1781 static void
1782 set_debug_options(nat n) {
1783   nat i;
1784
1785   for (i=0; i<=MAX_DEBUG_OPTION; i++)
1786     if ((n>>i)&1) {
1787       fprintf(stderr, debug_opts_strs[i]);
1788       switch (i) {
1789         case 0:  RtsFlags.DebugFlags.scheduler   = rtsTrue; break;
1790         case 1:  RtsFlags.DebugFlags.evaluator   = rtsTrue; break;
1791         case 2:  RtsFlags.DebugFlags.codegen     = rtsTrue; break;
1792         case 3:  RtsFlags.DebugFlags.weak        = rtsTrue; break;
1793         case 4:  RtsFlags.DebugFlags.gccafs      = rtsTrue; break;
1794         case 5:  RtsFlags.DebugFlags.gc          = rtsTrue; break;
1795         case 6:  RtsFlags.DebugFlags.block_alloc = rtsTrue; break;
1796         case 7:  RtsFlags.DebugFlags.sanity      = rtsTrue; break;
1797         case 8:  RtsFlags.DebugFlags.stable      = rtsTrue; break;
1798         case 9:  RtsFlags.DebugFlags.prof        = rtsTrue; break;
1799         case 10: RtsFlags.DebugFlags.gran        = rtsTrue; break;
1800         case 11: RtsFlags.DebugFlags.par         = rtsTrue; break;
1801         case 12: RtsFlags.DebugFlags.linker      = rtsTrue; break;
1802       } /* switch */
1803     } /* if */
1804 }
1805
1806 static void
1807 help_debug_options(nat n) {
1808   nat i;
1809
1810   for (i=0; i<=MAX_DEBUG_OPTION; i++)
1811     if ((n>>i)&1)
1812       fprintf(stderr, debug_opts_strs[i]);
1813 }
1814 #endif /* DEBUG */
1815
1816 //@node Aux fcts,  , GranSim specific options
1817 //@subsection Aux fcts
1818
1819 static FILE *           /* return NULL on error */
1820 open_stats_file (
1821     I_ arg,
1822     int argc, char *argv[],
1823     int rts_argc, char *rts_argv[],
1824     const char *FILENAME_FMT)
1825 {
1826     FILE *f = NULL;
1827
1828     if (strequal(rts_argv[arg]+2, "stderr")) /* use real stderr */
1829         f = stderr;
1830     else if (rts_argv[arg][2] != '\0')      /* stats file specified */
1831         f = fopen(rts_argv[arg]+2,"w");
1832     else {
1833         char stats_filename[STATS_FILENAME_MAXLEN]; /* default <program>.<ext> */
1834         sprintf(stats_filename, FILENAME_FMT, argv[0]);
1835         f = fopen(stats_filename,"w");
1836     }
1837     if (f == NULL) {
1838         fprintf(stderr, "Can't open stats file %s\n", rts_argv[arg]+2);
1839     } else {
1840         /* Write argv and rtsv into start of stats file */
1841         I_ count;
1842         for(count = 0; count < argc; count++)
1843             fprintf(f, "%s ", argv[count]);
1844         fprintf(f, "+RTS ");
1845         for(count = 0; count < rts_argc; count++)
1846             fprintf(f, "%s ", rts_argv[count]);
1847         fprintf(f, "\n");
1848     }
1849
1850     return(f);
1851 }
1852
1853 static I_
1854 decode(const char *s)
1855 {
1856     I_ c;
1857     StgDouble m;
1858
1859     if (!*s)
1860         return 0;
1861
1862     m = atof(s);
1863     c = s[strlen(s)-1];
1864
1865     if (c == 'g' || c == 'G')
1866         m *= 1000*1000*1000;    /* UNchecked! */
1867     else if (c == 'm' || c == 'M')
1868         m *= 1000*1000;                 /* We do not use powers of 2 (1024) */
1869     else if (c == 'k' || c == 'K')      /* to avoid possible bad effects on */
1870         m *= 1000;                      /* a direct-mapped cache.           */
1871     else if (c == 'w' || c == 'W')
1872         m *= sizeof(W_);
1873
1874     return (I_)m;
1875 }
1876
1877 static void
1878 bad_option(const char *s)
1879 {
1880   prog_belch("bad RTS option: %s", s);
1881   stg_exit(EXIT_FAILURE);
1882 }