RepoMirrors/ceph
1
0
Fork 0
mirror of https://github.com/ceph/ceph synced 2025-02-23 11:07:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
Signed-off-by: Adam C. Emerson <aemerson@redhat.com>
This commit is contained in:
Adam C. Emerson 2017-12-06 15:52:17 -05:00
parent 2d45f808ef
commit e08a1cd88a
4 changed files with 63 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/common/convenience.h
View File

@ -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)...);
}

4
src/common/shunique_lock.h
View File

@ -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) { }

3
src/rgw/rgw_sync_trace.h
View File

@ -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;

109
src/test/common/test_shunique_lock.cc
View File

@ -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);