fix #3910

[ghc-hetmet.git] / rts / RtsFlags.c

diff --git a/rts/RtsFlags.c b/rts/RtsFlags.c
index 93482f5..067986f 100644 (file)
--- a/rts/RtsFlags.c
+++ b/rts/RtsFlags.c
@@ -69,6 +69,8 @@ void initRtsFlagsDefaults(void)
 
     RtsFlags.GcFlags.maxStkSize                = (8 * 1024 * 1024) / sizeof(W_);
     RtsFlags.GcFlags.initialStkSize    = 1024 / sizeof(W_);
+    RtsFlags.GcFlags.stkChunkSize       = (32 * 1024) / sizeof(W_);
+    RtsFlags.GcFlags.stkChunkBufferSize = (1 * 1024) / sizeof(W_);
 
     RtsFlags.GcFlags.minAllocAreaSize   = (512 * 1024)        / BLOCK_SIZE;
     RtsFlags.GcFlags.minOldGenSize      = (1024 * 1024)       / BLOCK_SIZE;
@@ -194,7 +196,9 @@ usage_text[] = {
 "  --info   Print information about the RTS used by this program",
 "",
 "  -K<size> Sets the maximum stack size (default 8M)  Egs: -K32k   -K512k",
-"  -k<size> Sets the initial thread stack size (default 1k)  Egs: -k4k   -k2m",
+"  -ki<size> Sets the initial thread stack size (default 1k)  Egs: -ki4k -ki2m",
+"  -kc<size> Sets the stack chunk size (default 32k)",
+"  -kb<size> Sets the stack chunk buffer size (default 1k)",
 "",
 "  -A<size> Sets the minimum allocation area size (default 512k) Egs: -A1m -A10k",
 "  -M<size> Sets the maximum heap size (default unlimited)  Egs: -M256k -M1G",
@@ -324,9 +328,6 @@ usage_text[] = {
 "  --install-signal-handlers=<yes|no>",
 "            Install signal handlers (default: yes)",
 #if defined(THREADED_RTS)
-"  -e<size>  Size of spark pools (default 100)",
-#endif
-#if defined(THREADED_RTS)
 "  -e<n>     Maximum number of outstanding local sparks (default: 4096)",
 #endif
 #if defined(x86_64_HOST_ARCH)
@@ -343,6 +344,8 @@ usage_text[] = {
 "            b - branch mispredictions",
 "            s - stalled cycles",
 "            e - cache miss and branch misprediction events",
+"            +PAPI_EVENT   - collect papi preset event PAPI_EVENT",
+"            #NATIVE_EVENT - collect native event NATIVE_EVENT (in hex)",
 #endif
 "",
 "RTS options may also be specified using the GHCRTS environment variable.",
@@ -414,7 +417,7 @@ setupRtsFlags(int *argc, char *argv[], int *rts_argc, char *rts_argv[])
        char *ghc_rts = getenv("GHCRTS");
 
        if (ghc_rts != NULL) {
-            if (rtsOptsEnabled) {
+            if (rtsOptsEnabled != rtsOptsNone) {
                 splitRtsFlags(ghc_rts, rts_argc, rts_argv);
             }
             else {
@@ -439,7 +442,7 @@ setupRtsFlags(int *argc, char *argv[], int *rts_argc, char *rts_argv[])
            break;
        }
        else if (strequal("+RTS", argv[arg])) {
-            if (rtsOptsEnabled) {
+            if (rtsOptsEnabled != rtsOptsNone) {
                 mode = RTS;
             }
             else {
@@ -451,9 +454,9 @@ setupRtsFlags(int *argc, char *argv[], int *rts_argc, char *rts_argv[])
            mode = PGM;
        }
        else if (mode == RTS && *rts_argc < MAX_RTS_ARGS-1) {
-           rts_argv[(*rts_argc)++] = argv[arg];
-       }
-       else if (mode == PGM) {
+            rts_argv[(*rts_argc)++] = argv[arg];
+        }
+        else if (mode == PGM) {
            argv[(*argc)++] = argv[arg];
        }
        else {
@@ -475,7 +478,25 @@ setupRtsFlags(int *argc, char *argv[], int *rts_argc, char *rts_argv[])
            error = rtsTrue;
 
         } else {
-           switch(rts_argv[arg][1]) {
+
+            switch(rts_argv[arg][1]) {
+            case '-':
+                if (strequal("info", &rts_argv[arg][2])) {
+                    printRtsInfo();
+                    stg_exit(0);
+                }
+                break;
+            default:
+                break;
+            }
+
+            if (rtsOptsEnabled != rtsOptsAll)
+            {
+                errorBelch("Most RTS options are disabled. Link with -rtsopts to enable them.");
+                stg_exit(EXIT_FAILURE);
+            }
+
+            switch(rts_argv[arg][1]) {
 
              /* process: general args, then PROFILING-only ones, then
                 CONCURRENT-only, TICKY-only (same order as defined in
@@ -548,7 +569,7 @@ error = rtsTrue;
                   else if (strequal("info",
                                &rts_argv[arg][2])) {
                       printRtsInfo();
-                      exit(0);
+                      stg_exit(0);
                   }
                   else {
                      errorBelch("unknown RTS option: %s",rts_argv[arg]);
@@ -580,12 +601,18 @@ error = rtsTrue;
                  RtsFlags.PapiFlags.eventType = PAPI_FLAG_CB_EVENTS;
                  break;
                 case '+':
+                case '#':
                   if (RtsFlags.PapiFlags.numUserEvents >= MAX_PAPI_USER_EVENTS) {
                       errorBelch("maximum number of PAPI events reached");
                       stg_exit(EXIT_FAILURE);
                   }
+                  nat eventNum  = RtsFlags.PapiFlags.numUserEvents++;
+                  char kind     = rts_argv[arg][2];
+                  nat eventKind = kind == '+' ? PAPI_PRESET_EVENT_KIND : PAPI_NATIVE_EVENT_KIND;
+
+                  RtsFlags.PapiFlags.userEvents[eventNum] = rts_argv[arg] + 3;
                   RtsFlags.PapiFlags.eventType = PAPI_USER_EVENTS;
-                  RtsFlags.PapiFlags.userEvents[RtsFlags.PapiFlags.numUserEvents++] = rts_argv[arg] + 3;
+                  RtsFlags.PapiFlags.userEventsKind[eventNum] = eventKind;
                   break;
                default:
                  bad_option( rts_argv[arg] );
@@ -681,15 +708,31 @@ error = rtsTrue;
 
              case 'K':
                   RtsFlags.GcFlags.maxStkSize =
-                      decodeSize(rts_argv[arg], 2, 1, HS_WORD_MAX) / sizeof(W_);
+                      decodeSize(rts_argv[arg], 2, sizeof(W_), HS_WORD_MAX) / sizeof(W_);
                   break;
 
              case 'k':
+               switch(rts_argv[arg][2]) {
+                case 'c':
+                  RtsFlags.GcFlags.stkChunkSize =
+                      decodeSize(rts_argv[arg], 3, sizeof(W_), HS_WORD_MAX) / sizeof(W_);
+                  break;
+                case 'b':
+                  RtsFlags.GcFlags.stkChunkBufferSize =
+                      decodeSize(rts_argv[arg], 3, sizeof(W_), HS_WORD_MAX) / sizeof(W_);
+                  break;
+                case 'i':
                   RtsFlags.GcFlags.initialStkSize =
-                      decodeSize(rts_argv[arg], 2, 1, HS_WORD_MAX) / sizeof(W_);
+                      decodeSize(rts_argv[arg], 3, sizeof(W_), HS_WORD_MAX) / sizeof(W_);
                   break;
+                default:
+                  RtsFlags.GcFlags.initialStkSize =
+                      decodeSize(rts_argv[arg], 2, sizeof(W_), HS_WORD_MAX) / sizeof(W_);
+                  break;
+                }
+                break;
 
-             case 'M':
+              case 'M':
                   RtsFlags.GcFlags.maxHeapSize =
                       decodeSize(rts_argv[arg], 2, BLOCK_SIZE, HS_WORD_MAX) / BLOCK_SIZE;
                   /* user give size in *bytes* but "maxHeapSize" is in *blocks* */
@@ -1191,6 +1234,12 @@ error = rtsTrue;
         RtsFlags.ProfFlags.profileIntervalTicks = 0;
     }
 
+    if (RtsFlags.GcFlags.stkChunkBufferSize >
+        RtsFlags.GcFlags.stkChunkSize / 2) {
+        errorBelch("stack chunk buffer size (-kb) must be less than 50%% of the stack chunk size (-kc)");
+        error = rtsTrue;
+    }
+
     if (error) {
        const char **p;