geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [17/34] geode-native git commit: GEODE-2494: Replace SpinLock with spinlock_mutex.
Date Wed, 15 Mar 2017 17:51:18 GMT
GEODE-2494: Replace SpinLock with spinlock_mutex.


Project: http://git-wip-us.apache.org/repos/asf/geode-native/repo
Commit: http://git-wip-us.apache.org/repos/asf/geode-native/commit/e1d9d0ce
Tree: http://git-wip-us.apache.org/repos/asf/geode-native/tree/e1d9d0ce
Diff: http://git-wip-us.apache.org/repos/asf/geode-native/diff/e1d9d0ce

Branch: refs/heads/feature/GEODE-2602
Commit: e1d9d0ce239eae89b029a903e003eae485105216
Parents: 2e6a5bc
Author: Jacob Barrett <jbarrett@pivotal.io>
Authored: Mon Feb 20 13:42:19 2017 -0800
Committer: Jacob Barrett <jbarrett@pivotal.io>
Committed: Wed Mar 15 10:44:22 2017 -0700

----------------------------------------------------------------------
 src/cppcache/src/LRUList.cpp | 47 ++++++++++++++++++++++++---------------
 src/cppcache/src/LRUList.hpp | 38 ++++++++++++++++---------------
 2 files changed, 49 insertions(+), 36 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/geode-native/blob/e1d9d0ce/src/cppcache/src/LRUList.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/LRUList.cpp b/src/cppcache/src/LRUList.cpp
index c752faa..00879c9 100644
--- a/src/cppcache/src/LRUList.cpp
+++ b/src/cppcache/src/LRUList.cpp
@@ -15,12 +15,18 @@
  * limitations under the License.
  */
 #include "LRUList.hpp"
-#include "SpinLock.hpp"
+#include "util/concurrent/spinlock_mutex.hpp"
 
-using namespace apache::geode::client;
+#include <mutex>
 
