ghc/rts/RtsFlags.c

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