static FILE * open_stats_file (I_ arg,
int argc, char *argv[], int rts_argc, char *rts_argv[],
const char *FILENAME_FMT);
+#ifdef GRAN
+static void process_gran_option(int arg,
+ int *rts_argc, char *rts_argv[], rtsBool *error);
+#endif
/* extern decls */
long strtol PROTO((const char *, char **, int));
#endif /* PROFILING or PAR */
#ifdef PROFILING
- RTSflags.ProfFlags.doHeapProfile = rtsFalse;
+ RTSflags.ProfFlags.doHeapProfile = rtsFalse;
+
+ RTSflags.ProfFlags.ccSelector = NULL;
+ RTSflags.ProfFlags.modSelector = NULL;
+ RTSflags.ProfFlags.grpSelector = NULL;
+ RTSflags.ProfFlags.descrSelector = NULL;
+ RTSflags.ProfFlags.typeSelector = NULL;
+ RTSflags.ProfFlags.kindSelector = NULL;
#endif /* PROFILING */
#ifdef CONCURRENT
RTSflags.ParFlags.packBufferSize = 1024;
#endif /* PAR */
+#ifdef GRAN
+ RTSflags.GranFlags.granSimStats = rtsFalse;
+ RTSflags.GranFlags.granSimStats_suppressed = rtsFalse;
+ RTSflags.GranFlags.granSimStats_Binary = rtsFalse;
+ RTSflags.GranFlags.granSimStats_Sparks = rtsFalse;
+ RTSflags.GranFlags.granSimStats_Heap = rtsFalse;
+ RTSflags.GranFlags.labelling = rtsFalse;
+ RTSflags.GranFlags.packBufferSize = 1024;
+ RTSflags.GranFlags.packBufferSize_internal = GRANSIM_DEFAULT_PACK_BUFFER_SIZE;
+
+ RTSflags.GranFlags.proc = MAX_PROC;
+ RTSflags.GranFlags.max_fishes = MAX_FISHES;
+ RTSflags.GranFlags.time_slice = GRAN_TIME_SLICE;
+ RTSflags.GranFlags.Light = rtsFalse;
+
+ RTSflags.GranFlags.gran_latency = LATENCY;
+ RTSflags.GranFlags.gran_additional_latency = ADDITIONAL_LATENCY;
+ RTSflags.GranFlags.gran_fetchtime = FETCHTIME;
+ RTSflags.GranFlags.gran_lunblocktime = LOCALUNBLOCKTIME;
+ RTSflags.GranFlags.gran_gunblocktime = GLOBALUNBLOCKTIME;
+ RTSflags.GranFlags.gran_mpacktime = MSGPACKTIME;
+ RTSflags.GranFlags.gran_munpacktime = MSGUNPACKTIME;
+ RTSflags.GranFlags.gran_mtidytime = MSGTIDYTIME;
+
+ RTSflags.GranFlags.gran_threadcreatetime = THREADCREATETIME;
+ RTSflags.GranFlags.gran_threadqueuetime = THREADQUEUETIME;
+ RTSflags.GranFlags.gran_threaddescheduletime = THREADDESCHEDULETIME;
+ RTSflags.GranFlags.gran_threadscheduletime = THREADSCHEDULETIME;
+ RTSflags.GranFlags.gran_threadcontextswitchtime = THREADCONTEXTSWITCHTIME;
+
+ RTSflags.GranFlags.gran_arith_cost = ARITH_COST;
+ RTSflags.GranFlags.gran_branch_cost = BRANCH_COST;
+ RTSflags.GranFlags.gran_load_cost = LOAD_COST;
+ RTSflags.GranFlags.gran_store_cost = STORE_COST;
+ RTSflags.GranFlags.gran_float_cost = FLOAT_COST;
+
+ RTSflags.GranFlags.gran_heapalloc_cost = HEAPALLOC_COST;
+
+ RTSflags.GranFlags.gran_pri_spark_overhead = PRI_SPARK_OVERHEAD;
+ RTSflags.GranFlags.gran_pri_sched_overhead = PRI_SCHED_OVERHEAD;
+
+ RTSflags.GranFlags.DoFairSchedule = rtsFalse;
+ RTSflags.GranFlags.DoReScheduleOnFetch = rtsFalse;
+ RTSflags.GranFlags.DoStealThreadsFirst = rtsFalse;
+ RTSflags.GranFlags.SimplifiedFetch = rtsFalse;
+ RTSflags.GranFlags.DoAlwaysCreateThreads = rtsFalse;
+ RTSflags.GranFlags.DoGUMMFetching = rtsFalse;
+ RTSflags.GranFlags.DoThreadMigration = rtsFalse;
+ RTSflags.GranFlags.FetchStrategy = 2;
+ RTSflags.GranFlags.PreferSparksOfLocalNodes = rtsFalse;
+ RTSflags.GranFlags.DoPrioritySparking = rtsFalse;
+ RTSflags.GranFlags.DoPriorityScheduling = rtsFalse;
+ RTSflags.GranFlags.SparkPriority = 0;
+ RTSflags.GranFlags.SparkPriority2 = 0;
+ RTSflags.GranFlags.RandomPriorities = rtsFalse;
+ RTSflags.GranFlags.InversePriorities = rtsFalse;
+ RTSflags.GranFlags.IgnorePriorities = rtsFalse;
+ RTSflags.GranFlags.ThunksToPack = 0;
+ RTSflags.GranFlags.RandomSteal = rtsTrue;
+ RTSflags.GranFlags.NoForward = rtsFalse;
+ RTSflags.GranFlags.PrintFetchMisses = rtsFalse;
+
+ RTSflags.GranFlags.debug = 0x0;
+ RTSflags.GranFlags.event_trace = rtsFalse;
+ RTSflags.GranFlags.event_trace_all = rtsFalse;
+#endif
+
#ifdef TICKY_TICKY
RTSflags.TickyFlags.showTickyStats = rtsFalse;
RTSflags.TickyFlags.tickyFile = NULL;
" -p<sort> Produce cost centre time profile (output file <program>.prof)",
" sort: T = time (default), A = alloc, C = cost centre label",
" -P<sort> Produce serial time profile (output file <program>.time)",
-" and a -p profile with detailed caf/enter/tick/alloc info",
+" and a -p profile with detailed tick/alloc info",
# if defined(PROFILING)
"",
" -h<break-down> Heap residency profile (output file <program>.hp)",
" -d Turn on PVM-ish debugging",
" -O Disable output for performance measurement",
# endif /* PAR */
+# ifdef GRAN /* ToDo: fill in decent Docu here */
+" -b... All GranSim options start with -b; see GranSim User's Guide for details",
+# endif
#endif /* CONCURRENT */
"",
"Other RTS options may be available for programs compiled a different way.",
#endif
#ifdef PROFILING
-# define PROFILING_BUILD_ONLY(x)
+# define PROFILING_BUILD_ONLY(x) x
#else
# define PROFILING_BUILD_ONLY(x) \
fprintf(stderr, "setupRtsFlags: GHC not built for: -prof\n"); \
#endif
#ifdef CONCURRENT
-# define CONCURRENT_BUILD_ONLY(x)
+# define CONCURRENT_BUILD_ONLY(x) x
#else
# define CONCURRENT_BUILD_ONLY(x) \
fprintf(stderr, "setupRtsFlags: GHC not built for: -concurrent\n"); \
#endif
#ifdef PAR
-# define PAR_BUILD_ONLY(x)
+# define PAR_BUILD_ONLY(x) x
#else
# define PAR_BUILD_ONLY(x) \
fprintf(stderr, "setupRtsFlags: GHC not built for: -parallel\n"); \
#endif
#ifdef GRAN
-# define GRAN_BUILD_ONLY(x)
+# define GRAN_BUILD_ONLY(x) x
#else
# define GRAN_BUILD_ONLY(x) \
fprintf(stderr, "setupRtsFlags: GHC not built for: -gransim\n"); \
)
case 'p': /* cost centre profiling (time/alloc) */
COST_CENTRE_USING_BUILD_ONLY(
- { char ch;
RTSflags.CcFlags.doCostCentres++;
- for (ch = 2; rts_argv[arg][ch]; ch++) {
switch (rts_argv[arg][2]) {
case SORTCC_LABEL:
case SORTCC_TIME:
case SORTCC_ALLOC:
- RTSflags.CcFlags.sortBy = rts_argv[arg][ch];
+ RTSflags.CcFlags.sortBy = rts_argv[arg][2];
break;
default:
+ PAR_BUILD_ONLY(
+ break; /* we do not care about sortBy for parallel */
+ )
+ PROFILING_BUILD_ONLY(
fprintf(stderr, "Invalid profiling sort option %s\n", rts_argv[arg]);
- error = 1;
- }}}
+ error = rtsTrue;
+ )
+ }
) break;
case 'i': /* serial profiling -- initial timer interval */
default:
fprintf(stderr, "Invalid heap profile option: %s\n",
rts_argv[arg]);
- error = 1;
+ error = rtsTrue;
}
) break;
max_cc_no = (hash_t) decode(rts_argv[arg]+3);
if (max_cc_no == 0) {
fprintf(stderr, "Bad number of cost centres %s\n", rts_argv[arg]);
- error = 1;
+ error = rtsTrue;
}
break;
case MODchar:
max_mod_no = (hash_t) decode(rts_argv[arg]+3);
if (max_mod_no == 0) {
fprintf(stderr, "Bad number of modules %s\n", rts_argv[arg]);
- error = 1;
+ error = rtsTrue;
}
break;
case GRPchar:
max_grp_no = (hash_t) decode(rts_argv[arg]+3);
if (max_grp_no == 0) {
fprintf(stderr, "Bad number of groups %s\n", rts_argv[arg]);
- error = 1;
+ error = rtsTrue;
}
break;
case DESCRchar:
max_descr_no = (hash_t) decode(rts_argv[arg]+3);
if (max_descr_no == 0) {
fprintf(stderr, "Bad number of closure descriptions %s\n", rts_argv[arg]);
- error = 1;
+ error = rtsTrue;
}
break;
case TYPEchar:
max_type_no = (hash_t) decode(rts_argv[arg]+3);
if (max_type_no == 0) {
fprintf(stderr, "Bad number of type descriptions %s\n", rts_argv[arg]);
- error = 1;
+ error = rtsTrue;
}
break;
default:
fprintf(stderr, "Invalid index table size option: %s\n",
rts_argv[arg]);
- error = 1;
+ error = rtsTrue;
}
) break;
case 'y': /* closure type select */
case 'k': /* closure kind select */
PROFILING_BUILD_ONLY(
+ {char *left = strchr(rts_argv[arg], '{');
+ char *right = strrchr(rts_argv[arg], '}');
- left = strchr(rts_argv[arg], '{');
- right = strrchr(rts_argv[arg], '}');
if (! left || ! right ||
strrchr(rts_argv[arg], '{') != left ||
strchr(rts_argv[arg], '}') != right) {
fprintf(stderr, "Invalid heap profiling selection bracketing\n %s\n", rts_argv[arg]);
- error = 1;
+ error = rtsTrue;
} else {
*right = '\0';
switch (rts_argv[arg][1]) {
case 'c': /* cost centre label select */
- select_cc = left + 1;
+ RTSflags.ProfFlags.ccSelector = left + 1;
break;
case 'm': /* cost centre module select */
- select_mod = left + 1;
+ RTSflags.ProfFlags.modSelector = left + 1;
break;
case 'g': /* cost centre group select */
- select_grp = left + 1;
+ RTSflags.ProfFlags.grpSelector = left + 1;
break;
case 'd': /* closure descr select */
- select_descr = left + 1;
+ RTSflags.ProfFlags.descrSelector = left + 1;
break;
case 't': /* closure type select */
- select_type = left + 1;
+ RTSflags.ProfFlags.typeSelector = left + 1;
break;
case 'k': /* closure kind select */
- select_kind = left + 1;
+ RTSflags.ProfFlags.kindSelector = left + 1;
break;
- }
- }
+ }
+ }}
) break;
/* =========== CONCURRENT ========================= */
case 'b':
GRAN_BUILD_ONLY(
- process_gran_option();
+ process_gran_option(arg, rts_argc, rts_argv, &error);
) break;
/* =========== TICKY ============================== */
}
-#ifdef GRAN
+#if defined(GRAN)
+void
+enable_GrAnSimLight() {
+
+ fprintf(stderr,"GrAnSim Light enabled (infinite number of processors; 0 communication costs)\n");
+ RTSflags.GranFlags.Light=rtsTrue;
+ RTSflags.GranFlags.gran_latency =
+ RTSflags.GranFlags.gran_fetchtime =
+ RTSflags.GranFlags.gran_additional_latency =
+ RTSflags.GranFlags.gran_gunblocktime =
+ RTSflags.GranFlags.gran_lunblocktime =
+ RTSflags.GranFlags.gran_threadcreatetime =
+ RTSflags.GranFlags.gran_threadqueuetime =
+ RTSflags.GranFlags.gran_threadscheduletime =
+ RTSflags.GranFlags.gran_threaddescheduletime =
+ RTSflags.GranFlags.gran_threadcontextswitchtime = 0;
+
+ RTSflags.GranFlags.gran_mpacktime =
+ RTSflags.GranFlags.gran_munpacktime = 0;
+
+ RTSflags.GranFlags.DoFairSchedule = rtsTrue;
+ RTSflags.GranFlags.DoReScheduleOnFetch = rtsFalse;
+ RTSflags.GranFlags.DoAlwaysCreateThreads = rtsTrue;
+ /* FetchStrategy is irrelevant in GrAnSim-Light */
+
+ /* GrAnSim Light often creates an abundance of parallel threads,
+ each with its own stack etc. Therefore, it's in general a good
+ idea to use small stack chunks (use the -o<size> option to
+ increase it again).
+ */
+ RTSflags.ConcFlags.stkChunkSize = 100;
+
+ RTSflags.GranFlags.proc = 1;
+}
+
static void
-process_gran_option()
+process_gran_option(int arg, int *rts_argc, char *rts_argv[], rtsBool *error)
{
- if (rts_argv[arg][2] != '\0') {
+ if (rts_argv[arg][1] != 'b') /* All GranSim options start with -b */
+ return;
/* Should we emulate hbcpp */
- if(strequal((rts_argv[arg]+2),"roken")) {
- ++DoAlwaysCreateThreads;
+ if(strcmp((rts_argv[arg]+2),"roken")==0) {
+ RTSflags.GranFlags.DoAlwaysCreateThreads=rtsTrue;
strcpy(rts_argv[arg]+2,"oring");
}
/* or a ridiculously idealised simulator */
- if(strequal((rts_argv[arg]+2),"oring")) {
- gran_latency = gran_fetchtime = gran_additional_latency =
- gran_gunblocktime = gran_lunblocktime
- = gran_threadcreatetime = gran_threadqueuetime
- = gran_threadscheduletime = gran_threaddescheduletime
- = gran_threadcontextswitchtime
- = 0;
-
- gran_mpacktime = gran_munpacktime = 0;
-
- gran_arith_cost = gran_float_cost = gran_load_cost
- = gran_store_cost = gran_branch_cost = 0;
-
- gran_heapalloc_cost = 1;
-
- /* ++DoFairSchedule; */
- ++DoStealThreadsFirst;
- ++DoThreadMigration;
- RTSflags.ParFlags.granSimStats = rtsTrue;
+ if(strcmp((rts_argv[arg]+2),"oring")==0) {
+ RTSflags.GranFlags.gran_latency =
+ RTSflags.GranFlags.gran_fetchtime =
+ RTSflags.GranFlags.gran_additional_latency =
+ RTSflags.GranFlags.gran_gunblocktime =
+ RTSflags.GranFlags.gran_lunblocktime =
+ RTSflags.GranFlags.gran_threadcreatetime =
+ RTSflags.GranFlags.gran_threadqueuetime =
+ RTSflags.GranFlags.gran_threadscheduletime =
+ RTSflags.GranFlags.gran_threaddescheduletime =
+ RTSflags.GranFlags.gran_threadcontextswitchtime = 0;
+
+ RTSflags.GranFlags.gran_mpacktime =
+ RTSflags.GranFlags.gran_munpacktime = 0;
+
+ RTSflags.GranFlags.gran_arith_cost =
+ RTSflags.GranFlags.gran_float_cost =
+ RTSflags.GranFlags.gran_load_cost =
+ RTSflags.GranFlags.gran_store_cost =
+ RTSflags.GranFlags.gran_branch_cost = 0;
+
+ RTSflags.GranFlags.gran_heapalloc_cost = 1;
+
+ /* ++RTSflags.GranFlags.DoFairSchedule; */
+ RTSflags.GranFlags.DoStealThreadsFirst = rtsTrue; /* -bZ */
+ RTSflags.GranFlags.DoThreadMigration = rtsTrue; /* -bM */
+ RTSflags.GranFlags.granSimStats = rtsTrue; /* -bP */
+ return;
}
- /* or a ridiculously idealised simulator */
- if(strequal((rts_argv[arg]+2),"onzo")) {
- gran_latency = gran_fetchtime = gran_additional_latency =
- gran_gunblocktime = gran_lunblocktime
- = gran_threadcreatetime = gran_threadqueuetime
- = gran_threadscheduletime = gran_threaddescheduletime
- = gran_threadcontextswitchtime
- = 0;
-
- gran_mpacktime = gran_munpacktime = 0;
-
- /* Keep default values for these
- gran_arith_cost = gran_float_cost = gran_load_cost
- = gran_store_cost = gran_branch_cost = 0;
- */
-
- gran_heapalloc_cost = 1;
-
- /* ++DoFairSchedule; */ /* -b-R */
- /* ++DoStealThreadsFirst; */ /* -b-T */
- ++DoReScheduleOnFetch; /* -bZ */
- ++DoThreadMigration; /* -bM */
- RTSflags.ParFlags.granSimStats = rtsTrue; /* -bP */
-# if defined(GRAN_CHECK) && defined(GRAN)
- debug = 0x20; /* print event statistics */
-# endif
+ /* or a somewhat idealised simulator */
+ if(strcmp((rts_argv[arg]+2),"onzo")==0) {
+ RTSflags.GranFlags.gran_latency =
+ RTSflags.GranFlags.gran_fetchtime =
+ RTSflags.GranFlags.gran_additional_latency =
+ RTSflags.GranFlags.gran_gunblocktime =
+ RTSflags.GranFlags.gran_lunblocktime =
+ RTSflags.GranFlags.gran_threadcreatetime =
+ RTSflags.GranFlags.gran_threadqueuetime =
+ RTSflags.GranFlags.gran_threadscheduletime =
+ RTSflags.GranFlags.gran_threaddescheduletime =
+ RTSflags.GranFlags.gran_threadcontextswitchtime = 0;
+
+ RTSflags.GranFlags.gran_mpacktime =
+ RTSflags.GranFlags.gran_munpacktime = 0;
+
+ RTSflags.GranFlags.gran_heapalloc_cost = 1;
+
+ /* RTSflags.GranFlags.DoFairSchedule = rtsTrue; */ /* -b-R */
+ /* RTSflags.GranFlags.DoStealThreadsFirst = rtsTrue; */ /* -b-T */
+ RTSflags.GranFlags.DoReScheduleOnFetch = rtsTrue; /* -bZ */
+ RTSflags.GranFlags.DoThreadMigration = rtsTrue; /* -bM */
+ RTSflags.GranFlags.granSimStats = rtsTrue; /* -bP */
+# if defined(GRAN_CHECK) && defined(GRAN)
+ RTSflags.GranFlags.debug = 0x20; /* print event statistics */
+# endif
+ return;
}
/* Communication and task creation cost parameters */
- else switch(rts_argv[arg][2]) {
- case 'l':
+ switch(rts_argv[arg][2]) {
+ case ':':
+ enable_GrAnSimLight(); /* set flags for GrAnSim-Light mode */
+ break;
+
+ case 'l':
if (rts_argv[arg][3] != '\0')
{
- gran_gunblocktime = gran_latency = decode(rts_argv[arg]+3);
- gran_fetchtime = 2* gran_latency;
+ RTSflags.GranFlags.gran_gunblocktime =
+ RTSflags.GranFlags.gran_latency = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_fetchtime = 2*RTSflags.GranFlags.gran_latency;
}
else
- gran_latency = LATENCY;
+ RTSflags.GranFlags.gran_latency = LATENCY;
break;
- case 'a':
+ case 'a':
if (rts_argv[arg][3] != '\0')
- gran_additional_latency = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_additional_latency = decode(rts_argv[arg]+3);
else
- gran_additional_latency = ADDITIONAL_LATENCY;
+ RTSflags.GranFlags.gran_additional_latency = ADDITIONAL_LATENCY;
break;
- case 'm':
+ case 'm':
if (rts_argv[arg][3] != '\0')
- gran_mpacktime = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_mpacktime = decode(rts_argv[arg]+3);
else
- gran_mpacktime = MSGPACKTIME;
+ RTSflags.GranFlags.gran_mpacktime = MSGPACKTIME;
break;
- case 'x':
+ case 'x':
if (rts_argv[arg][3] != '\0')
- gran_mtidytime = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_mtidytime = decode(rts_argv[arg]+3);
else
- gran_mtidytime = 0;
+ RTSflags.GranFlags.gran_mtidytime = 0;
break;
- case 'r':
+ case 'r':
if (rts_argv[arg][3] != '\0')
- gran_munpacktime = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_munpacktime = decode(rts_argv[arg]+3);
else
- gran_munpacktime = MSGUNPACKTIME;
+ RTSflags.GranFlags.gran_munpacktime = MSGUNPACKTIME;
break;
-
- case 'f':
+
+ case 'g':
if (rts_argv[arg][3] != '\0')
- gran_fetchtime = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_fetchtime = decode(rts_argv[arg]+3);
else
- gran_fetchtime = FETCHTIME;
+ RTSflags.GranFlags.gran_fetchtime = FETCHTIME;
break;
-
- case 'n':
+
+ case 'n':
if (rts_argv[arg][3] != '\0')
- gran_gunblocktime = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_gunblocktime = decode(rts_argv[arg]+3);
else
- gran_gunblocktime = GLOBALUNBLOCKTIME;
+ RTSflags.GranFlags.gran_gunblocktime = GLOBALUNBLOCKTIME;
break;
- case 'u':
+ case 'u':
if (rts_argv[arg][3] != '\0')
- gran_lunblocktime = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_lunblocktime = decode(rts_argv[arg]+3);
else
- gran_lunblocktime = LOCALUNBLOCKTIME;
+ RTSflags.GranFlags.gran_lunblocktime = LOCALUNBLOCKTIME;
break;
/* Thread-related metrics */
- case 't':
+ case 't':
if (rts_argv[arg][3] != '\0')
- gran_threadcreatetime = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_threadcreatetime = decode(rts_argv[arg]+3);
else
- gran_threadcreatetime = THREADCREATETIME;
+ RTSflags.GranFlags.gran_threadcreatetime = THREADCREATETIME;
break;
-
- case 'q':
+
+ case 'q':
if (rts_argv[arg][3] != '\0')
- gran_threadqueuetime = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_threadqueuetime = decode(rts_argv[arg]+3);
else
- gran_threadqueuetime = THREADQUEUETIME;
+ RTSflags.GranFlags.gran_threadqueuetime = THREADQUEUETIME;
break;
-
- case 'c':
+
+ case 'c':
if (rts_argv[arg][3] != '\0')
- gran_threadscheduletime = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_threadscheduletime = decode(rts_argv[arg]+3);
else
- gran_threadscheduletime = THREADSCHEDULETIME;
-
- gran_threadcontextswitchtime = gran_threadscheduletime
- + gran_threaddescheduletime;
+ RTSflags.GranFlags.gran_threadscheduletime = THREADSCHEDULETIME;
+
+ RTSflags.GranFlags.gran_threadcontextswitchtime = RTSflags.GranFlags.gran_threadscheduletime
+ + RTSflags.GranFlags.gran_threaddescheduletime;
break;
- case 'd':
+ case 'd':
if (rts_argv[arg][3] != '\0')
- gran_threaddescheduletime = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_threaddescheduletime = decode(rts_argv[arg]+3);
else
- gran_threaddescheduletime = THREADDESCHEDULETIME;
-
- gran_threadcontextswitchtime = gran_threadscheduletime
- + gran_threaddescheduletime;
+ RTSflags.GranFlags.gran_threaddescheduletime = THREADDESCHEDULETIME;
+
+ RTSflags.GranFlags.gran_threadcontextswitchtime = RTSflags.GranFlags.gran_threadscheduletime
+ + RTSflags.GranFlags.gran_threaddescheduletime;
break;
/* Instruction Cost Metrics */
- case 'A':
+ case 'A':
if (rts_argv[arg][3] != '\0')
- gran_arith_cost = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_arith_cost = decode(rts_argv[arg]+3);
else
- gran_arith_cost = ARITH_COST;
+ RTSflags.GranFlags.gran_arith_cost = ARITH_COST;
break;
- case 'F':
+ case 'F':
if (rts_argv[arg][3] != '\0')
- gran_float_cost = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_float_cost = decode(rts_argv[arg]+3);
else
- gran_float_cost = FLOAT_COST;
+ RTSflags.GranFlags.gran_float_cost = FLOAT_COST;
break;
-
- case 'B':
+
+ case 'B':
if (rts_argv[arg][3] != '\0')
- gran_branch_cost = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_branch_cost = decode(rts_argv[arg]+3);
else
- gran_branch_cost = BRANCH_COST;
+ RTSflags.GranFlags.gran_branch_cost = BRANCH_COST;
break;
- case 'L':
+ case 'L':
if (rts_argv[arg][3] != '\0')
- gran_load_cost = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_load_cost = decode(rts_argv[arg]+3);
else
- gran_load_cost = LOAD_COST;
+ RTSflags.GranFlags.gran_load_cost = LOAD_COST;
+ break;
+
+ case 'S':
+ if (rts_argv[arg][3] != '\0')
+ RTSflags.GranFlags.gran_store_cost = decode(rts_argv[arg]+3);
+ else
+ RTSflags.GranFlags.gran_store_cost = STORE_COST;
break;
- case 'S':
+ case 'H':
if (rts_argv[arg][3] != '\0')
- gran_store_cost = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_heapalloc_cost = decode(rts_argv[arg]+3);
else
- gran_store_cost = STORE_COST;
+ RTSflags.GranFlags.gran_heapalloc_cost = 0;
break;
- case 'H':
+ case 'y':
+ RTSflags.GranFlags.DoReScheduleOnFetch = rtsTrue;
+ if (rts_argv[arg][3] != '\0')
+ RTSflags.GranFlags.FetchStrategy = decode(rts_argv[arg]+3);
+ if (RTSflags.GranFlags.FetchStrategy == 0)
+ RTSflags.GranFlags.DoReScheduleOnFetch = rtsFalse;
+ else
+ RTSflags.GranFlags.FetchStrategy = 2; /* default: fetch everything */
+ break;
+
+ case 'K': /* sort overhead (per elem in spark list) */
if (rts_argv[arg][3] != '\0')
- gran_heapalloc_cost = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_pri_spark_overhead = decode(rts_argv[arg]+3);
else
- gran_heapalloc_cost = 0;
+ RTSflags.GranFlags.gran_pri_spark_overhead = PRI_SPARK_OVERHEAD;
+ fprintf(stderr,"Overhead for pri spark: %d (per elem).\n",
+ RTSflags.GranFlags.gran_pri_spark_overhead);
break;
- case 'y':
+ case 'O': /* sort overhead (per elem in spark list) */
if (rts_argv[arg][3] != '\0')
- FetchStrategy = decode(rts_argv[arg]+3);
+ RTSflags.GranFlags.gran_pri_sched_overhead = decode(rts_argv[arg]+3);
else
- FetchStrategy = 4; /* default: fetch everything */
+ RTSflags.GranFlags.gran_pri_sched_overhead = PRI_SCHED_OVERHEAD;
+ fprintf(stderr,"Overhead for pri sched: %d (per elem).\n",
+ RTSflags.GranFlags.gran_pri_sched_overhead);
break;
- /* General Parameters */
- case 'p':
+ /* General Parameters */
+ case 'p':
if (rts_argv[arg][3] != '\0')
{
- max_proc = decode(rts_argv[arg]+3);
- if(max_proc > MAX_PROC || max_proc < 1)
+ RTSflags.GranFlags.proc = decode(rts_argv[arg]+3);
+ if (RTSflags.GranFlags.proc==0) {
+ enable_GrAnSimLight(); /* set flags for GrAnSim-Light mode */
+ } else if (RTSflags.GranFlags.proc > MAX_PROC ||
+ RTSflags.GranFlags.proc < 1)
{
- fprintf(stderr,"setupRtsFlags: no more than %u processors allowed\n", MAX_PROC);
- error = rtsTrue;
+ fprintf(stderr,"setupRtsFlags: no more than %u processors
+allowed\n",
+ MAX_PROC);
+ *error = rtsTrue;
}
}
else
- max_proc = MAX_PROC;
+ RTSflags.GranFlags.proc = MAX_PROC;
break;
- case 'C':
- ++DoAlwaysCreateThreads;
- ++DoThreadMigration;
+ case 'f':
+ if (rts_argv[arg][3] != '\0')
+ RTSflags.GranFlags.max_fishes = decode(rts_argv[arg]+3);
+ else
+ RTSflags.GranFlags.max_fishes = 1;
break;
-
- case 'G':
- ++DoGUMMFetching;
+
+ case 'w':
+ if (rts_argv[arg][3] != '\0')
+ RTSflags.GranFlags.time_slice = decode(rts_argv[arg]+3);
+ else
+ RTSflags.GranFlags.time_slice = GRAN_TIME_SLICE;
break;
-
- case 'M':
- ++DoThreadMigration;
+
+ case 'C':
+ RTSflags.GranFlags.DoAlwaysCreateThreads=rtsTrue;
+ RTSflags.GranFlags.DoThreadMigration=rtsTrue;
break;
- case 'R':
- ++DoFairSchedule;
+ case 'G':
+ fprintf(stderr,"Bulk fetching enabled.\n");
+ RTSflags.GranFlags.DoGUMMFetching=rtsTrue;
break;
-
- case 'T':
- ++DoStealThreadsFirst;
- ++DoThreadMigration;
+
+ case 'M':
+ fprintf(stderr,"Thread migration enabled.\n");
+ RTSflags.GranFlags.DoThreadMigration=rtsTrue;
break;
- case 'Z':
- ++DoReScheduleOnFetch;
+ case 'R':
+ fprintf(stderr,"Fair Scheduling enabled.\n");
+ RTSflags.GranFlags.DoFairSchedule=rtsTrue;
+ break;
+
+ case 'I':
+ fprintf(stderr,"Priority Scheduling enabled.\n");
+ RTSflags.GranFlags.DoPriorityScheduling=rtsTrue;
break;
- case 'z':
- ++SimplifiedFetch;
+ case 'T':
+ RTSflags.GranFlags.DoStealThreadsFirst=rtsTrue;
+ RTSflags.GranFlags.DoThreadMigration=rtsTrue;
+ break;
+
+ case 'Z':
+ RTSflags.GranFlags.DoReScheduleOnFetch=rtsTrue;
+ break;
+
+ case 'z':
+ RTSflags.GranFlags.SimplifiedFetch=rtsTrue;
+ break;
+
+ case 'N':
+ RTSflags.GranFlags.PreferSparksOfLocalNodes=rtsTrue;
+ break;
+
+ case 'b':
+ RTSflags.GranFlags.granSimStats_Binary=rtsTrue;
+ break;
+
+ case 'P':
+ RTSflags.GranFlags.granSimStats=rtsTrue;
break;
- case 'N':
- ++PreferSparksOfLocalNodes;
+ case 's':
+ RTSflags.GranFlags.granSimStats_Sparks=rtsTrue;
break;
- case 'b':
- RTSflags.ParFlags.granSimStats_Binary = rtsTrue;
+ case 'h':
+ RTSflags.GranFlags.granSimStats_Heap=rtsTrue;
break;
- case 'P':
- RTSflags.ParFlags.granSimStats = rtsTrue;
+ case 'U':
+ RTSflags.GranFlags.labelling=rtsTrue;
break;
- case 's':
- ++do_sp_profile;
+ case 'Y': /* syntax: -bY<n>[,<n>] n ... pos int */
+ if (rts_argv[arg][3] != '\0') {
+ char *arg0, *tmp;
+
+ arg0 = rts_argv[arg]+3;
+ if ((tmp = strstr(arg0,","))==NULL) {
+ RTSflags.GranFlags.SparkPriority = decode(arg0);
+ fprintf(stderr,"SparkPriority: %u.\n",RTSflags.GranFlags.SparkPriority);
+ } else {
+ *(tmp++) = '\0';
+ RTSflags.GranFlags.SparkPriority = decode(arg0);
+ RTSflags.GranFlags.SparkPriority2 = decode(tmp);
+ fprintf(stderr,"SparkPriority: %u.\n",
+ RTSflags.GranFlags.SparkPriority);
+ fprintf(stderr,"SparkPriority2:%u.\n",
+ RTSflags.GranFlags.SparkPriority2);
+ if (RTSflags.GranFlags.SparkPriority2 <
+ RTSflags.GranFlags.SparkPriority) {
+ fprintf(stderr,"WARNING: 2nd pri < main pri (%u<%u); 2nd pri has no effect\n",
+ RTSflags.GranFlags.SparkPriority2,
+ RTSflags.GranFlags.SparkPriority);
+ }
+ }
+ } else {
+ /* plain pri spark is now invoked with -bX
+ RTSflags.GranFlags.DoPrioritySparking = 1;
+ fprintf(stderr,"PrioritySparking.\n");
+ */
+ }
break;
- case '-':
+ case 'Q':
+ if (rts_argv[arg][3] != '\0') {
+ RTSflags.GranFlags.ThunksToPack = decode(rts_argv[arg]+3);
+ } else {
+ RTSflags.GranFlags.ThunksToPack = 1;
+ }
+ fprintf(stderr,"Thunks To Pack in one packet: %u.\n",
+ RTSflags.GranFlags.ThunksToPack);
+ break;
+
+ case 'e':
+ RTSflags.GranFlags.RandomSteal = rtsFalse;
+ fprintf(stderr,"Deterministic mode (no random stealing)\n");
+ break;
+
+ /* The following class of options contains eXperimental */
+ /* features in connection with exploiting granularity */
+ /* information. I.e. if -bY is chosen these options */
+ /* tell the RTS what to do with the supplied info --HWL */
+
+ case 'W':
+ if (rts_argv[arg][3] != '\0') {
+ RTSflags.GranFlags.packBufferSize_internal = decode(rts_argv[arg]+3);
+ } else {
+ RTSflags.GranFlags.packBufferSize_internal = GRANSIM_DEFAULT_PACK_BUFFER_SIZE;
+ }
+ fprintf(stderr,"Size of GranSim internal pack buffer: %u.\n",
+ RTSflags.GranFlags.packBufferSize_internal);
+ break;
+
+ case 'X':
switch(rts_argv[arg][3]) {
+
+ case '\0':
+ RTSflags.GranFlags.DoPrioritySparking = 1;
+ fprintf(stderr,"Priority Sparking with Normal Priorities.\n");
+ RTSflags.GranFlags.InversePriorities = rtsFalse;
+ RTSflags.GranFlags.RandomPriorities = rtsFalse;
+ RTSflags.GranFlags.IgnorePriorities = rtsFalse;
+ break;
+
+ case 'I':
+ RTSflags.GranFlags.DoPrioritySparking = 1;
+ fprintf(stderr,"Priority Sparking with Inverse Priorities.\n");
+ RTSflags.GranFlags.InversePriorities++;
+ break;
+
+ case 'R':
+ RTSflags.GranFlags.DoPrioritySparking = 1;
+ fprintf(stderr,"Priority Sparking with Random Priorities.\n");
+ RTSflags.GranFlags.RandomPriorities++;
+ break;
+
+ case 'N':
+ RTSflags.GranFlags.DoPrioritySparking = 1;
+ fprintf(stderr,"Priority Sparking with No Priorities.\n");
+ RTSflags.GranFlags.IgnorePriorities++;
+ break;
+
+ default:
+ bad_option( rts_argv[arg] );
+ break;
+ }
+ break;
- case 'C':
- DoAlwaysCreateThreads=0;
- DoThreadMigration=0;
- break;
-
- case 'G':
- DoGUMMFetching=0;
- break;
-
- case 'M':
- DoThreadMigration=0;
- break;
+ case '-':
+ switch(rts_argv[arg][3]) {
+
+ case 'C':
+ RTSflags.GranFlags.DoAlwaysCreateThreads=rtsFalse;
+ RTSflags.GranFlags.DoThreadMigration=rtsFalse;
+ break;
+
+ case 'G':
+ RTSflags.GranFlags.DoGUMMFetching=rtsFalse;
+ break;
+
+ case 'M':
+ RTSflags.GranFlags.DoThreadMigration=rtsFalse;
+ break;
case 'R':
- DoFairSchedule=0;
- break;
-
- case 'T':
- DoStealThreadsFirst=0;
- DoThreadMigration=0;
- break;
-
- case 'Z':
- DoReScheduleOnFetch=0;
- break;
-
- case 'N':
- PreferSparksOfLocalNodes=0;
- break;
-
- case 'P':
- RTSflags.ParFlags.granSimStats = rtsFalse;
- no_gr_profile=1;
- break;
-
- case 's':
- do_sp_profile=0;
- break;
-
- case 'b':
- RTSflags.ParFlags.granSimStats_Binary = rtsFalse;
- break;
-
- default:
- bad_option( rts_argv[arg] );
- break;
- }
+ RTSflags.GranFlags.DoFairSchedule=rtsFalse;
+ break;
+
+ case 'T':
+ RTSflags.GranFlags.DoStealThreadsFirst=rtsFalse;
+ RTSflags.GranFlags.DoThreadMigration=rtsFalse;
+ break;
+
+ case 'Z':
+ RTSflags.GranFlags.DoReScheduleOnFetch=rtsFalse;
+ break;
+
+ case 'N':
+ RTSflags.GranFlags.PreferSparksOfLocalNodes=rtsFalse;
+ break;
+
+ case 'P':
+ RTSflags.GranFlags.granSimStats_suppressed=rtsTrue;
+ break;
+
+ case 's':
+ RTSflags.GranFlags.granSimStats_Sparks=rtsFalse;
+ break;
+
+ case 'h':
+ RTSflags.GranFlags.granSimStats_Heap=rtsFalse;
+ break;
+
+ case 'b':
+ RTSflags.GranFlags.granSimStats_Binary=rtsFalse;
+ break;
+
+ case 'X':
+ RTSflags.GranFlags.DoPrioritySparking = rtsFalse;
+ break;
+
+ case 'Y':
+ RTSflags.GranFlags.DoPrioritySparking = rtsFalse;
+ RTSflags.GranFlags.SparkPriority = rtsFalse;
+ break;
+
+ case 'I':
+ RTSflags.GranFlags.DoPriorityScheduling = rtsFalse;
+ break;
+
+ case 'e':
+ RTSflags.GranFlags.RandomSteal = rtsFalse;
+ break;
+
+ default:
+ bad_option( rts_argv[arg] );
+ break;
+ }
break;
-# if defined(GRAN_CHECK) && defined(GRAN)
- case 'D':
+# if defined(GRAN_CHECK) && defined(GRAN)
+ case 'D':
switch(rts_argv[arg][3]) {
- case 'e': /* event trace */
- fprintf(stderr,"Printing event trace.\n");
- ++event_trace;
- break;
-
- case 'f':
- fprintf(stderr,"Printing forwarding of FETCHNODES.\n");
- debug |= 0x2; /* print fwd messages */
- break;
-
- case 'z':
- fprintf(stderr,"Check for blocked on fetch.\n");
- debug |= 0x4; /* debug non-reschedule-on-fetch */
- break;
-
- case 't':
- fprintf(stderr,"Check for TSO asleep on fetch.\n");
- debug |= 0x10; /* debug TSO asleep for fetch */
- break;
-
- case 'E':
- fprintf(stderr,"Printing event statistics.\n");
- debug |= 0x20; /* print event statistics */
- break;
-
- case 'F':
- fprintf(stderr,"Prohibiting forward.\n");
- NoForward = 1; /* prohibit forwarding */
- break;
-
- case 'm':
- fprintf(stderr,"Printing fetch misses.\n");
- PrintFetchMisses = 1; /* prohibit forwarding */
- break;
-
- case 'd':
- fprintf(stderr,"Debug mode.\n");
- debug |= 0x40;
- break;
-
- case 'D':
- fprintf(stderr,"Severe debug mode.\n");
- debug |= 0x80;
- break;
-
- case '\0':
- debug = 1;
- break;
-
- default:
- bad_option( rts_argv[arg] );
- break;
- }
- break;
-# endif
- default:
- bad_option( rts_argv[arg] );
+ case 'Q': /* Set pack buffer size (same as 'Q' in GUM) */
+ if (rts_argv[arg][4] != '\0') {
+ RTSflags.GranFlags.packBufferSize = decode(rts_argv[arg]+4);
+ fprintf(stderr,"Pack buffer size: %d\n",
+ RTSflags.GranFlags.packBufferSize);
+ } else {
+ fprintf(stderr, "setupRtsFlags: missing size of PackBuffer (for -Q)\n");
+ error = rtsTrue;
+ }
+ break;
+
+ case 'e': /* event trace */
+ fprintf(stderr,"Printing event trace.\n");
+ RTSflags.GranFlags.event_trace=rtsTrue;
+ break;
+
+ case 'f':
+ fprintf(stderr,"Printing forwarding of FETCHNODES.\n");
+ RTSflags.GranFlags.debug |= 0x2; /* print fwd messages */
+ break;
+
+ case 'z':
+ fprintf(stderr,"Check for blocked on fetch.\n");
+ RTSflags.GranFlags.debug |= 0x4; /* debug non-reschedule-on-fetch */
+ break;
+
+ case 't':
+ fprintf(stderr,"Check for TSO asleep on fetch.\n");
+ RTSflags.GranFlags.debug |= 0x10; /* debug TSO asleep for fetch */
+ break;
+
+ case 'E':
+ fprintf(stderr,"Printing event statistics.\n");
+ RTSflags.GranFlags.debug |= 0x20; /* print event statistics */
+ break;
+
+ case 'F':
+ fprintf(stderr,"Prohibiting forward.\n");
+ RTSflags.GranFlags.NoForward = rtsTrue; /* prohibit forwarding */
+ break;
+
+ case 'm':
+ fprintf(stderr,"Printing fetch misses.\n");
+ RTSflags.GranFlags.PrintFetchMisses = rtsTrue; /* prohibit forwarding */
+ break;
+
+ case 'd':
+ fprintf(stderr,"Debug mode.\n");
+ RTSflags.GranFlags.debug |= 0x40;
+ break;
+
+ case 'D':
+ fprintf(stderr,"Severe debug mode.\n");
+ RTSflags.GranFlags.debug |= 0x80;
+ break;
+
+ case 'q':
+ fprintf(stderr,"FULL event trace.\n");
+ RTSflags.GranFlags.event_trace_all =rtsTrue;
+ break;
+
+ case 'G':
+ fprintf(stderr,"Debugging packet fetching.\n");
+ RTSflags.GranFlags.debug |= 0x100;
+ break;
+
+ case 'n':
+ fprintf(stderr,"Ignore events till end of time slice\n");
+ RTSflags.GranFlags.debug |= 0x200;
+ IgnoreEvents = rtsTrue;
+ break;
+
+ case 'S':
+ fprintf(stderr,"Check that spark queues are sorted.\n");
+ RTSflags.GranFlags.debug |= 0x400;
+ break;
+
+ case 'H':
+ fprintf(stderr,"Print heap allocation messages (RBH).\n");
+ RTSflags.GranFlags.debug |= 0x800;
+ break;
+
+ case 'p':
+ fprintf(stderr,"Debug breadth-first pruning.\n");
+ RTSflags.GranFlags.debug |= 0x1000;
+ break;
+
+ case 'r':
+ fprintf(stderr,"Debug random stealing.\n");
+ RTSflags.GranFlags.debug |= 0x2000;
+ break;
+
+ case 'B':
+ fprintf(stderr,"Debug busyness.\n");
+ RTSflags.GranFlags.debug |= 0x4000;
+ break;
+
+ case 'P':
+ fprintf(stderr,"Debug pack buffer handling.\n");
+ RTSflags.GranFlags.debug |= 0x8000;
+ break;
+
+ case 's':
+ fprintf(stderr,"Debug spark-queue manipulations.\n");
+ RTSflags.GranFlags.debug |= 0x10000;
+ break;
+
+ case ':':
+ fprintf(stderr,"Debug GrAnSim Light.\n");
+ RTSflags.GranFlags.debug |= 0x20000;
+ break;
+
+ case '\0':
+ RTSflags.GranFlags.debug = 1;
+ break;
+
+ default:
+ bad_option( rts_argv[arg] );
+ break;
+ }
break;
- }
- }
- do_gr_sim++;
- RTSflags.ConcFlags.ctxtSwitchTime = 0;
-}
+# endif /* GRAN_CHECK */
+ default:
+ bad_option( rts_argv[arg] );
+ break;
+ }
+}
#endif /* GRAN */
\end{code}
projects / ghc-hetmet.git / blobdiff