common: Switch from boost::shared_mutex to std::shared_mutex

Signed-off-by: Adam C. Emerson <aemerson@redhat.com>

diff --git a/src/common/convenience.h b/src/common/convenience.h
index 65fc30d54be3503da02d460401d4c58b1a86dfef..66baf562d2922dc3a4778c7c05ff46f3566f62c8 100644 (file)
--- a/src/common/convenience.h
+++ b/src/common/convenience.h
@@ -14,11 +14,11 @@
 
 #include <mutex>
 #include <memory>
+#include <shared_mutex>
 #include <type_traits>
 #include <utility>
 
 #include <boost/optional.hpp>
-#include <boost/thread/shared_mutex.hpp>
 
 #include "common/backport_std.h"
 #include "common/shunique_lock.h"
@@ -53,9 +53,9 @@ inline auto uniquely_lock(Mutex&& m, Args&& ...args)
 
 template<typename Mutex, typename ...Args>
 inline auto sharingly_lock(Mutex&& m, Args&& ...args)
-  -> boost::shared_lock<std::remove_reference_t<Mutex> > {
+  -> std::shared_lock<std::remove_reference_t<Mutex> > {
   return
-    boost::shared_lock<std::remove_reference_t<Mutex> >(
+    std::shared_lock<std::remove_reference_t<Mutex> >(
       std::forward<Mutex>(m), std::forward<Args>(args)...);
 }
 
@@ -67,10 +67,10 @@ inline auto shuniquely_lock(std::unique_lock<Mutex>&& m, Args&& ...args)
 }
 
 template<typename Mutex, typename ...Args>
-inline auto shuniquely_lock(boost::shared_lock<Mutex>&& m, Args&& ...args)
+inline auto shuniquely_lock(std::shared_lock<Mutex>&& m, Args&& ...args)
   -> shunique_lock<std::remove_reference_t<Mutex> > {
   return shunique_lock<std::remove_reference_t<Mutex> >(
-    std::forward<boost::shared_lock<Mutex> >(m),
+    std::forward<std::shared_lock<Mutex> >(m),
     std::forward<Args>(args)...);
 }
 

diff --git a/src/common/shunique_lock.h b/src/common/shunique_lock.h
index 0064b4aab04c2464774a426cfe9ae87b62513bc8..2a8da953c13ba06342e334f283c3a56b190745f1 100644 (file)
--- a/src/common/shunique_lock.h
+++ b/src/common/shunique_lock.h
@@ -5,8 +5,8 @@
 #define CEPH_COMMON_SHUNIQUE_LOCK_H
 
 #include <mutex>
+#include <shared_mutex>
 #include <system_error>
-#include <boost/thread/shared_mutex.hpp>
 
 namespace ceph {
 // This is a 'lock' class in the style of shared_lock and
@@ -48,7 +48,7 @@ class shunique_lock {
 public:
   typedef Mutex mutex_type;
   typedef std::unique_lock<Mutex> unique_lock_type;
-  typedef boost::shared_lock<Mutex> shared_lock_type;
+  typedef std::shared_lock<Mutex> shared_lock_type;
 
   shunique_lock() noexcept : m(nullptr), o(ownership::none) { }
 

diff --git a/src/rgw/rgw_sync_trace.h b/src/rgw/rgw_sync_trace.h
index b1a89e82f1e7c4e8e1841530005e8e55c9c730ff..b1cd5e6b2e234bd0b73d39f33bfa721daebf05c2 100644 (file)
--- a/src/rgw/rgw_sync_trace.h
+++ b/src/rgw/rgw_sync_trace.h
@@ -10,6 +10,7 @@
 #include <set>
 #include <ostream>
 #include <string>
+#include <shared_mutex>
 #include <boost/circular_buffer.hpp>
 
 #define SSTR(o) ({      \
@@ -99,7 +100,7 @@ public:
 class RGWSyncTraceManager : public AdminSocketHook {
   friend class RGWSyncTraceNode;
 
-  mutable boost::shared_mutex lock;
+  mutable std::shared_timed_mutex lock;
   using shunique_lock = ceph::shunique_lock<decltype(lock)>;
 
   CephContext *cct;

diff --git a/src/test/common/test_shunique_lock.cc b/src/test/common/test_shunique_lock.cc
index 77f9708259d2b5c42d936bfa3b59fae9164d42ab..b7696fe6e85f3a12c1b66ab0696bc2cd679296d8 100644 (file)
--- a/src/test/common/test_shunique_lock.cc
+++ b/src/test/common/test_shunique_lock.cc
@@ -14,10 +14,9 @@
 
 #include <future>
 #include <mutex>
+#include <shared_mutex>
 #include <thread>
 
-#include <boost/thread/shared_mutex.hpp>
-
 #include "common/ceph_time.h"
 #include "common/shunique_lock.h"
 
@@ -45,24 +44,24 @@ static void check_conflicts(SharedMutex sm, AcquireType) {
 
 template<typename SharedMutex>
 static void ensure_conflicts(SharedMutex& sm, ceph::acquire_unique_t) {
-  auto ttl = &test_try_lock<boost::shared_mutex>;
-  auto ttls = &test_try_lock_shared<boost::shared_mutex>;
+  auto ttl = &test_try_lock<std::shared_timed_mutex>;
+  auto ttls = &test_try_lock_shared<std::shared_timed_mutex>;
   ASSERT_FALSE(std::async(std::launch::async, ttl, &sm).get());
   ASSERT_FALSE(std::async(std::launch::async, ttls, &sm).get());
 }
 
 template<typename SharedMutex>
 static void ensure_conflicts(SharedMutex& sm, ceph::acquire_shared_t) {
-  auto ttl = &test_try_lock<boost::shared_mutex>;
-  auto ttls = &test_try_lock_shared<boost::shared_mutex>;
+  auto ttl = &test_try_lock<std::shared_timed_mutex>;
+  auto ttls = &test_try_lock_shared<std::shared_timed_mutex>;
   ASSERT_FALSE(std::async(std::launch::async, ttl, &sm).get());
   ASSERT_TRUE(std::async(std::launch::async, ttls, &sm).get());
 }
 
 template<typename SharedMutex>
 static void ensure_free(SharedMutex& sm) {
-  auto ttl = &test_try_lock<boost::shared_mutex>;
-  auto ttls = &test_try_lock_shared<boost::shared_mutex>;
+  auto ttl = &test_try_lock<std::shared_timed_mutex>;
+  auto ttls = &test_try_lock_shared<std::shared_timed_mutex>;
   ASSERT_TRUE(std::async(std::launch::async, ttl, &sm).get());
   ASSERT_TRUE(std::async(std::launch::async, ttls, &sm).get());
 }
@@ -108,7 +107,7 @@ static void check_abjures_lock(const ceph::shunique_lock<SharedMutex>& sul) {
 }
 
 TEST(ShuniqueLock, DefaultConstructor) {
-  typedef ceph::shunique_lock<boost::shared_mutex> shunique_lock;
+  typedef ceph::shunique_lock<std::shared_timed_mutex> shunique_lock;
 
   shunique_lock l;
 
@@ -138,8 +137,8 @@ TEST(ShuniqueLock, DefaultConstructor) {
 
 template<typename AcquireType>
 void lock_unlock(AcquireType at) {
-  boost::shared_mutex sm;
-  typedef ceph::shunique_lock<boost::shared_mutex> shunique_lock;
+  std::shared_timed_mutex sm;
+  typedef ceph::shunique_lock<std::shared_timed_mutex> shunique_lock;
 
   shunique_lock l(sm, at);
 
@@ -164,8 +163,8 @@ TEST(ShuniqueLock, LockUnlock) {
 
 template<typename AcquireType>
 void lock_destruct(AcquireType at) {
-  boost::shared_mutex sm;
-  typedef ceph::shunique_lock<boost::shared_mutex> shunique_lock;
+  std::shared_timed_mutex sm;
+  typedef ceph::shunique_lock<std::shared_timed_mutex> shunique_lock;
 
   {
     shunique_lock l(sm, at);
@@ -184,9 +183,9 @@ TEST(ShuniqueLock, LockDestruct) {
 
 template<typename AcquireType>
 void move_construct(AcquireType at) {
-  boost::shared_mutex sm;
+  std::shared_timed_mutex sm;
 
-  typedef ceph::shunique_lock<boost::shared_mutex> shunique_lock;
+  typedef ceph::shunique_lock<std::shared_timed_mutex> shunique_lock;
 
   {
     shunique_lock l(sm, at);
@@ -219,45 +218,45 @@ TEST(ShuniqueLock, MoveConstruct) {
   move_construct(ceph::acquire_unique);
   move_construct(ceph::acquire_shared);
 
-  boost::shared_mutex sm;
+  std::shared_timed_mutex sm;
   {
-    std::unique_lock<boost::shared_mutex> ul(sm);
+    std::unique_lock<std::shared_timed_mutex> ul(sm);
     ensure_conflicts(sm, ceph::acquire_unique);
-    ceph::shunique_lock<boost::shared_mutex> l(std::move(ul));
+    ceph::shunique_lock<std::shared_timed_mutex> l(std::move(ul));
     check_owns_lock(sm, l, ceph::acquire_unique);
     ensure_conflicts(sm, ceph::acquire_unique);
   }
   {
-    std::unique_lock<boost::shared_mutex> ul(sm, std::defer_lock);
+    std::unique_lock<std::shared_timed_mutex> ul(sm, std::defer_lock);
     ensure_free(sm);
-    ceph::shunique_lock<boost::shared_mutex> l(std::move(ul));
+    ceph::shunique_lock<std::shared_timed_mutex> l(std::move(ul));
     check_abjures_lock(sm, l);
     ensure_free(sm);
   }
   {
-    std::unique_lock<boost::shared_mutex> ul;
-    ceph::shunique_lock<boost::shared_mutex> l(std::move(ul));
+    std::unique_lock<std::shared_timed_mutex> ul;
+    ceph::shunique_lock<std::shared_timed_mutex> l(std::move(ul));
     check_abjures_lock(l);
   }
   {
-    boost::shared_lock<boost::shared_mutex> sl(sm);
+    std::shared_lock<std::shared_timed_mutex> sl(sm);
     ensure_conflicts(sm, ceph::acquire_shared);
-    ceph::shunique_lock<boost::shared_mutex> l(std::move(sl));
+    ceph::shunique_lock<std::shared_timed_mutex> l(std::move(sl));
     check_owns_lock(sm, l, ceph::acquire_shared);
     ensure_conflicts(sm, ceph::acquire_shared);
   }
   {
-    boost::shared_lock<boost::shared_mutex> sl;
-    ceph::shunique_lock<boost::shared_mutex> l(std::move(sl));
+    std::shared_lock<std::shared_timed_mutex> sl;
+    ceph::shunique_lock<std::shared_timed_mutex> l(std::move(sl));
     check_abjures_lock(l);
   }
 }
 
 template<typename AcquireType>
 void move_assign(AcquireType at) {
-  boost::shared_mutex sm;
+  std::shared_timed_mutex sm;
 
-  typedef ceph::shunique_lock<boost::shared_mutex> shunique_lock;
+  typedef ceph::shunique_lock<std::shared_timed_mutex> shunique_lock;
 
   {
     shunique_lock l(sm, at);
@@ -298,40 +297,40 @@ TEST(ShuniqueLock, MoveAssign) {
   move_assign(ceph::acquire_unique);
   move_assign(ceph::acquire_shared);
 
-  boost::shared_mutex sm;
+  std::shared_timed_mutex sm;
   {
-    std::unique_lock<boost::shared_mutex> ul(sm);
+    std::unique_lock<std::shared_timed_mutex> ul(sm);
     ensure_conflicts(sm, ceph::acquire_unique);
-    ceph::shunique_lock<boost::shared_mutex> l;
+    ceph::shunique_lock<std::shared_timed_mutex> l;
     l = std::move(ul);
     check_owns_lock(sm, l, ceph::acquire_unique);
     ensure_conflicts(sm, ceph::acquire_unique);
   }
   {
-    std::unique_lock<boost::shared_mutex> ul(sm, std::defer_lock);
+    std::unique_lock<std::shared_timed_mutex> ul(sm, std::defer_lock);
     ensure_free(sm);
-    ceph::shunique_lock<boost::shared_mutex> l;
+    ceph::shunique_lock<std::shared_timed_mutex> l;
     l = std::move(ul);
     check_abjures_lock(sm, l);
     ensure_free(sm);
   }
   {
-    std::unique_lock<boost::shared_mutex> ul;
-    ceph::shunique_lock<boost::shared_mutex> l;
+    std::unique_lock<std::shared_timed_mutex> ul;
+    ceph::shunique_lock<std::shared_timed_mutex> l;
     l = std::move(ul);
     check_abjures_lock(l);
   }
   {
-    boost::shared_lock<boost::shared_mutex> sl(sm);
+    std::shared_lock<std::shared_timed_mutex> sl(sm);
     ensure_conflicts(sm, ceph::acquire_shared);
-    ceph::shunique_lock<boost::shared_mutex> l;
+    ceph::shunique_lock<std::shared_timed_mutex> l;
     l = std::move(sl);
     check_owns_lock(sm, l, ceph::acquire_shared);
     ensure_conflicts(sm, ceph::acquire_shared);
   }
   {
-    boost::shared_lock<boost::shared_mutex> sl;
-    ceph::shunique_lock<boost::shared_mutex> l;
+    std::shared_lock<std::shared_timed_mutex> sl;
+    ceph::shunique_lock<std::shared_timed_mutex> l;
     l = std::move(sl);
     check_abjures_lock(l);
   }
@@ -340,9 +339,9 @@ TEST(ShuniqueLock, MoveAssign) {
 
 template<typename AcquireType>
 void construct_deferred(AcquireType at) {
-  boost::shared_mutex sm;
+  std::shared_timed_mutex sm;
 
-  typedef ceph::shunique_lock<boost::shared_mutex> shunique_lock;
+  typedef ceph::shunique_lock<std::shared_timed_mutex> shunique_lock;
 
   {
     shunique_lock l(sm, std::defer_lock);
@@ -379,8 +378,8 @@ TEST(ShuniqueLock, ConstructDeferred) {
 
 template<typename AcquireType>
 void construct_try(AcquireType at) {
-  boost::shared_mutex sm;
-  typedef ceph::shunique_lock<boost::shared_mutex> shunique_lock;
+  std::shared_timed_mutex sm;
+  typedef ceph::shunique_lock<std::shared_timed_mutex> shunique_lock;
 
   {
     shunique_lock l(sm, at, std::try_to_lock);
@@ -389,7 +388,7 @@ void construct_try(AcquireType at) {
   }
 
   {
-    std::unique_lock<boost::shared_mutex> l(sm);
+    std::unique_lock<std::shared_timed_mutex> l(sm);
     ensure_conflicts(sm, ceph::acquire_unique);
 
     std::async(std::launch::async, [&sm, at]() {
@@ -415,9 +414,9 @@ TEST(ShuniqueLock, ConstructTry) {
 
 template<typename AcquireType>
 void construct_adopt(AcquireType at) {
-  boost::shared_mutex sm;
+  std::shared_timed_mutex sm;
 
-  typedef ceph::shunique_lock<boost::shared_mutex> shunique_lock;
+  typedef ceph::shunique_lock<std::shared_timed_mutex> shunique_lock;
 
   {
     shunique_lock d(sm, at);
@@ -442,9 +441,9 @@ TEST(ShuniqueLock, ConstructAdopt) {
 
 template<typename AcquireType>
 void try_lock(AcquireType at) {
-  boost::shared_mutex sm;
+  std::shared_timed_mutex sm;
 
-  typedef ceph::shunique_lock<boost::shared_mutex> shunique_lock;
+  typedef ceph::shunique_lock<std::shared_timed_mutex> shunique_lock;
 
   {
     shunique_lock l(sm, std::defer_lock);
@@ -455,7 +454,7 @@ void try_lock(AcquireType at) {
   }
 
   {
-    std::unique_lock<boost::shared_mutex> l(sm);
+    std::unique_lock<std::shared_timed_mutex> l(sm);
 
     std::async(std::launch::async, [&sm, at]() {
        shunique_lock l(sm, std::defer_lock);
@@ -483,8 +482,8 @@ TEST(ShuniqueLock, TryLock) {
 }
 
 TEST(ShuniqueLock, Release) {
-  boost::shared_mutex sm;
-  typedef ceph::shunique_lock<boost::shared_mutex> shunique_lock;
+  std::shared_timed_mutex sm;
+  typedef ceph::shunique_lock<std::shared_timed_mutex> shunique_lock;
 
   {
     shunique_lock l(sm, ceph::acquire_unique);
@@ -528,7 +527,7 @@ TEST(ShuniqueLock, Release) {
   ensure_free(sm);
 
   {
-    std::unique_lock<boost::shared_mutex> ul;
+    std::unique_lock<std::shared_timed_mutex> ul;
     shunique_lock l(sm, std::defer_lock);
     check_abjures_lock(sm, l);
     ensure_free(sm);
@@ -542,7 +541,7 @@ TEST(ShuniqueLock, Release) {
   ensure_free(sm);
 
   {
-    std::unique_lock<boost::shared_mutex> ul;
+    std::unique_lock<std::shared_timed_mutex> ul;
     shunique_lock l;
     check_abjures_lock(l);
 
@@ -554,9 +553,9 @@ TEST(ShuniqueLock, Release) {
 }
 
 TEST(ShuniqueLock, NoRecursion) {
-  boost::shared_mutex sm;
+  std::shared_timed_mutex sm;
 
-  typedef ceph::shunique_lock<boost::shared_mutex> shunique_lock;
+  typedef ceph::shunique_lock<std::shared_timed_mutex> shunique_lock;
 
   {
     shunique_lock l(sm, ceph::acquire_unique);