ReadWriteLock upgradeToWrite fix for simultaneous upgrades.

quantum/impl/quantum_read_write_mutex_impl.h

@@ -91,7 +91,8 @@ void ReadWriteMutex::upgradeToWrite()
 inline
 void ReadWriteMutex::upgradeToWrite(ICoroSync::Ptr sync)
 {
-    while (!tryUpgradeToWrite())
+    bool pendingUpgrade = false;
+    while (!tryUpgradeToWriteImpl(&pendingUpgrade))
     {
         yield(sync);
     }
@@ -100,7 +101,19 @@ void ReadWriteMutex::upgradeToWrite(ICoroSync::Ptr sync)
 inline
 bool ReadWriteMutex::tryUpgradeToWrite()
 {
-    bool rc = _spinlock.tryUpgradeToWrite();
+    return tryUpgradeToWriteImpl(nullptr);
+}
+
+inline
+bool ReadWriteMutex::tryUpgradeToWriteImpl(bool* pendingUpgrade)
+{
+    bool rc;
+    if (pendingUpgrade) {
+        rc = _spinlock.tryUpgradeToWrite(*pendingUpgrade);
+    }
+    else {
+        rc = _spinlock.tryUpgradeToWrite();
+    }
     if (rc)
     {
         _taskId = local::taskId();
@@ -119,7 +132,6 @@ void ReadWriteMutex::unlockWrite()
 {
     assert(_taskId == local::taskId());
     _taskId = TaskId{}; //reset the task id
-
     _spinlock.unlockWrite();
 }
 

quantum/impl/quantum_read_write_spinlock_impl.h

@@ -71,25 +71,25 @@ namespace quantum {
 inline
 void ReadWriteSpinLock::lockRead()
 {
-    SpinLockUtil::lockRead(_count);
+    SpinLockUtil::lockRead(_count, LockTraits::Attempt::Unlimited);
 }
 
 inline
 void ReadWriteSpinLock::lockWrite()
 {
-    SpinLockUtil::lockWrite(_count);
+    SpinLockUtil::lockWrite(_count, LockTraits::Attempt::Unlimited);
 }
 
 inline
 bool ReadWriteSpinLock::tryLockRead()
 {
-    return SpinLockUtil::lockRead(_count, true);
+    return SpinLockUtil::lockRead(_count, LockTraits::Attempt::Once);
 }
 
 inline
 bool ReadWriteSpinLock::tryLockWrite()
 {
-    return SpinLockUtil::lockWrite(_count, true);
+    return SpinLockUtil::lockWrite(_count, LockTraits::Attempt::Once);
 }
 
 inline
@@ -107,13 +107,19 @@ void ReadWriteSpinLock::unlockWrite()
 inline
 void ReadWriteSpinLock::upgradeToWrite()
 {
-    SpinLockUtil::upgradeToWrite(_count);
+    SpinLockUtil::upgradeToWrite(_count, LockTraits::Attempt::Unlimited);
 }
 
 inline
 bool ReadWriteSpinLock::tryUpgradeToWrite()
 {
-    return SpinLockUtil::upgradeToWrite(_count, true);
+    return SpinLockUtil::upgradeToWrite(_count, LockTraits::Attempt::Once);
+}
+
+inline
+bool ReadWriteSpinLock::tryUpgradeToWrite(bool& pendingUpgrade)
+{
+    return SpinLockUtil::upgradeToWrite(_count, pendingUpgrade, LockTraits::Attempt::Reentrant);
 }
 
 inline

quantum/impl/quantum_spinlock_impl.h

@@ -31,13 +31,13 @@ namespace quantum {
 inline
 void SpinLock::lock()
 {
-    SpinLockUtil::lockWrite(_flag);
+    SpinLockUtil::lockWrite(_flag, LockTraits::Attempt::Unlimited);
 }
 
 inline
 bool SpinLock::tryLock()
 {
-    return SpinLockUtil::lockWrite(_flag, true);
+    return SpinLockUtil::lockWrite(_flag, LockTraits::Attempt::Once);
 }
 
 inline

quantum/quantum_read_write_mutex.h

@@ -194,6 +194,8 @@ class ReadWriteMutex
     };
 
 private:
+    bool tryUpgradeToWriteImpl(bool* pendingUpgrade);
+
     // Members
     mutable ReadWriteSpinLock   _spinlock;
     mutable TaskId              _taskId;

quantum/quantum_read_write_spinlock.h

@@ -67,8 +67,11 @@ class ReadWriteSpinLock
     void upgradeToWrite();
 
     /// @brief Attempts to upgrade a reader lock to a writer lock. This operation never blocks.
+    /// @param pendingUpdate Use this overload when calling this function in a loop.
+    ///                      PendingUpdate must be initialized to 'false'.
     /// @return True if the lock operation succeeded, false otherwise.
     bool tryUpgradeToWrite();
+    bool tryUpgradeToWrite(bool& pendingUpdate);
 
     /// @bried Determines if this object is either read or write locked.
     /// @return True if locked, false otherwise.

quantum/quantum_spinlock_traits.h

@@ -75,6 +75,11 @@ struct SpinLockTraits {
 //==============================================================================
 struct LockTraits
 {
+    enum class Attempt : uint8_t {
+        Once,         ///> Try to obtain lock once and return success of failure
+        Unlimited,    ///> Try until lock is obtained
+        Reentrant     ///> Try continuously but return on each iteration w/o blocking
+    };
     using TryToLock = std::try_to_lock_t;
     using AdoptLock = std::adopt_lock_t;
     using DeferLock = std::defer_lock_t;

quantum/util/impl/quantum_sequencer_impl.h

@@ -373,12 +373,8 @@ Sequencer<SequenceKey, Hash, KeyEqual, Allocator>::singleSequenceKeyTaskSchedule
         FUNC&& func,
         ARGS&&... args)
 {
-    // find the dependent
-    typename ContextMap::iterator contextIt = sequencer._contexts.find(sequenceKey);
-    if (contextIt == sequencer._contexts.end())
-    {
-        contextIt = sequencer._contexts.emplace(sequenceKey, SequenceKeyData()).first;
-    }
+    // find the dependent or create a new element
+    typename ContextMap::iterator contextIt = sequencer._contexts.emplace(sequenceKey, SequenceKeyData()).first;
     // update stats
     contextIt->second._stats->incrementPostedTaskCount();
     contextIt->second._stats->incrementPendingTaskCount();