Changeset 225617 in webkit


Ignore:
Timestamp:
Dec 6, 2017 7:52:09 PM (6 years ago)
Author:
Yusuke Suzuki
Message:

[WTF] Remove XXXLockBase since constexpr constructor can initialize static variables without calling global constructors
​https://bugs.webkit.org/show_bug.cgi?id=180495

Reviewed by Mark Lam.

Very nice feature of C++11 is that constexpr constructor can initialize static global variables
without calling global constructors. We do not need to have XXXLockBase with derived XXXLock
class since StaticXXXLock can have constructors as long as it is constexpr.
We remove bunch of these classes, and set XXXLock() = default; explicitly for readability.
C++11's default constructor is constexpr as long as its member's default constructor / default
initializer is constexpr.

  • wtf/Condition.h:

(WTF::ConditionBase::construct): Deleted.
(WTF::ConditionBase::waitUntil): Deleted.
(WTF::ConditionBase::waitFor): Deleted.
(WTF::ConditionBase::wait): Deleted.
(WTF::ConditionBase::notifyOne): Deleted.
(WTF::ConditionBase::notifyAll): Deleted.
(WTF::Condition::Condition): Deleted.

  • wtf/CountingLock.h:

(WTF::CountingLock::CountingLock): Deleted.
(WTF::CountingLock::~CountingLock): Deleted.

  • wtf/Lock.cpp:

(WTF::Lock::lockSlow):
(WTF::Lock::unlockSlow):
(WTF::Lock::unlockFairlySlow):
(WTF::Lock::safepointSlow):
(WTF::LockBase::lockSlow): Deleted.
(WTF::LockBase::unlockSlow): Deleted.
(WTF::LockBase::unlockFairlySlow): Deleted.
(WTF::LockBase::safepointSlow): Deleted.

  • wtf/Lock.h:

(WTF::LockBase::construct): Deleted.
(WTF::LockBase::lock): Deleted.
(WTF::LockBase::tryLock): Deleted.
(WTF::LockBase::try_lock): Deleted.
(WTF::LockBase::unlock): Deleted.
(WTF::LockBase::unlockFairly): Deleted.
(WTF::LockBase::safepoint): Deleted.
(WTF::LockBase::isHeld const): Deleted.
(WTF::LockBase::isLocked const): Deleted.
(WTF::LockBase::isFullyReset const): Deleted.
(WTF::Lock::Lock): Deleted.

  • wtf/ReadWriteLock.cpp:

(WTF::ReadWriteLock::readLock):
(WTF::ReadWriteLock::readUnlock):
(WTF::ReadWriteLock::writeLock):
(WTF::ReadWriteLock::writeUnlock):
(WTF::ReadWriteLockBase::construct): Deleted.
(WTF::ReadWriteLockBase::readLock): Deleted.
(WTF::ReadWriteLockBase::readUnlock): Deleted.
(WTF::ReadWriteLockBase::writeLock): Deleted.
(WTF::ReadWriteLockBase::writeUnlock): Deleted.

  • wtf/ReadWriteLock.h:

(WTF::ReadWriteLock::read):
(WTF::ReadWriteLock::write):
(WTF::ReadWriteLockBase::ReadLock::tryLock): Deleted.
(WTF::ReadWriteLockBase::ReadLock::lock): Deleted.
(WTF::ReadWriteLockBase::ReadLock::unlock): Deleted.
(WTF::ReadWriteLockBase::WriteLock::tryLock): Deleted.
(WTF::ReadWriteLockBase::WriteLock::lock): Deleted.
(WTF::ReadWriteLockBase::WriteLock::unlock): Deleted.
(WTF::ReadWriteLockBase::read): Deleted.
(WTF::ReadWriteLockBase::write): Deleted.
(WTF::ReadWriteLock::ReadWriteLock): Deleted.

  • wtf/RecursiveLockAdapter.h:

(WTF::RecursiveLockAdapter::RecursiveLockAdapter): Deleted.

  • wtf/WordLock.cpp:

