Changeset 188444 in webkit for trunk/Source/JavaScriptCore/disassembler

Timestamp:

Aug 13, 2015, 11:46:46 PM (10 years ago)

Author:

[email protected]

Message:

Use WTF::Lock and WTF::Condition instead of WTF::Mutex, WTF::ThreadCondition, std::mutex, and std::condition_variable
​https://bugs.webkit.org/show_bug.cgi?id=147999

Reviewed by Geoffrey Garen.

Source/JavaScriptCore:

• API/JSVirtualMachine.mm:

(initWrapperCache):
(+[JSVMWrapperCache addWrapper:forJSContextGroupRef:]):
(+[JSVMWrapperCache wrapperForJSContextGroupRef:]):
(wrapperCacheMutex): Deleted.

• bytecode/SamplingTool.cpp:

(JSC::SamplingTool::doRun):
(JSC::SamplingTool::notifyOfScope):

• bytecode/SamplingTool.h:
• dfg/DFGThreadData.h:
• dfg/DFGWorklist.cpp:

(JSC::DFG::Worklist::~Worklist):
(JSC::DFG::Worklist::isActiveForVM):
(JSC::DFG::Worklist::enqueue):
(JSC::DFG::Worklist::compilationState):
(JSC::DFG::Worklist::waitUntilAllPlansForVMAreReady):
(JSC::DFG::Worklist::removeAllReadyPlansForVM):
(JSC::DFG::Worklist::completeAllReadyPlansForVM):
(JSC::DFG::Worklist::visitWeakReferences):
(JSC::DFG::Worklist::removeDeadPlans):
(JSC::DFG::Worklist::queueLength):
(JSC::DFG::Worklist::dump):
(JSC::DFG::Worklist::runThread):

• dfg/DFGWorklist.h:
• disassembler/Disassembler.cpp:
• heap/CopiedSpace.cpp:

(JSC::CopiedSpace::doneFillingBlock):
(JSC::CopiedSpace::doneCopying):

• heap/CopiedSpace.h:
• heap/CopiedSpaceInlines.h:

(JSC::CopiedSpace::recycleBorrowedBlock):
(JSC::CopiedSpace::allocateBlockForCopyingPhase):

• heap/GCThread.cpp:

(JSC::GCThread::waitForNextPhase):
(JSC::GCThread::gcThreadMain):

• heap/GCThreadSharedData.cpp:

(JSC::GCThreadSharedData::GCThreadSharedData):
(JSC::GCThreadSharedData::~GCThreadSharedData):
(JSC::GCThreadSharedData::startNextPhase):
(JSC::GCThreadSharedData::endCurrentPhase):
(JSC::GCThreadSharedData::didStartMarking):
(JSC::GCThreadSharedData::didFinishMarking):

• heap/GCThreadSharedData.h:
• heap/HeapTimer.h:
• heap/MachineStackMarker.cpp:

(JSC::ActiveMachineThreadsManager::Locker::Locker):
(JSC::ActiveMachineThreadsManager::add):
(JSC::ActiveMachineThreadsManager::remove):
(JSC::ActiveMachineThreadsManager::ActiveMachineThreadsManager):
(JSC::MachineThreads::~MachineThreads):
(JSC::MachineThreads::addCurrentThread):
(JSC::MachineThreads::removeThreadIfFound):
(JSC::MachineThreads::tryCopyOtherThreadStack):
(JSC::MachineThreads::tryCopyOtherThreadStacks):
(JSC::MachineThreads::gatherConservativeRoots):

• heap/MachineStackMarker.h:
• heap/SlotVisitor.cpp:

(JSC::SlotVisitor::donateKnownParallel):
(JSC::SlotVisitor::drain):
(JSC::SlotVisitor::drainFromShared):
(JSC::SlotVisitor::mergeOpaqueRoots):

• heap/SlotVisitorInlines.h:

(JSC::SlotVisitor::containsOpaqueRootTriState):

• inspector/remote/RemoteInspectorDebuggableConnection.h:
• inspector/remote/RemoteInspectorDebuggableConnection.mm:

