Changeset 188499 in webkit for trunk/Source/JavaScriptCore/profiler/ProfilerDatabase.h

Timestamp:

Aug 14, 2015, 5:14:52 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:

Relanding after fixing a deadlock on Linux.

• 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):

• wtf/ParkingLot.cpp:

(WTF::ParkingLot::parkConditionally): Work around a Linux C++ bug where wait_until with time_point::max() immediately returns and doesn't flash the lock.

File:

• trunk/Source/JavaScriptCore/profiler/ProfilerDatabase.h (modified) (2 diffs)

trunk/Source/JavaScriptCore/profiler/ProfilerDatabase.h

@@ -33 +33 @@
 #include <wtf/FastMalloc.h>
 #include <wtf/HashMap.h>
+#include <wtf/Lock.h>
 #include <wtf/Noncopyable.h>
 #include <wtf/PassRefPtr.h>
@@ -71 +72 @@
     
 private:
-    // Use a full-blown adaptive mutex because:
-    // - There is only one ProfilerDatabase per VM. The size overhead of the system's
-    //   mutex is negligible if you only have one of them.
-    // - It's locked infrequently - once per bytecode generation, compilation, and
-    //   code block collection - so the fact that the fast path still requires a
-    //   function call is neglible.
-    // - It tends to be held for a while. Currently, we hold it while generating
-    //   Profiler::Bytecodes for a CodeBlock. That's uncommon and shouldn't affect
-    //   performance, but if we did have contention, we would want a sensible,
-    //   power-aware backoff. An adaptive mutex will do this as a matter of course,
-    //   but a spinlock won't.
-    typedef Mutex Lock;
-    typedef MutexLocker Locker;
-    
-
     void addDatabaseToAtExit();
     void removeDatabaseFromAtExit();