Add logging to warn about under-estimated FTL inline cache sizes.
authormark.lam@apple.com <mark.lam@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 26 Oct 2015 21:45:59 +0000 (21:45 +0000)
committermark.lam@apple.com <mark.lam@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 26 Oct 2015 21:45:59 +0000 (21:45 +0000)
https://bugs.webkit.org/show_bug.cgi?id=150570

Reviewed by Geoffrey Garen.

Added 2 options:
1. JSC_dumpFailedICSizing - dumps an error message if the FTL encounters IC size
   estimates that are less than the actual needed code size.

   This option is useful for when we add a new IC and want to compute an
   estimated size for the IC.  To do this:
   1. Build jsc for the target port with a very small IC size (enough to
      store the jump instruction needed for the out of line fallback
      implementation).
   2. Implement a test suite with scenarios that exercise all the code paths in
      the IC generator.
   3. Run jsc with JSC_dumpFailedICSizing=true on the test suite.
   4. The max value reported by the dumps will be the worst case size needed to
      store the IC.  We should use this value for our estimate.
   5. Update the IC's estimated size and rebuild jsc.
   6. Re-run (3) and confirm that there are no more error messages about the
      IC sizing.

2. JSC_assertICSizing - same as JSC_dumpFailedICSizing except that it also
   crashes the VM each time it encounters an inadequate IC size estimate.

   This option is useful for regression testing to ensure that our estimates
   do not regress.

* ftl/FTLCompile.cpp:
(JSC::FTL::generateInlineIfPossibleOutOfLineIfNot):
* runtime/Options.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@191602 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/ftl/FTLCompile.cpp
Source/JavaScriptCore/runtime/Options.h

index 4a70506..8861efa 100644 (file)
@@ -1,3 +1,38 @@
+2015-10-26  Mark Lam  <mark.lam@apple.com>
+
+        Add logging to warn about under-estimated FTL inline cache sizes.
+        https://bugs.webkit.org/show_bug.cgi?id=150570
+
+        Reviewed by Geoffrey Garen.
+
+        Added 2 options:
+        1. JSC_dumpFailedICSizing - dumps an error message if the FTL encounters IC size
+           estimates that are less than the actual needed code size.
+
+           This option is useful for when we add a new IC and want to compute an
+           estimated size for the IC.  To do this:
+           1. Build jsc for the target port with a very small IC size (enough to
+              store the jump instruction needed for the out of line fallback
+              implementation).
+           2. Implement a test suite with scenarios that exercise all the code paths in
+              the IC generator.
+           3. Run jsc with JSC_dumpFailedICSizing=true on the test suite.
+           4. The max value reported by the dumps will be the worst case size needed to
+              store the IC.  We should use this value for our estimate.
+           5. Update the IC's estimated size and rebuild jsc.
+           6. Re-run (3) and confirm that there are no more error messages about the
+              IC sizing.
+
+        2. JSC_assertICSizing - same as JSC_dumpFailedICSizing except that it also
+           crashes the VM each time it encounters an inadequate IC size estimate.
+
+           This option is useful for regression testing to ensure that our estimates
+           do not regress.
+
+        * ftl/FTLCompile.cpp:
+        (JSC::FTL::generateInlineIfPossibleOutOfLineIfNot):
+        * runtime/Options.h:
+
 2015-10-26  Saam barati  <sbarati@apple.com>
 
         r190735 Caused us to maybe trample the base's tag-GPR on 32-bit inline cache when the cache allocates a scratch register and then jumps to the slow path
index 9934f4e..f8cae46 100644 (file)
@@ -169,6 +169,15 @@ static void generateInlineIfPossibleOutOfLineIfNot(State& state, VM& vm, CodeBlo
         return;
     }
 
+    if (Options::assertICSizing() || Options::dumpFailedICSizing()) {
+        static size_t maxSize = 0;
+        if (maxSize < actualCodeSize)
+            maxSize = actualCodeSize;
+        dataLogF("ALERT: Under-estimated FTL Inline Cache Size for %s: estimated %zu, actual %zu, max %zu\n", codeDescription, sizeOfInlineCode, actualCodeSize, maxSize);
+        if (Options::assertICSizing())
+            CRASH();
+    }
+
     // If there isn't enough space in the provided inline code area, allocate out of line
     // executable memory to link the provided code. Place a jump at the beginning of the
     // inline area and jump to the out of line code. Similarly return by appending a jump
index 81fe6e6..99baede 100644 (file)
@@ -280,6 +280,9 @@ typedef const char* optionString;
     \
     v(unsigned, reoptimizationRetryCounterMax, 0, nullptr)  \
     \
+    v(bool, assertICSizing, false, "crash if estimated IC sizes are inadequate")  \
+    v(bool, dumpFailedICSizing, false, "dumps a log entry if estimated IC sizes are inadequate")  \
+    \
     v(unsigned, minimumOptimizationDelay, 1, nullptr) \
     v(unsigned, maximumOptimizationDelay, 5, nullptr) \
     v(double, desiredProfileLivenessRate, 0.75, nullptr) \