Changeset 161705 in webkit

Timestamp:

Jan 10, 2014 5:29:24 PM (10 years ago)

Author:

fpizlo@apple.com

Message:

It should be easier to diagnose FTL performance issues due to register preservation thunks
​https://bugs.webkit.org/show_bug.cgi?id=126798

Not yet reviewed.

You can now use --verboseFTLToJSThunk=true --verboseFTLFailure=true to figure out
which code blocks are rejected by the FTL and yet get called from functions that
were FTL compiled. Any such rejections in major benchmarks should be fixed.

• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::CodeBlock):

• ftl/FTLCapabilities.cpp:

(JSC::FTL::verboseCapabilities):
(JSC::FTL::canCompile):

• jit/RegisterPreservationWrapperGenerator.cpp:

(JSC::generateRegisterPreservationWrapper):

• runtime/Executable.cpp:

(JSC::ExecutableBase::dump):

• runtime/Executable.h:
• runtime/Options.cpp:

(JSC::Options::initialize):

• runtime/Options.h:

Location:

branches/jsCStack/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• bytecode/CodeBlock.cpp (modified) (1 diff)
• ftl/FTLCapabilities.cpp (modified) (5 diffs)
• jit/RegisterPreservationWrapperGenerator.cpp (modified) (1 diff)
• runtime/Executable.cpp (modified) (1 diff)
• runtime/Executable.h (modified) (1 diff)
• runtime/Options.cpp (modified) (1 diff)
• runtime/Options.h (modified) (1 diff)

branches/jsCStack/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2014-01-10  Filip Pizlo  <fpizlo@apple.com>
+
+        It should be easier to diagnose FTL performance issues due to register preservation thunks
+        https://bugs.webkit.org/show_bug.cgi?id=126798
+
+        Not yet reviewed.
+        
+        You can now use --verboseFTLToJSThunk=true --verboseFTLFailure=true to figure out
+        which code blocks are rejected by the FTL and yet get called from functions that
+        were FTL compiled. Any such rejections in major benchmarks should be fixed.
+
+        * bytecode/CodeBlock.cpp:
+        (JSC::CodeBlock::CodeBlock):
+        * ftl/FTLCapabilities.cpp:
+        (JSC::FTL::verboseCapabilities):
+        (JSC::FTL::canCompile):
+        * jit/RegisterPreservationWrapperGenerator.cpp:
+        (JSC::generateRegisterPreservationWrapper):
+        * runtime/Executable.cpp:
+        (JSC::ExecutableBase::dump):
+        * runtime/Executable.h:
+        * runtime/Options.cpp:
+        (JSC::Options::initialize):
+        * runtime/Options.h:
+
 2014-01-10  Filip Pizlo  <fpizlo@apple.com>
 

branches/jsCStack/Source/JavaScriptCore/bytecode/CodeBlock.cpp

@@ -1844 +1844 @@
     // If the concurrent thread will want the code block's hash, then compute it here
     // synchronously.
-    if (Options::showDisassembly()
-        || Options::showDFGDisassembly()
-        || Options::dumpBytecodeAtDFGTime()
-        || Options::dumpGraphAtEachPhase()
-        || Options::verboseCompilation()
-        || Options::logCompilationChanges()
-        || Options::validateGraph()
-        || Options::validateGraphAtEachPhase()
-        || Options::verboseOSR()
-        || Options::verboseCompilationQueue()
-        || Options::reportCompileTimes()
-        || Options::verboseCFA())
+    if (Options::alwaysComputeHash())
         hash();
 

branches/jsCStack/Source/JavaScriptCore/ftl/FTLCapabilities.cpp

@@ -32 +32 @@
 
 using namespace DFG;
+
+static bool verboseCapabilities()
+{
+    return verboseCompilationEnabled() || Options::verboseFTLFailure();
+}
 
 inline CapabilityLevel canCompile(Node* node)
@@ -235 +240 @@
 {
     if (graph.m_codeBlock->codeType() != FunctionCode) {
-        if (verboseCompilationEnabled())
-            dataLog("FTL rejecting code block that doesn't belong to a function.\n");
+        if (verboseCapabilities())
+            dataLog("FTL rejecting ", *graph.m_codeBlock, " because it doesn't belong to a function.\n");
         return CannotCompile;
     }
@@ -244 +249 @@
         // CreateActivation/TearOffActivation, we might not see those nodes in case of
         // OSR entry.
-        if (verboseCompilationEnabled())
-            dataLog("FTL rejecting code block that uses activations.\n");
+        if (verboseCapabilities())
+            dataLog("FTL rejecting ", *graph.m_codeBlock, " because it uses activations.\n");
         return CannotCompile;
     }
@@ -286 +291 @@
                 default:
                     // Don't know how to handle anything else.
