Changeset 233158 in webkit

Timestamp:

Jun 25, 2018 11:30:47 AM (6 years ago)

Author:

commit-queue@webkit.org

Message:

Add API for configuring the number of threads used by DFG and FTL
​https://bugs.webkit.org/show_bug.cgi?id=186859
<rdar://problem/41093519>

Patch by Tadeu Zagallo <Tadeu Zagallo> on 2018-06-25
Reviewed by Filip Pizlo.

Add new private APIs for limiting the number of threads to be used by
the DFG and FTL compilers. It was already possible to configure the
limit through JSC Options, but now it can be changed at runtime, even
in the case when the VM is already running.

Add a test for both cases: when trying to configure the limit before
and after the Worklist has been created, but in order to simulate the
first scenario, we must guarantee that the test runs at the very
beginning, so I also added a check for that.

• API/JSVirtualMachine.mm:

(+[JSVirtualMachine setNumberOfDFGCompilerThreads:]):
(+[JSVirtualMachine setNumberOfFTLCompilerThreads:]):

• API/JSVirtualMachinePrivate.h:
• API/tests/testapi.mm:

(runJITThreadLimitTests):
(testObjectiveCAPIMain):

• dfg/DFGWorklist.cpp:

(JSC::DFG::Worklist::finishCreation):
(JSC::DFG::Worklist::createNewThread):
(JSC::DFG::Worklist::setNumberOfThreads):

• dfg/DFGWorklist.h:

Location:

trunk/Source/JavaScriptCore

Files:

• API/JSVirtualMachine.mm (modified) (2 diffs)
• API/JSVirtualMachinePrivate.h (modified) (2 diffs)
• API/tests/testapi.mm (modified) (2 diffs)
• ChangeLog (modified) (1 diff)
• dfg/DFGWorklist.cpp (modified) (2 diffs)
• dfg/DFGWorklist.h (modified) (2 diffs)

trunk/Source/JavaScriptCore/API/JSVirtualMachine.mm

@@ -31 +31 @@
 
 #import "APICast.h"
+#import "DFGWorklist.h"
 #import "JSManagedValueInternal.h"
 #import "JSVirtualMachine.h"
@@ -275 +276 @@
     vm->shrinkFootprintWhenIdle();
 }
+
+#if ENABLE(DFG_JIT)
+
++ (NSUInteger)setNumberOfDFGCompilerThreads:(NSUInteger)numberOfThreads
+{
+    JSC::DFG::Worklist* worklist = JSC::DFG::existingGlobalDFGWorklistOrNull();
+    if (worklist)
+        return worklist->setNumberOfThreads(numberOfThreads, JSC::Options::priorityDeltaOfDFGCompilerThreads());
+
+    auto currentNumberOfThreads = JSC::Options::numberOfDFGCompilerThreads();
+    JSC::Options::numberOfDFGCompilerThreads() = numberOfThreads;
+    return currentNumberOfThreads;
+}
+
++ (NSUInteger)setNumberOfFTLCompilerThreads:(NSUInteger)numberOfThreads
+{
+    JSC::DFG::Worklist* worklist = JSC::DFG::existingGlobalFTLWorklistOrNull();
+    if (worklist)
+        return worklist->setNumberOfThreads(numberOfThreads, JSC::Options::priorityDeltaOfFTLCompilerThreads());
+
+    auto currentNumberOfThreads = JSC::Options::numberOfFTLCompilerThreads();
+    JSC::Options::numberOfFTLCompilerThreads() = numberOfThreads;
+    return currentNumberOfThreads;
+}
+
+#endif // ENABLE(DFG_JIT)
 
 @end

trunk/Source/JavaScriptCore/API/JSVirtualMachinePrivate.h

@@ -24 +24 @@
  */
 
+#include "JSExportMacros.h"
 #include <JavaScriptCore/JavaScript.h>
 
@@ -45 +46 @@
 - (void)shrinkFootprintWhenIdle NS_AVAILABLE(10_14, 12_0);
 
