Changeset 162352 in webkit


Ignore:
Timestamp:
Jan 20, 2014 9:10:36 AM (10 years ago)
Author:
andersca@apple.com
Message:

Convert GCThreadSharedData over to STL threading primitives
https://bugs.webkit.org/show_bug.cgi?id=127256

Reviewed by Andreas Kling.

  • 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/SlotVisitor.cpp:

(JSC::SlotVisitor::donateKnownParallel):
(JSC::SlotVisitor::drainFromShared):

Location:
trunk/Source/JavaScriptCore
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/JavaScriptCore/ChangeLog

    r162284 r162352  
     12014-01-19  Anders Carlsson  <andersca@apple.com>
     2
     3        Convert GCThreadSharedData over to STL threading primitives
     4        https://bugs.webkit.org/show_bug.cgi?id=127256
     5
     6        Reviewed by Andreas Kling.
     7
     8        * heap/GCThread.cpp:
     9        (JSC::GCThread::waitForNextPhase):
     10        (JSC::GCThread::gcThreadMain):
     11        * heap/GCThreadSharedData.cpp:
     12        (JSC::GCThreadSharedData::GCThreadSharedData):
     13        (JSC::GCThreadSharedData::~GCThreadSharedData):
     14        (JSC::GCThreadSharedData::startNextPhase):
     15        (JSC::GCThreadSharedData::endCurrentPhase):
     16        (JSC::GCThreadSharedData::didStartMarking):
     17        (JSC::GCThreadSharedData::didFinishMarking):
     18        * heap/GCThreadSharedData.h:
     19        * heap/SlotVisitor.cpp:
     20        (JSC::SlotVisitor::donateKnownParallel):
     21        (JSC::SlotVisitor::drainFromShared):
     22
    1232014-01-18  Andreas Kling  <akling@apple.com>
    224
  • trunk/Source/JavaScriptCore/heap/GCThread.cpp

    r140594 r162352  
    7070GCPhase GCThread::waitForNextPhase()
    7171{
    72     MutexLocker locker(m_shared.m_phaseLock);
    73     while (m_shared.m_gcThreadsShouldWait)
    74         m_shared.m_phaseCondition.wait(m_shared.m_phaseLock);
     72    std::unique_lock<std::mutex> lock(m_shared.m_phaseMutex);
     73    m_shared.m_phaseConditionVariable.wait(lock, [this] { return !m_shared.m_gcThreadsShouldWait; });
    7574
    7675    m_shared.m_numberOfActiveGCThreads--;
    7776    if (!m_shared.m_numberOfActiveGCThreads)
    78         m_shared.m_activityCondition.signal();
     77        m_shared.m_activityConditionVariable.notify_one();
    7978
    80     while (m_shared.m_currentPhase == NoPhase)
    81         m_shared.m_phaseCondition.wait(m_shared.m_phaseLock);
     79    m_shared.m_phaseConditionVariable.wait(lock, [this] { return m_shared.m_currentPhase != NoPhase; });
    8280    m_shared.m_numberOfActiveGCThreads++;
    8381    return m_shared.m_currentPhase;
     
    9391    // creating this thread. We aren't guaranteed to have a valid threadID until the main thread releases this lock.
    9492    {
    95         MutexLocker locker(m_shared.m_phaseLock);
     93        std::lock_guard<std::mutex> lock(m_shared.m_phaseMutex);
    9694    }
    9795    {
  • trunk/Source/JavaScriptCore/heap/GCThreadSharedData.cpp

    r162017 r162352  
    8484#if ENABLE(PARALLEL_GC)
    8585    // Grab the lock so the new GC threads can be properly initialized before they start running.
    86     MutexLocker locker(m_phaseLock);
     86    std::unique_lock<std::mutex> lock(m_phaseMutex);
    8787    for (unsigned i = 1; i < Options::numberOfGCMarkers(); ++i) {
    8888        m_numberOfActiveGCThreads++;
     
    9696
    9797    // Wait for all the GCThreads to get to the right place.
    98     while (m_numberOfActiveGCThreads)
    99         m_activityCondition.wait(m_phaseLock);
     98    m_activityConditionVariable.wait(lock, [this] { return !m_numberOfActiveGCThreads; });
    10099#endif
    101100}
     
    106105    // Destroy our marking threads.
    107106    {
    108         MutexLocker markingLocker(m_markingLock);
    109         MutexLocker phaseLocker(m_phaseLock);
     107        std::lock_guard<std::mutex> markingLock(m_markingMutex);
     108        std::lock_guard<std::mutex> phaseLock(m_phaseMutex);
    110109        ASSERT(m_currentPhase == NoPhase);
    111110        m_parallelMarkersShouldExit = true;
    112111        m_gcThreadsShouldWait = false;
    113112        m_currentPhase = Exit;
    114         m_phaseCondition.broadcast();
     113        m_phaseConditionVariable.notify_all();
    115114    }
    116115    for (unsigned i = 0; i < m_gcThreads.size(); ++i) {
     
    140139void GCThreadSharedData::startNextPhase(GCPhase phase)
    141140{
    142     MutexLocker phaseLocker(m_phaseLock);
     141    std::lock_guard<std::mutex> lock(m_phaseMutex);
    143142    ASSERT(!m_gcThreadsShouldWait);
    144143    ASSERT(m_currentPhase == NoPhase);
    145144    m_gcThreadsShouldWait = true;
    146145    m_currentPhase = phase;
    147     m_phaseCondition.broadcast();
     146    m_phaseConditionVariable.notify_all();
    148147}
    149148
     
    151150{
    152151    ASSERT(m_gcThreadsShouldWait);
    153     MutexLocker locker(m_phaseLock);
     152    std::unique_lock<std::mutex> lock(m_phaseMutex);
    154153    m_currentPhase = NoPhase;
    155154    m_gcThreadsShouldWait = false;
    156     m_phaseCondition.broadcast();
    157     while (m_numberOfActiveGCThreads)
    158         m_activityCondition.wait(m_phaseLock);
     155    m_phaseConditionVariable.notify_all();
     156    m_activityConditionVariable.wait(lock, [this] { return !m_numberOfActiveGCThreads; });
    159157}
    160158
    161159void GCThreadSharedData::didStartMarking()
    162160{
    163     MutexLocker markingLocker(m_markingLock);
     161    std::lock_guard<std::mutex> lock(m_markingMutex);
    164162    m_parallelMarkersShouldExit = false;
    165163    startNextPhase(Mark);
     
    169167{
    170168    {
    171         MutexLocker markingLocker(m_markingLock);
     169        std::lock_guard<std::mutex> lock(m_markingMutex);
    172170        m_parallelMarkersShouldExit = true;
    173         m_markingCondition.broadcast();
     171        m_markingConditionVariable.notify_all();
    174172    }
    175173
  • trunk/Source/JavaScriptCore/heap/GCThreadSharedData.h

    r155317 r162352  
    3232#include "UnconditionalFinalizer.h"
    3333#include "WeakReferenceHarvester.h"
     34#include <condition_variable>
    3435#include <wtf/HashSet.h>
    3536#include <wtf/TCSpinLock.h>
    36 #include <wtf/Threading.h>
    3737#include <wtf/Vector.h>
    3838
     
    8787    Vector<GCThread*> m_gcThreads;
    8888
    89     Mutex m_markingLock;
    90     ThreadCondition m_markingCondition;
     89    std::mutex m_markingMutex;
     90    std::condition_variable m_markingConditionVariable;
    9191    MarkStackArray m_sharedMarkStack;
    9292    unsigned m_numberOfActiveParallelMarkers;
     
    101101    static const size_t s_blockFragmentLength = 32;
    102102
    103     Mutex m_phaseLock;
    104     ThreadCondition m_phaseCondition;
    105     ThreadCondition m_activityCondition;
     103    std::mutex m_phaseMutex;
     104    std::condition_variable m_phaseConditionVariable;
     105    std::condition_variable m_activityConditionVariable;
    106106    unsigned m_numberOfActiveGCThreads;
    107107    bool m_gcThreadsShouldWait;
  • trunk/Source/JavaScriptCore/heap/SlotVisitor.cpp

    r161615 r162352  
    119119    // If we're contending on the lock, be conservative and assume that another
    120120    // thread is already donating.
    121     MutexTryLocker locker(m_shared.m_markingLock);
    122     if (!locker.locked())
     121    std::unique_lock<std::mutex> lock(m_shared.m_markingMutex, std::try_to_lock);
     122    if (!lock.owns_lock())
    123123        return;
    124124
     
    127127
    128128    if (m_shared.m_numberOfActiveParallelMarkers < Options::numberOfGCMarkers())
    129         m_shared.m_markingCondition.broadcast();
     129        m_shared.m_markingConditionVariable.notify_all();
    130130}
    131131
     
    182182#if ENABLE(PARALLEL_GC)
    183183    {
    184         MutexLocker locker(m_shared.m_markingLock);
     184        std::lock_guard<std::mutex> lock(m_shared.m_markingMutex);
    185185        m_shared.m_numberOfActiveParallelMarkers++;
    186186    }
    187187    while (true) {
    188188        {
    189             MutexLocker locker(m_shared.m_markingLock);
     189            std::unique_lock<std::mutex> lock(m_shared.m_markingMutex);
    190190            m_shared.m_numberOfActiveParallelMarkers--;
    191191
     
    198198                    if (!m_shared.m_numberOfActiveParallelMarkers && m_shared.m_sharedMarkStack.isEmpty()) {
    199199                        // Let any sleeping slaves know it's time for them to return;
    200                         m_shared.m_markingCondition.broadcast();
     200                        m_shared.m_markingConditionVariable.notify_all();
    201201                        return;
    202202                    }
     
    207207                   
    208208                    // Otherwise wait.
    209                     m_shared.m_markingCondition.wait(m_shared.m_markingLock);
     209                    m_shared.m_markingConditionVariable.wait(lock);
    210210                }
    211211            } else {
     
    214214                // Did we detect termination? If so, let the master know.
    215215                if (!m_shared.m_numberOfActiveParallelMarkers && m_shared.m_sharedMarkStack.isEmpty())
    216                     m_shared.m_markingCondition.broadcast();
    217                
    218                 while (m_shared.m_sharedMarkStack.isEmpty() && !m_shared.m_parallelMarkersShouldExit)
    219                     m_shared.m_markingCondition.wait(m_shared.m_markingLock);
     216                    m_shared.m_markingConditionVariable.notify_all();
     217
     218                m_shared.m_markingConditionVariable.wait(lock, [this] { return !m_shared.m_sharedMarkStack.isEmpty() || m_shared.m_parallelMarkersShouldExit; });
    220219               
    221220                // Is the current phase done? If so, return from this function.
Note: See TracChangeset for help on using the changeset viewer.