-                    if (verboseCompilationEnabled()) {
-                        dataLog("FTL rejecting node because of bad use kind: ", edge.useKind(), " in node:\n");
+                    if (verboseCapabilities()) {
+                        dataLog("FTL rejecting node in ", *graph.m_codeBlock, " because of bad use kind: ", edge.useKind(), " in node:\n");
                         graph.dump(WTF::dataFile(), "    ", node);
                     }
@@ -296 +301 @@
             switch (canCompile(node)) {
             case CannotCompile: 
-                if (verboseCompilationEnabled()) {
-                    dataLog("FTL rejecting node:\n");
+                if (verboseCapabilities()) {
+                    dataLog("FTL rejecting node in ", *graph.m_codeBlock, ":\n");
                     graph.dump(WTF::dataFile(), "    ", node);
                 }

branches/jsCStack/Source/JavaScriptCore/jit/RegisterPreservationWrapperGenerator.cpp

@@ -117 +117 @@
     LinkBuffer linkBuffer(vm, &jit, GLOBAL_THUNK_ID);
     linkBuffer.link(call, CodeLocationLabel(target));
+
+    if (Options::verboseFTLToJSThunk())
+        dataLog("Need a thunk for calls from FTL to non-FTL version of ", *executable, "\n");
     
     return FINALIZE_DFG_CODE(linkBuffer, ("Register preservation wrapper for %s/%s, %p", toCString(executable->hashFor(CodeForCall)).data(), toCString(executable->hashFor(CodeForConstruct)).data(), target.executableAddress()));

branches/jsCStack/Source/JavaScriptCore/runtime/Executable.cpp

@@ -607 +607 @@
 }
 
+void ExecutableBase::dump(PrintStream& out) const
+{
+    ExecutableBase* realThis = const_cast<ExecutableBase*>(this);
+    
+    if (classInfo() == NativeExecutable::info()) {
+        NativeExecutable* native = jsCast<NativeExecutable*>(realThis);
+        out.print("NativeExecutable:", RawPointer(bitwise_cast<void*>(native->function())), "/", RawPointer(bitwise_cast<void*>(native->constructor())));
+        return;
+    }
+    
+    if (classInfo() == EvalExecutable::info()) {
+        EvalExecutable* eval = jsCast<EvalExecutable*>(realThis);
+        if (CodeBlock* codeBlock = eval->codeBlock())
+            out.print(*codeBlock);
+        else
+            out.print("EvalExecutable w/o CodeBlock");
+        return;
+    }
+    
+    if (classInfo() == ProgramExecutable::info()) {
+        ProgramExecutable* eval = jsCast<ProgramExecutable*>(realThis);
+        if (CodeBlock* codeBlock = eval->codeBlock())
+            out.print(*codeBlock);
+        else
+            out.print("ProgramExecutable w/o CodeBlock");
+        return;
+    }
+    
+    FunctionExecutable* function = jsCast<FunctionExecutable*>(realThis);
+    if (!function->eitherCodeBlock())
+        out.print("FunctionExecutable w/o CodeBlock");
+    else {
+        CommaPrinter comma("/");
+        if (function->codeBlockForCall())
+            out.print(comma, *function->codeBlockForCall());
+        if (function->codeBlockForConstruct())
+            out.print(comma, *function->codeBlockForConstruct());
+    }
+}
+
 CodeBlockHash ExecutableBase::hashFor(CodeSpecializationKind kind) const
 {

branches/jsCStack/Source/JavaScriptCore/runtime/Executable.h

@@ -270 +270 @@
         return NoIntrinsic;
     }
+    
+    void dump(PrintStream&) const;
         
 protected:

branches/jsCStack/Source/JavaScriptCore/runtime/Options.cpp

@@ -212 +212 @@
     useRegExpJIT() = false;
 #endif
-
+    
+    if (showDisassembly()
+        || showDFGDisassembly()
+        || dumpBytecodeAtDFGTime()
+        || dumpGraphAtEachPhase()
+        || verboseCompilation()
+        || logCompilationChanges()
+        || validateGraph()
+        || validateGraphAtEachPhase()
+        || verboseOSR()
+        || verboseCompilationQueue()
+        || reportCompileTimes()
+        || verboseCFA()
+        || verboseFTLFailure())
+        alwaysComputeHash() = true;
+    
     // Do range checks where needed and make corrections to the options:
     ASSERT(thresholdForOptimizeAfterLongWarmUp() >= thresholdForOptimizeAfterWarmUp());

branches/jsCStack/Source/JavaScriptCore/runtime/Options.h

@@ -125 +125 @@
     v(bool, reportCompileTimes, false) \
     v(bool, verboseCFA, false) \
+    v(bool, verboseFTLToJSThunk, false) \
+    v(bool, verboseFTLFailure, false) \
+    v(bool, alwaysComputeHash, false) \
     \
     v(bool, enableOSREntryToDFG, true) \