+#if ENABLE(DFG_JIT)
+
+/*!
+@method
+@abstract Set the number of threads to be used by the DFG JIT compiler.
+@discussion If called after the VM has been initialized, it will terminate
+ threads until it meets the new limit or create new threads accordingly if the
+ new limit is higher than the previous limit. If called before initialization,
+ the Options value for the number of DFG threads will be updated to ensure the
+ DFG compiler already starts with the up-to-date limit.
+@param numberOfThreads The number of threads the DFG compiler should use going forward
+@result The previous number of threads being used by the DFG compiler
+*/
++ (NSUInteger)setNumberOfDFGCompilerThreads:(NSUInteger)numberOfThreads NS_AVAILABLE(10_14, 12_0);
+
+/*!
+@method
+@abstract Set the number of threads to be used by the FTL JIT compiler.
+@discussion If called after the VM has been initialized, it will terminate
+ threads until it meets the new limit or create new threads accordingly if the
+ new limit is higher than the previous limit. If called before initialization,
+ the Options value for the number of FTL threads will be updated to ensure the
+ FTL compiler already starts with the up-to-date limit.
+@param numberOfThreads The number of threads the FTL compiler should use going forward
+@result The previous number of threads being used by the FTL compiler
+*/
++ (NSUInteger)setNumberOfFTLCompilerThreads:(NSUInteger)numberOfThreads NS_AVAILABLE(10_14, 12_0);
+
+#endif // ENABLE(DFG_JIT)
+
 @end
 

trunk/Source/JavaScriptCore/API/tests/testapi.mm

@@ -24 +24 @@
  */
 
+#import "JSExportMacros.h"
 #import <JavaScriptCore/JavaScriptCore.h>
 
+#undef NS_AVAILABLE
+#define NS_AVAILABLE(_mac, _ios)
+
 #import "CurrentThisInsideBlockGetterTest.h"
+#import "DFGWorklist.h"
 #import "DateTests.h"
 #import "JSExportTests.h"
@@ -515 +520 @@
 }
 
+static void runJITThreadLimitTests()
+{
+    auto testDFG = [] {
+        unsigned defaultNumberOfThreads = JSC::Options::numberOfDFGCompilerThreads();
+        unsigned targetNumberOfThreads = 1;
+        unsigned initialNumberOfThreads = [JSVirtualMachine setNumberOfDFGCompilerThreads:1];
+        checkResult(@"Initial number of DFG threads should be the value provided through Options", initialNumberOfThreads == defaultNumberOfThreads);
+        unsigned updatedNumberOfThreads = [JSVirtualMachine setNumberOfDFGCompilerThreads:initialNumberOfThreads];
+        checkResult(@"Number of DFG threads should have been updated", updatedNumberOfThreads == targetNumberOfThreads);
+    };
+
+    auto testFTL = [] {
+        unsigned defaultNumberOfThreads = JSC::Options::numberOfFTLCompilerThreads();
+        unsigned targetNumberOfThreads = 3;
+        unsigned initialNumberOfThreads = [JSVirtualMachine setNumberOfFTLCompilerThreads:1];
+        checkResult(@"Initial number of FTL threads should be the value provided through Options", initialNumberOfThreads == defaultNumberOfThreads);
+        unsigned updatedNumberOfThreads = [JSVirtualMachine setNumberOfFTLCompilerThreads:initialNumberOfThreads];
+        checkResult(@"Number of FTL threads should have been updated", updatedNumberOfThreads == targetNumberOfThreads);
+    };
+
+    checkResult(@"runJITThreadLimitTests() must run at the very beginning to test the case where the global JIT worklist was not initialized yet", !JSC::DFG::existingGlobalDFGWorklistOrNull() && !JSC::DFG::existingGlobalFTLWorklistOrNull());
+
+    testDFG();
+    JSC::DFG::ensureGlobalDFGWorklist();
+    testDFG();
+
+    testFTL();
+    JSC::DFG::ensureGlobalFTLWorklist();
+    testFTL();
+}
+
 static void testObjectiveCAPIMain()
 {
+    runJITThreadLimitTests();
+
     @autoreleasepool {
         JSVirtualMachine* vm = [[JSVirtualMachine alloc] init];

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2018-06-25  Tadeu Zagallo  <tzagallo@apple.com>
+
+        Add API for configuring the number of threads used by DFG and FTL
+        https://bugs.webkit.org/show_bug.cgi?id=186859
+        <rdar://problem/41093519>
+
+        Reviewed by Filip Pizlo.
+
+        Add new private APIs for limiting the number of threads to be used by
+        the DFG and FTL compilers. It was already possible to configure the
+        limit through JSC Options, but now it can be changed at runtime, even
+        in the case when the VM is already running.
+
+        Add a test for both cases: when trying to configure the limit before
+        and after the Worklist has been created, but in order to simulate the
+        first scenario, we must guarantee that the test runs at the very
+        beginning, so I also added a check for that.
+
+        * API/JSVirtualMachine.mm:
+        (+[JSVirtualMachine setNumberOfDFGCompilerThreads:]):
+        (+[JSVirtualMachine setNumberOfFTLCompilerThreads:]):
+        * API/JSVirtualMachinePrivate.h:
+        * API/tests/testapi.mm:
+        (runJITThreadLimitTests):
+        (testObjectiveCAPIMain):
+        * dfg/DFGWorklist.cpp:
+        (JSC::DFG::Worklist::finishCreation):
+        (JSC::DFG::Worklist::createNewThread):
+        (JSC::DFG::Worklist::setNumberOfThreads):
+        * dfg/DFGWorklist.h:
+
 2018-06-25  Yusuke Suzuki  <utatane.tea@gmail.com>
 

trunk/Source/JavaScriptCore/dfg/DFGWorklist.cpp

@@ -201 +201 @@
     LockHolder locker(*m_lock);
     for (unsigned i = numberOfThreads; i--;) {
-        std::unique_ptr<ThreadData> data = std::make_unique<ThreadData>(this);
-        data->m_thread = adoptRef(new ThreadBody(locker, *this, *data, m_lock, m_planEnqueued.copyRef(), relativePriority));
-        m_threads.append(WTFMove(data));
-    }
+        createNewThread(locker, relativePriority);
+    }
+}
+
+void Worklist::createNewThread(const AbstractLocker& locker, int relativePriority)
+{
+    std::unique_ptr<ThreadData> data = std::make_unique<ThreadData>(this);
+    data->m_thread = adoptRef(new ThreadBody(locker, *this, *data, m_lock, m_planEnqueued.copyRef(), relativePriority));
+    m_threads.append(WTFMove(data));
 }
 
