[project @ 1999-01-26 16:16:19 by simonm]
[ghc-hetmet.git] / ghc / rts / RtsFlags.c
1 /* -----------------------------------------------------------------------------
2  * $Id: RtsFlags.c,v 1.7 1999/01/26 16:16:28 simonm Exp $
3  *
4  * Functions for parsing the argument list.
5  *
6  * ---------------------------------------------------------------------------*/
7
8 #include "Rts.h"
9 #include "RtsFlags.h"
10 #include "RtsUtils.h"
11 #include "BlockAlloc.h"
12 #include "ProfRts.h"
13
14 #if HAVE_STDLIB_H
15 #include <stdlib.h>
16 #endif
17
18 #ifdef HAVE_STRING_H
19 #include <string.h>
20 #endif
21
22 extern struct RTS_FLAGS RtsFlags;
23
24 /*
25  * Split argument lists
26  */
27 int     prog_argc; /* an "int" so as to match normal "argc" */
28 char  **prog_argv = NULL;
29 int     rts_argc;  /* ditto */
30 char   *rts_argv[MAX_RTS_ARGS];
31
32 /*
33  * constants, used later 
34  */
35 #define RTS 1
36 #define PGM 0
37
38 /* -----------------------------------------------------------------------------
39    Static function decls
40    -------------------------------------------------------------------------- */
41
42 static FILE *           /* return NULL on error */
43 open_stats_file (
44     I_ arg,
45     int argc, char *argv[],
46     int rts_argc, char *rts_argv[],
47     const char *FILENAME_FMT);
48
49 static I_ decode(const char *s);
50 static void bad_option(const char *s);
51
52 /* -----------------------------------------------------------------------------
53  * Command-line option parsing routines.
54  * ---------------------------------------------------------------------------*/
55
56 void initRtsFlagsDefaults(void)
57 {
58     RtsFlags.GcFlags.statsFile          = NULL;
59     RtsFlags.GcFlags.giveStats          = NO_GC_STATS;
60
61     RtsFlags.GcFlags.maxStkSize         = (1024 * 1024) / sizeof(W_);
62     RtsFlags.GcFlags.initialStkSize     = 1024 / sizeof(W_);
63
64     RtsFlags.GcFlags.minAllocAreaSize   = (256 * 1024)        / BLOCK_SIZE;
65     RtsFlags.GcFlags.minOldGenSize      = (1024 * 1024)       / BLOCK_SIZE;
66     RtsFlags.GcFlags.maxHeapSize        = (64  * 1024 * 1024) / BLOCK_SIZE;
67     RtsFlags.GcFlags.pcFreeHeap         = 3;    /* 3% */
68     RtsFlags.GcFlags.oldGenFactor       = 2;
69     RtsFlags.GcFlags.generations        = 2;
70     RtsFlags.GcFlags.steps              = 2;
71
72     RtsFlags.GcFlags.forceGC            = rtsFalse;
73     RtsFlags.GcFlags.forcingInterval    = 5000000; /* 5MB (or words?) */
74     RtsFlags.GcFlags.ringBell           = rtsFalse;
75
76     RtsFlags.GcFlags.squeezeUpdFrames   = rtsTrue;
77
78 #if defined(PROFILING) || defined(PAR)
79     RtsFlags.CcFlags.doCostCentres      = 0;
80     RtsFlags.CcFlags.sortBy             = SORTCC_TIME;
81 #endif /* PROFILING or PAR */
82
83 #ifdef PROFILING
84     RtsFlags.ProfFlags.doHeapProfile = rtsFalse;
85
86     RtsFlags.ProfFlags.ccSelector    = NULL;
87     RtsFlags.ProfFlags.modSelector   = NULL;
88     RtsFlags.ProfFlags.grpSelector   = NULL;
89     RtsFlags.ProfFlags.descrSelector = NULL;
90     RtsFlags.ProfFlags.typeSelector  = NULL;
91     RtsFlags.ProfFlags.kindSelector  = NULL;
92 #elif defined(DEBUG)
93     RtsFlags.ProfFlags.doHeapProfile = rtsFalse;
94 #endif
95
96 /* there really shouldn't be a threads limit for concurrent mandatory threads.
97    For now, unlimitied means less than 64k (there's a storage overhead) -- SOF
98 */
99 #if defined(CONCURRENT) && !defined(GRAN)
100     RtsFlags.ConcFlags.ctxtSwitchTime   = CS_MIN_MILLISECS;  /* In milliseconds */
101     RtsFlags.ConcFlags.maxThreads       = 65536;
102     RtsFlags.ConcFlags.stkChunkSize     = 1024;
103     RtsFlags.ConcFlags.maxLocalSparks   = 65536;
104 #endif /* CONCURRENT only */
105
106 #if GRAN
107     RtsFlags.ConcFlags.ctxtSwitchTime   = CS_MIN_MILLISECS;  /* In milliseconds */
108     RtsFlags.ConcFlags.maxThreads       = 32;
109     RtsFlags.ConcFlags.stkChunkSize     = 1024;
110     RtsFlags.ConcFlags.maxLocalSparks   = 500;
111 #endif /* GRAN */
112
113 #ifdef PAR
114     RtsFlags.ParFlags.parallelStats     = rtsFalse;
115     RtsFlags.ParFlags.granSimStats      = rtsFalse;
116     RtsFlags.ParFlags.granSimStats_Binary = rtsFalse;
117
118     RtsFlags.ParFlags.outputDisabled    = rtsFalse;
119
120     RtsFlags.ParFlags.packBufferSize    = 1024;
121     RtsFlags.ParFlags.maxLocalSparks    = 4096;
122 #endif /* PAR */
123
124 #ifdef GRAN
125     RtsFlags.GranFlags.granSimStats     = rtsFalse;
126     RtsFlags.GranFlags.granSimStats_suppressed  = rtsFalse;
127     RtsFlags.GranFlags.granSimStats_Binary = rtsFalse;
128     RtsFlags.GranFlags.granSimStats_Sparks = rtsFalse;
129     RtsFlags.GranFlags.granSimStats_Heap = rtsFalse;
130     RtsFlags.GranFlags.labelling        = rtsFalse;
131     RtsFlags.GranFlags.packBufferSize   = 1024;
132     RtsFlags.GranFlags.packBufferSize_internal = GRANSIM_DEFAULT_PACK_BUFFER_SIZE;
133
134     RtsFlags.GranFlags.proc  = MAX_PROC;
135     RtsFlags.GranFlags.max_fishes = MAX_FISHES;
136     RtsFlags.GranFlags.time_slice = GRAN_TIME_SLICE;
137     RtsFlags.GranFlags.Light = rtsFalse;
138
139     RtsFlags.GranFlags.gran_latency =             LATENCY;          
140     RtsFlags.GranFlags.gran_additional_latency =  ADDITIONAL_LATENCY; 
141     RtsFlags.GranFlags.gran_fetchtime =           FETCHTIME; 
142     RtsFlags.GranFlags.gran_lunblocktime =        LOCALUNBLOCKTIME; 
143     RtsFlags.GranFlags.gran_gunblocktime =        GLOBALUNBLOCKTIME;
144     RtsFlags.GranFlags.gran_mpacktime =           MSGPACKTIME;      
145     RtsFlags.GranFlags.gran_munpacktime =         MSGUNPACKTIME;
146     RtsFlags.GranFlags.gran_mtidytime =           MSGTIDYTIME;
147
148     RtsFlags.GranFlags.gran_threadcreatetime =         THREADCREATETIME;
149     RtsFlags.GranFlags.gran_threadqueuetime =          THREADQUEUETIME;
150     RtsFlags.GranFlags.gran_threaddescheduletime =     THREADDESCHEDULETIME;
151     RtsFlags.GranFlags.gran_threadscheduletime =       THREADSCHEDULETIME;
152     RtsFlags.GranFlags.gran_threadcontextswitchtime =  THREADCONTEXTSWITCHTIME;
153
154     RtsFlags.GranFlags.gran_arith_cost =         ARITH_COST;       
155     RtsFlags.GranFlags.gran_branch_cost =        BRANCH_COST; 
156     RtsFlags.GranFlags.gran_load_cost =          LOAD_COST;        
157     RtsFlags.GranFlags.gran_store_cost =         STORE_COST; 
158     RtsFlags.GranFlags.gran_float_cost =         FLOAT_COST;       
159
160     RtsFlags.GranFlags.gran_heapalloc_cost =     HEAPALLOC_COST;
161
162     RtsFlags.GranFlags.gran_pri_spark_overhead = PRI_SPARK_OVERHEAD;        
163     RtsFlags.GranFlags.gran_pri_sched_overhead = PRI_SCHED_OVERHEAD;        
164
165     RtsFlags.GranFlags.DoFairSchedule = rtsFalse;             
166     RtsFlags.GranFlags.DoReScheduleOnFetch = rtsFalse;        
167     RtsFlags.GranFlags.DoStealThreadsFirst = rtsFalse;        
168     RtsFlags.GranFlags.SimplifiedFetch = rtsFalse;            
169     RtsFlags.GranFlags.DoAlwaysCreateThreads = rtsFalse;      
170     RtsFlags.GranFlags.DoGUMMFetching = rtsFalse;             
171     RtsFlags.GranFlags.DoThreadMigration = rtsFalse;          
172     RtsFlags.GranFlags.FetchStrategy = 2;                     
173     RtsFlags.GranFlags.PreferSparksOfLocalNodes = rtsFalse;   
174     RtsFlags.GranFlags.DoPrioritySparking = rtsFalse;         
175     RtsFlags.GranFlags.DoPriorityScheduling = rtsFalse;       
176     RtsFlags.GranFlags.SparkPriority = 0;
177     RtsFlags.GranFlags.SparkPriority2 = 0; 
178     RtsFlags.GranFlags.RandomPriorities = rtsFalse;           
179     RtsFlags.GranFlags.InversePriorities = rtsFalse;          
180     RtsFlags.GranFlags.IgnorePriorities = rtsFalse;           
181     RtsFlags.GranFlags.ThunksToPack = 0;                      
182     RtsFlags.GranFlags.RandomSteal = rtsTrue;
183     RtsFlags.GranFlags.NoForward = rtsFalse;
184     RtsFlags.GranFlags.PrintFetchMisses = rtsFalse;
185
186     RtsFlags.GranFlags.debug = 0x0;
187     RtsFlags.GranFlags.event_trace = rtsFalse;
188     RtsFlags.GranFlags.event_trace_all = rtsFalse;
189 #endif
190
191 #ifdef TICKY_TICKY
192     RtsFlags.TickyFlags.showTickyStats  = rtsFalse;
193     RtsFlags.TickyFlags.tickyFile       = NULL;
194 #endif
195 }
196
197 static const char *
198 usage_text[] = {
199 "",
200 "Usage: <prog> <args> [+RTS <rtsopts> | -RTS <args>] ... --RTS <args>",
201 "",
202 "   +RTS    Indicates run time system options follow",
203 "   -RTS    Indicates program arguments follow",
204 "  --RTS    Indicates that ALL subsequent arguments will be given to the",
205 "           program (including any of these RTS flags)",
206 "",
207 "The following run time system options are available:",
208 "",
209 "  -? -f    Prints this message and exits; the program is not executed",
210 "",
211 "  -K<size> Sets the maximum stack size (default 1M)  Egs: -K32k   -K512k",
212 "  -k<size> Sets the initial thread stack size (default 1k)  Egs: -K4k   -K2m",
213 "",
214 "  -A<size> Sets the minimum allocation area size (default 256k) Egs: -A1m -A10k",
215 "  -M<size> Sets the maximum heap size (default 64M)  Egs: -H256k -H1G",
216 "  -m<n>%   Minimum % of heap which must be available (default 3%)",
217 "  -G<n>    Number of generations (default: 2)",
218 "  -T<n>    Number of steps in younger generations (default: 2)",
219 "  -s<file> Summary GC statistics   (default file: <program>.stat)",
220 "  -S<file> Detailed GC statistics  (with -Sstderr going to stderr)",
221 "",
222 "",
223 "  -Z       Don't squeeze out update frames on stack overflow",
224 "  -B       Sound the bell at the start of each garbage collection",
225 #if defined(PROFILING) || defined(PAR)
226 "",
227 "  -p<sort> Produce cost centre time profile  (output file <program>.prof)",
228 "             sort: T = time (default), A = alloc, C = cost centre label",
229 "  -P<sort> Produce serial time profile (output file <program>.time)",
230 "             and a -p profile with detailed tick/alloc info",
231 # if defined(PROFILING)
232 "",
233 "  -h<break-down> Heap residency profile      (output file <program>.hp)",
234 "     break-down: C = cost centre (default), M = module, G = group",
235 "                 D = closure description, Y = type description",
236 "                 T<ints>,<start> = time closure created",
237 "                    ints:  no. of interval bands plotted (default 18)",
238 "                    start: seconds after which intervals start (default 0.0)",
239 "  A subset of closures may be selected by the attached cost centre using:",
240 "    -c{mod:lab,mod:lab...}, specific module:label cost centre(s)",
241 "    -m{mod,mod...} all cost centres from the specified modules(s)",
242 "    -g{grp,grp...} all cost centres from the specified group(s)",
243 "  Selections can also be made by description, type, kind and age:",
244 "    -d{des,des...} closures with specified closure descriptions",
245 "    -y{typ,typ...} closures with specified type descriptions",
246 "    -k{knd,knd...} closures of the specified kinds",
247 "    -a<age>        closures which survived <age> complete intervals",
248 "  The selection logic used is summarised as follows:",
249 "    ([-c] or [-m] or [-g]) and ([-d] or [-y] or [-k]) and [-a]",
250 "    where an option is true if not specified",
251 # endif
252 "",
253 "  -z<tbl><size>  set hash table <size> for <tbl> (C, M, G, D or Y)",
254 "",
255 "  -i<secs> Number of seconds in a profiling interval (default 1.0):",
256 "           heap profile (-h) and/or serial time profile (-P) frequency",
257 #endif /* PROFILING or PAR */
258 #if !defined(PROFILING) && defined(DEBUG)
259 "",
260 "  -h<break-down> Debugging Heap residency profile",
261 "                 (output file <program>.hp)",
262 "     break-down: L = closure label (default)",
263 "                 T = closure type (constructor, thunk etc.)",
264 #endif
265 "",
266 #if defined(TICKY_TICKY)
267 "  -r<file>  Produce reduction profiling statistics (with -rstderr for stderr)",
268 "",
269 #endif
270 # ifdef PAR
271 "  -N<n>     Use <n> PVMish processors in parallel (default: 2)",
272 /* NB: the -N<n> is implemented by the driver!! */
273 # endif
274 "  -C<secs>  Context-switch interval in seconds",
275 "                (0 or no argument means switch as often as possible)",
276 "                the default is .01 sec; resolution is .01 sec",
277 "  -e<size>        Size of spark pools (default 100)",
278 # ifdef PAR
279 "  -q        Enable activity profile (output files in ~/<program>*.gr)",
280 "  -qb       Enable binary activity profile (output file /tmp/<program>.gb)",
281 "  -Q<size>  Set pack-buffer size (default: 1024)",
282 # else
283 "  -q[v]     Enable quasi-parallel profile (output file <program>.qp)",
284 # endif
285 "  -t<num>   Set maximum number of advisory threads per PE (default 32)",
286 "  -o<num>   Set stack chunk size (default 1024)",
287 # ifdef PAR
288 "  -d        Turn on PVM-ish debugging",
289 "  -O        Disable output for performance measurement",
290 # endif /* PAR */
291 # ifdef GRAN  /* ToDo: fill in decent Docu here */
292 "  -b...     All GranSim options start with -b; see GranSim User's Guide for details",
293 # endif
294 "",
295 "Other RTS options may be available for programs compiled a different way.",
296 "The GHC User's Guide has full details.",
297 "",
298 0
299 };
300
301 static __inline__ rtsBool
302 strequal(const char *a, const char * b)
303 {
304     return(strcmp(a, b) == 0);
305 }
306
307 void
308 setupRtsFlags(int *argc, char *argv[], int *rts_argc, char *rts_argv[])
309 {
310     rtsBool error = rtsFalse;
311     I_ mode;
312     I_ arg, total_arg;
313     char *last_slash;
314
315     /* Remove directory from argv[0] -- default files in current directory */
316
317     if ((last_slash = (char *) strrchr(argv[0], '/')) != NULL)
318         strcpy(argv[0], last_slash+1);
319
320     /* Split arguments (argv) into PGM (argv) and RTS (rts_argv) parts */
321     /*   argv[0] must be PGM argument -- leave in argv                 */
322
323     total_arg = *argc;
324     arg = 1;
325
326     *argc = 1;
327     *rts_argc = 0;
328
329     for (mode = PGM; arg < total_arg && ! strequal("--RTS", argv[arg]); arg++) {
330         if (strequal("+RTS", argv[arg])) {
331             mode = RTS;
332         }
333         else if (strequal("-RTS", argv[arg])) {
334             mode = PGM;
335         }
336         else if (mode == RTS && *rts_argc < MAX_RTS_ARGS-1) {
337             rts_argv[(*rts_argc)++] = argv[arg];
338         }
339         else if (mode == PGM) {
340             argv[(*argc)++] = argv[arg];
341         }
342         else {
343           barf("too many RTS arguments (max %d)", MAX_RTS_ARGS-1);
344         }
345     }
346     if (arg < total_arg) {
347         /* arg must be --RTS; process remaining program arguments */
348         while (++arg < total_arg) {
349             argv[(*argc)++] = argv[arg];
350         }
351     }
352     argv[*argc] = (char *) 0;
353     rts_argv[*rts_argc] = (char *) 0;
354
355     /* Process RTS (rts_argv) part: mainly to determine statsfile */
356
357     for (arg = 0; arg < *rts_argc; arg++) {
358         if (rts_argv[arg][0] != '-') {
359             fflush(stdout);
360             fprintf(stderr, "setupRtsFlags: Unexpected RTS argument: %s\n",
361                     rts_argv[arg]);
362             error = rtsTrue;
363
364         } else {
365             switch(rts_argv[arg][1]) {
366
367               /* process: general args, then PROFILING-only ones,
368                  then CONCURRENT-only, PARallel-only, GRAN-only,
369                  TICKY-only (same order as defined in RtsFlags.lh);
370                  within those groups, mostly in case-insensitive
371                  alphabetical order.
372               */
373
374 #ifdef TICKY_TICKY
375 # define TICKY_BUILD_ONLY(x) x
376 #else
377 # define TICKY_BUILD_ONLY(x) \
378 fprintf(stderr, "setupRtsFlags: GHC not built for: ticky-ticky stats\n"); \
379 error = rtsTrue;
380 #endif
381
382 #if defined(PROFILING) 
383 # define COST_CENTRE_USING_BUILD_ONLY(x) x
384 #else
385 # define COST_CENTRE_USING_BUILD_ONLY(x) \
386 fprintf(stderr, "setupRtsFlags: GHC not built for: -prof or -parallel\n"); \
387 error = rtsTrue;
388 #endif
389
390 #ifdef PROFILING
391 # define PROFILING_BUILD_ONLY(x)   x
392 #else
393 # define PROFILING_BUILD_ONLY(x) \
394 fprintf(stderr, "setupRtsFlags: GHC not built for: -prof\n"); \
395 error = rtsTrue;
396 #endif
397
398 #ifdef PAR
399 # define PAR_BUILD_ONLY(x)      x
400 #else
401 # define PAR_BUILD_ONLY(x) \
402 fprintf(stderr, "setupRtsFlags: GHC not built for: -parallel\n"); \
403 error = rtsTrue;
404 #endif
405
406 #ifdef GRAN
407 # define GRAN_BUILD_ONLY(x)     x
408 #else
409 # define GRAN_BUILD_ONLY(x) \
410 fprintf(stderr, "setupRtsFlags: GHC not built for: -gransim\n"); \
411 error = rtsTrue;
412 #endif
413
414               /* =========== GENERAL ========================== */
415               case '?':
416               case 'f':
417                 error = rtsTrue;
418                 break;
419
420               case 'A':
421                 RtsFlags.GcFlags.minAllocAreaSize
422                   = decode(rts_argv[arg]+2) / BLOCK_SIZE;
423                 if (RtsFlags.GcFlags.minAllocAreaSize <= 0) {
424                   bad_option(rts_argv[arg]);
425                 }
426                 break;
427
428               case 'B':
429                 RtsFlags.GcFlags.ringBell = rtsTrue;
430                 break;
431
432               case 'F':
433                 RtsFlags.GcFlags.oldGenFactor = atof(rts_argv[arg]+2);
434               
435                 if (RtsFlags.GcFlags.oldGenFactor < 0)
436                   bad_option( rts_argv[arg] );
437                 break;
438               
439 #ifdef DEBUG
440               case 'D':
441                 /* hack warning: interpret the flags as a binary number */
442                 *(int*)(&RtsFlags.DebugFlags) = decode(rts_argv[arg]+2);
443                 break;
444 #endif
445
446               case 'K':
447                 RtsFlags.GcFlags.maxStkSize = 
448                   decode(rts_argv[arg]+2) / sizeof(W_);
449
450                 if (RtsFlags.GcFlags.maxStkSize == 0) 
451                   bad_option( rts_argv[arg] );
452                 break;
453
454               case 'k':
455                 RtsFlags.GcFlags.initialStkSize = 
456                   decode(rts_argv[arg]+2) / sizeof(W_);
457
458                 if (RtsFlags.GcFlags.initialStkSize == 0) 
459                   bad_option( rts_argv[arg] );
460                 break;
461
462               case 'M':
463                 RtsFlags.GcFlags.maxHeapSize = 
464                   decode(rts_argv[arg]+2) / BLOCK_SIZE;
465                 /* user give size in *bytes* but "maxHeapSize" is in *blocks* */
466
467                 if (RtsFlags.GcFlags.maxHeapSize <= 0) {
468                   bad_option(rts_argv[arg]);
469                 }
470                 break;
471
472               case 'm':
473                 RtsFlags.GcFlags.pcFreeHeap = atof(rts_argv[arg]+2);
474
475                 if (RtsFlags.GcFlags.pcFreeHeap < 0 || 
476                     RtsFlags.GcFlags.pcFreeHeap > 100)
477                   bad_option( rts_argv[arg] );
478                 break;
479
480               case 'G':
481                 RtsFlags.GcFlags.generations = decode(rts_argv[arg]+2);
482                 if (RtsFlags.GcFlags.generations < 1) {
483                   bad_option(rts_argv[arg]);
484                 }
485                 break;
486
487               case 'T':
488                 RtsFlags.GcFlags.steps = decode(rts_argv[arg]+2);
489                 if (RtsFlags.GcFlags.steps < 1) {
490                   bad_option(rts_argv[arg]);
491                 }
492                 break;
493
494               case 'H':
495                 /* ignore for compatibility with older versions */
496                 break;
497
498               case 'j': /* force GC option */
499                 RtsFlags.GcFlags.forceGC = rtsTrue;
500                 if (rts_argv[arg][2]) {
501                     RtsFlags.GcFlags.forcingInterval
502                         = decode(rts_argv[arg]+2) / sizeof(W_);
503                 }
504                 break;
505
506               case 'S': /* NB: no difference at present ! */
507               case 's':
508                 RtsFlags.GcFlags.giveStats ++; /* will be VERBOSE_GC_STATS */
509 #ifdef PAR
510                 /* Opening all those files would almost certainly fail... */
511                 RtsFlags.ParFlags.parallelStats = rtsTrue;
512                 RtsFlags.GcFlags.statsFile = stderr; /* temporary; ToDo: rm */
513 #else
514                 RtsFlags.GcFlags.statsFile
515                   = open_stats_file(arg, *argc, argv,
516                         *rts_argc, rts_argv, STAT_FILENAME_FMT);
517
518                 if (RtsFlags.GcFlags.statsFile == NULL) error = rtsTrue;
519 #endif
520                 break;
521
522               case 'Z':
523                 RtsFlags.GcFlags.squeezeUpdFrames = rtsFalse;
524                 break;
525
526               /* =========== PROFILING ========================== */
527
528               case 'P': /* detailed cost centre profiling (time/alloc) */
529                 COST_CENTRE_USING_BUILD_ONLY(
530                 RtsFlags.CcFlags.doCostCentres++;
531                 )
532               case 'p': /* cost centre profiling (time/alloc) */
533                 COST_CENTRE_USING_BUILD_ONLY(
534                 RtsFlags.CcFlags.doCostCentres++;
535
536                 switch (rts_argv[arg][2]) {
537                   case SORTCC_LABEL:
538                   case SORTCC_TIME:
539                   case SORTCC_ALLOC:
540                         RtsFlags.CcFlags.sortBy = rts_argv[arg][2];
541                     break;
542                   default:
543                         RtsFlags.CcFlags.sortBy = SORTCC_TIME;
544                     break;
545                 }
546                 ) break;
547
548               case 'i': /* serial profiling -- initial timer interval */
549                 COST_CENTRE_USING_BUILD_ONLY(
550                 interval_ticks = (I_) ((atof(rts_argv[arg]+2) * TICK_FREQUENCY));
551                 if (interval_ticks <= 0)
552                     interval_ticks = 1;
553                 ) break;
554
555               case 'h': /* serial heap profile */
556 #if !defined(PROFILING) && defined(DEBUG)
557                 switch (rts_argv[arg][2]) {
558                   case '\0':
559                   case 'L':
560                     RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_INFOPTR;
561                     break;
562                   case 'T':
563                     RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_CLOSURE_TYPE;
564                     break;
565                   default:
566                     fprintf(stderr, "Invalid heap profile option: %s\n",
567                             rts_argv[arg]);
568                     error = rtsTrue;
569                 }
570 #else
571                 PROFILING_BUILD_ONLY(
572                 switch (rts_argv[arg][2]) {
573                   case '\0':
574                   case CCchar:
575                     RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_CC;
576                     break;
577                   case MODchar:
578                     RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_MOD;
579                     break;
580                   case GRPchar:
581                     RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_GRP;
582                     break;
583                   case DESCRchar:
584                     RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_DESCR;
585                     break;
586                   case TYPEchar:
587                     RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_TYPE;
588                     break;
589                   case TIMEchar:
590                     RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_TIME;
591                     if (rts_argv[arg][3]) {
592                         char *start_str = strchr(rts_argv[arg]+3, ',');
593                         I_ intervals;
594                         if (start_str) *start_str = '\0';
595
596                         if ((intervals = decode(rts_argv[arg]+3)) != 0) {
597                             time_intervals = (hash_t) intervals;
598                             /* ToDo: and what if it *is* zero intervals??? */
599                         }
600                         if (start_str) {
601                             earlier_ticks = (I_)((atof(start_str + 1) * TICK_FREQUENCY));
602                         }
603                     }
604                     break;
605                   default:
606                     fprintf(stderr, "Invalid heap profile option: %s\n",
607                             rts_argv[arg]);
608                     error = rtsTrue;
609                 }
610                 ) 
611 #endif
612                 break;
613
614               case 'z': /* size of index tables */
615                 PROFILING_BUILD_ONLY(
616                 switch (rts_argv[arg][2]) {
617                   case CCchar:
618                     max_cc_no = (hash_t) decode(rts_argv[arg]+3);
619                     if (max_cc_no == 0) {
620                         fprintf(stderr, "Bad number of cost centres %s\n", rts_argv[arg]);
621                         error = rtsTrue;
622                     }
623                     break;
624                   case MODchar:
625                     max_mod_no = (hash_t) decode(rts_argv[arg]+3);
626                     if (max_mod_no == 0) {
627                         fprintf(stderr, "Bad number of modules %s\n", rts_argv[arg]);
628                         error = rtsTrue;
629                     }
630                     break;
631                   case GRPchar:
632                     max_grp_no = (hash_t) decode(rts_argv[arg]+3);
633                     if (max_grp_no == 0) {
634                         fprintf(stderr, "Bad number of groups %s\n", rts_argv[arg]);
635                         error = rtsTrue;
636                     }
637                     break;
638                   case DESCRchar:
639                     max_descr_no = (hash_t) decode(rts_argv[arg]+3);
640                     if (max_descr_no == 0) {
641                         fprintf(stderr, "Bad number of closure descriptions %s\n", rts_argv[arg]);
642                         error = rtsTrue;
643                     }
644                     break;
645                   case TYPEchar:
646                     max_type_no = (hash_t) decode(rts_argv[arg]+3);
647                     if (max_type_no == 0) {
648                         fprintf(stderr, "Bad number of type descriptions %s\n", rts_argv[arg]);
649                         error = rtsTrue;
650                     }
651                     break;
652                   default:
653                     fprintf(stderr, "Invalid index table size option: %s\n",
654                             rts_argv[arg]);
655                     error = rtsTrue;
656                 }
657                 ) break;
658
659               case 'c': /* cost centre label select */
660               case 'g': /* cost centre group select */
661               case 'd': /* closure descr select */
662               case 'y': /* closure type select */
663                 PROFILING_BUILD_ONLY(
664                 {char *left  = strchr(rts_argv[arg], '{');
665                  char *right = strrchr(rts_argv[arg], '}');
666
667                 if (! left || ! right ||
668                         strrchr(rts_argv[arg], '{') != left ||
669                          strchr(rts_argv[arg], '}') != right) {
670                     fprintf(stderr, "Invalid heap profiling selection bracketing\n   %s\n", rts_argv[arg]);
671                     error = rtsTrue;
672                 } else {
673                     *right = '\0';
674                     switch (rts_argv[arg][1]) {
675                       case 'c': /* cost centre label select */
676                         RtsFlags.ProfFlags.ccSelector = left + 1;
677                         break;
678                       case 'm': /* cost centre module select */
679                         RtsFlags.ProfFlags.modSelector = left + 1;
680                         break;
681                       case 'g': /* cost centre group select */
682                         RtsFlags.ProfFlags.grpSelector = left + 1;
683                         break;
684                       case 'd': /* closure descr select */
685                         RtsFlags.ProfFlags.descrSelector = left + 1;
686                         break;
687                       case 'y': /* closure type select */
688                         RtsFlags.ProfFlags.typeSelector = left + 1;
689                         break;
690                       case 'k': /* closure kind select */
691                         RtsFlags.ProfFlags.kindSelector = left + 1;
692                         break;
693                     }
694                 }}
695                 ) break;
696
697               /* =========== CONCURRENT ========================= */
698               case 'C': /* context switch interval */
699                 if (rts_argv[arg][2] == '\0')
700                     RtsFlags.ConcFlags.ctxtSwitchTime = 0;
701                 else {
702                     I_ cst; /* tmp */
703
704                     /* Convert to milliseconds */
705                     cst = (I_) ((atof(rts_argv[arg]+2) * 1000));
706                     cst = (cst / CS_MIN_MILLISECS) * CS_MIN_MILLISECS;
707                     if (cst < CS_MIN_MILLISECS)
708                         cst = CS_MIN_MILLISECS;
709
710                     RtsFlags.ConcFlags.ctxtSwitchTime = cst;
711                 }
712                 break;
713
714               case 't':
715                 if (rts_argv[arg][2] != '\0') {
716                     RtsFlags.ConcFlags.maxThreads
717                       = strtol(rts_argv[arg]+2, (char **) NULL, 10);
718                 } else {
719                     fprintf(stderr, "setupRtsFlags: missing size for -t\n");
720                     error = rtsTrue;
721                 }
722                 break;
723
724               /* =========== PARALLEL =========================== */
725               case 'e':
726                 PAR_BUILD_ONLY(
727                 if (rts_argv[arg][2] != '\0') { /* otherwise, stick w/ the default */
728
729                     RtsFlags.ParFlags.maxLocalSparks
730                       = strtol(rts_argv[arg]+2, (char **) NULL, 10);
731
732                     if (RtsFlags.ParFlags.maxLocalSparks <= 0) {
733                         fprintf(stderr, "setupRtsFlags: bad value for -e\n");
734                         error = rtsTrue;
735                     }
736                 }
737                 ) break;
738
739               case 'O':
740                 PAR_BUILD_ONLY(
741                 RtsFlags.ParFlags.outputDisabled = rtsTrue;
742                 ) break;
743
744               case 'q': /* activity profile option */
745                 PAR_BUILD_ONLY(
746                 if (rts_argv[arg][2] == 'b')
747                     RtsFlags.ParFlags.granSimStats_Binary = rtsTrue;
748                 else
749                     RtsFlags.ParFlags.granSimStats = rtsTrue;
750                 ) break;
751
752 #if 0 /* or??? */
753               case 'q': /* quasi-parallel profile option */
754                 GRAN_BUILD_ONLY (
755                 if (rts_argv[arg][2] == 'v')
756                     do_qp_prof = 2;
757                 else
758                     do_qp_prof++;
759                 ) break;
760 #endif /* 0??? */
761
762               case 'Q': /* Set pack buffer size */
763                 PAR_BUILD_ONLY(
764                 if (rts_argv[arg][2] != '\0') {
765                     RtsFlags.ParFlags.packBufferSize = decode(rts_argv[arg]+2);
766                 } else {
767                     fprintf(stderr, "setupRtsFlags: missing size of PackBuffer (for -Q)\n");
768                     error = rtsTrue;
769                 }
770                 ) break;
771
772               /* =========== GRAN =============================== */
773
774               case 'b':
775                 GRAN_BUILD_ONLY(
776                 process_gran_option(arg, rts_argc, rts_argv, &error);
777                 ) break;
778
779               /* =========== TICKY ============================== */
780
781               case 'r': /* Basic profiling stats */
782                 TICKY_BUILD_ONLY(
783
784                 RtsFlags.TickyFlags.showTickyStats = rtsTrue;
785                 RtsFlags.TickyFlags.tickyFile
786                   = open_stats_file(arg, *argc, argv,
787                         *rts_argc, rts_argv, TICKY_FILENAME_FMT);
788
789                 if (RtsFlags.TickyFlags.tickyFile == NULL) error = rtsTrue;
790                 ) break;
791
792               /* =========== OH DEAR ============================ */
793               default:
794                 fprintf(stderr, "setupRtsFlags: Unknown RTS option: %s\n",rts_argv[arg]);
795                 error = rtsTrue;
796                 break;
797             }
798         }
799     }
800     if (error) {
801         const char **p;
802
803         fflush(stdout);
804         for (p = usage_text; *p; p++)
805             fprintf(stderr, "%s\n", *p);
806         stg_exit(EXIT_FAILURE);
807     }
808
809 }
810
811 static FILE *           /* return NULL on error */
812 open_stats_file (
813     I_ arg,
814     int argc, char *argv[],
815     int rts_argc, char *rts_argv[],
816     const char *FILENAME_FMT)
817 {
818     FILE *f = NULL;
819
820     if (strequal(rts_argv[arg]+2, "stderr")) /* use real stderr */
821         f = stderr;
822     else if (rts_argv[arg][2] != '\0')      /* stats file specified */
823         f = fopen(rts_argv[arg]+2,"w");
824     else {
825         char stats_filename[STATS_FILENAME_MAXLEN]; /* default <program>.<ext> */
826         sprintf(stats_filename, FILENAME_FMT, argv[0]);
827         f = fopen(stats_filename,"w");
828     }
829     if (f == NULL) {
830         fprintf(stderr, "Can't open stats file %s\n", rts_argv[arg]+2);
831     } else {
832         /* Write argv and rtsv into start of stats file */
833         I_ count;
834         for(count = 0; count < argc; count++)
835             fprintf(f, "%s ", argv[count]);
836         fprintf(f, "+RTS ");
837         for(count = 0; count < rts_argc; count++)
838             fprintf(f, "%s ", rts_argv[count]);
839         fprintf(f, "\n");
840     }
841
842     return(f);
843 }
844
845 static I_
846 decode(const char *s)
847 {
848     I_ c;
849     StgDouble m;
850
851     if (!*s)
852         return 0;
853
854     m = atof(s);
855     c = s[strlen(s)-1];
856
857     if (c == 'g' || c == 'G')
858         m *= 1000*1000*1000;    /* UNchecked! */
859     else if (c == 'm' || c == 'M')
860         m *= 1000*1000;                 /* We do not use powers of 2 (1024) */
861     else if (c == 'k' || c == 'K')      /* to avoid possible bad effects on */
862         m *= 1000;                      /* a direct-mapped cache.           */ 
863     else if (c == 'w' || c == 'W')
864         m *= sizeof(W_);
865
866     return (I_)m;
867 }
868
869 static void
870 bad_option(const char *s)
871 {
872   fflush(stdout);
873   fprintf(stderr, "initSM: Bad RTS option: %s\n", s);
874   stg_exit(EXIT_FAILURE);
875 }