rts/RtsFlags.c

   1 /* -----------------------------------------------------------------------------
   2  *
   3  * (c) The AQUA Project, Glasgow University, 1994-1997
   4  * (c) The GHC Team, 1998-2006
   5  *
   6  * Functions for parsing the argument list.
   7  *
   8  * ---------------------------------------------------------------------------*/
   9
  10 #include "PosixSource.h"
  11 #include "Rts.h"
  12 #include "RtsFlags.h"
  13 #include "RtsUtils.h"
  14 #include "Profiling.h"
  15
  16 #ifdef HAVE_CTYPE_H
  17 #include <ctype.h>
  18 #endif
  19
  20 #ifdef HAVE_UNISTD_H
  21 #include <unistd.h>
  22 #endif
  23
  24 #ifdef HAVE_WINDOWS_H
  25 #include <windows.h>
  26 #endif
  27
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 // Flag Structure
  32 RTS_FLAGS RtsFlags;
  33
  34 /*
  35  * Split argument lists
  36  */
  37 int     prog_argc = 0;    /* an "int" so as to match normal "argc" */
  38 char  **prog_argv = NULL;
  39 int     full_prog_argc = 0;    /* an "int" so as to match normal "argc" */
  40 char  **full_prog_argv = NULL;
  41 char   *prog_name = NULL; /* 'basename' of prog_argv[0] */
  42 int     rts_argc = 0;  /* ditto */
  43 char   *rts_argv[MAX_RTS_ARGS];
  44
  45 /*
  46  * constants, used later
  47  */
  48 #define RTS 1
  49 #define PGM 0
  50
  51 #if defined(GRAN)
  52
  53 static char *gran_debug_opts_strs[] = {
  54   "DEBUG (-bDe, -bD1): event_trace; printing event trace.\n",
  55   "DEBUG (-bDE, -bD2): event_stats; printing event statistics.\n",
  56   "DEBUG (-bDb, -bD4): bq; check blocking queues\n",
  57   "DEBUG (-bDG, -bD8): pack; routines for (un-)packing graph structures.\n",
  58   "DEBUG (-bDq, -bD16): checkSparkQ; check consistency of the spark queues.\n",
  59   "DEBUG (-bDf, -bD32): thunkStealing; print forwarding of fetches.\n",
  60   "DEBUG (-bDr, -bD64): randomSteal; stealing sparks/threads from random PEs.\n",
  61   "DEBUG (-bDF, -bD128): findWork; searching spark-pools (local & remote), thread queues for work.\n",
  62   "DEBUG (-bDu, -bD256): unused; currently unused flag.\n",
  63   "DEBUG (-bDS, -bD512): pri; priority sparking or scheduling.\n",
  64   "DEBUG (-bD:, -bD1024): checkLight; check GranSim-Light setup.\n",
  65   "DEBUG (-bDo, -bD2048): sortedQ; check whether spark/thread queues are sorted.\n",
  66   "DEBUG (-bDz, -bD4096): blockOnFetch; check for blocked on fetch.\n",
  67   "DEBUG (-bDP, -bD8192): packBuffer; routines handling pack buffer (GranSim internal!).\n",
  68   "DEBUG (-bDt, -bD16384): blockOnFetch_sanity; check for TSO asleep on fetch.\n",
  69 };
  70
  71 /* one character codes for the available debug options */
  72 static char gran_debug_opts_flags[] = {
  73   'e', 'E', 'b', 'G', 'q', 'f', 'r', 'F', 'u', 'S', ':', 'o', 'z', 'P', 't'
  74 };
  75
  76 #elif defined(PAR)
  77
  78 static char *par_debug_opts_strs[] = {
  79   "DEBUG (-qDv, -qD1): verbose; be generally verbose with parallel related stuff.\n",
  80   "DEBUG (-qDq, -qD2): bq; print blocking queues.\n",
  81   "DEBUG (-qDs, -qD4): schedule; scheduling of parallel threads.\n",
  82   "DEBUG (-qDe, -qD8): free; free messages.\n",
  83   "DEBUG (-qDr, -qD16): resume; resume messages.\n",
  84   "DEBUG (-qDw, -qD32): weight; print weights and distrib GC stuff.\n",
  85   "DEBUG (-qDF, -qD64): fetch; fetch messages.\n",
  86   // "DEBUG (-qDa, -qD128): ack; ack messages.\n",
  87   "DEBUG (-qDf, -qD128): fish; fish messages.\n",
  88   //"DEBUG (-qDo, -qD512): forward; forwarding messages to other PEs.\n",
  89   "DEBUG (-qDl, -qD256): tables; print internal LAGA etc tables.\n",
  90   "DEBUG (-qDo, -qD512): packet; packets and graph structures when packing.\n",
  91   "DEBUG (-qDp, -qD1024): pack; packing and unpacking graphs.\n",
  92   "DEBUG (-qDz, -qD2048): paranoia; ridiculously detailed output (excellent for filling a partition).\n"
  93 };
  94
  95 /* one character codes for the available debug options */
  96 static char par_debug_opts_flags[] = {
  97   'v', 'q', 's', 'e', 'r', 'w', 'F', 'f', 'l', 'o', 'p', 'z'
  98 };
  99
 100 #endif /* PAR */
 101
 102 /* -----------------------------------------------------------------------------
 103    Static function decls
 104    -------------------------------------------------------------------------- */
 105
 106 static int              /* return NULL on error */
 107 open_stats_file (
 108     I_ arg,
 109     int argc, char *argv[],
 110     int rts_argc, char *rts_argv[],
 111     const char *FILENAME_FMT,
 112     FILE **file_ret);
 113
 114 static I_ decode(const char *s);
 115 static void bad_option(const char *s);
 116
 117 #if defined(GRAN)
 118 static void enable_GranSimLight(void);
 119 static void process_gran_option(int arg, int *rts_argc, char *rts_argv[], rtsBool *error);
 120 static void set_GranSim_debug_options(nat n);
 121 static void help_GranSim_debug_options(nat n);
 122 #elif defined(PAR)
 123 static void process_par_option(int arg, int *rts_argc, char *rts_argv[], rtsBool *error);
 124 static void set_par_debug_options(nat n);
 125 static void help_par_debug_options(nat n);
 126 #endif
 127
 128 /* -----------------------------------------------------------------------------
 129  * Command-line option parsing routines.
 130  * ---------------------------------------------------------------------------*/
 131
 132 void initRtsFlagsDefaults(void)
 133 {
 134     RtsFlags.GcFlags.statsFile          = NULL;
 135     RtsFlags.GcFlags.giveStats          = NO_GC_STATS;
 136
 137     RtsFlags.GcFlags.maxStkSize         = (8 * 1024 * 1024) / sizeof(W_);
 138     RtsFlags.GcFlags.initialStkSize     = 1024 / sizeof(W_);
 139
 140     RtsFlags.GcFlags.minAllocAreaSize   = (512 * 1024)        / BLOCK_SIZE;
 141     RtsFlags.GcFlags.minOldGenSize      = (1024 * 1024)       / BLOCK_SIZE;
 142     RtsFlags.GcFlags.maxHeapSize        = 0;    /* off by default */
 143     RtsFlags.GcFlags.heapSizeSuggestion = 0;    /* none */
 144     RtsFlags.GcFlags.pcFreeHeap         = 3;    /* 3% */
 145     RtsFlags.GcFlags.oldGenFactor       = 2;
 146 #if defined(PAR)
 147     /* A hack currently needed for GUM -- HWL */
 148     RtsFlags.GcFlags.generations        = 1;
 149     RtsFlags.GcFlags.steps              = 2;
 150     RtsFlags.GcFlags.squeezeUpdFrames   = rtsFalse;
 151 #else
 152     RtsFlags.GcFlags.generations        = 2;
 153     RtsFlags.GcFlags.steps              = 2;
 154     RtsFlags.GcFlags.squeezeUpdFrames   = rtsTrue;
 155 #endif
 156     RtsFlags.GcFlags.compact            = rtsFalse;
 157     RtsFlags.GcFlags.compactThreshold   = 30.0;
 158     RtsFlags.GcFlags.sweep              = rtsFalse;
 159 #ifdef RTS_GTK_FRONTPANEL
 160     RtsFlags.GcFlags.frontpanel         = rtsFalse;
 161 #endif
 162     RtsFlags.GcFlags.idleGCDelayTime    = 300; /* millisecs */
 163
 164 #if osf3_HOST_OS
 165 /* ToDo: Perhaps by adjusting this value we can make linking without
 166  * -static work (i.e., not generate a core-dumping executable)? */
 167 # if SIZEOF_VOID_P == 8
 168     RtsFlags.GcFlags.heapBase           = 0x180000000L;
 169 # else
 170 #  error I have no idea where to begin the heap on a non-64-bit osf3 machine.
 171 # endif
 172 #else
 173     RtsFlags.GcFlags.heapBase           = 0;   /* means don't care */
 174 #endif
 175
 176 #ifdef DEBUG
 177     RtsFlags.DebugFlags.scheduler       = rtsFalse;
 178     RtsFlags.DebugFlags.interpreter     = rtsFalse;
 179     RtsFlags.DebugFlags.weak            = rtsFalse;
 180     RtsFlags.DebugFlags.gccafs          = rtsFalse;
 181     RtsFlags.DebugFlags.gc              = rtsFalse;
 182     RtsFlags.DebugFlags.block_alloc     = rtsFalse;
 183     RtsFlags.DebugFlags.sanity          = rtsFalse;
 184     RtsFlags.DebugFlags.stable          = rtsFalse;
 185     RtsFlags.DebugFlags.stm             = rtsFalse;
 186     RtsFlags.DebugFlags.prof            = rtsFalse;
 187     RtsFlags.DebugFlags.gran            = rtsFalse;
 188     RtsFlags.DebugFlags.par             = rtsFalse;
 189     RtsFlags.DebugFlags.apply           = rtsFalse;
 190     RtsFlags.DebugFlags.linker          = rtsFalse;
 191     RtsFlags.DebugFlags.squeeze         = rtsFalse;
 192     RtsFlags.DebugFlags.hpc             = rtsFalse;
 193 #endif
 194
 195 #if defined(PROFILING) || defined(PAR)
 196     RtsFlags.CcFlags.doCostCentres      = 0;
 197 #endif /* PROFILING or PAR */
 198
 199     RtsFlags.ProfFlags.doHeapProfile      = rtsFalse;
 200     RtsFlags.ProfFlags.profileInterval    = 100;
 201
 202 #ifdef PROFILING
 203     RtsFlags.ProfFlags.includeTSOs        = rtsFalse;
 204     RtsFlags.ProfFlags.showCCSOnException = rtsFalse;
 205     RtsFlags.ProfFlags.maxRetainerSetSize = 8;
 206     RtsFlags.ProfFlags.ccsLength          = 25;
 207     RtsFlags.ProfFlags.modSelector        = NULL;
 208     RtsFlags.ProfFlags.descrSelector      = NULL;
 209     RtsFlags.ProfFlags.typeSelector       = NULL;
 210     RtsFlags.ProfFlags.ccSelector         = NULL;
 211     RtsFlags.ProfFlags.ccsSelector        = NULL;
 212     RtsFlags.ProfFlags.retainerSelector   = NULL;
 213     RtsFlags.ProfFlags.bioSelector        = NULL;
 214 #endif
 215
 216     RtsFlags.MiscFlags.tickInterval     = 20;  /* In milliseconds */
 217     RtsFlags.ConcFlags.ctxtSwitchTime   = 20;  /* In milliseconds */
 218
 219     RtsFlags.MiscFlags.install_signal_handlers = rtsTrue;
 220     RtsFlags.MiscFlags.machineReadable = rtsFalse;
 221     RtsFlags.MiscFlags.linkerMemBase    = 0;
 222
 223 #ifdef THREADED_RTS
 224     RtsFlags.ParFlags.nNodes            = 1;
 225     RtsFlags.ParFlags.migrate           = rtsTrue;
 226     RtsFlags.ParFlags.wakeupMigrate     = rtsFalse;
 227     RtsFlags.ParFlags.parGcEnabled      = 1;
 228     RtsFlags.ParFlags.parGcGen          = 1;
 229 #endif
 230
 231 #ifdef PAR
 232     RtsFlags.ParFlags.ParStats.Full       = rtsFalse;
 233     RtsFlags.ParFlags.ParStats.Suppressed = rtsFalse;
 234     RtsFlags.ParFlags.ParStats.Binary     = rtsFalse;
 235     RtsFlags.ParFlags.ParStats.Sparks     = rtsFalse;
 236     RtsFlags.ParFlags.ParStats.Heap       = rtsFalse;
 237     RtsFlags.ParFlags.ParStats.NewLogfile = rtsFalse;
 238     RtsFlags.ParFlags.ParStats.Global     = rtsFalse;
 239
 240     RtsFlags.ParFlags.outputDisabled    = rtsFalse;
 241 #ifdef DIST
 242     RtsFlags.ParFlags.doFairScheduling  = rtsTrue;  /* fair sched by def */
 243 #else
 244     RtsFlags.ParFlags.doFairScheduling  = rtsFalse;  /* unfair sched by def */
 245 #endif
 246     RtsFlags.ParFlags.packBufferSize    = 1024;
 247     RtsFlags.ParFlags.thunksToPack      = 1; /* 0 ... infinity; */
 248     RtsFlags.ParFlags.globalising       = 1; /* 0 ... everything */
 249     RtsFlags.ParFlags.maxThreads        = 1024;
 250     RtsFlags.ParFlags.maxFishes        = MAX_FISHES;
 251     RtsFlags.ParFlags.fishDelay         = FISH_DELAY;
 252 #endif
 253
 254 #if defined(PAR) || defined(THREADED_RTS)
 255     RtsFlags.ParFlags.maxLocalSparks    = 4096;
 256 #endif /* PAR || THREADED_RTS */
 257
 258 #if defined(GRAN)
 259     /* ToDo: check defaults for GranSim and GUM */
 260     RtsFlags.GcFlags.maxStkSize         = (8 * 1024 * 1024) / sizeof(W_);
 261     RtsFlags.GcFlags.initialStkSize     = 1024 / sizeof(W_);
 262
 263     RtsFlags.GranFlags.maxThreads       = 65536; // refers to mandatory threads
 264     RtsFlags.GranFlags.GranSimStats.Full        = rtsFalse;
 265     RtsFlags.GranFlags.GranSimStats.Suppressed  = rtsFalse;
 266     RtsFlags.GranFlags.GranSimStats.Binary      = rtsFalse;
 267     RtsFlags.GranFlags.GranSimStats.Sparks      = rtsFalse;
 268     RtsFlags.GranFlags.GranSimStats.Heap        = rtsFalse;
 269     RtsFlags.GranFlags.GranSimStats.NewLogfile  = rtsFalse;
 270     RtsFlags.GranFlags.GranSimStats.Global      = rtsFalse;
 271
 272     RtsFlags.GranFlags.packBufferSize   = 1024;
 273     RtsFlags.GranFlags.packBufferSize_internal = GRANSIM_DEFAULT_PACK_BUFFER_SIZE;
 274
 275     RtsFlags.GranFlags.proc         = MAX_PROC;
 276     RtsFlags.GranFlags.Fishing      = rtsFalse;
 277     RtsFlags.GranFlags.maxFishes   = MAX_FISHES;
 278     RtsFlags.GranFlags.time_slice   = GRAN_TIME_SLICE;
 279     RtsFlags.GranFlags.Light        = rtsFalse;
 280
 281     RtsFlags.GranFlags.Costs.latency =             LATENCY;
 282     RtsFlags.GranFlags.Costs.additional_latency =  ADDITIONAL_LATENCY;
 283     RtsFlags.GranFlags.Costs.fetchtime =           FETCHTIME;
 284     RtsFlags.GranFlags.Costs.lunblocktime =        LOCALUNBLOCKTIME;
 285     RtsFlags.GranFlags.Costs.gunblocktime =        GLOBALUNBLOCKTIME;
 286     RtsFlags.GranFlags.Costs.mpacktime =           MSGPACKTIME;
 287     RtsFlags.GranFlags.Costs.munpacktime =         MSGUNPACKTIME;
 288     RtsFlags.GranFlags.Costs.mtidytime =           MSGTIDYTIME;
 289
 290     RtsFlags.GranFlags.Costs.threadcreatetime =         THREADCREATETIME;
 291     RtsFlags.GranFlags.Costs.threadqueuetime =          THREADQUEUETIME;
 292     RtsFlags.GranFlags.Costs.threaddescheduletime =     THREADDESCHEDULETIME;
 293     RtsFlags.GranFlags.Costs.threadscheduletime =       THREADSCHEDULETIME;
 294     RtsFlags.GranFlags.Costs.threadcontextswitchtime =  THREADCONTEXTSWITCHTIME;
 295
 296     RtsFlags.GranFlags.Costs.arith_cost =         ARITH_COST;
 297     RtsFlags.GranFlags.Costs.branch_cost =        BRANCH_COST;
 298     RtsFlags.GranFlags.Costs.load_cost =          LOAD_COST;
 299     RtsFlags.GranFlags.Costs.store_cost =         STORE_COST;
 300     RtsFlags.GranFlags.Costs.float_cost =         FLOAT_COST;
 301
 302     RtsFlags.GranFlags.Costs.heapalloc_cost =     HEAPALLOC_COST;
 303
 304     RtsFlags.GranFlags.Costs.pri_spark_overhead = PRI_SPARK_OVERHEAD;
 305     RtsFlags.GranFlags.Costs.pri_sched_overhead = PRI_SCHED_OVERHEAD;
 306
 307     RtsFlags.GranFlags.DoFairSchedule           = rtsFalse;
 308     RtsFlags.GranFlags.DoAsyncFetch             = rtsFalse;
 309     RtsFlags.GranFlags.DoStealThreadsFirst      = rtsFalse;
 310     RtsFlags.GranFlags.DoAlwaysCreateThreads    = rtsFalse;
 311     RtsFlags.GranFlags.DoBulkFetching           = rtsFalse;
 312     RtsFlags.GranFlags.DoThreadMigration        = rtsFalse;
 313     RtsFlags.GranFlags.FetchStrategy            = 2;
 314     RtsFlags.GranFlags.PreferSparksOfLocalNodes = rtsFalse;
 315     RtsFlags.GranFlags.DoPrioritySparking       = rtsFalse;
 316     RtsFlags.GranFlags.DoPriorityScheduling     = rtsFalse;
 317     RtsFlags.GranFlags.SparkPriority            = 0;
 318     RtsFlags.GranFlags.SparkPriority2           = 0;
 319     RtsFlags.GranFlags.RandomPriorities         = rtsFalse;
 320     RtsFlags.GranFlags.InversePriorities        = rtsFalse;
 321     RtsFlags.GranFlags.IgnorePriorities         = rtsFalse;
 322     RtsFlags.GranFlags.ThunksToPack             = 0;
 323     RtsFlags.GranFlags.RandomSteal              = rtsTrue;
 324 #endif
 325
 326 #ifdef TICKY_TICKY
 327     RtsFlags.TickyFlags.showTickyStats   = rtsFalse;
 328     RtsFlags.TickyFlags.tickyFile        = NULL;
 329 #endif
 330
 331     RtsFlags.TraceFlags.timestamp       = rtsFalse;
 332     RtsFlags.TraceFlags.sched           = rtsFalse;
 333     RtsFlags.TraceFlags.gc              = rtsFalse;
 334
 335 #ifdef USE_PAPI
 336     /* By default no special measurements taken */
 337     RtsFlags.PapiFlags.eventType        = 0;
 338     RtsFlags.PapiFlags.numUserEvents    = 0;
 339 #endif
 340 }
 341
 342 static const char *
 343 usage_text[] = {
 344 "",
 345 "Usage: <prog> <args> [+RTS <rtsopts> | -RTS <args>] ... --RTS <args>",
 346 "",
 347 "   +RTS    Indicates run time system options follow",
 348 "   -RTS    Indicates program arguments follow",
 349 "  --RTS    Indicates that ALL subsequent arguments will be given to the",
 350 "           program (including any of these RTS flags)",
 351 "",
 352 "The following run time system options are available:",
 353 "",
 354 "  -?       Prints this message and exits; the program is not executed",
 355 "  --info   Print information about the RTS used by this program",
 356 "",
 357 "  -K<size> Sets the maximum stack size (default 8M)  Egs: -K32k   -K512k",
 358 "  -k<size> Sets the initial thread stack size (default 1k)  Egs: -k4k   -k2m",
 359 "",
 360 "  -A<size> Sets the minimum allocation area size (default 256k) Egs: -A1m -A10k",
 361 "  -M<size> Sets the maximum heap size (default unlimited)  Egs: -M256k -M1G",
 362 "  -H<size> Sets the minimum heap size (default 0M)   Egs: -H24m  -H1G",
 363 "  -m<n>    Minimum % of heap which must be available (default 3%)",
 364 "  -G<n>    Number of generations (default: 2)",
 365 "  -T<n>    Number of steps in younger generations (default: 2)",
 366 "  -c<n>    Auto-enable compaction of the oldest generation when live data is",
 367 "           at least <n>% of the maximum heap size set with -M (default: 30%)",
 368 "  -c       Enable compaction for all major collections",
 369 "  -w       Use mark-region for the oldest generation (experimental)",
 370 #if defined(THREADED_RTS)
 371 "  -I<sec>  Perform full GC after <sec> idle time (default: 0.3, 0 == off)",
 372 #endif
 373 "",
 374 "  -t[<file>] One-line GC statistics (if <file> omitted, uses stderr)",
 375 "  -s[<file>] Summary  GC statistics (if <file> omitted, uses stderr)",
 376 "  -S[<file>] Detailed GC statistics (if <file> omitted, uses stderr)",
 377 #ifdef RTS_GTK_FRONTPANEL
 378 "  -f       Display front panel (requires X11 & GTK+)",
 379 #endif
 380 "",
 381 "",
 382 "  -Z       Don't squeeze out update frames on stack overflow",
 383 "  -B       Sound the bell at the start of each garbage collection",
 384 #if defined(PROFILING) || defined(PAR)
 385 "",
 386 "  -px      Time/allocation profile (XML)  (output file <program>.prof)",
 387 "  -p       Time/allocation profile        (output file <program>.prof)",
 388 "  -P       More detailed Time/Allocation profile",
 389 "  -Pa      Give information about *all* cost centres",
 390
 391 # if defined(PROFILING)
 392 "",
 393 "  -hx            Heap residency profile (XML)   (output file <program>.prof)",
 394 "  -h<break-down> Heap residency profile (hp2ps) (output file <program>.hp)",
 395 "     break-down: c = cost centre stack (default)",
 396 "                 m = module",
 397 "                 d = closure description",
 398 "                 y = type description",
 399 "                 r = retainer",
 400 "                 b = biography (LAG,DRAG,VOID,USE)",
 401 "  A subset of closures may be selected thusly:",
 402 "    -hc<cc>,...  specific cost centre(s) (top of stack only)",
 403 "    -hC<cc>,...  specific cost centre(s) (anywhere in stack)",
 404 "    -hm<mod>...  all cost centres from the specified modules(s)",
 405 "    -hd<des>,... closures with specified closure descriptions",
 406 "    -hy<typ>...  closures with specified type descriptions",
 407 "    -hr<cc>...   closures with specified retainers",
 408 "    -hb<bio>...  closures with specified biographies (lag,drag,void,use)",
 409 "",
 410 "  -R<size>       Set the maximum retainer set size (default: 8)",
 411 "",
 412 "  -L<chars>      Maximum length of a cost-centre stack in a heap profile",
 413 "                 (default: 25)",
 414 "",
 415 "  -xt            Include threads (TSOs) in a heap profile",
 416 "",
 417 "  -xc      Show current cost centre stack on raising an exception",
 418 "",
 419 # endif
 420 #endif /* PROFILING or PAR */
 421 #if !defined(PROFILING)
 422 "",
 423 "  -hT      Heap residency profile (output file <program>.hp)",
 424 #endif
 425 "  -i<sec>  Time between heap samples (seconds, default: 0.1)",
 426 "",
 427 #if defined(TICKY_TICKY)
 428 "  -r<file>  Produce ticky-ticky statistics (with -rstderr for stderr)",
 429 "",
 430 #endif
 431 #if defined(PAR)
 432 "  -N<n>     Use <n> PVMish processors in parallel (default: 2)",
 433 /* NB: the -N<n> is implemented by the driver!! */
 434 #endif
 435 "  -C<secs>  Context-switch interval in seconds.",
 436 "            0 or no argument means switch as often as possible.",
 437 "            Default: 0.02 sec; resolution is set by -V below.",
 438 "  -V<secs>  Master tick interval in seconds (0 == disable timer).",
 439 "            This sets the resolution for -C and the profile timer -i.",
 440 "            Default: 0.02 sec.",
 441 "",
 442 "  -vs       Trace scheduler events (see also -Ds with -debug)",
 443 "  -vt       Time-stamp trace messages",
 444 "",
 445 #if defined(DEBUG)
 446 "  -Ds  DEBUG: scheduler",
 447 "  -Di  DEBUG: interpreter",
 448 "  -Dw  DEBUG: weak",
 449 "  -DG  DEBUG: gccafs",
 450 "  -Dg  DEBUG: gc",
 451 "  -Db  DEBUG: block",
 452 "  -DS  DEBUG: sanity",
 453 "  -Dt  DEBUG: stable",
 454 "  -Dp  DEBUG: prof",
 455 "  -Dr  DEBUG: gran",
 456 "  -DP  DEBUG: par",
 457 "  -Da  DEBUG: apply",
 458 "  -Dl  DEBUG: linker",
 459 "  -Dm  DEBUG: stm",
 460 "  -Dz  DEBUG: stack squezing",
 461 "  -Dc  DEBUG: program coverage",
 462 "",
 463 #endif /* DEBUG */
 464 #if defined(THREADED_RTS) && !defined(NOSMP)
 465 "  -N<n>     Use <n> processors (default: 1)",
 466 "  -N        Determine the number of processors to use automatically",
 467 "  -q1       Use one OS thread for GC (turns off parallel GC)",
 468 "  -qg<n>    Use parallel GC only for generations >= <n> (default: 1)",
 469 "  -qm       Don't automatically migrate threads between CPUs",
 470 "  -qw       Migrate a thread to the current CPU when it is woken up",
 471 #endif
 472 "  --install-signal-handlers=<yes|no>",
 473 "            Install signal handlers (default: yes)",
 474 #if defined(THREADED_RTS) || defined(PAR)
 475 "  -e<size>  Size of spark pools (default 100)",
 476 #endif
 477 #if defined(PAR)
 478 "  -t<num>   Set maximum number of advisory threads per PE (default 32)",
 479 "  -qP       Enable activity profile (output files in ~/<program>*.gr)",
 480 "  -qQ<size> Set pack-buffer size (default: 1024)",
 481 "  -qd       Turn on PVM-ish debugging",
 482 "  -qO       Disable output for performance measurement",
 483 #endif
 484 #if defined(THREADED_RTS) || defined(PAR)
 485 "  -e<n>     Maximum number of outstanding local sparks (default: 4096)",
 486 #endif
 487 #if defined(PAR)
 488 "  -d        Turn on PVM-ish debugging",
 489 "  -O        Disable output for performance measurement",
 490 #endif /* PAR */
 491 #if defined(GRAN)  /* ToDo: fill in decent Docu here */
 492 "  -b...     All GranSim options start with -b; see GranSim User's Guide for details",
 493 #endif
 494 #if defined(x86_64_HOST_ARCH)
 495 "  -xm       Base address to mmap memory in the GHCi linker",
 496 "            (hex; must be <80000000)",
 497 #endif
 498 #if defined(USE_PAPI)
 499 "  -aX       CPU performance counter measurements using PAPI",
 500 "            (use with the -s<file> option).  X is one of:",
 501 "",
 502 /* "            y - cycles", */
 503 "            1 - level 1 cache misses",
 504 "            2 - level 2 cache misses",
 505 "            b - branch mispredictions",
 506 "            s - stalled cycles",
 507 "            e - cache miss and branch misprediction events",
 508 #endif
 509 "",
 510 "RTS options may also be specified using the GHCRTS environment variable.",
 511 "",
 512 "Other RTS options may be available for programs compiled a different way.",
 513 "The GHC User's Guide has full details.",
 514 "",
 515 0
 516 };
 517
 518 STATIC_INLINE rtsBool
 519 strequal(const char *a, const char * b)
 520 {
 521     return(strcmp(a, b) == 0);
 522 }
 523
 524 static void
 525 splitRtsFlags(char *s, int *rts_argc, char *rts_argv[])
 526 {
 527     char *c1, *c2;
 528
 529     c1 = s;
 530     do {
 531         while (isspace(*c1)) { c1++; };
 532         c2 = c1;
 533         while (!isspace(*c2) && *c2 != '\0') { c2++; };
 534
 535         if (c1 == c2) { break; }
 536
 537         if (*rts_argc < MAX_RTS_ARGS-1) {
 538             s = stgMallocBytes(c2-c1+1, "RtsFlags.c:splitRtsFlags()");
 539             strncpy(s, c1, c2-c1);
 540             s[c2-c1] = '\0';
 541             rts_argv[(*rts_argc)++] = s;
 542         } else {
 543             barf("too many RTS arguments (max %d)", MAX_RTS_ARGS-1);
 544         }
 545
 546         c1 = c2;
 547     } while (*c1 != '\0');
 548 }
 549
 550 void
 551 setupRtsFlags(int *argc, char *argv[], int *rts_argc, char *rts_argv[])
 552 {
 553     rtsBool error = rtsFalse;
 554     I_ mode;
 555     I_ arg, total_arg;
 556
 557     setProgName (argv);
 558     total_arg = *argc;
 559     arg = 1;
 560
 561     *argc = 1;
 562     *rts_argc = 0;
 563
 564     // process arguments from the ghc_rts_opts global variable first.
 565     // (arguments from the GHCRTS environment variable and the command
 566     // line override these).
 567     {
 568         if (ghc_rts_opts != NULL) {
 569             splitRtsFlags(ghc_rts_opts, rts_argc, rts_argv);
 570         }
 571     }
 572
 573     // process arguments from the GHCRTS environment variable next
 574     // (arguments from the command line override these).
 575     {
 576         char *ghc_rts = getenv("GHCRTS");
 577
 578         if (ghc_rts != NULL) {
 579             splitRtsFlags(ghc_rts, rts_argc, rts_argv);
 580         }
 581     }
 582
 583     // Split arguments (argv) into PGM (argv) and RTS (rts_argv) parts
 584     //   argv[0] must be PGM argument -- leave in argv
 585
 586     for (mode = PGM; arg < total_arg; arg++) {
 587         // The '--RTS' argument disables all future +RTS ... -RTS processing.
 588         if (strequal("--RTS", argv[arg])) {
 589             arg++;
 590             break;
 591         }
 592         // The '--' argument is passed through to the program, but
 593         // disables all further +RTS ... -RTS processing.
 594         else if (strequal("--", argv[arg])) {
 595             break;
 596         }
 597         else if (strequal("+RTS", argv[arg])) {
 598             mode = RTS;
 599         }
 600         else if (strequal("-RTS", argv[arg])) {
 601             mode = PGM;
 602         }
 603         else if (mode == RTS && *rts_argc < MAX_RTS_ARGS-1) {
 604             rts_argv[(*rts_argc)++] = argv[arg];
 605         }
 606         else if (mode == PGM) {
 607             argv[(*argc)++] = argv[arg];
 608         }
 609         else {
 610           barf("too many RTS arguments (max %d)", MAX_RTS_ARGS-1);
 611         }
 612     }
 613     // process remaining program arguments
 614     for (; arg < total_arg; arg++) {
 615         argv[(*argc)++] = argv[arg];
 616     }
 617     argv[*argc] = (char *) 0;
 618     rts_argv[*rts_argc] = (char *) 0;
 619
 620     // Process RTS (rts_argv) part: mainly to determine statsfile
 621     for (arg = 0; arg < *rts_argc; arg++) {
 622         if (rts_argv[arg][0] != '-') {
 623             fflush(stdout);
 624             errorBelch("unexpected RTS argument: %s", rts_argv[arg]);
 625             error = rtsTrue;
 626
 627         } else {
 628             switch(rts_argv[arg][1]) {
 629
 630               /* process: general args, then PROFILING-only ones,
 631                  then CONCURRENT-only, PARallel-only, GRAN-only,
 632                  TICKY-only (same order as defined in RtsFlags.lh);
 633                  within those groups, mostly in case-insensitive
 634                  alphabetical order.
 635                  Final group is x*, which allows for more options.
 636               */
 637
 638 #ifdef TICKY_TICKY
 639 # define TICKY_BUILD_ONLY(x) x
 640 #else
 641 # define TICKY_BUILD_ONLY(x) \
 642 errorBelch("not built for: ticky-ticky stats"); \
 643 error = rtsTrue;
 644 #endif
 645
 646 #if defined(PROFILING)
 647 # define COST_CENTRE_USING_BUILD_ONLY(x) x
 648 #else
 649 # define COST_CENTRE_USING_BUILD_ONLY(x) \
 650 errorBelch("not built for: -prof or -parallel"); \
 651 error = rtsTrue;
 652 #endif
 653
 654 #ifdef PROFILING
 655 # define PROFILING_BUILD_ONLY(x)   x
 656 #else
 657 # define PROFILING_BUILD_ONLY(x) \
 658 errorBelch("not built for: -prof"); \
 659 error = rtsTrue;
 660 #endif
 661
 662 #ifdef PAR
 663 # define PAR_BUILD_ONLY(x)      x
 664 #else
 665 # define PAR_BUILD_ONLY(x) \
 666 errorBelch("not built for: -parallel"); \
 667 error = rtsTrue;
 668 #endif
 669
 670 #ifdef THREADED_RTS
 671 # define THREADED_BUILD_ONLY(x)      x
 672 #else
 673 # define THREADED_BUILD_ONLY(x) \
 674 errorBelch("not built for: -smp"); \
 675 error = rtsTrue;
 676 #endif
 677
 678 #if defined(THREADED_RTS) || defined(PAR)
 679 # define PAR_OR_THREADED_BUILD_ONLY(x)      x
 680 #else
 681 # define PAR_OR_THREADED_BUILD_ONLY(x) \
 682 errorBelch("not built for: -parallel or -smp"); \
 683 error = rtsTrue;
 684 #endif
 685
 686 #ifdef GRAN
 687 # define GRAN_BUILD_ONLY(x)     x
 688 #else
 689 # define GRAN_BUILD_ONLY(x) \
 690 errorBelch("not built for: -gransim"); \
 691 error = rtsTrue;
 692 #endif
 693
 694               /* =========== GENERAL ========================== */
 695               case '?':
 696                 error = rtsTrue;
 697                 break;
 698
 699               /* This isn't going to allow us to keep related options
 700                  together as we add more --* flags. We really need a
 701                  proper options parser. */
 702               case '-':
 703                   if (strequal("install-signal-handlers=yes",
 704                                &rts_argv[arg][2])) {
 705                       RtsFlags.MiscFlags.install_signal_handlers = rtsTrue;
 706                   }
 707                   else if (strequal("install-signal-handlers=no",
 708                                &rts_argv[arg][2])) {
 709                       RtsFlags.MiscFlags.install_signal_handlers = rtsFalse;
 710                   }
 711                   else if (strequal("machine-readable",
 712                                &rts_argv[arg][2])) {
 713                       RtsFlags.MiscFlags.machineReadable = rtsTrue;
 714                   }
 715                   else if (strequal("info",
 716                                &rts_argv[arg][2])) {
 717                       printRtsInfo();
 718                       exit(0);
 719                   }
 720                   else {
 721                       errorBelch("unknown RTS option: %s",rts_argv[arg]);
 722                       error = rtsTrue;
 723                   }
 724                   break;
 725               case 'A':
 726                 RtsFlags.GcFlags.minAllocAreaSize
 727                   = decode(rts_argv[arg]+2) / BLOCK_SIZE;
 728                 if (RtsFlags.GcFlags.minAllocAreaSize <= 0) {
 729                   bad_option(rts_argv[arg]);
 730                 }
 731                 break;
 732
 733 #ifdef USE_PAPI
 734               case 'a':
 735                 switch(rts_argv[arg][2]) {
 736                 case '1':
 737                   RtsFlags.PapiFlags.eventType = PAPI_FLAG_CACHE_L1;
 738                   break;
 739                 case '2':
 740                   RtsFlags.PapiFlags.eventType = PAPI_FLAG_CACHE_L2;
 741                   break;
 742                 case 'b':
 743                   RtsFlags.PapiFlags.eventType = PAPI_FLAG_BRANCH;
 744                   break;
 745                 case 's':
 746                   RtsFlags.PapiFlags.eventType = PAPI_FLAG_STALLS;
 747                   break;
 748                 case 'e':
 749                   RtsFlags.PapiFlags.eventType = PAPI_FLAG_CB_EVENTS;
 750                   break;
 751                 case '+':
 752                   if (RtsFlags.PapiFlags.numUserEvents >= MAX_PAPI_USER_EVENTS) {
 753                       errorBelch("maximum number of PAPI events reached");
 754                       stg_exit(EXIT_FAILURE);
 755                   }
 756                   RtsFlags.PapiFlags.eventType = PAPI_USER_EVENTS;
 757                   RtsFlags.PapiFlags.userEvents[RtsFlags.PapiFlags.numUserEvents++] = rts_argv[arg] + 3;
 758                   break;
 759                 default:
 760                   bad_option( rts_argv[arg] );
 761                 }
 762                 break;
 763 #endif
 764
 765               case 'B':
 766                 RtsFlags.GcFlags.ringBell = rtsTrue;
 767                 break;
 768
 769               case 'c':
 770                   if (rts_argv[arg][2] != '\0') {
 771                       RtsFlags.GcFlags.compactThreshold =
 772                           atof(rts_argv[arg]+2);
 773                   } else {
 774                       RtsFlags.GcFlags.compact = rtsTrue;
 775                   }
 776                   break;
 777
 778               case 'w':
 779                 RtsFlags.GcFlags.sweep = rtsTrue;
 780                 break;
 781
 782               case 'F':
 783                 RtsFlags.GcFlags.oldGenFactor = atof(rts_argv[arg]+2);
 784
 785                 if (RtsFlags.GcFlags.oldGenFactor < 0)
 786                   bad_option( rts_argv[arg] );
 787                 break;
 788
 789 #ifdef DEBUG
 790               case 'D':
 791               {
 792                   char *c;
 793
 794                   for (c  = rts_argv[arg] + 2; *c != '\0'; c++) {
 795                       switch (*c) {
 796                       case 's':
 797                           RtsFlags.DebugFlags.scheduler = rtsTrue;
 798                           break;
 799                       case 'i':
 800                           RtsFlags.DebugFlags.interpreter = rtsTrue;
 801                           break;
 802                       case 'w':
 803                           RtsFlags.DebugFlags.weak = rtsTrue;
 804                           break;
 805                       case 'G':
 806                           RtsFlags.DebugFlags.gccafs = rtsTrue;
 807                           break;
 808                       case 'g':
 809                           RtsFlags.DebugFlags.gc = rtsTrue;
 810                           break;
 811                       case 'b':
 812                           RtsFlags.DebugFlags.block_alloc = rtsTrue;
 813                           break;
 814                       case 'S':
 815                           RtsFlags.DebugFlags.sanity = rtsTrue;
 816                           break;
 817                       case 't':
 818                           RtsFlags.DebugFlags.stable = rtsTrue;
 819                           break;
 820                       case 'p':
 821                           RtsFlags.DebugFlags.prof = rtsTrue;
 822                           break;
 823                       case 'r':
 824                           RtsFlags.DebugFlags.gran = rtsTrue;
 825                           break;
 826                       case 'P':
 827                           RtsFlags.DebugFlags.par = rtsTrue;
 828                           break;
 829                       case 'l':
 830                           RtsFlags.DebugFlags.linker = rtsTrue;
 831                           break;
 832                       case 'a':
 833                           RtsFlags.DebugFlags.apply = rtsTrue;
 834                           break;
 835                       case 'm':
 836                           RtsFlags.DebugFlags.stm = rtsTrue;
 837                           break;
 838                       case 'z':
 839                           RtsFlags.DebugFlags.squeeze = rtsTrue;
 840                           break;
 841                       case 'c':
 842                           RtsFlags.DebugFlags.hpc = rtsTrue;
 843                           break;
 844                       default:
 845                           bad_option( rts_argv[arg] );
 846                       }
 847                   }
 848                   break;
 849               }
 850 #endif
 851
 852               case 'K':
 853                 RtsFlags.GcFlags.maxStkSize =
 854                   decode(rts_argv[arg]+2) / sizeof(W_);
 855
 856                 if (RtsFlags.GcFlags.maxStkSize == 0)
 857                   bad_option( rts_argv[arg] );
 858                 break;
 859
 860               case 'k':
 861                 RtsFlags.GcFlags.initialStkSize =
 862                   decode(rts_argv[arg]+2) / sizeof(W_);
 863
 864                 if (RtsFlags.GcFlags.initialStkSize == 0)
 865                   bad_option( rts_argv[arg] );
 866                 break;
 867
 868               case 'M':
 869                 RtsFlags.GcFlags.maxHeapSize =
 870                   decode(rts_argv[arg]+2) / BLOCK_SIZE;
 871                 /* user give size in *bytes* but "maxHeapSize" is in *blocks* */
 872
 873                 if (RtsFlags.GcFlags.maxHeapSize <= 0) {
 874                   bad_option(rts_argv[arg]);
 875                 }
 876                 break;
 877
 878               case 'm':
 879                 RtsFlags.GcFlags.pcFreeHeap = atof(rts_argv[arg]+2);
 880
 881                 if (RtsFlags.GcFlags.pcFreeHeap < 0 ||
 882                     RtsFlags.GcFlags.pcFreeHeap > 100)
 883                   bad_option( rts_argv[arg] );
 884                 break;
 885
 886               case 'G':
 887                 RtsFlags.GcFlags.generations = decode(rts_argv[arg]+2);
 888                 if (RtsFlags.GcFlags.generations < 1) {
 889                   bad_option(rts_argv[arg]);
 890                 }
 891                 break;
 892
 893               case 'T':
 894                 RtsFlags.GcFlags.steps = decode(rts_argv[arg]+2);
 895                 if (RtsFlags.GcFlags.steps < 1) {
 896                   bad_option(rts_argv[arg]);
 897                 }
 898                 break;
 899
 900               case 'H':
 901                 RtsFlags.GcFlags.heapSizeSuggestion =
 902                   decode(rts_argv[arg]+2) / BLOCK_SIZE;
 903                 break;
 904
 905 #ifdef RTS_GTK_FRONTPANEL
 906               case 'f':
 907                   RtsFlags.GcFlags.frontpanel = rtsTrue;
 908                   break;
 909 #endif
 910
 911               case 'I': /* idle GC delay */
 912                 if (rts_argv[arg][2] == '\0') {
 913                   /* use default */
 914                 } else {
 915                     I_ cst; /* tmp */
 916
 917                     /* Convert to millisecs */
 918                     cst = (I_) ((atof(rts_argv[arg]+2) * 1000));
 919                     RtsFlags.GcFlags.idleGCDelayTime = cst;
 920                 }
 921                 break;
 922
 923               case 'S':
 924                   RtsFlags.GcFlags.giveStats = VERBOSE_GC_STATS;
 925                   goto stats;
 926
 927               case 's':
 928                   RtsFlags.GcFlags.giveStats = SUMMARY_GC_STATS;
 929                   goto stats;
 930
 931               case 't':
 932                   RtsFlags.GcFlags.giveStats = ONELINE_GC_STATS;
 933                   goto stats;
 934
 935             stats:
 936 #ifdef PAR
 937                 /* Opening all those files would almost certainly fail... */
 938                 // RtsFlags.ParFlags.ParStats.Full = rtsTrue;
 939                 RtsFlags.GcFlags.statsFile = NULL; /* temporary; ToDo: rm */
 940 #else
 941                 {
 942                     int r;
 943                     r = open_stats_file(arg, *argc, argv,
 944                                         *rts_argc, rts_argv, NULL,
 945                                         &RtsFlags.GcFlags.statsFile);
 946                     if (r == -1) { error = rtsTrue; }
 947                 }
 948 #endif
 949                   break;
 950
 951               case 'Z':
 952                 RtsFlags.GcFlags.squeezeUpdFrames = rtsFalse;
 953                 break;
 954
 955               /* =========== PROFILING ========================== */
 956
 957               case 'P': /* detailed cost centre profiling (time/alloc) */
 958               case 'p': /* cost centre profiling (time/alloc) */
 959                 COST_CENTRE_USING_BUILD_ONLY(
 960                 switch (rts_argv[arg][2]) {
 961                   case 'x':
 962                     RtsFlags.CcFlags.doCostCentres = COST_CENTRES_XML;
 963                     break;
 964                   case 'a':
 965                     RtsFlags.CcFlags.doCostCentres = COST_CENTRES_ALL;
 966                     break;
 967                   default:
 968                       if (rts_argv[arg][1] == 'P') {
 969                           RtsFlags.CcFlags.doCostCentres =
 970                               COST_CENTRES_VERBOSE;
 971                       } else {
 972                           RtsFlags.CcFlags.doCostCentres =
 973                               COST_CENTRES_SUMMARY;
 974                       }
 975                       break;
 976                 }
 977                 ) break;
 978
 979               case 'R':
 980                   PROFILING_BUILD_ONLY(
 981                       RtsFlags.ProfFlags.maxRetainerSetSize = atof(rts_argv[arg]+2);
 982                   ) break;
 983               case 'L':
 984                   PROFILING_BUILD_ONLY(
 985                       RtsFlags.ProfFlags.ccsLength = atof(rts_argv[arg]+2);
 986                       if(RtsFlags.ProfFlags.ccsLength <= 0) {
 987                         bad_option(rts_argv[arg]);
 988                       }
 989                   ) break;
 990               case 'h': /* serial heap profile */
 991 #if !defined(PROFILING)
 992                 switch (rts_argv[arg][2]) {
 993                   case '\0':
 994                   case 'T':
 995                     RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_CLOSURE_TYPE;
 996                     break;
 997                   default:
 998                     errorBelch("invalid heap profile option: %s",rts_argv[arg]);
 999                     error = rtsTrue;
1000                 }
1001 #else
1002                 PROFILING_BUILD_ONLY(
1003                 switch (rts_argv[arg][2]) {
1004                 case '\0':
1005                 case 'C':
1006                 case 'c':
1007                 case 'M':
1008                 case 'm':
1009                 case 'D':
1010                 case 'd':
1011                 case 'Y':
1012                 case 'y':
1013                 case 'R':
1014                 case 'r':
1015                 case 'B':
1016                 case 'b':
1017                     if (rts_argv[arg][2] != '\0' && rts_argv[arg][3] != '\0') {
1018                         {
1019                             char *left  = strchr(rts_argv[arg], '{');
1020                             char *right = strrchr(rts_argv[arg], '}');
1021
1022                             // curly braces are optional, for
1023                             // backwards compat.
1024                             if (left)
1025                                 left = left+1;
1026                             else
1027                                 left = rts_argv[arg] + 3;
1028
1029                             if (!right)
1030                                 right = rts_argv[arg] + strlen(rts_argv[arg]);
1031
1032                             *right = '\0';
1033
1034                             switch (rts_argv[arg][2]) {
1035                             case 'c': // cost centre label select
1036                                 RtsFlags.ProfFlags.ccSelector = left;
1037                                 break;
1038                             case 'C':
1039                                 RtsFlags.ProfFlags.ccsSelector = left;
1040                                 break;
1041                             case 'M':
1042                             case 'm': // cost centre module select
1043                                 RtsFlags.ProfFlags.modSelector = left;
1044                                 break;
1045                             case 'D':
1046                             case 'd': // closure descr select
1047                                 RtsFlags.ProfFlags.descrSelector = left;
1048                                 break;
1049                             case 'Y':
1050                             case 'y': // closure type select
1051                                 RtsFlags.ProfFlags.typeSelector = left;
1052                                 break;
1053                             case 'R':
1054                             case 'r': // retainer select
1055                                 RtsFlags.ProfFlags.retainerSelector = left;
1056                                 break;
1057                             case 'B':
1058                             case 'b': // biography select
1059                                 RtsFlags.ProfFlags.bioSelector = left;
1060                                 break;
1061                             }
1062                         }
1063                         break;
1064                     }
1065
1066                     if (RtsFlags.ProfFlags.doHeapProfile != 0) {
1067                         errorBelch("multiple heap profile options");
1068                         error = rtsTrue;
1069                         break;
1070                     }
1071
1072                     switch (rts_argv[arg][2]) {
1073                     case '\0':
1074                     case 'C':
1075                     case 'c':
1076                         RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_CCS;
1077                         break;
1078                     case 'M':
1079                     case 'm':
1080                           RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_MOD;
1081                           break;
1082                     case 'D':
1083                     case 'd':
1084                           RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_DESCR;
1085                           break;
1086                     case 'Y':
1087                     case 'y':
1088                           RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_TYPE;
1089                           break;
1090                     case 'R':
1091                     case 'r':
1092                           RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_RETAINER;
1093                           break;
1094                     case 'B':
1095                     case 'b':
1096                           RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_LDV;
1097                           break;
1098                     }
1099                     break;
1100
1101                 default:
1102                     errorBelch("invalid heap profile option: %s",rts_argv[arg]);
1103                     error = rtsTrue;
1104                 }
1105                 )
1106 #endif /* PROFILING */
1107                 break;
1108
1109               case 'i': /* heap sample interval */
1110                 if (rts_argv[arg][2] == '\0') {
1111                   /* use default */
1112                 } else {
1113                     I_ cst; /* tmp */
1114
1115                     /* Convert to milliseconds */
1116                     cst = (I_) ((atof(rts_argv[arg]+2) * 1000));
1117                     RtsFlags.ProfFlags.profileInterval = cst;
1118                 }
1119                 break;
1120
1121               /* =========== CONCURRENT ========================= */
1122               case 'C': /* context switch interval */
1123                 if (rts_argv[arg][2] == '\0')
1124                     RtsFlags.ConcFlags.ctxtSwitchTime = 0;
1125                 else {
1126                     I_ cst; /* tmp */
1127
1128                     /* Convert to milliseconds */
1129                     cst = (I_) ((atof(rts_argv[arg]+2) * 1000));
1130                     RtsFlags.ConcFlags.ctxtSwitchTime = cst;
1131                 }
1132                 break;
1133
1134               case 'V': /* master tick interval */
1135                 if (rts_argv[arg][2] == '\0') {
1136                     // turns off ticks completely
1137                     RtsFlags.MiscFlags.tickInterval = 0;
1138                 } else {
1139                     I_ cst; /* tmp */
1140
1141                     /* Convert to milliseconds */
1142                     cst = (I_) ((atof(rts_argv[arg]+2) * 1000));
1143                     RtsFlags.MiscFlags.tickInterval = cst;
1144                 }
1145                 break;
1146
1147 #if defined(THREADED_RTS) && !defined(NOSMP)
1148               case 'N':
1149                 THREADED_BUILD_ONLY(
1150                 if (rts_argv[arg][2] == '\0') {
1151 #if defined(PROFILING)
1152                     RtsFlags.ParFlags.nNodes = 1;
1153 #else
1154 #if defined(mingw32_HOST_OS)
1155                     {
1156                         SYSTEM_INFO si;
1157                         GetSystemInfo(&si);
1158                         RtsFlags.ParFlags.nNodes = si.dwNumberOfProcessors;
1159                     }
1160 #elif defined(HAVE_SYSCONF)
1161                     RtsFlags.ParFlags.nNodes = sysconf(_SC_NPROCESSORS_CONF);
1162 #else
1163                     RtsFlags.ParFlags.nNodes = 1;
1164 #endif
1165 #endif
1166                 } else {
1167                     RtsFlags.ParFlags.nNodes
1168                       = strtol(rts_argv[arg]+2, (char **) NULL, 10);
1169                     if (RtsFlags.ParFlags.nNodes <= 0) {
1170                       errorBelch("bad value for -N");
1171                       error = rtsTrue;
1172                     }
1173 #if defined(PROFILING)
1174                     if (RtsFlags.ParFlags.nNodes > 1) {
1175                         errorBelch("bad option %s: only -N1 is supported with profiling", rts_argv[arg]);
1176                       error = rtsTrue;
1177                     }
1178 #endif
1179                 }
1180                 ) break;
1181
1182               case 'g':
1183                 THREADED_BUILD_ONLY(
1184                     switch (rts_argv[arg][2]) {
1185                     case '1':
1186                         // backwards compat only
1187                         RtsFlags.ParFlags.parGcEnabled = rtsFalse;
1188                         break;
1189                     default:
1190                         errorBelch("unknown RTS option: %s",rts_argv[arg]);
1191                         error = rtsTrue;
1192                         break;
1193                     }
1194                     ) break;
1195
1196               case 'q':
1197                     switch (rts_argv[arg][2]) {
1198                     case '\0':
1199                         errorBelch("incomplete RTS option: %s",rts_argv[arg]);
1200                         error = rtsTrue;
1201                         break;
1202                     case '1':
1203                         RtsFlags.ParFlags.parGcEnabled = rtsFalse;
1204                         break;
1205                     case 'g':
1206                         if (rts_argv[arg][3] != '\0') {
1207                             RtsFlags.ParFlags.parGcGen
1208                                 = strtol(rts_argv[arg]+3, (char **) NULL, 10);
1209                         } else {
1210                             errorBelch("bad value for -qg");
1211                             error = rtsTrue;
1212                         }
1213                         break;
1214                     case 'm':
1215                         RtsFlags.ParFlags.migrate = rtsFalse;
1216                         break;
1217                     case 'w':
1218                         RtsFlags.ParFlags.wakeupMigrate = rtsTrue;
1219                         break;
1220                     default:
1221                         errorBelch("unknown RTS option: %s",rts_argv[arg]);
1222                         error = rtsTrue;
1223                         break;
1224                     }
1225                     break;
1226 #endif
1227               /* =========== PARALLEL =========================== */
1228               case 'e':
1229                 PAR_OR_THREADED_BUILD_ONLY(
1230                 if (rts_argv[arg][2] != '\0') {
1231                     RtsFlags.ParFlags.maxLocalSparks
1232                       = strtol(rts_argv[arg]+2, (char **) NULL, 10);
1233                     if (RtsFlags.ParFlags.maxLocalSparks <= 0) {
1234                       errorBelch("bad value for -e");
1235                       error = rtsTrue;
1236                     }
1237                 }
1238                 ) break;
1239
1240 #ifdef PAR
1241               case 'q':
1242                 PAR_BUILD_ONLY(
1243                   process_par_option(arg, rts_argc, rts_argv, &error);
1244                 ) break;
1245 #endif
1246
1247               /* =========== GRAN =============================== */
1248
1249               case 'b':
1250                 GRAN_BUILD_ONLY(
1251                   process_gran_option(arg, rts_argc, rts_argv, &error);
1252                 ) break;
1253
1254               /* =========== TICKY ============================== */
1255
1256               case 'r': /* Basic profiling stats */
1257                 TICKY_BUILD_ONLY(
1258
1259                 RtsFlags.TickyFlags.showTickyStats = rtsTrue;
1260
1261                 {
1262                     int r;
1263                     r = open_stats_file(arg, *argc, argv,
1264                                         *rts_argc, rts_argv, TICKY_FILENAME_FMT,
1265                                         &RtsFlags.TickyFlags.tickyFile);
1266                     if (r == -1) { error = rtsTrue; }
1267                 }
1268                 ) break;
1269
1270               /* =========== TRACING ---------=================== */
1271
1272               case 'v':
1273                 switch(rts_argv[arg][2]) {
1274                 case '\0':
1275                     errorBelch("incomplete RTS option: %s",rts_argv[arg]);
1276                     error = rtsTrue;
1277                     break;
1278                 case 't':
1279                     RtsFlags.TraceFlags.timestamp = rtsTrue;
1280                     break;
1281                 case 's':
1282                     RtsFlags.TraceFlags.sched = rtsTrue;
1283                     break;
1284                 case 'g':
1285                     RtsFlags.TraceFlags.gc = rtsTrue;
1286                     break;
1287                 default:
1288                     errorBelch("unknown RTS option: %s",rts_argv[arg]);
1289                     error = rtsTrue;
1290                     break;
1291                 }
1292                 break;
1293
1294               /* =========== EXTENDED OPTIONS =================== */
1295
1296               case 'x': /* Extend the argument space */
1297                 switch(rts_argv[arg][2]) {
1298                   case '\0':
1299                     errorBelch("incomplete RTS option: %s",rts_argv[arg]);
1300                     error = rtsTrue;
1301                     break;
1302
1303                 case 'b': /* heapBase in hex; undocumented */
1304                     if (rts_argv[arg][3] != '\0') {
1305                         RtsFlags.GcFlags.heapBase
1306                             = strtol(rts_argv[arg]+3, (char **) NULL, 16);
1307                     } else {
1308                         errorBelch("-xb: requires argument");
1309                         error = rtsTrue;
1310                     }
1311                     break;
1312
1313 #if defined(x86_64_HOST_ARCH)
1314                 case 'm': /* linkerMemBase */
1315                     if (rts_argv[arg][3] != '\0') {
1316                         RtsFlags.MiscFlags.linkerMemBase
1317                             = strtol(rts_argv[arg]+3, (char **) NULL, 16);
1318                         if (RtsFlags.MiscFlags.linkerMemBase > 0x80000000) {
1319                             errorBelch("-xm: value must be <80000000");
1320                             error = rtsTrue;
1321                         }
1322                     } else {
1323                         RtsFlags.MiscFlags.linkerMemBase = 0;
1324                     }
1325                     break;
1326 #endif
1327
1328                 case 'c': /* Debugging tool: show current cost centre on an exception */
1329                     PROFILING_BUILD_ONLY(
1330                         RtsFlags.ProfFlags.showCCSOnException = rtsTrue;
1331                         );
1332                     break;
1333
1334                 case 't':  /* Include memory used by TSOs in a heap profile */
1335                     PROFILING_BUILD_ONLY(
1336                         RtsFlags.ProfFlags.includeTSOs = rtsTrue;
1337                         );
1338                     break;
1339
1340                   /* The option prefix '-xx' is reserved for future extension.  KSW 1999-11. */
1341
1342                   default:
1343                     errorBelch("unknown RTS option: %s",rts_argv[arg]);
1344                     error = rtsTrue;
1345                     break;
1346                 }
1347                 break;  /* defensive programming */
1348
1349               /* =========== OH DEAR ============================ */
1350               default:
1351                 errorBelch("unknown RTS option: %s",rts_argv[arg]);
1352                 error = rtsTrue;
1353                 break;
1354             }
1355         }
1356     }
1357
1358     if (RtsFlags.MiscFlags.tickInterval < 0) {
1359         RtsFlags.MiscFlags.tickInterval = 50;
1360     }
1361
1362     // If the master timer is disabled, turn off the other timers.
1363     if (RtsFlags.MiscFlags.tickInterval == 0) {
1364         RtsFlags.ConcFlags.ctxtSwitchTime  = 0;
1365         RtsFlags.GcFlags.idleGCDelayTime   = 0;
1366         RtsFlags.ProfFlags.profileInterval = 0;
1367     }
1368
1369     // Determine what tick interval we should use for the RTS timer
1370     // by taking the shortest of the various intervals that we need to
1371     // monitor.
1372     if (RtsFlags.ConcFlags.ctxtSwitchTime > 0) {
1373         RtsFlags.MiscFlags.tickInterval =
1374             stg_min(RtsFlags.ConcFlags.ctxtSwitchTime,
1375                     RtsFlags.MiscFlags.tickInterval);
1376     }
1377
1378     if (RtsFlags.GcFlags.idleGCDelayTime > 0) {
1379         RtsFlags.MiscFlags.tickInterval =
1380             stg_min(RtsFlags.GcFlags.idleGCDelayTime,
1381                     RtsFlags.MiscFlags.tickInterval);
1382     }
1383
1384     if (RtsFlags.ProfFlags.profileInterval > 0) {
1385         RtsFlags.MiscFlags.tickInterval =
1386             stg_min(RtsFlags.ProfFlags.profileInterval,
1387                     RtsFlags.MiscFlags.tickInterval);
1388     }
1389
1390     if (RtsFlags.ConcFlags.ctxtSwitchTime > 0) {
1391         RtsFlags.ConcFlags.ctxtSwitchTicks =
1392             RtsFlags.ConcFlags.ctxtSwitchTime /
1393             RtsFlags.MiscFlags.tickInterval;
1394     } else {
1395         RtsFlags.ConcFlags.ctxtSwitchTicks = 0;
1396     }
1397
1398     if (RtsFlags.ProfFlags.profileInterval > 0) {
1399         RtsFlags.ProfFlags.profileIntervalTicks =
1400             RtsFlags.ProfFlags.profileInterval /
1401             RtsFlags.MiscFlags.tickInterval;
1402     } else {
1403         RtsFlags.ProfFlags.profileIntervalTicks = 0;
1404     }
1405
1406     if (error) {
1407         const char **p;
1408
1409         fflush(stdout);
1410         for (p = usage_text; *p; p++)
1411             errorBelch("%s", *p);
1412         stg_exit(EXIT_FAILURE);
1413     }
1414 }
1415
1416 #if defined(GRAN)
1417
1418 static void
1419 enable_GranSimLight(void) {
1420
1421     debugBelch("GrAnSim Light enabled (infinite number of processors;  0 communication costs)\n");
1422     RtsFlags.GranFlags.Light=rtsTrue;
1423     RtsFlags.GranFlags.Costs.latency =
1424         RtsFlags.GranFlags.Costs.fetchtime =
1425         RtsFlags.GranFlags.Costs.additional_latency =
1426         RtsFlags.GranFlags.Costs.gunblocktime =
1427         RtsFlags.GranFlags.Costs.lunblocktime =
1428         RtsFlags.GranFlags.Costs.threadcreatetime =
1429         RtsFlags.GranFlags.Costs.threadqueuetime =
1430         RtsFlags.GranFlags.Costs.threadscheduletime =
1431         RtsFlags.GranFlags.Costs.threaddescheduletime =
1432         RtsFlags.GranFlags.Costs.threadcontextswitchtime = 0;
1433
1434     RtsFlags.GranFlags.Costs.mpacktime =
1435         RtsFlags.GranFlags.Costs.munpacktime = 0;
1436
1437     RtsFlags.GranFlags.DoFairSchedule = rtsTrue;
1438     RtsFlags.GranFlags.DoAsyncFetch = rtsFalse;
1439     RtsFlags.GranFlags.DoAlwaysCreateThreads = rtsTrue;
1440     /* FetchStrategy is irrelevant in GrAnSim-Light */
1441
1442     /* GrAnSim Light often creates an abundance of parallel threads,
1443        each with its own stack etc. Therefore, it's in general a good
1444        idea to use small stack chunks (use the -o<size> option to
1445        increase it again).
1446     */
1447     // RtsFlags.ConcFlags.stkChunkSize = 100;
1448
1449     RtsFlags.GranFlags.proc = 1;
1450 }
1451
1452 static void
1453 process_gran_option(int arg, int *rts_argc, char *rts_argv[], rtsBool *error)
1454 {
1455     if (rts_argv[arg][1] != 'b') /* All GranSim options start with -b */
1456       return;
1457
1458     /* or a ridiculously idealised simulator */
1459     if(strcmp((rts_argv[arg]+2),"oring")==0) {
1460       RtsFlags.GranFlags.Costs.latency =
1461         RtsFlags.GranFlags.Costs.fetchtime =
1462         RtsFlags.GranFlags.Costs.additional_latency =
1463         RtsFlags.GranFlags.Costs.gunblocktime =
1464         RtsFlags.GranFlags.Costs.lunblocktime =
1465         RtsFlags.GranFlags.Costs.threadcreatetime =
1466         RtsFlags.GranFlags.Costs.threadqueuetime =
1467         RtsFlags.GranFlags.Costs.threadscheduletime =
1468         RtsFlags.GranFlags.Costs.threaddescheduletime =
1469         RtsFlags.GranFlags.Costs.threadcontextswitchtime = 0;
1470
1471       RtsFlags.GranFlags.Costs.mpacktime =
1472         RtsFlags.GranFlags.Costs.munpacktime = 0;
1473
1474       RtsFlags.GranFlags.Costs.arith_cost =
1475         RtsFlags.GranFlags.Costs.float_cost =
1476         RtsFlags.GranFlags.Costs.load_cost =
1477         RtsFlags.GranFlags.Costs.store_cost =
1478         RtsFlags.GranFlags.Costs.branch_cost = 0;
1479
1480       RtsFlags.GranFlags.Costs.heapalloc_cost = 1;
1481
1482       /* ++RtsFlags.GranFlags.DoFairSchedule; */
1483       RtsFlags.GranFlags.DoStealThreadsFirst = rtsTrue;        /* -bZ */
1484       RtsFlags.GranFlags.DoThreadMigration   = rtsTrue;        /* -bM */
1485       RtsFlags.GranFlags.GranSimStats.Full   = rtsTrue;        /* -bP */
1486       return;
1487     }
1488
1489       /* or a somewhat idealised simulator */
1490       if(strcmp((rts_argv[arg]+2),"onzo")==0) {
1491         RtsFlags.GranFlags.Costs.latency =
1492         RtsFlags.GranFlags.Costs.fetchtime =
1493         RtsFlags.GranFlags.Costs.additional_latency =
1494         RtsFlags.GranFlags.Costs.gunblocktime =
1495         RtsFlags.GranFlags.Costs.lunblocktime =
1496         RtsFlags.GranFlags.Costs.threadcreatetime =
1497         RtsFlags.GranFlags.Costs.threadqueuetime =
1498         RtsFlags.GranFlags.Costs.threadscheduletime =
1499         RtsFlags.GranFlags.Costs.threaddescheduletime =
1500         RtsFlags.GranFlags.Costs.threadcontextswitchtime = 0;
1501
1502         RtsFlags.GranFlags.Costs.mpacktime =
1503         RtsFlags.GranFlags.Costs.munpacktime = 0;
1504
1505         RtsFlags.GranFlags.Costs.heapalloc_cost = 1;
1506
1507         /* RtsFlags.GranFlags.DoFairSchedule  = rtsTrue; */       /* -b-R */
1508         /* RtsFlags.GranFlags.DoStealThreadsFirst = rtsTrue; */   /* -b-T */
1509         RtsFlags.GranFlags.DoAsyncFetch = rtsTrue;         /* -bZ */
1510         RtsFlags.GranFlags.DoThreadMigration  = rtsTrue;          /* -bM */
1511         RtsFlags.GranFlags.GranSimStats.Full  = rtsTrue;          /* -bP */
1512 #  if defined(GRAN_CHECK) && defined(GRAN)
1513         RtsFlags.GranFlags.Debug.event_stats = rtsTrue; /* print event statistics   */
1514 #  endif
1515         return;
1516       }
1517
1518       /* Communication and task creation cost parameters */
1519       switch(rts_argv[arg][2]) {
1520         case '.':
1521           IgnoreYields = rtsTrue; // HWL HACK
1522           break;
1523
1524         case ':':
1525           enable_GranSimLight();       /* set flags for GrAnSim-Light mode */
1526           break;
1527
1528         case 'l':
1529           if (rts_argv[arg][3] != '\0')
1530             {
1531               RtsFlags.GranFlags.Costs.gunblocktime =
1532               RtsFlags.GranFlags.Costs.latency = decode(rts_argv[arg]+3);
1533               RtsFlags.GranFlags.Costs.fetchtime = 2*RtsFlags.GranFlags.Costs.latency;
1534             }
1535           else
1536             RtsFlags.GranFlags.Costs.latency = LATENCY;
1537           break;
1538
1539         case 'a':
1540           if (rts_argv[arg][3] != '\0')
1541             RtsFlags.GranFlags.Costs.additional_latency = decode(rts_argv[arg]+3);
1542           else
1543             RtsFlags.GranFlags.Costs.additional_latency = ADDITIONAL_LATENCY;
1544           break;
1545
1546         case 'm':
1547           if (rts_argv[arg][3] != '\0')
1548             RtsFlags.GranFlags.Costs.mpacktime = decode(rts_argv[arg]+3);
1549           else
1550             RtsFlags.GranFlags.Costs.mpacktime = MSGPACKTIME;
1551           break;
1552
1553         case 'x':
1554           if (rts_argv[arg][3] != '\0')
1555             RtsFlags.GranFlags.Costs.mtidytime = decode(rts_argv[arg]+3);
1556           else
1557             RtsFlags.GranFlags.Costs.mtidytime = 0;
1558           break;
1559
1560         case 'r':
1561           if (rts_argv[arg][3] != '\0')
1562             RtsFlags.GranFlags.Costs.munpacktime = decode(rts_argv[arg]+3);
1563           else
1564             RtsFlags.GranFlags.Costs.munpacktime = MSGUNPACKTIME;
1565           break;
1566
1567         case 'g':
1568           if (rts_argv[arg][3] != '\0')
1569             RtsFlags.GranFlags.Costs.fetchtime = decode(rts_argv[arg]+3);
1570           else
1571             RtsFlags.GranFlags.Costs.fetchtime = FETCHTIME;
1572           break;
1573
1574         case 'n':
1575           if (rts_argv[arg][3] != '\0')
1576             RtsFlags.GranFlags.Costs.gunblocktime = decode(rts_argv[arg]+3);
1577           else
1578             RtsFlags.GranFlags.Costs.gunblocktime = GLOBALUNBLOCKTIME;
1579           break;
1580
1581         case 'u':
1582           if (rts_argv[arg][3] != '\0')
1583             RtsFlags.GranFlags.Costs.lunblocktime = decode(rts_argv[arg]+3);
1584           else
1585             RtsFlags.GranFlags.Costs.lunblocktime = LOCALUNBLOCKTIME;
1586           break;
1587
1588         /* Thread-related metrics */
1589         case 't':
1590           if (rts_argv[arg][3] != '\0')
1591             RtsFlags.GranFlags.Costs.threadcreatetime = decode(rts_argv[arg]+3);
1592           else
1593             RtsFlags.GranFlags.Costs.threadcreatetime = THREADCREATETIME;
1594           break;
1595
1596         case 'q':
1597           if (rts_argv[arg][3] != '\0')
1598             RtsFlags.GranFlags.Costs.threadqueuetime = decode(rts_argv[arg]+3);
1599           else
1600             RtsFlags.GranFlags.Costs.threadqueuetime = THREADQUEUETIME;
1601           break;
1602
1603         case 'c':
1604           if (rts_argv[arg][3] != '\0')
1605             RtsFlags.GranFlags.Costs.threadscheduletime = decode(rts_argv[arg]+3);
1606           else
1607             RtsFlags.GranFlags.Costs.threadscheduletime = THREADSCHEDULETIME;
1608
1609           RtsFlags.GranFlags.Costs.threadcontextswitchtime = RtsFlags.GranFlags.Costs.threadscheduletime
1610             + RtsFlags.GranFlags.Costs.threaddescheduletime;
1611           break;
1612
1613         case 'd':
1614           if (rts_argv[arg][3] != '\0')
1615             RtsFlags.GranFlags.Costs.threaddescheduletime = decode(rts_argv[arg]+3);
1616           else
1617             RtsFlags.GranFlags.Costs.threaddescheduletime = THREADDESCHEDULETIME;
1618
1619           RtsFlags.GranFlags.Costs.threadcontextswitchtime = RtsFlags.GranFlags.Costs.threadscheduletime
1620             + RtsFlags.GranFlags.Costs.threaddescheduletime;
1621           break;
1622
1623         /* Instruction Cost Metrics */
1624         case 'A':
1625           if (rts_argv[arg][3] != '\0')
1626             RtsFlags.GranFlags.Costs.arith_cost = decode(rts_argv[arg]+3);
1627           else
1628             RtsFlags.GranFlags.Costs.arith_cost = ARITH_COST;
1629           break;
1630
1631         case 'F':
1632           if (rts_argv[arg][3] != '\0')
1633             RtsFlags.GranFlags.Costs.float_cost = decode(rts_argv[arg]+3);
1634           else
1635             RtsFlags.GranFlags.Costs.float_cost = FLOAT_COST;
1636           break;
1637
1638         case 'B':
1639           if (rts_argv[arg][3] != '\0')
1640             RtsFlags.GranFlags.Costs.branch_cost = decode(rts_argv[arg]+3);
1641           else
1642             RtsFlags.GranFlags.Costs.branch_cost = BRANCH_COST;
1643           break;
1644
1645         case 'L':
1646           if (rts_argv[arg][3] != '\0')
1647             RtsFlags.GranFlags.Costs.load_cost = decode(rts_argv[arg]+3);
1648           else
1649             RtsFlags.GranFlags.Costs.load_cost = LOAD_COST;
1650           break;
1651
1652         case 'S':
1653           if (rts_argv[arg][3] != '\0')
1654             RtsFlags.GranFlags.Costs.store_cost = decode(rts_argv[arg]+3);
1655           else
1656             RtsFlags.GranFlags.Costs.store_cost = STORE_COST;
1657           break;
1658
1659         case 'H':
1660           if (rts_argv[arg][3] != '\0')
1661             RtsFlags.GranFlags.Costs.heapalloc_cost = decode(rts_argv[arg]+3);
1662           else
1663             RtsFlags.GranFlags.Costs.heapalloc_cost = 0;
1664           break;
1665
1666         case 'y':
1667           RtsFlags.GranFlags.DoAsyncFetch = rtsTrue;
1668           if (rts_argv[arg][3] != '\0')
1669             RtsFlags.GranFlags.FetchStrategy = decode(rts_argv[arg]+3);
1670           else
1671             RtsFlags.GranFlags.FetchStrategy = 2;
1672           if (RtsFlags.GranFlags.FetchStrategy == 0)
1673             RtsFlags.GranFlags.DoAsyncFetch = rtsFalse;
1674           break;
1675
1676         case 'K':   /* sort overhead (per elem in spark list) */
1677           if (rts_argv[arg][3] != '\0')
1678             RtsFlags.GranFlags.Costs.pri_spark_overhead = decode(rts_argv[arg]+3);
1679           else
1680             RtsFlags.GranFlags.Costs.pri_spark_overhead = PRI_SPARK_OVERHEAD;
1681           debugBelch("Overhead for pri spark: %d (per elem).\n",
1682                          RtsFlags.GranFlags.Costs.pri_spark_overhead);
1683           break;
1684
1685         case 'O':  /* sort overhead (per elem in spark list) */
1686           if (rts_argv[arg][3] != '\0')
1687             RtsFlags.GranFlags.Costs.pri_sched_overhead = decode(rts_argv[arg]+3);
1688           else
1689             RtsFlags.GranFlags.Costs.pri_sched_overhead = PRI_SCHED_OVERHEAD;
1690           debugBelch("Overhead for pri sched: %d (per elem).\n",
1691                        RtsFlags.GranFlags.Costs.pri_sched_overhead);
1692           break;
1693
1694         /* General Parameters */
1695         case 'p':
1696           if (rts_argv[arg][3] != '\0')
1697             {
1698               RtsFlags.GranFlags.proc = decode(rts_argv[arg]+3);
1699               if (RtsFlags.GranFlags.proc==0) {
1700                   enable_GranSimLight(); /* set flags for GrAnSim-Light mode */
1701               } else if (RtsFlags.GranFlags.proc > MAX_PROC ||
1702                          RtsFlags.GranFlags.proc < 1)
1703                 {
1704                   debugBelch("setupRtsFlags: no more than %u processors allowed\n",
1705                           MAX_PROC);
1706                   *error = rtsTrue;
1707                 }
1708             }
1709           else
1710             RtsFlags.GranFlags.proc = MAX_PROC;
1711           break;
1712
1713         case 'f':
1714           RtsFlags.GranFlags.Fishing = rtsTrue;
1715           if (rts_argv[arg][3] != '\0')
1716             RtsFlags.GranFlags.maxFishes = decode(rts_argv[arg]+3);
1717           else
1718             RtsFlags.GranFlags.maxFishes = MAX_FISHES;
1719           break;
1720
1721         case 'w':
1722           if (rts_argv[arg][3] != '\0')
1723             RtsFlags.GranFlags.time_slice = decode(rts_argv[arg]+3);
1724           else
1725             RtsFlags.GranFlags.time_slice = GRAN_TIME_SLICE;
1726           break;
1727
1728         case 'C':
1729           RtsFlags.GranFlags.DoAlwaysCreateThreads=rtsTrue;
1730           RtsFlags.GranFlags.DoThreadMigration=rtsTrue;
1731           break;
1732
1733         case 'G':
1734           debugBelch("Bulk fetching enabled.\n");
1735           RtsFlags.GranFlags.DoBulkFetching=rtsTrue;
1736           break;
1737
1738         case 'M':
1739           debugBelch("Thread migration enabled.\n");
1740           RtsFlags.GranFlags.DoThreadMigration=rtsTrue;
1741           break;
1742
1743         case 'R':
1744           debugBelch("Fair Scheduling enabled.\n");
1745           RtsFlags.GranFlags.DoFairSchedule=rtsTrue;
1746           break;
1747
1748         case 'I':
1749           debugBelch("Priority Scheduling enabled.\n");
1750           RtsFlags.GranFlags.DoPriorityScheduling=rtsTrue;
1751           break;
1752
1753         case 'T':
1754           RtsFlags.GranFlags.DoStealThreadsFirst=rtsTrue;
1755           RtsFlags.GranFlags.DoThreadMigration=rtsTrue;
1756           break;
1757
1758         case 'Z':
1759           RtsFlags.GranFlags.DoAsyncFetch=rtsTrue;
1760           break;
1761
1762 /*          case 'z': */
1763 /*        RtsFlags.GranFlags.SimplifiedFetch=rtsTrue; */
1764 /*        break; */
1765
1766         case 'N':
1767           RtsFlags.GranFlags.PreferSparksOfLocalNodes=rtsTrue;
1768           break;
1769
1770         case 'b':
1771           RtsFlags.GranFlags.GranSimStats.Binary=rtsTrue;
1772           break;
1773
1774         case 'P':
1775           /* format is -bP<c> where <c> is one char describing kind of profile */
1776           RtsFlags.GranFlags.GranSimStats.Full = rtsTrue;
1777           switch(rts_argv[arg][3]) {
1778           case '\0': break; // nothing special, just an ordinary profile
1779           case '0': RtsFlags.GranFlags.GranSimStats.Suppressed = rtsTrue;
1780             break;
1781           case 'b': RtsFlags.GranFlags.GranSimStats.Binary = rtsTrue;
1782             break;
1783           case 's': RtsFlags.GranFlags.GranSimStats.Sparks = rtsTrue;
1784             break;
1785           case 'h': RtsFlags.GranFlags.GranSimStats.Heap = rtsTrue;
1786             break;
1787           case 'n': RtsFlags.GranFlags.GranSimStats.NewLogfile = rtsTrue;
1788             break;
1789           case 'g': RtsFlags.GranFlags.GranSimStats.Global = rtsTrue;
1790             break;
1791           default: barf("Unknown option -bP%c", rts_argv[arg][3]);
1792           }
1793           break;
1794
1795         case 's':
1796           RtsFlags.GranFlags.GranSimStats.Sparks=rtsTrue;
1797           break;
1798
1799         case 'h':
1800           RtsFlags.GranFlags.GranSimStats.Heap=rtsTrue;
1801           break;
1802
1803         case 'Y':   /* syntax: -bY<n>[,<n>]  n ... pos int */
1804           if (rts_argv[arg][3] != '\0') {
1805             char *arg0, *tmp;
1806
1807             arg0 = rts_argv[arg]+3;
1808             if ((tmp = strstr(arg0,","))==NULL) {
1809               RtsFlags.GranFlags.SparkPriority = decode(arg0);
1810               debugBelch("SparkPriority: %u.\n",RtsFlags.GranFlags.SparkPriority);
1811             } else {
1812               *(tmp++) = '\0';
1813               RtsFlags.GranFlags.SparkPriority = decode(arg0);
1814               RtsFlags.GranFlags.SparkPriority2 = decode(tmp);
1815               debugBelch("SparkPriority: %u.\n",
1816                       RtsFlags.GranFlags.SparkPriority);
1817               debugBelch("SparkPriority2:%u.\n",
1818                       RtsFlags.GranFlags.SparkPriority2);
1819               if (RtsFlags.GranFlags.SparkPriority2 <
1820                   RtsFlags.GranFlags.SparkPriority) {
1821                 debugBelch("WARNING: 2nd pri < main pri (%u<%u); 2nd pri has no effect\n",
1822                         RtsFlags.GranFlags.SparkPriority2,
1823                         RtsFlags.GranFlags.SparkPriority);
1824               }
1825             }
1826           } else {
1827             /* plain pri spark is now invoked with -bX
1828                RtsFlags.GranFlags.DoPrioritySparking = 1;
1829                debugBelch("PrioritySparking.\n");
1830             */
1831           }
1832           break;
1833
1834         case 'Q':
1835           if (rts_argv[arg][3] != '\0') {
1836             RtsFlags.GranFlags.ThunksToPack = decode(rts_argv[arg]+3);
1837           } else {
1838             RtsFlags.GranFlags.ThunksToPack = 1;
1839           }
1840           debugBelch("Thunks To Pack in one packet: %u.\n",
1841                   RtsFlags.GranFlags.ThunksToPack);
1842           break;
1843
1844         case 'e':
1845           RtsFlags.GranFlags.RandomSteal = rtsFalse;
1846           debugBelch("Deterministic mode (no random stealing)\n");
1847                       break;
1848
1849           /* The following class of options contains eXperimental */
1850           /* features in connection with exploiting granularity */
1851           /* information. I.e. if -bY is chosen these options */
1852           /* tell the RTS what to do with the supplied info --HWL */
1853
1854         case 'W':
1855           if (rts_argv[arg][3] != '\0') {
1856             RtsFlags.GranFlags.packBufferSize_internal = decode(rts_argv[arg]+3);
1857           } else {
1858             RtsFlags.GranFlags.packBufferSize_internal = GRANSIM_DEFAULT_PACK_BUFFER_SIZE;
1859           }
1860           debugBelch("Size of GranSim internal pack buffer: %u.\n",
1861                   RtsFlags.GranFlags.packBufferSize_internal);
1862           break;
1863
1864         case 'X':
1865           switch(rts_argv[arg][3]) {
1866
1867             case '\0':
1868               RtsFlags.GranFlags.DoPrioritySparking = 1;
1869               debugBelch("Priority Sparking with Normal Priorities.\n");
1870               RtsFlags.GranFlags.InversePriorities = rtsFalse;
1871               RtsFlags.GranFlags.RandomPriorities = rtsFalse;
1872               RtsFlags.GranFlags.IgnorePriorities = rtsFalse;
1873               break;
1874
1875             case 'I':
1876               RtsFlags.GranFlags.DoPrioritySparking = 1;
1877               debugBelch("Priority Sparking with Inverse Priorities.\n");
1878               RtsFlags.GranFlags.InversePriorities++;
1879               break;
1880
1881             case 'R':
1882               RtsFlags.GranFlags.DoPrioritySparking = 1;
1883               debugBelch("Priority Sparking with Random Priorities.\n");
1884               RtsFlags.GranFlags.RandomPriorities++;
1885               break;
1886
1887             case 'N':
1888               RtsFlags.GranFlags.DoPrioritySparking = 1;
1889               debugBelch("Priority Sparking with No Priorities.\n");
1890               RtsFlags.GranFlags.IgnorePriorities++;
1891               break;
1892
1893             default:
1894               bad_option( rts_argv[arg] );
1895               break;
1896           }
1897           break;
1898
1899         case '-':
1900           switch(rts_argv[arg][3]) {
1901
1902             case 'C':
1903               RtsFlags.GranFlags.DoAlwaysCreateThreads=rtsFalse;
1904               RtsFlags.GranFlags.DoThreadMigration=rtsFalse;
1905               break;
1906
1907             case 'G':
1908               RtsFlags.GranFlags.DoBulkFetching=rtsFalse;
1909               break;
1910
1911             case 'M':
1912               RtsFlags.GranFlags.DoThreadMigration=rtsFalse;
1913               break;
1914
1915             case 'R':
1916               RtsFlags.GranFlags.DoFairSchedule=rtsFalse;
1917               break;
1918
1919             case 'T':
1920               RtsFlags.GranFlags.DoStealThreadsFirst=rtsFalse;
1921               RtsFlags.GranFlags.DoThreadMigration=rtsFalse;
1922               break;
1923
1924             case 'Z':
1925               RtsFlags.GranFlags.DoAsyncFetch=rtsFalse;
1926               break;
1927
1928             case 'N':
1929               RtsFlags.GranFlags.PreferSparksOfLocalNodes=rtsFalse;
1930                          break;
1931
1932             case 'P':
1933               RtsFlags.GranFlags.GranSimStats.Suppressed=rtsTrue;
1934               break;
1935
1936             case 's':
1937               RtsFlags.GranFlags.GranSimStats.Sparks=rtsFalse;
1938               break;
1939
1940             case 'h':
1941               RtsFlags.GranFlags.GranSimStats.Heap=rtsFalse;
1942               break;
1943
1944             case 'b':
1945               RtsFlags.GranFlags.GranSimStats.Binary=rtsFalse;
1946               break;
1947
1948             case 'X':
1949               RtsFlags.GranFlags.DoPrioritySparking = rtsFalse;
1950               break;
1951
1952             case 'Y':
1953               RtsFlags.GranFlags.DoPrioritySparking = rtsFalse;
1954               RtsFlags.GranFlags.SparkPriority = rtsFalse;
1955               break;
1956
1957             case 'I':
1958               RtsFlags.GranFlags.DoPriorityScheduling = rtsFalse;
1959               break;
1960
1961             case 'e':
1962               RtsFlags.GranFlags.RandomSteal = rtsFalse;
1963               break;
1964
1965             default:
1966               bad_option( rts_argv[arg] );
1967               break;
1968           }
1969           break;
1970
1971 #  if defined(GRAN_CHECK) && defined(GRAN)
1972         case 'D':
1973           switch(rts_argv[arg][3]) {
1974             case 'Q':    /* Set pack buffer size (same as 'Q' in GUM) */
1975               if (rts_argv[arg][4] != '\0') {
1976                 RtsFlags.GranFlags.packBufferSize = decode(rts_argv[arg]+4);
1977                 debugBelch("Pack buffer size: %d\n",
1978                         RtsFlags.GranFlags.packBufferSize);
1979               } else {
1980                 debugBelch("setupRtsFlags: missing size of PackBuffer (for -Q)\n");
1981                 *error = rtsTrue;
1982               }
1983               break;
1984
1985           default:
1986               if (isdigit(rts_argv[arg][3])) {/* Set all debugging options in one */
1987                 /* hack warning: interpret the flags as a binary number */
1988                 nat n = decode(rts_argv[arg]+3);
1989                 set_GranSim_debug_options(n);
1990               } else {
1991                 nat i;
1992                 for (i=0; i<=MAX_GRAN_DEBUG_OPTION; i++)
1993                   if (rts_argv[arg][3] == gran_debug_opts_flags[i])
1994                     break;
1995
1996                 if (i==MAX_GRAN_DEBUG_OPTION+1) {
1997                   debugBelch("Valid GranSim debug options are:\n");
1998                   help_GranSim_debug_options(MAX_GRAN_DEBUG_MASK);
1999                   bad_option( rts_argv[arg] );
2000                 } else { // flag found; now set it
2001                   set_GranSim_debug_options(GRAN_DEBUG_MASK(i));  // 2^i
2002                 }
2003               }
2004               break;
2005
2006 #if 0
2007             case 'e':       /* event trace; also -bD1 */
2008               debugBelch("DEBUG: event_trace; printing event trace.\n");
2009               RtsFlags.GranFlags.Debug.event_trace = rtsTrue;
2010               /* RtsFlags.GranFlags.event_trace=rtsTrue; */
2011               break;
2012
2013             case 'E':       /* event statistics; also -bD2 */
2014               debugBelch("DEBUG: event_stats; printing event statistics.\n");
2015               RtsFlags.GranFlags.Debug.event_stats = rtsTrue;
2016               /* RtsFlags.GranFlags.Debug |= 0x20; print event statistics   */
2017               break;
2018
2019             case 'f':       /* thunkStealing; also -bD4 */
2020               debugBelch("DEBUG: thunkStealing; printing forwarding of FETCHNODES.\n");
2021               RtsFlags.GranFlags.Debug.thunkStealing = rtsTrue;
2022               /* RtsFlags.GranFlags.Debug |= 0x2;  print fwd messages */
2023               break;
2024
2025             case 'z':       /* blockOnFetch; also -bD8 */
2026               debugBelch("DEBUG: blockOnFetch; check for blocked on fetch.\n");
2027               RtsFlags.GranFlags.Debug.blockOnFetch = rtsTrue;
2028               /* RtsFlags.GranFlags.Debug |= 0x4; debug non-reschedule-on-fetch */
2029               break;
2030
2031             case 't':       /* blockOnFetch_sanity; also -bD16 */
2032               debugBelch("DEBUG: blockOnFetch_sanity; check for TSO asleep on fetch.\n");
2033               RtsFlags.GranFlags.Debug.blockOnFetch_sanity = rtsTrue;
2034               /* RtsFlags.GranFlags.Debug |= 0x10; debug TSO asleep for fetch  */
2035               break;
2036
2037             case 'S':       /* priSpark; also -bD32 */
2038               debugBelch("DEBUG: priSpark; priority sparking.\n");
2039               RtsFlags.GranFlags.Debug.priSpark = rtsTrue;
2040               break;
2041
2042             case 's':       /* priSched; also -bD64 */
2043               debugBelch("DEBUG: priSched; priority scheduling.\n");
2044               RtsFlags.GranFlags.Debug.priSched = rtsTrue;
2045               break;
2046
2047             case 'F':       /* findWork; also -bD128 */
2048               debugBelch("DEBUG: findWork; searching spark-pools (local & remote), thread queues for work.\n");
2049               RtsFlags.GranFlags.Debug.findWork = rtsTrue;
2050               break;
2051
2052             case 'g':       /* globalBlock; also -bD256 */
2053               debugBelch("DEBUG: globalBlock; blocking on remote closures (FETCHMEs etc in GUM).\n");
2054               RtsFlags.GranFlags.Debug.globalBlock = rtsTrue;
2055               break;
2056
2057             case 'G':       /* pack; also -bD512 */
2058               debugBelch("DEBUG: pack; routines for (un-)packing graph structures.\n");
2059               RtsFlags.GranFlags.Debug.pack = rtsTrue;
2060               break;
2061
2062             case 'P':       /* packBuffer; also -bD1024 */
2063               debugBelch("DEBUG: packBuffer; routines handling pack buffer (GranSim internal!).\n");
2064               RtsFlags.GranFlags.Debug.packBuffer = rtsTrue;
2065               break;
2066
2067             case 'o':       /* sortedQ; also -bD2048 */
2068               debugBelch("DEBUG: sortedQ; check whether spark/thread queues are sorted.\n");
2069               RtsFlags.GranFlags.Debug.sortedQ = rtsTrue;
2070               break;
2071
2072             case 'r':       /* randomSteal; also -bD4096 */
2073               debugBelch("DEBUG: randomSteal; stealing sparks/threads from random PEs.\n");
2074               RtsFlags.GranFlags.Debug.randomSteal = rtsTrue;
2075               break;
2076
2077             case 'q':       /* checkSparkQ; also -bD8192 */
2078               debugBelch("DEBUG: checkSparkQ; check consistency of the spark queues.\n");
2079               RtsFlags.GranFlags.Debug.checkSparkQ = rtsTrue;
2080               break;
2081
2082             case ':':       /* checkLight; also -bD16384 */
2083               debugBelch("DEBUG: checkLight; check GranSim-Light setup.\n");
2084               RtsFlags.GranFlags.Debug.checkLight = rtsTrue;
2085               break;
2086
2087             case 'b':       /* bq; also -bD32768 */
2088               debugBelch("DEBUG: bq; check blocking queues\n");
2089               RtsFlags.GranFlags.Debug.bq = rtsTrue;
2090               break;
2091
2092             case 'd':       /* all options turned on */
2093               debugBelch("DEBUG: all options turned on.\n");
2094               set_GranSim_debug_options(MAX_GRAN_DEBUG_MASK);
2095               /* RtsFlags.GranFlags.Debug |= 0x40; */
2096               break;
2097
2098 /*          case '\0': */
2099 /*            RtsFlags.GranFlags.Debug = 1; */
2100 /*            break; */
2101 #endif
2102
2103           }
2104           break;
2105 #  endif  /* GRAN_CHECK */
2106       default:
2107         bad_option( rts_argv[arg] );
2108         break;
2109       }
2110 }
2111
2112 /*
2113   Interpret n as a binary number masking GranSim debug options and set the
2114   correxponding option. See gran_debug_opts_strs for explanations of the flags.
2115 */
2116 static void
2117 set_GranSim_debug_options(nat n) {
2118   nat i;
2119
2120   for (i=0; i<=MAX_GRAN_DEBUG_OPTION; i++)
2121     if ((n>>i)&1) {
2122       errorBelch(gran_debug_opts_strs[i]);
2123       switch (i) {
2124         case 0: RtsFlags.GranFlags.Debug.event_trace   = rtsTrue;  break;
2125         case 1: RtsFlags.GranFlags.Debug.event_stats   = rtsTrue;  break;
2126         case 2: RtsFlags.GranFlags.Debug.bq            = rtsTrue;  break;
2127         case 3: RtsFlags.GranFlags.Debug.pack          = rtsTrue;  break;
2128         case 4: RtsFlags.GranFlags.Debug.checkSparkQ   = rtsTrue;  break;
2129         case 5: RtsFlags.GranFlags.Debug.thunkStealing = rtsTrue;  break;
2130         case 6: RtsFlags.GranFlags.Debug.randomSteal   = rtsTrue;  break;
2131         case 7: RtsFlags.GranFlags.Debug.findWork      = rtsTrue;  break;
2132         case 8: RtsFlags.GranFlags.Debug.unused        = rtsTrue;  break;
2133         case 9: RtsFlags.GranFlags.Debug.pri           = rtsTrue;  break;
2134         case 10: RtsFlags.GranFlags.Debug.checkLight   = rtsTrue;  break;
2135         case 11: RtsFlags.GranFlags.Debug.sortedQ      = rtsTrue;  break;
2136         case 12: RtsFlags.GranFlags.Debug.blockOnFetch = rtsTrue;  break;
2137         case 13: RtsFlags.GranFlags.Debug.packBuffer   = rtsTrue;  break;
2138         case 14: RtsFlags.GranFlags.Debug.blockOnFetch_sanity = rtsTrue;  break;
2139         default: barf("set_GranSim_debug_options: only %d debug options expected");
2140       } /* switch */
2141     } /* if */
2142 }
2143
2144 /*
2145   Print one line explanation for each of the GranSim debug options specified
2146   in the bitmask n.
2147 */
2148 static void
2149 help_GranSim_debug_options(nat n) {
2150   nat i;
2151
2152   for (i=0; i<=MAX_GRAN_DEBUG_OPTION; i++)
2153     if ((n>>i)&1)
2154       debugBelch(gran_debug_opts_strs[i]);
2155 }
2156
2157 # elif defined(PAR)
2158
2159 static void
2160 process_par_option(int arg, int *rts_argc, char *rts_argv[], rtsBool *error)
2161 {
2162
2163   if (rts_argv[arg][1] != 'q') { /* All GUM options start with -q */
2164     errorBelch("Warning: GUM option does not start with -q: %s", rts_argv[arg]);
2165     return;
2166   }
2167
2168   /* Communication and task creation cost parameters */
2169   switch(rts_argv[arg][2]) {
2170   case 'e':  /* -qe<n>  ... allow <n> local sparks */
2171     if (rts_argv[arg][3] != '\0') { /* otherwise, stick w/ the default */
2172       RtsFlags.ParFlags.maxLocalSparks
2173         = strtol(rts_argv[arg]+3, (char **) NULL, 10);
2174
2175       if (RtsFlags.ParFlags.maxLocalSparks <= 0) {
2176         errorBelch("setupRtsFlags: bad value for -e\n");
2177         *error = rtsTrue;
2178       }
2179     }
2180     IF_PAR_DEBUG(verbose,
2181                  errorBelch("-qe<n>: max %d local sparks",
2182                        RtsFlags.ParFlags.maxLocalSparks));
2183     break;
2184
2185   case 't':
2186     if (rts_argv[arg][3] != '\0') {
2187       RtsFlags.ParFlags.maxThreads
2188         = strtol(rts_argv[arg]+3, (char **) NULL, 10);
2189     } else {
2190       errorBelch("missing size for -qt\n");
2191       *error = rtsTrue;
2192     }
2193     IF_PAR_DEBUG(verbose,
2194                  errorBelch("-qt<n>: max %d threads",
2195                        RtsFlags.ParFlags.maxThreads));
2196     break;
2197
2198   case 'f':
2199     if (rts_argv[arg][3] != '\0')
2200       RtsFlags.ParFlags.maxFishes = decode(rts_argv[arg]+3);
2201     else
2202       RtsFlags.ParFlags.maxFishes = MAX_FISHES;
2203     break;
2204     IF_PAR_DEBUG(verbose,
2205                  errorBelch("-qf<n>: max %d fishes sent out at one time",
2206                        RtsFlags.ParFlags.maxFishes));
2207     break;
2208
2209   case 'F':
2210     if (rts_argv[arg][3] != '\0') {
2211       RtsFlags.ParFlags.fishDelay
2212         = strtol(rts_argv[arg]+3, (char **) NULL, 10);
2213     } else {
2214       errorBelch("missing fish delay time for -qF\n");
2215       *error = rtsTrue;
2216     }
2217     IF_PAR_DEBUG(verbose,
2218                  errorBelch("-qF<n>: fish delay time %d us",
2219                        RtsFlags.ParFlags.fishDelay));
2220     break;
2221
2222   case 'O':
2223     RtsFlags.ParFlags.outputDisabled = rtsTrue;
2224     IF_PAR_DEBUG(verbose,
2225                  errorBelch("-qO: output disabled"));
2226     break;
2227
2228   case 'g': /* -qg<n> ... globalisation scheme */
2229     if (rts_argv[arg][3] != '\0') {
2230       RtsFlags.ParFlags.globalising = decode(rts_argv[arg]+3);
2231     } else {
2232       errorBelch("missing identifier for globalisation scheme (for -qg)\n");
2233       *error = rtsTrue;
2234     }
2235     IF_PAR_DEBUG(verbose,
2236                  debugBelch("-qg<n>: globalisation scheme set to  %d",
2237                        RtsFlags.ParFlags.globalising));
2238     break;
2239
2240   case 'h': /* -qh<n> ... max number of thunks (except root) in packet */
2241     if (rts_argv[arg][3] != '\0') {
2242       RtsFlags.ParFlags.thunksToPack = decode(rts_argv[arg]+3);
2243     } else {
2244       errorBelch("missing number of thunks per packet (for -qh)\n");
2245       *error = rtsTrue;
2246     }
2247     IF_PAR_DEBUG(verbose,
2248                  debugBelch("-qh<n>: thunks per packet set to %d",
2249                        RtsFlags.ParFlags.thunksToPack));
2250     break;
2251
2252   case 'P': /* -qP for writing a log file */
2253     //RtsFlags.ParFlags.ParStats.Full = rtsFalse;
2254     /* same encoding as in GranSim after -bP */
2255     switch(rts_argv[arg][3]) {
2256     case '\0': RtsFlags.ParFlags.ParStats.Full = rtsTrue;
2257       break; // nothing special, just an ordinary profile
2258     case '0': RtsFlags.ParFlags.ParStats.Suppressed = rtsTrue;
2259         RtsFlags.ParFlags.ParStats.Full = rtsFalse;
2260       break;
2261     case 'b': RtsFlags.ParFlags.ParStats.Binary = rtsTrue;
2262       break;
2263     case 's': RtsFlags.ParFlags.ParStats.Sparks = rtsTrue;
2264       break;
2265       //case 'h': RtsFlags.parFlags.ParStats.Heap = rtsTrue;
2266       //  break;
2267     case 'n': RtsFlags.ParFlags.ParStats.NewLogfile = rtsTrue;
2268       break;
2269     case 'g':
2270 # if defined(PAR_TICKY)
2271       RtsFlags.ParFlags.ParStats.Global = rtsTrue;
2272 # else
2273       errorBelch("-qPg is only possible for a PAR_TICKY RTS, which this is not");
2274       stg_exit(EXIT_FAILURE);
2275 # endif
2276       break;
2277     default: barf("Unknown option -qP%c", rts_argv[arg][2]);
2278     }
2279     IF_PAR_DEBUG(verbose,
2280                  debugBelch("(-qP) writing to log-file (RtsFlags.ParFlags.ParStats.Full=%s)",
2281                        (RtsFlags.ParFlags.ParStats.Full ? "rtsTrue" : "rtsFalse")));
2282     break;
2283
2284   case 'Q': /* -qQ<n> ... set pack buffer size to <n> */
2285     if (rts_argv[arg][3] != '\0') {
2286       RtsFlags.ParFlags.packBufferSize = decode(rts_argv[arg]+3);
2287     } else {
2288       errorBelch("missing size of PackBuffer (for -qQ)\n");
2289       *error = rtsTrue;
2290     }
2291     IF_PAR_DEBUG(verbose,
2292                  debugBelch("-qQ<n>: pack buffer size set to %d",
2293                        RtsFlags.ParFlags.packBufferSize));
2294     break;
2295
2296   case 'R':
2297     RtsFlags.ParFlags.doFairScheduling = rtsTrue;
2298     IF_PAR_DEBUG(verbose,
2299                  debugBelch("-qR: fair-ish scheduling"));
2300     break;
2301
2302 # if defined(DEBUG)
2303   case 'w':
2304     if (rts_argv[arg][3] != '\0') {
2305       RtsFlags.ParFlags.wait
2306         = strtol(rts_argv[arg]+3, (char **) NULL, 10);
2307     } else {
2308       RtsFlags.ParFlags.wait = 1000;
2309     }
2310     IF_PAR_DEBUG(verbose,
2311                  debugBelch("-qw<n>: length of wait loop after synchr before reduction: %d",
2312                        RtsFlags.ParFlags.wait));
2313     break;
2314
2315   case 'D':  /* -qD ... all the debugging options */
2316     if (isdigit(rts_argv[arg][3])) {/* Set all debugging options in one */
2317       /* hack warning: interpret the flags as a binary number */
2318       nat n = decode(rts_argv[arg]+3);
2319       set_par_debug_options(n);
2320     } else {
2321       nat i;
2322       for (i=0; i<=MAX_PAR_DEBUG_OPTION; i++)
2323         if (rts_argv[arg][3] == par_debug_opts_flags[i])
2324           break;
2325
2326       if (i==MAX_PAR_DEBUG_OPTION+1) {
2327         errorBelch("Valid GUM debug options are:\n");
2328         help_par_debug_options(MAX_PAR_DEBUG_MASK);
2329         bad_option( rts_argv[arg] );
2330       } else { // flag found; now set it
2331         set_par_debug_options(PAR_DEBUG_MASK(i));  // 2^i
2332       }
2333     }
2334     break;
2335 # endif
2336   default:
2337     errorBelch("Unknown option -q%c (%d opts in total)",
2338           rts_argv[arg][2], *rts_argc);
2339     break;
2340   } /* switch */
2341 }
2342
2343 /*
2344   Interpret n as a binary number masking Par debug options and set the
2345   correxponding option. See par_debug_opts_strs for explanations of the flags.
2346 */
2347 static void
2348 set_par_debug_options(nat n) {
2349   nat i;
2350
2351   for (i=0; i<=MAX_PAR_DEBUG_OPTION; i++)
2352     if ((n>>i)&1) {
2353       debugBelch(par_debug_opts_strs[i]);
2354       switch (i) {
2355         case 0: RtsFlags.ParFlags.Debug.verbose       = rtsTrue;  break;
2356         case 1: RtsFlags.ParFlags.Debug.bq            = rtsTrue;  break;
2357         case 2: RtsFlags.ParFlags.Debug.schedule      = rtsTrue;  break;
2358         case 3: RtsFlags.ParFlags.Debug.free          = rtsTrue;  break;
2359         case 4: RtsFlags.ParFlags.Debug.resume        = rtsTrue;  break;
2360         case 5: RtsFlags.ParFlags.Debug.weight        = rtsTrue;  break;
2361         case 6: RtsFlags.ParFlags.Debug.fetch         = rtsTrue;  break;
2362           //case 7: RtsFlags.ParFlags.Debug.ack           = rtsTrue;  break;
2363         case 7: RtsFlags.ParFlags.Debug.fish          = rtsTrue;  break;
2364         case 8: RtsFlags.ParFlags.Debug.tables        = rtsTrue;  break;
2365         case 9: RtsFlags.ParFlags.Debug.packet        = rtsTrue;  break;
2366         case 10: RtsFlags.ParFlags.Debug.pack         = rtsTrue;  break;
2367         case 11: RtsFlags.ParFlags.Debug.paranoia     = rtsTrue;  break;
2368         default: barf("set_par_debug_options: only %d debug options expected",
2369                       MAX_PAR_DEBUG_OPTION);
2370       } /* switch */
2371     } /* if */
2372 }
2373
2374 /*
2375   Print one line explanation for each of the GranSim debug options specified
2376   in the bitmask n.
2377 */
2378 static void
2379 help_par_debug_options(nat n) {
2380   nat i;
2381
2382   for (i=0; i<=MAX_PAR_DEBUG_OPTION; i++)
2383     if ((n>>i)&1)
2384       debugBelch(par_debug_opts_strs[i]);
2385 }
2386
2387 #endif /* PAR */
2388
2389 static void
2390 stats_fprintf(FILE *f, char *s, ...)
2391 {
2392     va_list ap;
2393     va_start(ap,s);
2394     if (f == NULL) {
2395         vdebugBelch(s, ap);
2396     } else {
2397         vfprintf(f, s, ap);
2398     }
2399     va_end(ap);
2400 }
2401
2402 static int              /* return -1 on error */
2403 open_stats_file (
2404     I_ arg,
2405     int argc, char *argv[],
2406     int rts_argc, char *rts_argv[],
2407     const char *FILENAME_FMT,
2408     FILE **file_ret)
2409 {
2410     FILE *f = NULL;
2411
2412     if (strequal(rts_argv[arg]+2, "stderr")
2413         || (FILENAME_FMT == NULL && rts_argv[arg][2] == '\0')) {
2414         f = NULL; /* NULL means use debugBelch */
2415     } else {
2416         if (rts_argv[arg][2] != '\0') {  /* stats file specified */
2417             f = fopen(rts_argv[arg]+2,"w");
2418         } else {
2419             char stats_filename[STATS_FILENAME_MAXLEN]; /* default <program>.<ext> */
2420             sprintf(stats_filename, FILENAME_FMT, argv[0]);
2421             f = fopen(stats_filename,"w");
2422         }
2423         if (f == NULL) {
2424             errorBelch("Can't open stats file %s\n", rts_argv[arg]+2);
2425             return -1;
2426         }
2427     }
2428     *file_ret = f;
2429
2430     {
2431         /* Write argv and rtsv into start of stats file */
2432         int count;
2433         for(count = 0; count < argc; count++) {
2434             stats_fprintf(f, "%s ", argv[count]);
2435         }
2436         stats_fprintf(f, "+RTS ");
2437         for(count = 0; count < rts_argc; count++)
2438             stats_fprintf(f, "%s ", rts_argv[count]);
2439         stats_fprintf(f, "\n");
2440     }
2441     return 0;
2442 }
2443
2444
2445
2446 static I_
2447 decode(const char *s)
2448 {
2449     I_ c;
2450     StgDouble m;
2451
2452     if (!*s)
2453         return 0;
2454
2455     m = atof(s);
2456     c = s[strlen(s)-1];
2457
2458     if (c == 'g' || c == 'G')
2459         m *= 1000*1000*1000;    /* UNchecked! */
2460     else if (c == 'm' || c == 'M')
2461         m *= 1000*1000;                 /* We do not use powers of 2 (1024) */
2462     else if (c == 'k' || c == 'K')      /* to avoid possible bad effects on */
2463         m *= 1000;                      /* a direct-mapped cache.           */
2464     else if (c == 'w' || c == 'W')
2465         m *= sizeof(W_);
2466
2467     return (I_)m;
2468 }
2469
2470 static void
2471 bad_option(const char *s)
2472 {
2473   errorBelch("bad RTS option: %s", s);
2474   stg_exit(EXIT_FAILURE);
2475 }
2476
2477 /* -----------------------------------------------------------------------------
2478    Getting/Setting the program's arguments.
2479
2480    These are used by System.Environment, and parts of the RTS.
2481    -------------------------------------------------------------------------- */
2482
2483 void
2484 setProgName(char *argv[])
2485 {
2486     /* Remove directory from argv[0] -- default files in current directory */
2487 #if !defined(mingw32_HOST_OS)
2488     char *last_slash;
2489     if ( (last_slash = (char *) strrchr(argv[0], '/')) != NULL ) {
2490         prog_name = last_slash+1;
2491    } else {
2492         prog_name = argv[0];
2493    }
2494 #else
2495     char* last_slash = argv[0] + (strlen(argv[0]) - 1);
2496     while ( last_slash > argv[0] ) {
2497         if ( *last_slash == '/' || *last_slash == '\\' ) {
2498             prog_name = last_slash+1;
2499             return;
2500         }
2501         last_slash--;
2502     }
2503     prog_name = argv[0];
2504 #endif
2505 }
2506
2507 void
2508 getProgArgv(int *argc, char **argv[])
2509 {
2510     if (argc) { *argc = prog_argc; }
2511     if (argv) { *argv = prog_argv; }
2512 }
2513
2514 void
2515 setProgArgv(int argc, char *argv[])
2516 {
2517    /* Usually this is done by startupHaskell, so we don't need to call this.
2518       However, sometimes Hugs wants to change the arguments which Haskell
2519       getArgs >>= ... will be fed.  So you can do that by calling here
2520       _after_ calling startupHaskell.
2521    */
2522    prog_argc = argc;
2523    prog_argv = argv;
2524    setProgName(prog_argv);
2525 }
2526
2527 /* These functions record and recall the full arguments, including the
2528    +RTS ... -RTS options. The reason for adding them was so that the
2529    ghc-inplace program can pass /all/ the arguments on to the real ghc. */
2530 void
2531 getFullProgArgv(int *argc, char **argv[])
2532 {
2533     if (argc) { *argc = full_prog_argc; }
2534     if (argv) { *argv = full_prog_argv; }
2535 }
2536
2537 void
2538 setFullProgArgv(int argc, char *argv[])
2539 {
2540     int i;
2541     full_prog_argc = argc;
2542     full_prog_argv = stgCallocBytes(argc + 1, sizeof (char *),
2543                                     "setFullProgArgv 1");
2544     for (i = 0; i < argc; i++) {
2545         full_prog_argv[i] = stgMallocBytes(strlen(argv[i]) + 1,
2546                                            "setFullProgArgv 2");
2547         strcpy(full_prog_argv[i], argv[i]);
2548     }
2549     full_prog_argv[argc] = NULL;
2550 }
2551