@@ -489 +494 @@
 }
 
+unsigned Worklist::setNumberOfThreads(unsigned numberOfThreads, int relativePriority)
+{
+    LockHolder locker(m_suspensionLock);
+    auto currentNumberOfThreads = m_threads.size();
+    if (numberOfThreads < currentNumberOfThreads) {
+        {
+            LockHolder locker(*m_lock);
+            for (unsigned i = currentNumberOfThreads; i-- > numberOfThreads;) {
+                if (m_threads[i]->m_thread->hasUnderlyingThread(locker)) {
+                    m_queue.append(nullptr);
+                    m_threads[i]->m_thread->notify(locker);
+                }
+            }
+        }
+        for (unsigned i = currentNumberOfThreads; i-- > numberOfThreads;) {
+            bool isStopped = false;
+            {
+                LockHolder locker(*m_lock);
+                isStopped = m_threads[i]->m_thread->tryStop(locker);
+            }
+            if (!isStopped)
+                m_threads[i]->m_thread->join();
+            m_threads.remove(i);
+        }
+        m_threads.shrinkToFit();
+        ASSERT(m_numberOfActiveThreads <= numberOfThreads);
+    } else if (numberOfThreads > currentNumberOfThreads) {
+        LockHolder locker(*m_lock);
+        for (unsigned i = currentNumberOfThreads; i < numberOfThreads; i++)
+            createNewThread(locker, relativePriority);
+    }
+    return currentNumberOfThreads;
+}
+
 static Worklist* theGlobalDFGWorklist;
 

trunk/Source/JavaScriptCore/dfg/DFGWorklist.h

@@ -80 +80 @@
     
     void dump(PrintStream&) const;
+    unsigned setNumberOfThreads(unsigned, int);
     
 private:
     Worklist(CString worklistName);
     void finishCreation(unsigned numberOfThreads, int);
+    void createNewThread(const AbstractLocker&, int);
     
     class ThreadBody;
@@ -122 +124 @@
 
 // For DFGMode compilations.
-Worklist& ensureGlobalDFGWorklist();
-Worklist* existingGlobalDFGWorklistOrNull();
+JS_EXPORT_PRIVATE Worklist& ensureGlobalDFGWorklist();
+JS_EXPORT_PRIVATE Worklist* existingGlobalDFGWorklistOrNull();
 
 // For FTLMode and FTLForOSREntryMode compilations.
-Worklist& ensureGlobalFTLWorklist();
-Worklist* existingGlobalFTLWorklistOrNull();
+JS_EXPORT_PRIVATE Worklist& ensureGlobalFTLWorklist();
+JS_EXPORT_PRIVATE Worklist* existingGlobalFTLWorklistOrNull();
 
 Worklist& ensureGlobalWorklistFor(CompilationMode);