Changeset 252115 in webkit

Timestamp:

Nov 5, 2019 5:30:41 PM (4 years ago)

Author:

Tadeu Zagallo

Message:

[WebAssembly] Allow tiering up from LLInt to BBQ
​https://bugs.webkit.org/show_bug.cgi?id=203793

Reviewed by Yusuke Suzuki.

Even though the interpreter was overall neutral on throughput, it's still a regression in pathological
cases where massive functions spend too long in the LLInt while compiling the function with OMG. This
patch makes it so that the LLInt can tier up to BBQ from the prologue, while still tiering up to OMG from
from loops. This is a huge speed up on the tsf-wasm subtest of JS2:

# BBQ -> OMG
Startup: 100.680
Runtime: 1.852
Score: 13.654

# LLInt -> OMG
Startup: 378.205
Runtime: 1.291
Score: 22.082

# LLInt -> BBQ -> OMG
Startup: 405.983
Runtime: 2.311
Score: 30.623

• runtime/Options.cpp:

(JSC::overrideDefaults):

• runtime/OptionsList.h:
• wasm/WasmBBQPlan.cpp:

(JSC::Wasm::BBQPlan::BBQPlan):
(JSC::Wasm::BBQPlan::work):
(JSC::Wasm::BBQPlan::compileFunction):

• wasm/WasmEntryPlan.cpp:

(JSC::Wasm::EntryPlan::EntryPlan):

• wasm/WasmEntryPlan.h:
• wasm/WasmLLIntTierUpCounter.h:

(JSC::Wasm::LLIntTierUpCounter::optimizeAfterWarmUp):
(JSC::Wasm::LLIntTierUpCounter::optimizeSoon):

• wasm/WasmOMGPlan.cpp:

(JSC::Wasm::OMGPlan::work):

• wasm/WasmSlowPaths.cpp:

(JSC::LLInt::jitCompileAndSetHeuristics):

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• runtime/Options.cpp (modified) (1 diff)
• runtime/OptionsList.h (modified) (2 diffs)
• wasm/WasmBBQPlan.cpp (modified) (6 diffs)
• wasm/WasmEntryPlan.cpp (modified) (1 diff)
• wasm/WasmEntryPlan.h (modified) (1 diff)
• wasm/WasmLLIntTierUpCounter.h (modified) (2 diffs)
• wasm/WasmOMGPlan.cpp (modified) (2 diffs)
• wasm/WasmSlowPaths.cpp (modified) (1 diff)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2019-11-05  Tadeu Zagallo  <tzagallo@apple.com>
+
+        [WebAssembly] Allow tiering up from LLInt to BBQ
+        https://bugs.webkit.org/show_bug.cgi?id=203793
+
+        Reviewed by Yusuke Suzuki.
+
+        Even though the interpreter was overall neutral on throughput, it's still a regression in pathological
+        cases where massive functions spend too long in the LLInt while compiling the function with OMG. This
+        patch makes it so that the LLInt can tier up to BBQ from the prologue, while still tiering up to OMG from
+        from loops. This is a huge speed up on the tsf-wasm subtest of JS2:
+
+        # BBQ -> OMG
+        Startup: 100.680
+        Runtime: 1.852
+        Score: 13.654
+
+        # LLInt -> OMG
+        Startup: 378.205
+        Runtime: 1.291
+        Score: 22.082
+
+        # LLInt -> BBQ -> OMG
+        Startup: 405.983
+        Runtime: 2.311
+        Score: 30.623
+
+        * runtime/Options.cpp:
+        (JSC::overrideDefaults):
+        * runtime/OptionsList.h:
+        * wasm/WasmBBQPlan.cpp:
+        (JSC::Wasm::BBQPlan::BBQPlan):
+        (JSC::Wasm::BBQPlan::work):
+        (JSC::Wasm::BBQPlan::compileFunction):
+        * wasm/WasmEntryPlan.cpp:
+        (JSC::Wasm::EntryPlan::EntryPlan):
+        * wasm/WasmEntryPlan.h:
+        * wasm/WasmLLIntTierUpCounter.h:
+        (JSC::Wasm::LLIntTierUpCounter::optimizeAfterWarmUp):
+        (JSC::Wasm::LLIntTierUpCounter::optimizeSoon):
+        * wasm/WasmOMGPlan.cpp:
+        (JSC::Wasm::OMGPlan::work):
+        * wasm/WasmSlowPaths.cpp:
+        (JSC::LLInt::jitCompileAndSetHeuristics):
+
 2019-11-04  Yusuke Suzuki  <ysuzuki@apple.com>
 