(WTF::WordLock::lockSlow):
(WTF::WordLock::unlockSlow):
(WTF::WordLockBase::lockSlow): Deleted.
(WTF::WordLockBase::unlockSlow): Deleted.

  • wtf/WordLock.h:

(WTF::WordLockBase::lock): Deleted.
(WTF::WordLockBase::unlock): Deleted.
(WTF::WordLockBase::isHeld const): Deleted.
(WTF::WordLockBase::isLocked const): Deleted.
(WTF::WordLockBase::isFullyReset const): Deleted.
(WTF::WordLock::WordLock): Deleted.

  • wtf/WorkQueue.cpp:
Location:
trunk/Source/WTF
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r225563 r225617  
     12017-12-06  Yusuke Suzuki  <utatane.tea@gmail.com>
     2
     3        [WTF] Remove XXXLockBase since constexpr constructor can initialize static variables without calling global constructors
     4        https://bugs.webkit.org/show_bug.cgi?id=180495
     5
     6        Reviewed by Mark Lam.
     7
     8        Very nice feature of C++11 is that constexpr constructor can initialize static global variables
     9        without calling global constructors. We do not need to have XXXLockBase with derived XXXLock
     10        class since StaticXXXLock can have constructors as long as it is constexpr.
     11        We remove bunch of these classes, and set `XXXLock() = default;` explicitly for readability.
     12        C++11's default constructor is constexpr as long as its member's default constructor / default
     13        initializer is constexpr.
     14
     15        * wtf/Condition.h:
     16        (WTF::ConditionBase::construct): Deleted.
     17        (WTF::ConditionBase::waitUntil): Deleted.
     18        (WTF::ConditionBase::waitFor): Deleted.
     19        (WTF::ConditionBase::wait): Deleted.
     20        (WTF::ConditionBase::notifyOne): Deleted.
     21        (WTF::ConditionBase::notifyAll): Deleted.
     22        (WTF::Condition::Condition): Deleted.
     23        * wtf/CountingLock.h:
     24        (WTF::CountingLock::CountingLock): Deleted.
     25        (WTF::CountingLock::~CountingLock): Deleted.
     26        * wtf/Lock.cpp:
     27        (WTF::Lock::lockSlow):
     28        (WTF::Lock::unlockSlow):
     29        (WTF::Lock::unlockFairlySlow):
     30        (WTF::Lock::safepointSlow):
     31        (WTF::LockBase::lockSlow): Deleted.
     32        (WTF::LockBase::unlockSlow): Deleted.
     33        (WTF::LockBase::unlockFairlySlow): Deleted.
     34        (WTF::LockBase::safepointSlow): Deleted.
     35        * wtf/Lock.h:
     36        (WTF::LockBase::construct): Deleted.
     37        (WTF::LockBase::lock): Deleted.
     38        (WTF::LockBase::tryLock): Deleted.
     39        (WTF::LockBase::try_lock): Deleted.
     40        (WTF::LockBase::unlock): Deleted.
     41        (WTF::LockBase::unlockFairly): Deleted.
     42        (WTF::LockBase::safepoint): Deleted.
     43        (WTF::LockBase::isHeld const): Deleted.
     44        (WTF::LockBase::isLocked const): Deleted.
     45        (WTF::LockBase::isFullyReset const): Deleted.
     46        (WTF::Lock::Lock): Deleted.
     47        * wtf/ReadWriteLock.cpp:
     48        (WTF::ReadWriteLock::readLock):
     49        (WTF::ReadWriteLock::readUnlock):
     50        (WTF::ReadWriteLock::writeLock):
     51        (WTF::ReadWriteLock::writeUnlock):
     52        (WTF::ReadWriteLockBase::construct): Deleted.
     53        (WTF::ReadWriteLockBase::readLock): Deleted.
     54        (WTF::ReadWriteLockBase::readUnlock): Deleted.
     55        (WTF::ReadWriteLockBase::writeLock): Deleted.
     56        (WTF::ReadWriteLockBase::writeUnlock): Deleted.
     57        * wtf/ReadWriteLock.h:
     58        (WTF::ReadWriteLock::read):
     59        (WTF::ReadWriteLock::write):
     60        (WTF::ReadWriteLockBase::ReadLock::tryLock): Deleted.
     61        (WTF::ReadWriteLockBase::ReadLock::lock): Deleted.
     62        (WTF::ReadWriteLockBase::ReadLock::unlock): Deleted.
     63        (WTF::ReadWriteLockBase::WriteLock::tryLock): Deleted.
     64        (WTF::ReadWriteLockBase::WriteLock::lock): Deleted.
     65        (WTF::ReadWriteLockBase::WriteLock::unlock): Deleted.
     66        (WTF::ReadWriteLockBase::read): Deleted.
     67        (WTF::ReadWriteLockBase::write): Deleted.
     68        (WTF::ReadWriteLock::ReadWriteLock): Deleted.
     69        * wtf/RecursiveLockAdapter.h:
     70        (WTF::RecursiveLockAdapter::RecursiveLockAdapter): Deleted.
     71        * wtf/WordLock.cpp:
     72        (WTF::WordLock::lockSlow):
     73        (WTF::WordLock::unlockSlow):
     74        (WTF::WordLockBase::lockSlow): Deleted.
     75        (WTF::WordLockBase::unlockSlow): Deleted.
     76        * wtf/WordLock.h:
     77        (WTF::WordLockBase::lock): Deleted.
     78        (WTF::WordLockBase::unlock): Deleted.
     79        (WTF::WordLockBase::isHeld const): Deleted.
     80        (WTF::WordLockBase::isLocked const): Deleted.
     81        (WTF::WordLockBase::isFullyReset const): Deleted.
     82        (WTF::WordLock::WordLock): Deleted.
     83        * wtf/WorkQueue.cpp:
     84
    1852017-12-05  Stephan Szabo  <stephan.szabo@sony.com>
    286

  • trunk/Source/WTF/wtf/Condition.h

    r220322 r225617  
    4242// case where no thread is waiting. This condition variable, when used with WTF::Lock, can
    4343// outperform a system condition variable and lock by up to 58x.
    44 
    45 // This is a struct without a constructor or destructor so that it can be statically initialized.
    46 // Use Lock in instance variables.
    47 struct ConditionBase {
     44class Condition {
     45    WTF_MAKE_NONCOPYABLE(Condition);
     46public:
    4847    // Condition will accept any kind of time and convert it internally, but this typedef tells
    4948    // you what kind of time Condition would be able to use without conversions. However, if you
    5049    // are unlikely to be affected by the cost of conversions, it is better to use MonotonicTime.
    51     typedef ParkingLot::Time Time;
    52    
    53     void construct()
    54     {
    55         m_hasWaiters.store(false);
    56     }
    57    
     50    using Time = ParkingLot::Time;
     51
     52    Condition() = default;
     53
    5854    // Wait on a parking queue while releasing the given lock. It will unlock the lock just before
    5955    // parking, and relock it upon wakeup. Returns true if we woke up due to some call to
    … …  
    175171   
    176172private:
    177     Atomic<bool> m_hasWaiters;
     173    Atomic<bool> m_hasWaiters { false };
    178174};
    179175
    180 class Condition : public ConditionBase {
    181     WTF_MAKE_NONCOPYABLE(Condition);
    182 public:
    183     Condition()
    184     {
    185         construct();
    186     }
    187 };
    188 
    189 typedef ConditionBase StaticCondition;
     176using StaticCondition = Condition;
    190177
    191178} // namespace WTF

  • trunk/Source/WTF/wtf/CountingLock.h

    r225524 r225617  
    5656
    5757class CountingLock {
     58    WTF_MAKE_NONCOPYABLE(CountingLock);
     59    WTF_MAKE_FAST_ALLOCATED;
     60
    5861    typedef unsigned LockType;
    5962   
    … …  
    7881   
    7982public:
    80     CountingLock()
    81     {
    82         m_word.storeRelaxed(0);
    83     }
    84    
    85     ~CountingLock()
    86     {
    87     }
     83    CountingLock() = default;
    8884   
    8985    bool tryLock()
    … …  
    266262    }
    267263   
    268     Atomic<LockType> m_word;
     264    Atomic<LockType> m_word { 0 };
    269265};
    270266

  • trunk/Source/WTF/wtf/Lock.cpp

    r225524 r225617  
    3434static constexpr bool profileLockContention = false;
    3535
    36 void LockBase::lockSlow()
     36void Lock::lockSlow()
    3737{
    3838    if (profileLockContention)
    … …  
    4141}
    4242
    43 void LockBase::unlockSlow()
     43void Lock::unlockSlow()
    4444{
    4545    DefaultLockAlgorithm::unlockSlow(m_byte, DefaultLockAlgorithm::Unfair);
    4646}
    4747
    48 void LockBase::unlockFairlySlow()
     48void Lock::unlockFairlySlow()
    4949{
    5050    DefaultLockAlgorithm::unlockSlow(m_byte, DefaultLockAlgorithm::Fair);
    5151}
    5252
    53 void LockBase::safepointSlow()
     53void Lock::safepointSlow()
    5454{
    5555    DefaultLockAlgorithm::safepointSlow(m_byte);

  • trunk/Source/WTF/wtf/Lock.h

    r220322 r225617  
    4949// the head of the queue. When there are collisions, each collision increases the fair unlock delay
    5050// by one millisecond in the worst case.
     51class Lock {
     52    WTF_MAKE_NONCOPYABLE(Lock);
     53    WTF_MAKE_FAST_ALLOCATED;
     54public:
     55    Lock() = default;
    5156
    52 // This is a struct without a constructor or destructor so that it can be statically initialized.
    53 // Use Lock in instance variables.
    54 struct LockBase {
    55     void construct()
    56     {
    57         m_byte.store(0, std::memory_order_relaxed);
    58     }
    59    
    6057    void lock()
    6158    {
    … …  
    133130    }
    134131
    135     Atomic<uint8_t> m_byte;
     132    Atomic<uint8_t> m_byte { 0 };
    136133};
    137134
    138 class Lock : public LockBase {
    139     WTF_MAKE_NONCOPYABLE(Lock);
    140     WTF_MAKE_FAST_ALLOCATED;
    141 public:
    142     Lock()
    143     {
    144         construct();
    145     }
    146 };
    147 
    148 typedef LockBase StaticLock;
    149 typedef Locker<LockBase> LockHolder;
     135using StaticLock = Lock;
     136using LockHolder = Locker<Lock>;
    150137
    151138} // namespace WTF

  • trunk/Source/WTF/wtf/ReadWriteLock.cpp

    r220322 r225617  
    3131namespace WTF {
    3232
    33 void ReadWriteLockBase::construct()
    34 {
    35     m_lock.construct();
    36     m_cond.construct();
    37     m_isWriteLocked = false;
    38     m_numReaders = 0;
    39     m_numWaitingWriters = 0;
    40 }
    41 
    42 void ReadWriteLockBase::readLock()
     33void ReadWriteLock::readLock()
    4334{
    4435    auto locker = holdLock(m_lock);
    … …  
    4839}
    4940
    50 void ReadWriteLockBase::readUnlock()
     41void ReadWriteLock::readUnlock()
    5142{
    5243    auto locker = holdLock(m_lock);
    … …  
    5647}
    5748
    58 void ReadWriteLockBase::writeLock()
     49void ReadWriteLock::writeLock()
    5950{
    6051    auto locker = holdLock(m_lock);
    … …  
    6758}
    6859
    69 void ReadWriteLockBase::writeUnlock()
     60void ReadWriteLock::writeUnlock()
    7061{
    7162    auto locker = holdLock(m_lock);

  • trunk/Source/WTF/wtf/ReadWriteLock.h

    r220322 r225617  
    3636// the longer the read critical section has to be for this locking scheme to be profitable.
    3737
    38 struct ReadWriteLockBase {
    39     WTF_EXPORT_PRIVATE void construct();
    40    
     38class ReadWriteLock {
     39    WTF_MAKE_NONCOPYABLE(ReadWriteLock);
     40    WTF_MAKE_FAST_ALLOCATED;
     41public:
     42    ReadWriteLock() = default;
     43
    4144    // It's easiest to read lock like this:
    4245    //
    … …  
    5962
    6063private:
    61     // These fields must work when zero-filled, so that StaticReadWriteLock works.
    62     LockBase m_lock;
    63     ConditionBase m_cond;
    64     bool m_isWriteLocked;
    65     unsigned m_numReaders;
    66     unsigned m_numWaitingWriters;
     64    Lock m_lock;
     65    Condition m_cond;
     66    bool m_isWriteLocked { false };
     67    unsigned m_numReaders { 0 };
     68    unsigned m_numWaitingWriters { 0 };
    6769};
    6870
    69 class ReadWriteLockBase::ReadLock : public ReadWriteLockBase {
     71class ReadWriteLock::ReadLock : public ReadWriteLock {
    7072public:
    7173    bool tryLock() { return false; }
    … …  
    7476};
    7577
    76 class ReadWriteLockBase::WriteLock : public ReadWriteLockBase {
     78class ReadWriteLock::WriteLock : public ReadWriteLock {
    7779public:
    7880    bool tryLock() { return false; }
    … …  
    8183};
    8284   
    83 inline ReadWriteLockBase::ReadLock& ReadWriteLockBase::read() { return *static_cast<ReadLock*>(this); }
    84 inline ReadWriteLockBase::WriteLock& ReadWriteLockBase::write() { return *static_cast<WriteLock*>(this); }
     85inline ReadWriteLock::ReadLock& ReadWriteLock::read() { return *static_cast<ReadLock*>(this); }
     86inline ReadWriteLock::WriteLock& ReadWriteLock::write() { return *static_cast<WriteLock*>(this); }
    8587
    86 class ReadWriteLock : public ReadWriteLockBase {
    87 public:
    88     ReadWriteLock()
    89     {
    90         construct();
    91     }
    92 };
    93 
    94 typedef ReadWriteLockBase StaticReadWriteLock;
     88using StaticReadWriteLock = ReadWriteLock;
    9589
    9690} // namespace WTF

  • trunk/Source/WTF/wtf/RecursiveLockAdapter.h

    r225470 r225617  
    3333class RecursiveLockAdapter {
    3434public:
    35     RecursiveLockAdapter()
    36     {
    37     }
    38    
     35    RecursiveLockAdapter() = default;
     36
    3937    void lock()
    4038    {

  • trunk/Source/WTF/wtf/WordLock.cpp

    r223965 r225617  
    7777} // anonymous namespace
    7878
    79 NEVER_INLINE void WordLockBase::lockSlow()
     79NEVER_INLINE void WordLock::lockSlow()
    8080{
    8181    unsigned spinCount = 0;
    … …  
    178178}
    179179
    180 NEVER_INLINE void WordLockBase::unlockSlow()
     180NEVER_INLINE void WordLock::unlockSlow()
    181181{
    182182    // The fast path can fail either because of spurious weak CAS failure, or because someone put a

  • trunk/Source/WTF/wtf/WordLock.h

    r209808 r225617  
    4747// try to use dataLog to debug this code, you will have a bad time.
    4848
    49 struct WordLockBase {
     49class WordLock {
     50    WTF_MAKE_NONCOPYABLE(WordLock);
     51    WTF_MAKE_FAST_ALLOCATED;
     52public:
     53    WordLock() = default;
     54
    5055    void lock()
    5156    {
    … …  
    9499    }
    95100
    96     Atomic<uintptr_t> m_word;
     101    Atomic<uintptr_t> m_word { 0 };
    97102};
    98103
    99 class WordLock : public WordLockBase {
    100     WTF_MAKE_NONCOPYABLE(WordLock);
    101 public:
    102     WordLock()
    103     {
    104         m_word.store(0, std::memory_order_relaxed);
    105     }
    106 };
    107 
    108 typedef WordLockBase StaticWordLock;
    109 typedef Locker<WordLockBase> WordLockHolder;
     104using StaticWordLock = WordLock;
     105using WordLockHolder = Locker<WordLock>;
    110106
    111107} // namespace WTF

  • trunk/Source/WTF/wtf/WorkQueue.cpp

    • Property svn:executable deleted
Note: See TracChangeset for help on using the changeset viewer.