-#define LOCK_HEAD SpinLockGuard headLockGuard(m_headLock)
-#define LOCK_TAIL SpinLockGuard tailLockGuard(m_tailLock)
+namespace apache {
+namespace geode {
+namespace client {
+
+using util::concurrent::spinlock_mutex;
+
+//#define LOCK_HEAD SpinLockGuard headLockGuard(m_headLock)
+//#define LOCK_TAIL SpinLockGuard tailLockGuard(m_tailLock)
 
 template <typename TEntry, typename TCreateEntry>
 LRUList<TEntry, TCreateEntry>::LRUList() : m_headLock(), m_tailLock() {
@@ -32,9 +38,9 @@ LRUList<TEntry, TCreateEntry>::LRUList() : m_headLock(), m_tailLock()
{
 
 template <typename TEntry, typename TCreateEntry>
 LRUList<TEntry, TCreateEntry>::~LRUList() {
-  m_tailNode = NULL;
+  m_tailNode = nullptr;
   LRUListNode* next;
-  while (m_headNode != NULL) {
+  while (m_headNode != nullptr) {
     next = m_headNode->getNextLRUListNode();
     delete m_headNode;
     m_headNode = next;
@@ -43,7 +49,7 @@ LRUList<TEntry, TCreateEntry>::~LRUList() {
 
 template <typename TEntry, typename TCreateEntry>
 void LRUList<TEntry, TCreateEntry>::appendEntry(const LRUListEntryPtr& entry) {
-  LOCK_TAIL;
+  std::lock_guard<spinlock_mutex> lk(m_tailLock);
 
   LRUListNode* aNode = new LRUListNode(entry);
   m_tailNode->setNextLRUListNode(aNode);
@@ -52,9 +58,9 @@ void LRUList<TEntry, TCreateEntry>::appendEntry(const LRUListEntryPtr&
entry) {
 
 template <typename TEntry, typename TCreateEntry>
 void LRUList<TEntry, TCreateEntry>::appendNode(LRUListNode* aNode) {
-  LOCK_TAIL;
+  std::lock_guard<spinlock_mutex> lk(m_tailLock);
 
-  GF_D_ASSERT(aNode != NULL);
+  GF_D_ASSERT(aNode != nullptr);
 
   aNode->clearNextLRUListNode();
   m_tailNode->setNextLRUListNode(aNode);
@@ -66,8 +72,8 @@ void LRUList<TEntry, TCreateEntry>::getLRUEntry(LRUListEntryPtr&
result) {
   bool isLast = false;
   LRUListNode* aNode;
   while (true) {
-    aNode = getHeadNode(isLast);
-    if (aNode == NULL) {
+    aNode = getHeadNode(&isLast);
+    if (aNode == nullptr) {
       result = NULLPTR;
       break;
     }
@@ -96,23 +102,24 @@ void LRUList<TEntry, TCreateEntry>::getLRUEntry(LRUListEntryPtr&
result) {
 
 template <typename TEntry, typename TCreateEntry>
 typename LRUList<TEntry, TCreateEntry>::LRUListNode*
-LRUList<TEntry, TCreateEntry>::getHeadNode(bool& isLast) {
-  LOCK_HEAD;
+LRUList<TEntry, TCreateEntry>::getHeadNode(bool* isLast) {
+  std::lock_guard<spinlock_mutex> lk(m_headLock);
 
   LRUListNode* result = m_headNode;
   LRUListNode* nextNode;
 
   {
-    LOCK_TAIL;
+    std::lock_guard<spinlock_mutex> lk(m_tailLock);
+
     nextNode = m_headNode->getNextLRUListNode();
-    if (nextNode == NULL) {
+    if (nextNode == nullptr) {
       // last one in the list...
-      isLast = true;
+      *isLast = true;
       LRUListEntryPtr entry;
       result->getEntry(entry);
       if (entry->getLRUProperties().testEvicted()) {
         // list is empty.
-        return NULL;
+        return nullptr;
       } else {
         entry->getLRUProperties().setEvicted();
         return result;
@@ -120,9 +127,13 @@ LRUList<TEntry, TCreateEntry>::getHeadNode(bool& isLast) {
     }
   }
 
-  isLast = false;
+  *isLast = false;
   // advance head node, and return old value.
   m_headNode = nextNode;
 
   return result;
 }
+
+}  // namespace client
+}  // namespace geode
+}  // namespace apache

http://git-wip-us.apache.org/repos/asf/geode-native/blob/e1d9d0ce/src/cppcache/src/LRUList.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/LRUList.hpp b/src/cppcache/src/LRUList.hpp
index 3e1d30a..fc18fcd 100644
--- a/src/cppcache/src/LRUList.hpp
+++ b/src/cppcache/src/LRUList.hpp
@@ -20,32 +20,32 @@
  * limitations under the License.
  */
 
+#include <atomic>
+
 #include <geode/geode_globals.hpp>
 #include <geode/SharedPtr.hpp>
-#include "SpinLock.hpp"
+
+#include "util/concurrent/spinlock_mutex.hpp"
 
 namespace apache {
 namespace geode {
 namespace client {
+
 // Bit mask for recently used
-#define RECENTLY_USED_BITS 1ul
+#define RECENTLY_USED_BITS 1u
 // Bit mask for evicted
-#define EVICTED_BITS 2ul
+#define EVICTED_BITS 2u
 
 /**
  * @brief This class encapsulates LRU specific properties for a LRUList node.
  */
 class CPPCACHE_EXPORT LRUEntryProperties {
  public:
-  inline LRUEntryProperties() : m_bits(0), m_persistenceInfo(NULL) {}
+  inline LRUEntryProperties() : m_bits(0), m_persistenceInfo(nullptr) {}
 
-  inline void setRecentlyUsed() {
-    HostAsm::atomicSetBits(m_bits, RECENTLY_USED_BITS);
-  }
+  inline void setRecentlyUsed() { m_bits |= RECENTLY_USED_BITS; }
 
-  inline void clearRecentlyUsed() {
-    HostAsm::atomicClearBits(m_bits, RECENTLY_USED_BITS);
-  }
+  inline void clearRecentlyUsed() { m_bits &= ~RECENTLY_USED_BITS; }
 
   inline bool testRecentlyUsed() const {
     return (m_bits & RECENTLY_USED_BITS) == RECENTLY_USED_BITS;
@@ -55,9 +55,9 @@ class CPPCACHE_EXPORT LRUEntryProperties {
     return (m_bits & EVICTED_BITS) == EVICTED_BITS;
   }
 
-  inline void setEvicted() { HostAsm::atomicSetBits(m_bits, EVICTED_BITS); }
+  inline void setEvicted() { m_bits |= EVICTED_BITS; }
 
-  inline void clearEvicted() { HostAsm::atomicClearBits(m_bits, EVICTED_BITS); }
+  inline void clearEvicted() { m_bits &= ~EVICTED_BITS; }
 
   inline void* getPersistenceInfo() const { return m_persistenceInfo; }
 
@@ -70,10 +70,12 @@ class CPPCACHE_EXPORT LRUEntryProperties {
   inline LRUEntryProperties(bool noInit) {}
 
  private:
-  volatile uint32_t m_bits;
+  std::atomic<uint32_t> m_bits;
   void* m_persistenceInfo;
 };
 
+using util::concurrent::spinlock_mutex;
+
 /**
  * @brief Maintains a list of entries returning them through head in
  * approximate LRU order. The <code>TEntry</code> template argument
@@ -92,7 +94,7 @@ class LRUList {
   class LRUListNode {
    public:
     inline LRUListNode(const LRUListEntryPtr& entry)
-        : m_entry(entry), m_nextLRUListNode(NULL) {}
+        : m_entry(entry), m_nextLRUListNode(nullptr) {}
 
     inline ~LRUListNode() {}
 
@@ -104,7 +106,7 @@ class LRUList {
       m_nextLRUListNode = next;
     }
 
-    inline void clearNextLRUListNode() { m_nextLRUListNode = NULL; }
+    inline void clearNextLRUListNode() { m_nextLRUListNode = nullptr; }
 
    private:
     LRUListEntryPtr m_entry;
@@ -140,10 +142,10 @@ class LRUList {
    * @brief return the head entry in the list,
    * and removing it from the list.
    */
-  LRUListNode* getHeadNode(bool& isLast);
+  LRUListNode* getHeadNode(bool* isLast);
 
-  SpinLock m_headLock;
-  SpinLock m_tailLock;
+  spinlock_mutex m_headLock;
+  spinlock_mutex m_tailLock;
 
   LRUListNode* m_headNode;
   LRUListNode* m_tailNode;


Mime
View raw message