trunk/Source/JavaScriptCore/runtime/Options.cpp

@@ -361 +361 @@
 #endif
 
-    if (Options::useWasmLLInt()) {
+    if (Options::useWasmLLInt() && !Options::wasmLLIntTiersUpToBBQ()) {
         Options::thresholdForOMGOptimizeAfterWarmUp() = 1500;
         Options::thresholdForOMGOptimizeSoon() = 100;

trunk/Source/JavaScriptCore/runtime/OptionsList.h

@@ -429 +429 @@
     v(Bool, useBBQTierUpChecks, true, Normal, "Enables tier up checks for our BBQ code.") \
     v(Bool, useWebAssemblyOSR, true, Normal, nullptr) \
+    v(Int32, thresholdForBBQOptimizeAfterWarmUp, 150, Normal, "The count before we tier up a function to BBQ.") \
+    v(Int32, thresholdForBBQOptimizeSoon, 50, Normal, nullptr) \
     v(Int32, thresholdForOMGOptimizeAfterWarmUp, 50000, Normal, "The count before we tier up a function to OMG.") \
     v(Int32, thresholdForOMGOptimizeSoon, 500, Normal, nullptr) \
@@ -443 +445 @@
     v(Bool, wasmBBQUsesAir, true, Normal, nullptr) \
     v(Bool, useWasmLLInt, true, Normal, nullptr) \
+    v(Bool, wasmLLIntTiersUpToBBQ, true, Normal, nullptr) \
     v(Size, webAssemblyBBQAirModeThreshold, isIOS() ? (10 * MB) : 0, Normal, "If 0, we always use BBQ Air. If Wasm module code size hits this threshold, we compile Wasm module with B3 BBQ mode.") \
     v(Bool, useWebAssemblyStreamingApi, enableWebAssemblyStreamingApi, Normal, "Allow to run WebAssembly's Streaming API") \

trunk/Source/JavaScriptCore/wasm/WasmBBQPlan.cpp

@@ -54 +54 @@
 }
 
+BBQPlan::BBQPlan(Context* context, Ref<ModuleInformation> moduleInformation, uint32_t functionIndex, CodeBlock* codeBlock, CompletionTask&& completionTask)
+    : EntryPlan(context, WTFMove(moduleInformation), WTFMove(completionTask))
+    , m_codeBlock(codeBlock)
+    , m_functionIndex(functionIndex)
+{
+    setMode(m_codeBlock->mode());
+}
+
 bool BBQPlan::prepareImpl()
 {
@@ -81 +89 @@
     std::unique_ptr<InternalFunction> function = compileFunction(m_functionIndex, context, unlinkedWasmToWasmCalls, tierUp.get());
 
-    Entrypoint bbqEntrypoint;
     LinkBuffer linkBuffer(*context.wasmEntrypointJIT, nullptr, JITCompilationCanFail);
     if (UNLIKELY(linkBuffer.didFailToAllocate())) {
@@ -89 +96 @@
 
     size_t functionIndexSpace = m_functionIndex + m_moduleInformation->importFunctionCount();
-    bbqEntrypoint.compilation = makeUnique<B3::Compilation>(
-        FINALIZE_CODE(linkBuffer, B3CompilationPtrTag, "WebAssembly BBQ function[%i] name %s", m_functionIndex, makeString(IndexOrName(functionIndexSpace, m_moduleInformation->nameSection->get(functionIndexSpace))).ascii().data()),
+    SignatureIndex signatureIndex = m_moduleInformation->internalFunctionSignatureIndices[m_functionIndex];
+    const Signature& signature = SignatureInformation::get(signatureIndex);
+    function->entrypoint.compilation = makeUnique<B3::Compilation>(
+        FINALIZE_WASM_CODE_FOR_MODE(CompilationMode::BBQMode, linkBuffer, B3CompilationPtrTag, "WebAssembly BBQ function[%i] %s name %s", m_functionIndex, signature.toString().ascii().data(), makeString(IndexOrName(functionIndexSpace, m_moduleInformation->nameSection->get(functionIndexSpace))).ascii().data()),
         WTFMove(context.wasmEntrypointByproducts));
-
-    bbqEntrypoint.calleeSaveRegisters = WTFMove(function->entrypoint.calleeSaveRegisters);
 
     MacroAssemblerCodePtr<WasmEntryPtrTag> entrypoint;
     {
-        Ref<BBQCallee> callee = BBQCallee::create(WTFMove(bbqEntrypoint), functionIndexSpace, m_moduleInformation->nameSection->get(functionIndexSpace), WTFMove(tierUp), WTFMove(unlinkedWasmToWasmCalls));
+        Ref<BBQCallee> callee = BBQCallee::create(WTFMove(function->entrypoint), functionIndexSpace, m_moduleInformation->nameSection->get(functionIndexSpace), WTFMove(tierUp), WTFMove(unlinkedWasmToWasmCalls));
         MacroAssembler::repatchPointer(function->calleeMoveLocation, CalleeBits::boxWasm(callee.ptr()));
         ASSERT(!m_codeBlock->m_bbqCallees[m_functionIndex]);
@@ -110 +117 @@
         {
             LLIntCallee& llintCallee = *m_codeBlock->m_llintCallees[m_functionIndex];
+            auto locker = holdLock(llintCallee.tierUpCounter().m_lock);
             llintCallee.setReplacement(callee.copyRef());
+            llintCallee.tierUpCounter().m_compilationStatus = LLIntTierUpCounter::CompilationStatus::Compiled;
         }
         for (auto& call : callee->wasmToWasmCallsites()) {
@@ -148 +157 @@
                 if (JITCallee* replacementCallee = llintCallee->replacement())
                     repatchCalls(replacementCallee->wasmToWasmCallsites());
+                if (OMGForOSREntryCallee* osrEntryCallee = llintCallee->osrEntryCallee())
+                    repatchCalls(osrEntryCallee->wasmToWasmCallsites());
             }
             if (BBQCallee* bbqCallee = m_codeBlock->m_bbqCallees[i].get()) {
@@ -191 +202 @@
     SignatureIndex signatureIndex = m_moduleInformation->internalFunctionSignatureIndices[functionIndex];
     const Signature& signature = SignatureInformation::get(signatureIndex);
-    unsigned functionIndexSpace = m_wasmToWasmExitStubs.size() + functionIndex;
+    unsigned functionIndexSpace = m_moduleInformation->importFunctionCount() + functionIndex;
     ASSERT_UNUSED(functionIndexSpace, m_moduleInformation->signatureIndexFromFunctionIndexSpace(functionIndexSpace) == signatureIndex);
     ASSERT(validateFunction(function, signature, m_moduleInformation.get()));

trunk/Source/JavaScriptCore/wasm/WasmEntryPlan.cpp

@@ -64 +64 @@
 }
 
+EntryPlan::EntryPlan(Context* context, Ref<ModuleInformation> moduleInformation, CompletionTask&& task)
+    : Base(context, WTFMove(moduleInformation), WTFMove(task))
+    , m_streamingParser(m_moduleInformation.get(), *this)
+    , m_state(State::Initial)
+    , m_asyncWork(AsyncWork::FullCompile)
+{
+}
+
 EntryPlan::EntryPlan(Context* context, AsyncWork work, CompletionTask&& task)
     : Base(context, WTFMove(task))

trunk/Source/JavaScriptCore/wasm/WasmEntryPlan.h

@@ -50 +50 @@
     EntryPlan(Context*, Ref<ModuleInformation>, AsyncWork, CompletionTask&&, CreateEmbedderWrapper&&, ThrowWasmException);
     JS_EXPORT_PRIVATE EntryPlan(Context*, Vector<uint8_t>&&, AsyncWork, CompletionTask&&, CreateEmbedderWrapper&&, ThrowWasmException);
+    EntryPlan(Context*, Ref<ModuleInformation>, CompletionTask&&);
     EntryPlan(Context*, AsyncWork, CompletionTask&&);
 

trunk/Source/JavaScriptCore/wasm/WasmLLIntTierUpCounter.h

@@ -51 +51 @@
     void optimizeAfterWarmUp()
     {
-        setNewThreshold(Options::thresholdForOMGOptimizeAfterWarmUp(), nullptr);
+        if (Options::wasmLLIntTiersUpToBBQ())
+            setNewThreshold(Options::thresholdForBBQOptimizeAfterWarmUp(), nullptr);
+        else
+            setNewThreshold(Options::thresholdForOMGOptimizeAfterWarmUp(), nullptr);
     }
 
@@ -61 +64 @@
     void optimizeSoon()
     {
-        setNewThreshold(Options::thresholdForOMGOptimizeSoon(), nullptr);
+        if (Options::wasmLLIntTiersUpToBBQ())
+            setNewThreshold(Options::thresholdForBBQOptimizeSoon(), nullptr);
+        else
+            setNewThreshold(Options::thresholdForOMGOptimizeSoon(), nullptr);
     }
 

trunk/Source/JavaScriptCore/wasm/WasmOMGPlan.cpp

@@ -122 +122 @@
                 bbqCallee->setReplacement(callee.copyRef());
                 bbqCallee->tierUpCount()->m_compilationStatusForOMG = TierUpCount::CompilationStatus::Compiled;
-            } else if (LLIntCallee* llintCallee = m_codeBlock->m_llintCallees[m_functionIndex].get()) {
+            }
+            if (LLIntCallee* llintCallee = m_codeBlock->m_llintCallees[m_functionIndex].get()) {
                 auto locker = holdLock(llintCallee->tierUpCounter().m_lock);
                 llintCallee->setReplacement(callee.copyRef());
@@ -164 +165 @@
                 if (JITCallee* replacementCallee = llintCallee->replacement())
                     repatchCalls(replacementCallee->wasmToWasmCallsites());
+                if (OMGForOSREntryCallee* osrEntryCallee = llintCallee->osrEntryCallee())
+                    repatchCalls(osrEntryCallee->wasmToWasmCallsites());
             }
             if (BBQCallee* bbqCallee = m_codeBlock->m_bbqCallees[i].get()) {

trunk/Source/JavaScriptCore/wasm/WasmSlowPaths.cpp

@@ -111 +111 @@
     if (compile) {
         uint32_t functionIndex = codeBlock->functionIndex();
-        Ref<Wasm::OMGPlan> plan = adoptRef(*new Wasm::OMGPlan(instance->context(), Ref<Wasm::Module>(instance->module()), functionIndex, instance->memory()->mode(), Wasm::Plan::dontFinalize()));
-
-        Wasm::ensureWorklist().enqueue(plan.copyRef());
+        RefPtr<Wasm::Plan> plan;
+        if (Options::wasmLLIntTiersUpToBBQ())
+            plan = adoptRef(*new Wasm::BBQPlan(instance->context(), makeRef(const_cast<Wasm::ModuleInformation&>(instance->module().moduleInformation())), functionIndex, instance->codeBlock(), Wasm::Plan::dontFinalize()));
+        else
+            plan = adoptRef(*new Wasm::OMGPlan(instance->context(), Ref<Wasm::Module>(instance->module()), functionIndex, instance->memory()->mode(), Wasm::Plan::dontFinalize()));
+
+        Wasm::ensureWorklist().enqueue(makeRef(*plan));
         if (UNLIKELY(!Options::useConcurrentJIT()))
             plan->waitForCompletion();