(Inspector::RemoteInspectorHandleRunSourceGlobal):
(Inspector::RemoteInspectorQueueTaskOnGlobalQueue):
(Inspector::RemoteInspectorInitializeGlobalQueue):
(Inspector::RemoteInspectorHandleRunSourceWithInfo):
(Inspector::RemoteInspectorDebuggableConnection::setup):
(Inspector::RemoteInspectorDebuggableConnection::closeFromDebuggable):
(Inspector::RemoteInspectorDebuggableConnection::close):
(Inspector::RemoteInspectorDebuggableConnection::sendMessageToBackend):
(Inspector::RemoteInspectorDebuggableConnection::queueTaskOnPrivateRunLoop):

• interpreter/JSStack.cpp:

(JSC::JSStack::JSStack):
(JSC::JSStack::releaseExcessCapacity):
(JSC::JSStack::addToCommittedByteCount):
(JSC::JSStack::committedByteCount):
(JSC::stackStatisticsMutex): Deleted.
(JSC::JSStack::initializeThreading): Deleted.

• interpreter/JSStack.h:

(JSC::JSStack::gatherConservativeRoots):
(JSC::JSStack::sanitizeStack):
(JSC::JSStack::size):
(JSC::JSStack::initializeThreading): Deleted.

• jit/ExecutableAllocator.cpp:

(JSC::DemandExecutableAllocator::DemandExecutableAllocator):
(JSC::DemandExecutableAllocator::~DemandExecutableAllocator):
(JSC::DemandExecutableAllocator::bytesAllocatedByAllAllocators):
(JSC::DemandExecutableAllocator::bytesCommittedByAllocactors):
(JSC::DemandExecutableAllocator::dumpProfileFromAllAllocators):
(JSC::DemandExecutableAllocator::allocators):
(JSC::DemandExecutableAllocator::allocatorsMutex):

• jit/JITThunks.cpp:

(JSC::JITThunks::ctiStub):

• jit/JITThunks.h:
• profiler/ProfilerDatabase.cpp:

(JSC::Profiler::Database::ensureBytecodesFor):
(JSC::Profiler::Database::notifyDestruction):

• profiler/ProfilerDatabase.h:
• runtime/InitializeThreading.cpp:

(JSC::initializeThreading):

• runtime/JSLock.cpp:

(JSC::GlobalJSLock::GlobalJSLock):
(JSC::GlobalJSLock::~GlobalJSLock):
(JSC::JSLockHolder::JSLockHolder):
(JSC::GlobalJSLock::initialize): Deleted.

• runtime/JSLock.h:

Source/WTF:

• wtf/Condition.h: "using WTF::Condition".
• wtf/Lock.h:

(WTF::LockBase::lock):
(WTF::LockBase::tryLock): Add tryLock() because it turns out that we use it sometimes.
(WTF::LockBase::try_lock): unique_lock needs this.
(WTF::LockBase::unlock):

File:

• trunk/Source/JavaScriptCore/disassembler/Disassembler.cpp (modified) (4 diffs)

trunk/Source/JavaScriptCore/disassembler/Disassembler.cpp

@@ -28 +28 @@
 
 #include "MacroAssemblerCodeRef.h"
+#include <wtf/Condition.h>
 #include <wtf/DataLog.h>
 #include <wtf/Deque.h>
+#include <wtf/Lock.h>
 #include <wtf/NeverDestroyed.h>
 #include <wtf/StringPrintStream.h>
 #include <wtf/Threading.h>
-#include <wtf/ThreadingPrimitives.h>
 
 namespace JSC {
@@ -79 +80 @@
     void enqueue(std::unique_ptr<DisassemblyTask> task)
     {
-        MutexLocker locker(m_lock);
+        LockHolder locker(m_lock);
         m_queue.append(WTF::move(task));
-        m_condition.broadcast();
+        m_condition.notifyAll();
     }
     
     void waitUntilEmpty()
     {
-        MutexLocker locker(m_lock);
+        LockHolder locker(m_lock);
         while (!m_queue.isEmpty() || m_working)
             m_condition.wait(m_lock);
@@ -97 +98 @@
             std::unique_ptr<DisassemblyTask> task;
             {
-                MutexLocker locker(m_lock);
+                LockHolder locker(m_lock);
                 m_working = false;
-                m_condition.broadcast();
+                m_condition.notifyAll();
                 while (m_queue.isEmpty())
                     m_condition.wait(m_lock);
@@ -113 +114 @@
     }
     
-    Mutex m_lock;
-    ThreadCondition m_condition;
+    Lock m_lock;
+    Condition m_condition;
     Deque<std::unique_ptr<DisassemblyTask>> m_queue;
     bool m_working { false };