ghc/rts/RtsFlags.c

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