From ed75406c4f04a0aad3a99e57bd50e5bb3352b4ad Mon Sep 17 00:00:00 2001 From: Kefu Chai Date: Sun, 7 Jul 2019 11:14:32 +0800 Subject: [PATCH] librados: s/Mutex/ceph::mutex/ Signed-off-by: Kefu Chai --- src/librados/AioCompletionImpl.h | 109 ++++------ src/librados/IoCtxImpl.cc | 180 +++++++--------- src/librados/IoCtxImpl.h | 21 +- src/librados/PoolAsyncCompletionImpl.h | 62 +++--- src/librados/RadosClient.cc | 199 ++++++++---------- src/librados/RadosClient.h | 7 +- src/librados/librados_cxx.cc | 4 +- src/libradosstriper/MultiAioCompletionImpl.cc | 7 +- src/libradosstriper/MultiAioCompletionImpl.h | 97 ++++----- src/libradosstriper/RadosStriperImpl.cc | 8 +- src/libradosstriper/RadosStriperImpl.h | 13 +- src/test/TestTimers.cc | 2 +- 12 files changed, 303 insertions(+), 406 deletions(-) diff --git a/src/librados/AioCompletionImpl.h b/src/librados/AioCompletionImpl.h index 98fa4e0c883..d3a674e8ee7 100644 --- a/src/librados/AioCompletionImpl.h +++ b/src/librados/AioCompletionImpl.h @@ -15,9 +15,7 @@ #ifndef CEPH_LIBRADOS_AIOCOMPLETIONIMPL_H #define CEPH_LIBRADOS_AIOCOMPLETIONIMPL_H -#include "common/Cond.h" -#include "common/Mutex.h" - +#include "common/ceph_mutex.h" #include "include/buffer.h" #include "include/xlist.h" #include "osd/osd_types.h" @@ -25,128 +23,103 @@ class IoCtxImpl; struct librados::AioCompletionImpl { - Mutex lock; - Cond cond; - int ref, rval; - bool released; - bool complete; - version_t objver; - ceph_tid_t tid; + ceph::mutex lock = ceph::make_mutex("AioCompletionImpl lock", false); + ceph::condition_variable cond; + int ref = 1, rval = 0; + bool released = false; + bool complete = false; + version_t objver = 0; + ceph_tid_t tid = 0; - rados_callback_t callback_complete, callback_safe; - void *callback_complete_arg, *callback_safe_arg; + rados_callback_t callback_complete = nullptr, callback_safe = nullptr; + void *callback_complete_arg = nullptr, *callback_safe_arg = nullptr; // for read - bool is_read; + bool is_read = false; bufferlist bl; - bufferlist *blp; - char *out_buf; + bufferlist *blp = nullptr; + char *out_buf = nullptr; - IoCtxImpl *io; - ceph_tid_t aio_write_seq; + IoCtxImpl *io = nullptr; + ceph_tid_t aio_write_seq = 0; xlist::item aio_write_list_item; - AioCompletionImpl() : lock("AioCompletionImpl lock", false, false), - ref(1), rval(0), released(false), - complete(false), - objver(0), - tid(0), - callback_complete(0), - callback_safe(0), - callback_complete_arg(0), - callback_safe_arg(0), - is_read(false), blp(nullptr), out_buf(nullptr), - io(NULL), aio_write_seq(0), aio_write_list_item(this) { } + AioCompletionImpl() : aio_write_list_item(this) { } int set_complete_callback(void *cb_arg, rados_callback_t cb) { - lock.Lock(); + std::scoped_lock l{lock}; callback_complete = cb; callback_complete_arg = cb_arg; - lock.Unlock(); return 0; } int set_safe_callback(void *cb_arg, rados_callback_t cb) { - lock.Lock(); + std::scoped_lock l{lock}; callback_safe = cb; callback_safe_arg = cb_arg; - lock.Unlock(); return 0; } int wait_for_complete() { - lock.Lock(); - while (!complete) - cond.Wait(lock); - lock.Unlock(); + std::unique_lock l{lock}; + cond.wait(l, [this] { return complete; }); return 0; } int wait_for_safe() { return wait_for_complete(); } int is_complete() { - lock.Lock(); - int r = complete; - lock.Unlock(); - return r; + std::scoped_lock l{lock}; + return complete; } int is_safe() { return is_complete(); } int wait_for_complete_and_cb() { - lock.Lock(); - while (!complete || callback_complete || callback_safe) - cond.Wait(lock); - lock.Unlock(); + std::unique_lock l{lock}; + cond.wait(l, [this] { return complete && !callback_complete && !callback_safe; }); return 0; } int wait_for_safe_and_cb() { return wait_for_complete_and_cb(); } int is_complete_and_cb() { - lock.Lock(); - int r = complete && !callback_complete && !callback_safe; - lock.Unlock(); - return r; + std::scoped_lock l{lock}; + return complete && !callback_complete && !callback_safe; } int is_safe_and_cb() { return is_complete_and_cb(); } int get_return_value() { - lock.Lock(); - int r = rval; - lock.Unlock(); - return r; + std::scoped_lock l{lock}; + return rval; } uint64_t get_version() { - lock.Lock(); - version_t v = objver; - lock.Unlock(); - return v; + std::scoped_lock l{lock}; + return objver; } void get() { - lock.Lock(); + std::scoped_lock l{lock}; _get(); - lock.Unlock(); } void _get() { - ceph_assert(lock.is_locked()); + ceph_assert(ceph_mutex_is_locked(lock)); ceph_assert(ref > 0); ++ref; } void release() { - lock.Lock(); + lock.lock(); ceph_assert(!released); released = true; put_unlock(); } void put() { - lock.Lock(); + lock.lock(); put_unlock(); } void put_unlock() { ceph_assert(ref > 0); int n = --ref; - lock.Unlock(); + lock.unlock(); if (!n) delete this; } @@ -171,10 +144,10 @@ struct C_AioComplete : public Context { if (cb_safe) cb_safe(c, cb_safe_arg); - c->lock.Lock(); + c->lock.lock(); c->callback_complete = NULL; c->callback_safe = NULL; - c->cond.Signal(); + c->cond.notify_all(); c->put_unlock(); } }; @@ -195,10 +168,10 @@ struct C_AioCompleteAndSafe : public Context { } void finish(int r) override { - c->lock.Lock(); + c->lock.lock(); c->rval = r; c->complete = true; - c->lock.Unlock(); + c->lock.unlock(); rados_callback_t cb_complete = c->callback_complete; void *cb_complete_arg = c->callback_complete_arg; @@ -210,10 +183,10 @@ struct C_AioCompleteAndSafe : public Context { if (cb_safe) cb_safe(c, cb_safe_arg); - c->lock.Lock(); + c->lock.lock(); c->callback_complete = NULL; c->callback_safe = NULL; - c->cond.Signal(); + c->cond.notify_all(); c->put_unlock(); } }; diff --git a/src/librados/IoCtxImpl.cc b/src/librados/IoCtxImpl.cc index 472d16fdea1..eceb16ba84a 100644 --- a/src/librados/IoCtxImpl.cc +++ b/src/librados/IoCtxImpl.cc @@ -107,10 +107,10 @@ struct C_aio_linger_Complete : public Context { c->io->client->finisher.queue(new C_aio_linger_cancel(c->io->objecter, linger_op)); - c->lock.Lock(); + c->lock.lock(); c->rval = r; c->complete = true; - c->cond.Signal(); + c->cond.notify_all(); if (c->callback_complete || c->callback_safe) { @@ -121,26 +121,25 @@ struct C_aio_linger_Complete : public Context { }; struct C_aio_notify_Complete : public C_aio_linger_Complete { - Mutex lock; + ceph::mutex lock = ceph::make_mutex("C_aio_notify_Complete::lock"); bool acked = false; bool finished = false; int ret_val = 0; C_aio_notify_Complete(AioCompletionImpl *_c, Objecter::LingerOp *_linger_op) - : C_aio_linger_Complete(_c, _linger_op, false), - lock("C_aio_notify_Complete::lock") { + : C_aio_linger_Complete(_c, _linger_op, false) { } void handle_ack(int r) { // invoked by C_aio_notify_Ack - lock.Lock(); + lock.lock(); acked = true; complete_unlock(r); } void complete(int r) override { // invoked by C_notify_Finish - lock.Lock(); + lock.lock(); finished = true; complete_unlock(r); } @@ -151,11 +150,11 @@ struct C_aio_notify_Complete : public C_aio_linger_Complete { } if (acked && finished) { - lock.Unlock(); + lock.unlock(); cancel = true; C_aio_linger_Complete::complete(ret_val); } else { - lock.Unlock(); + lock.unlock(); } } }; @@ -190,10 +189,10 @@ struct C_aio_selfmanaged_snap_op_Complete : public Context { } void finish(int r) override { - c->lock.Lock(); + c->lock.lock(); c->rval = r; c->complete = true; - c->cond.Signal(); + c->cond.notify_all(); if (c->callback_complete || c->callback_safe) { client->finisher.queue(new librados::C_AioComplete(c)); @@ -224,19 +223,13 @@ struct C_aio_selfmanaged_snap_create_Complete : public C_aio_selfmanaged_snap_op } // anonymous namespace } // namespace librados -librados::IoCtxImpl::IoCtxImpl() : - ref_cnt(0), client(NULL), poolid(0), assert_ver(0), last_objver(0), - notify_timeout(30), aio_write_list_lock("librados::IoCtxImpl::aio_write_list_lock"), - aio_write_seq(0), objecter(NULL) -{ -} +librados::IoCtxImpl::IoCtxImpl() = default; librados::IoCtxImpl::IoCtxImpl(RadosClient *c, Objecter *objecter, int64_t poolid, snapid_t s) - : ref_cnt(0), client(c), poolid(poolid), snap_seq(s), - assert_ver(0), last_objver(0), + : client(c), poolid(poolid), snap_seq(s), notify_timeout(c->cct->_conf->client_notify_timeout), - oloc(poolid), aio_write_list_lock("librados::IoCtxImpl::aio_write_list_lock"), + oloc(poolid), aio_write_seq(0), objecter(objecter) { } @@ -285,19 +278,18 @@ int librados::IoCtxImpl::get_object_pg_hash_position( void librados::IoCtxImpl::queue_aio_write(AioCompletionImpl *c) { get(); - aio_write_list_lock.Lock(); + std::scoped_lock l{aio_write_list_lock}; ceph_assert(c->io == this); c->aio_write_seq = ++aio_write_seq; ldout(client->cct, 20) << "queue_aio_write " << this << " completion " << c << " write_seq " << aio_write_seq << dendl; aio_write_list.push_back(&c->aio_write_list_item); - aio_write_list_lock.Unlock(); } void librados::IoCtxImpl::complete_aio_write(AioCompletionImpl *c) { ldout(client->cct, 20) << "complete_aio_write " << c << dendl; - aio_write_list_lock.Lock(); + aio_write_list_lock.lock(); ceph_assert(c->io == this); c->aio_write_list_item.remove_myself(); @@ -319,8 +311,8 @@ void librados::IoCtxImpl::complete_aio_write(AioCompletionImpl *c) aio_write_waiters.erase(waiters++); } - aio_write_cond.Signal(); - aio_write_list_lock.Unlock(); + aio_write_cond.notify_all(); + aio_write_list_lock.unlock(); put(); } @@ -345,12 +337,11 @@ void librados::IoCtxImpl::flush_aio_writes_async(AioCompletionImpl *c) void librados::IoCtxImpl::flush_aio_writes() { ldout(client->cct, 20) << "flush_aio_writes" << dendl; - aio_write_list_lock.Lock(); - ceph_tid_t seq = aio_write_seq; - while (!aio_write_list.empty() && - aio_write_list.front()->aio_write_seq <= seq) - aio_write_cond.Wait(aio_write_list_lock); - aio_write_list_lock.Unlock(); + std::unique_lock l{aio_write_list_lock}; + aio_write_cond.wait(l, [seq=aio_write_seq, this] { + return (aio_write_list.empty() || + aio_write_list.front()->aio_write_seq > seq); + }); } string librados::IoCtxImpl::get_cached_pool_name() @@ -367,19 +358,17 @@ int librados::IoCtxImpl::snap_create(const char *snapName) int reply; string sName(snapName); - Mutex mylock ("IoCtxImpl::snap_create::mylock"); - Cond cond; + ceph::mutex mylock = ceph::make_mutex("IoCtxImpl::snap_create::mylock"); + ceph::condition_variable cond; bool done; - Context *onfinish = new C_SafeCond(&mylock, &cond, &done, &reply); + Context *onfinish = new C_SafeCond(mylock, cond, &done, &reply); reply = objecter->create_pool_snap(poolid, sName, onfinish); if (reply < 0) { delete onfinish; } else { - mylock.Lock(); - while (!done) - cond.Wait(mylock); - mylock.Unlock(); + std::unique_lock l{mylock}; + cond.wait(l, [&done] { return done; }); } return reply; } @@ -388,20 +377,20 @@ int librados::IoCtxImpl::selfmanaged_snap_create(uint64_t *psnapid) { int reply; - Mutex mylock("IoCtxImpl::selfmanaged_snap_create::mylock"); - Cond cond; + ceph::mutex mylock = ceph::make_mutex("IoCtxImpl::selfmanaged_snap_create::mylock"); + ceph::condition_variable cond; bool done; - Context *onfinish = new C_SafeCond(&mylock, &cond, &done, &reply); + Context *onfinish = new C_SafeCond(mylock, cond, &done, &reply); snapid_t snapid; reply = objecter->allocate_selfmanaged_snap(poolid, &snapid, onfinish); if (reply < 0) { delete onfinish; } else { - mylock.Lock(); - while (!done) - cond.Wait(mylock); - mylock.Unlock(); + { + std::unique_lock l{mylock}; + cond.wait(l, [&done] { return done; }); + } if (reply == 0) *psnapid = snapid; } @@ -425,19 +414,17 @@ int librados::IoCtxImpl::snap_remove(const char *snapName) int reply; string sName(snapName); - Mutex mylock ("IoCtxImpl::snap_remove::mylock"); - Cond cond; + ceph::mutex mylock = ceph::make_mutex("IoCtxImpl::snap_remove::mylock"); + ceph::condition_variable cond; bool done; - Context *onfinish = new C_SafeCond(&mylock, &cond, &done, &reply); + Context *onfinish = new C_SafeCond(mylock, cond, &done, &reply); reply = objecter->delete_pool_snap(poolid, sName, onfinish); if (reply < 0) { delete onfinish; } else { - mylock.Lock(); - while(!done) - cond.Wait(mylock); - mylock.Unlock(); + unique_lock l{mylock}; + cond.wait(l, [&done] { return done; }); } return reply; } @@ -448,10 +435,10 @@ int librados::IoCtxImpl::selfmanaged_snap_rollback_object(const object_t& oid, { int reply; - Mutex mylock("IoCtxImpl::snap_rollback::mylock"); - Cond cond; + ceph::mutex mylock = ceph::make_mutex("IoCtxImpl::snap_rollback::mylock"); + ceph::condition_variable cond; bool done; - Context *onack = new C_SafeCond(&mylock, &cond, &done, &reply); + Context *onack = new C_SafeCond(mylock, cond, &done, &reply); ::ObjectOperation op; prepare_assert_ops(&op); @@ -460,9 +447,8 @@ int librados::IoCtxImpl::selfmanaged_snap_rollback_object(const object_t& oid, op, snapc, ceph::real_clock::now(), 0, onack, NULL); - mylock.Lock(); - while (!done) cond.Wait(mylock); - mylock.Unlock(); + std::unique_lock l{mylock}; + cond.wait(l, [&done] { return done; }); return reply; } @@ -482,15 +468,14 @@ int librados::IoCtxImpl::selfmanaged_snap_remove(uint64_t snapid) { int reply; - Mutex mylock("IoCtxImpl::selfmanaged_snap_remove::mylock"); - Cond cond; + ceph::mutex mylock = ceph::make_mutex("IoCtxImpl::selfmanaged_snap_remove::mylock"); + ceph::condition_variable cond; bool done; objecter->delete_selfmanaged_snap(poolid, snapid_t(snapid), - new C_SafeCond(&mylock, &cond, &done, &reply)); + new C_SafeCond(mylock, cond, &done, &reply)); - mylock.Lock(); - while (!done) cond.Wait(mylock); - mylock.Unlock(); + std::unique_lock l{mylock}; + cond.wait(l, [&done] { return done; }); return (int)reply; } @@ -538,10 +523,10 @@ int librados::IoCtxImpl::snap_get_stamp(uint64_t snapid, time_t *t) int librados::IoCtxImpl::nlist(Objecter::NListContext *context, int max_entries) { - Cond cond; bool done; int r = 0; - Mutex mylock("IoCtxImpl::nlist::mylock"); + ceph::mutex mylock = ceph::make_mutex("IoCtxImpl::nlist::mylock"); + ceph::condition_variable cond; if (context->at_end()) return 0; @@ -549,13 +534,10 @@ int librados::IoCtxImpl::nlist(Objecter::NListContext *context, int max_entries) context->max_entries = max_entries; context->nspace = oloc.nspace; - objecter->list_nobjects(context, new C_SafeCond(&mylock, &cond, &done, &r)); - - mylock.Lock(); - while(!done) - cond.Wait(mylock); - mylock.Unlock(); + objecter->list_nobjects(context, new C_SafeCond(mylock, cond, &done, &r)); + std::unique_lock l{mylock}; + cond.wait(l, [&done] { return done; }); return r; } @@ -673,13 +655,13 @@ int librados::IoCtxImpl::operate(const object_t& oid, ::ObjectOperation *o, if (!o->size()) return 0; - Mutex mylock("IoCtxImpl::operate::mylock"); - Cond cond; + ceph::mutex mylock = ceph::make_mutex("IoCtxImpl::operate::mylock"); + ceph::condition_variable cond; bool done; int r; version_t ver; - Context *oncommit = new C_SafeCond(&mylock, &cond, &done, &r); + Context *oncommit = new C_SafeCond(mylock, cond, &done, &r); int op = o->ops[0].op.op; ldout(client->cct, 10) << ceph_osd_op_name(op) << " oid=" << oid @@ -689,10 +671,10 @@ int librados::IoCtxImpl::operate(const object_t& oid, ::ObjectOperation *o, oncommit, &ver); objecter->op_submit(objecter_op); - mylock.Lock(); - while (!done) - cond.Wait(mylock); - mylock.Unlock(); + { + std::unique_lock l{mylock}; + cond.wait(l, [&done] { return done;}); + } ldout(client->cct, 10) << "Objecter returned from " << ceph_osd_op_name(op) << " r=" << r << dendl; @@ -709,13 +691,13 @@ int librados::IoCtxImpl::operate_read(const object_t& oid, if (!o->size()) return 0; - Mutex mylock("IoCtxImpl::operate_read::mylock"); - Cond cond; + ceph::mutex mylock = ceph::make_mutex("IoCtxImpl::operate_read::mylock"); + ceph::condition_variable cond; bool done; int r; version_t ver; - Context *onack = new C_SafeCond(&mylock, &cond, &done, &r); + Context *onack = new C_SafeCond(mylock, cond, &done, &r); int op = o->ops[0].op.op; ldout(client->cct, 10) << ceph_osd_op_name(op) << " oid=" << oid << " nspace=" << oloc.nspace << dendl; @@ -724,10 +706,10 @@ int librados::IoCtxImpl::operate_read(const object_t& oid, onack, &ver); objecter->op_submit(objecter_op); - mylock.Lock(); - while (!done) - cond.Wait(mylock); - mylock.Unlock(); + { + std::unique_lock l{mylock}; + cond.wait(l, [&done] { return done; }); + } ldout(client->cct, 10) << "Objecter returned from " << ceph_osd_op_name(op) << " r=" << r << dendl; @@ -1420,20 +1402,20 @@ int librados::IoCtxImpl::mapext(const object_t& oid, { bufferlist bl; - Mutex mylock("IoCtxImpl::read::mylock"); - Cond cond; + ceph::mutex mylock = ceph::make_mutex("IoCtxImpl::read::mylock"); + ceph::condition_variable cond; bool done; int r; - Context *onack = new C_SafeCond(&mylock, &cond, &done, &r); + Context *onack = new C_SafeCond(mylock, cond, &done, &r); objecter->mapext(oid, oloc, off, len, snap_seq, &bl, 0, onack); - mylock.Lock(); - while (!done) - cond.Wait(mylock); - mylock.Unlock(); + { + unique_lock l{mylock}; + cond.wait(l, [&done] { return done;}); + } ldout(client->cct, 10) << "Objecter returned from read r=" << r << dendl; if (r < 0) @@ -1908,10 +1890,10 @@ librados::IoCtxImpl::C_aio_stat_Ack::C_aio_stat_Ack(AioCompletionImpl *_c, void librados::IoCtxImpl::C_aio_stat_Ack::finish(int r) { - c->lock.Lock(); + c->lock.lock(); c->rval = r; c->complete = true; - c->cond.Signal(); + c->cond.notify_all(); if (r >= 0 && pmtime) { *pmtime = real_clock::to_time_t(mtime); @@ -1936,10 +1918,10 @@ librados::IoCtxImpl::C_aio_stat2_Ack::C_aio_stat2_Ack(AioCompletionImpl *_c, void librados::IoCtxImpl::C_aio_stat2_Ack::finish(int r) { - c->lock.Lock(); + c->lock.lock(); c->rval = r; c->complete = true; - c->cond.Signal(); + c->cond.notify_all(); if (r >= 0 && pts) { *pts = real_clock::to_timespec(mtime); @@ -1962,12 +1944,12 @@ librados::IoCtxImpl::C_aio_Complete::C_aio_Complete(AioCompletionImpl *_c) void librados::IoCtxImpl::C_aio_Complete::finish(int r) { - c->lock.Lock(); + c->lock.lock(); // Leave an existing rval unless r != 0 if (r) c->rval = r; // This clears the error set in C_ObjectOperation_scrub_ls::finish() c->complete = true; - c->cond.Signal(); + c->cond.notify_all(); if (r == 0 && c->blp && c->blp->length() > 0) { if (c->out_buf && !c->blp->is_contiguous()) { diff --git a/src/librados/IoCtxImpl.h b/src/librados/IoCtxImpl.h index 4de782cbec0..e96af0ae6c1 100644 --- a/src/librados/IoCtxImpl.h +++ b/src/librados/IoCtxImpl.h @@ -18,7 +18,7 @@ #include #include "common/Cond.h" -#include "common/Mutex.h" +#include "common/ceph_mutex.h" #include "common/snap_types.h" #include "common/zipkin_trace.h" #include "include/types.h" @@ -32,22 +32,23 @@ class RadosClient; struct librados::IoCtxImpl { std::atomic ref_cnt = { 0 }; - RadosClient *client; - int64_t poolid; + RadosClient *client = nullptr; + int64_t poolid = 0; snapid_t snap_seq; ::SnapContext snapc; - uint64_t assert_ver; - version_t last_objver; - uint32_t notify_timeout; + uint64_t assert_ver = 0; + version_t last_objver = 0; + uint32_t notify_timeout = 30; object_locator_t oloc; - Mutex aio_write_list_lock; - ceph_tid_t aio_write_seq; - Cond aio_write_cond; + ceph::mutex aio_write_list_lock = + ceph::make_mutex("librados::IoCtxImpl::aio_write_list_lock"); + ceph_tid_t aio_write_seq = 0; + ceph::condition_variable aio_write_cond; xlist aio_write_list; map > aio_write_waiters; - Objecter *objecter; + Objecter *objecter = nullptr; IoCtxImpl(); IoCtxImpl(RadosClient *c, Objecter *objecter, diff --git a/src/librados/PoolAsyncCompletionImpl.h b/src/librados/PoolAsyncCompletionImpl.h index 9a3b1be4bdc..b52d7fada20 100644 --- a/src/librados/PoolAsyncCompletionImpl.h +++ b/src/librados/PoolAsyncCompletionImpl.h @@ -15,73 +15,63 @@ #ifndef CEPH_LIBRADOS_POOLASYNCCOMPLETIONIMPL_H #define CEPH_LIBRADOS_POOLASYNCCOMPLETIONIMPL_H -#include "common/Cond.h" -#include "common/Mutex.h" +#include "common/ceph_mutex.h" #include "include/Context.h" #include "include/rados/librados.h" #include "include/rados/librados.hpp" namespace librados { struct PoolAsyncCompletionImpl { - Mutex lock; - Cond cond; - int ref, rval; - bool released; - bool done; + ceph::mutex lock = ceph::make_mutex("PoolAsyncCompletionImpl lock"); + ceph::condition_variable cond; + int ref = 1; + int rval = 0; + bool released = false; + bool done = false; - rados_callback_t callback; - void *callback_arg; + rados_callback_t callback = 0; + void *callback_arg = nullptr;; - PoolAsyncCompletionImpl() : lock("PoolAsyncCompletionImpl lock"), - ref(1), rval(0), released(false), done(false), - callback(0), callback_arg(0) {} + PoolAsyncCompletionImpl() = default; int set_callback(void *cb_arg, rados_callback_t cb) { - lock.Lock(); + std::scoped_lock l{lock}; callback = cb; callback_arg = cb_arg; - lock.Unlock(); return 0; } int wait() { - lock.Lock(); - while (!done) - cond.Wait(lock); - lock.Unlock(); + std::unique_lock l{lock}; + cond.wait(l, [this] { return done;}); return 0; } int is_complete() { - lock.Lock(); - int r = done; - lock.Unlock(); - return r; + std::scoped_lock l{lock}; + return done; } int get_return_value() { - lock.Lock(); - int r = rval; - lock.Unlock(); - return r; + std::scoped_lock l{lock}; + return rval; } void get() { - lock.Lock(); + std::scoped_lock l{lock}; ceph_assert(ref > 0); ref++; - lock.Unlock(); } void release() { - lock.Lock(); + lock.lock(); ceph_assert(!released); released = true; put_unlock(); } void put() { - lock.Lock(); + lock.lock(); put_unlock(); } void put_unlock() { ceph_assert(ref > 0); int n = --ref; - lock.Unlock(); + lock.unlock(); if (!n) delete this; } @@ -99,20 +89,20 @@ namespace librados { } void finish(int r) override { - c->lock.Lock(); + c->lock.lock(); c->rval = r; c->done = true; - c->cond.Signal(); + c->cond.notify_all(); if (c->callback) { rados_callback_t cb = c->callback; void *cb_arg = c->callback_arg; - c->lock.Unlock(); + c->lock.unlock(); cb(c, cb_arg); - c->lock.Lock(); + c->lock.lock(); } - c->lock.Unlock(); + c->lock.unlock(); } }; } diff --git a/src/librados/RadosClient.cc b/src/librados/RadosClient.cc index 125235ff7cd..f1184abf6ec 100644 --- a/src/librados/RadosClient.cc +++ b/src/librados/RadosClient.cc @@ -66,7 +66,6 @@ librados::RadosClient::RadosClient(CephContext *cct_) messenger(NULL), instance_id(0), objecter(NULL), - lock("librados::RadosClient::lock"), timer(cct, lock), refcnt(1), log_last_version(0), log_cb(NULL), log_cb2(NULL), log_cb_arg(NULL), @@ -317,7 +316,7 @@ int librados::RadosClient::connect() objecter->set_client_incarnation(0); objecter->start(); - lock.Lock(); + lock.lock(); timer.init(); @@ -326,7 +325,7 @@ int librados::RadosClient::connect() state = CONNECTED; instance_id = monclient.get_global_id(); - lock.Unlock(); + lock.unlock(); ldout(cct, 1) << "init done" << dendl; err = 0; @@ -350,9 +349,8 @@ int librados::RadosClient::connect() void librados::RadosClient::shutdown() { - lock.Lock(); + std::unique_lock l{lock}; if (state == DISCONNECTED) { - lock.Unlock(); return; } @@ -372,7 +370,7 @@ void librados::RadosClient::shutdown() state = DISCONNECTED; instance_id = 0; timer.shutdown(); // will drop+retake lock - lock.Unlock(); + l.unlock(); if (need_objecter) { objecter->shutdown(); } @@ -389,16 +387,13 @@ void librados::RadosClient::shutdown() int librados::RadosClient::watch_flush() { ldout(cct, 10) << __func__ << " enter" << dendl; - Mutex mylock("RadosClient::watch_flush::mylock"); - Cond cond; + ceph::mutex mylock = ceph::make_mutex("RadosClient::watch_flush::mylock"); + ceph::condition_variable cond; bool done; - objecter->linger_callback_flush(new C_SafeCond(&mylock, &cond, &done)); - - mylock.Lock(); - while (!done) - cond.Wait(mylock); - mylock.Unlock(); + objecter->linger_callback_flush(new C_SafeCond(mylock, cond, &done)); + std::unique_lock l{mylock}; + cond.wait(l, [&done] { return done; }); ldout(cct, 10) << __func__ << " exit" << dendl; return 0; } @@ -416,7 +411,7 @@ struct C_aio_watch_flush_Complete : public Context { c->lock.lock(); c->rval = r; c->complete = true; - c->cond.Signal(); + c->cond.notify_all(); if (c->callback_complete || c->callback_safe) { @@ -537,11 +532,11 @@ bool librados::RadosClient::ms_handle_refused(Connection *con) bool librados::RadosClient::_dispatch(Message *m) { - ceph_assert(lock.is_locked()); + ceph_assert(ceph_mutex_is_locked(lock)); switch (m->get_type()) { // OSD case CEPH_MSG_OSD_MAP: - cond.Signal(); + cond.notify_all(); m->put(); break; @@ -563,7 +558,7 @@ bool librados::RadosClient::_dispatch(Message *m) int librados::RadosClient::wait_for_osdmap() { - ceph_assert(!lock.is_locked_by_me()); + ceph_assert(ceph_mutex_is_not_locked_by_me(lock)); if (state != CONNECTED) { return -ENOTCONN; @@ -577,7 +572,7 @@ int librados::RadosClient::wait_for_osdmap() }); if (need_map) { - std::lock_guard l(lock); + std::unique_lock l(lock); ceph::timespan timeout{0}; if (cct->_conf->rados_mon_op_timeout > 0) { @@ -588,10 +583,9 @@ int librados::RadosClient::wait_for_osdmap() ldout(cct, 10) << __func__ << " waiting" << dendl; while (objecter->with_osdmap(std::mem_fn(&OSDMap::get_epoch)) == 0) { if (timeout == timeout.zero()) { - cond.Wait(lock); + cond.wait(l); } else { - int r = cond.WaitInterval(lock, timeout); - if (r == ETIMEDOUT) { + if (cond.wait_for(l, timeout) == std::cv_status::timeout) { lderr(cct) << "timed out waiting for first osdmap from monitors" << dendl; return -ETIMEDOUT; @@ -609,17 +603,14 @@ int librados::RadosClient::wait_for_osdmap() int librados::RadosClient::wait_for_latest_osdmap() { - Mutex mylock("RadosClient::wait_for_latest_osdmap"); - Cond cond; + ceph::mutex mylock = ceph::make_mutex("RadosClient::wait_for_latest_osdmap"); + ceph::condition_variable cond; bool done; - objecter->wait_for_latest_osdmap(new C_SafeCond(&mylock, &cond, &done)); - - mylock.Lock(); - while (!done) - cond.Wait(mylock); - mylock.Unlock(); + objecter->wait_for_latest_osdmap(new C_SafeCond(mylock, cond, &done)); + std::unique_lock l{mylock}; + cond.wait(l, [&done] {return done;}); return 0; } @@ -640,20 +631,17 @@ int librados::RadosClient::get_pool_stats(std::list& pools, map *result, bool *per_pool) { - Mutex mylock("RadosClient::get_pool_stats::mylock"); - Cond cond; + ceph::mutex mylock = ceph::make_mutex("RadosClient::get_pool_stats::mylock"); + ceph::condition_variable cond; bool done; int ret = 0; objecter->get_pool_stats(pools, result, per_pool, - new C_SafeCond(&mylock, &cond, &done, + new C_SafeCond(mylock, cond, &done, &ret)); - mylock.Lock(); - while (!done) - cond.Wait(mylock); - mylock.Unlock(); - + unique_lock l{mylock}; + cond.wait(l, [&done] { return done;}); return ret; } @@ -671,20 +659,19 @@ bool librados::RadosClient::get_pool_is_selfmanaged_snaps_mode( int librados::RadosClient::get_fs_stats(ceph_statfs& stats) { - Mutex mylock ("RadosClient::get_fs_stats::mylock"); - Cond cond; + ceph::mutex mylock = ceph::make_mutex("RadosClient::get_fs_stats::mylock"); + ceph::condition_variable cond; bool done; int ret = 0; - - lock.Lock(); - objecter->get_fs_stats(stats, boost::optional (), - new C_SafeCond(&mylock, &cond, &done, &ret)); - lock.Unlock(); - - mylock.Lock(); - while (!done) cond.Wait(mylock); - mylock.Unlock(); - + { + std::lock_guard l{mylock}; + objecter->get_fs_stats(stats, boost::optional (), + new C_SafeCond(mylock, cond, &done, &ret)); + } + { + std::unique_lock l{mylock}; + cond.wait(l, [&done] { return done;}); + } return ret; } @@ -712,20 +699,18 @@ int librados::RadosClient::pool_create(string& name, return r; } - Mutex mylock ("RadosClient::pool_create::mylock"); + ceph::mutex mylock = ceph::make_mutex("RadosClient::pool_create::mylock"); int reply; - Cond cond; + ceph::condition_variable cond; bool done; - Context *onfinish = new C_SafeCond(&mylock, &cond, &done, &reply); + Context *onfinish = new C_SafeCond(mylock, cond, &done, &reply); reply = objecter->create_pool(name, onfinish, crush_rule); if (reply < 0) { delete onfinish; } else { - mylock.Lock(); - while(!done) - cond.Wait(mylock); - mylock.Unlock(); + std::unique_lock l{mylock}; + cond.wait(l, [&done] { return done; }); } return reply; } @@ -776,20 +761,18 @@ int librados::RadosClient::pool_delete(const char *name) return r; } - Mutex mylock("RadosClient::pool_delete::mylock"); - Cond cond; + ceph::mutex mylock = ceph::make_mutex("RadosClient::pool_delete::mylock"); + ceph::condition_variable cond; bool done; int ret; - Context *onfinish = new C_SafeCond(&mylock, &cond, &done, &ret); + Context *onfinish = new C_SafeCond(mylock, cond, &done, &ret); ret = objecter->delete_pool(name, onfinish); if (ret < 0) { delete onfinish; } else { - mylock.Lock(); - while (!done) - cond.Wait(mylock); - mylock.Unlock(); + std::unique_lock l{mylock}; + cond.wait(l, [&done] { return done;}); } return ret; } @@ -859,9 +842,8 @@ void librados::RadosClient::mon_command_async(const vector& cmd, bufferlist *outbl, string *outs, Context *on_finish) { - lock.Lock(); + std::lock_guard l{lock}; monclient.start_mon_command(cmd, inbl, outbl, outs, on_finish); - lock.Unlock(); } int librados::RadosClient::mgr_command(const vector& cmd, @@ -875,13 +857,13 @@ int librados::RadosClient::mgr_command(const vector& cmd, if (r < 0) return r; - lock.Unlock(); + lock.unlock(); if (conf->rados_mon_op_timeout) { r = cond.wait_for(conf->rados_mon_op_timeout); } else { r = cond.wait(); } - lock.Lock(); + lock.lock(); return r; } @@ -891,18 +873,17 @@ int librados::RadosClient::mon_command(int rank, const vector& cmd, const bufferlist &inbl, bufferlist *outbl, string *outs) { - Mutex mylock("RadosClient::mon_command::mylock"); - Cond cond; + ceph::mutex mylock = ceph::make_mutex("RadosClient::mon_command::mylock"); + ceph::condition_variable cond; bool done; int rval; - lock.Lock(); - monclient.start_mon_command(rank, cmd, inbl, outbl, outs, - new C_SafeCond(&mylock, &cond, &done, &rval)); - lock.Unlock(); - mylock.Lock(); - while (!done) - cond.Wait(mylock); - mylock.Unlock(); + { + std::lock_guard l{mylock}; + monclient.start_mon_command(rank, cmd, inbl, outbl, outs, + new C_SafeCond(mylock, cond, &done, &rval)); + } + std::unique_lock l{mylock}; + cond.wait(l, [&done] { return done;}); return rval; } @@ -910,18 +891,17 @@ int librados::RadosClient::mon_command(string name, const vector& cmd, const bufferlist &inbl, bufferlist *outbl, string *outs) { - Mutex mylock("RadosClient::mon_command::mylock"); - Cond cond; + ceph::mutex mylock = ceph::make_mutex("RadosClient::mon_command::mylock"); + ceph::condition_variable cond; bool done; int rval; - lock.Lock(); - monclient.start_mon_command(name, cmd, inbl, outbl, outs, - new C_SafeCond(&mylock, &cond, &done, &rval)); - lock.Unlock(); - mylock.Lock(); - while (!done) - cond.Wait(mylock); - mylock.Unlock(); + { + std::lock_guard l{mylock}; + monclient.start_mon_command(name, cmd, inbl, outbl, outs, + new C_SafeCond(mylock, cond, &done, &rval)); + } + std::unique_lock l{mylock}; + cond.wait(l, [&done] { return done;}); return rval; } @@ -929,8 +909,8 @@ int librados::RadosClient::osd_command(int osd, vector& cmd, const bufferlist& inbl, bufferlist *poutbl, string *prs) { - Mutex mylock("RadosClient::osd_command::mylock"); - Cond cond; + ceph::mutex mylock = ceph::make_mutex("RadosClient::osd_command::mylock"); + ceph::condition_variable cond; bool done; int ret; ceph_tid_t tid; @@ -938,15 +918,14 @@ int librados::RadosClient::osd_command(int osd, vector& cmd, if (osd < 0) return -EINVAL; - lock.Lock(); - // XXX do anything with tid? - objecter->osd_command(osd, cmd, inbl, &tid, poutbl, prs, - new C_SafeCond(&mylock, &cond, &done, &ret)); - lock.Unlock(); - mylock.Lock(); - while (!done) - cond.Wait(mylock); - mylock.Unlock(); + { + std::lock_guard l{mylock}; + // XXX do anything with tid? + objecter->osd_command(osd, cmd, inbl, &tid, poutbl, prs, + new C_SafeCond(mylock, cond, &done, &ret)); + } + std::unique_lock l{mylock}; + cond.wait(l, [&done] { return done;}); return ret; } @@ -954,19 +933,19 @@ int librados::RadosClient::pg_command(pg_t pgid, vector& cmd, const bufferlist& inbl, bufferlist *poutbl, string *prs) { - Mutex mylock("RadosClient::pg_command::mylock"); - Cond cond; + ceph::mutex mylock = ceph::make_mutex("RadosClient::pg_command::mylock"); + ceph::condition_variable cond; bool done; int ret; ceph_tid_t tid; - lock.Lock(); - objecter->pg_command(pgid, cmd, inbl, &tid, poutbl, prs, - new C_SafeCond(&mylock, &cond, &done, &ret)); - lock.Unlock(); - mylock.Lock(); - while (!done) - cond.Wait(mylock); - mylock.Unlock(); + + { + std::lock_guard l{lock}; + objecter->pg_command(pgid, cmd, inbl, &tid, poutbl, prs, + new C_SafeCond(mylock, cond, &done, &ret)); + } + std::unique_lock l{mylock}; + cond.wait(l, [&done] { return done;}); return ret; } @@ -1027,7 +1006,7 @@ int librados::RadosClient::monitor_log(const string& level, void librados::RadosClient::handle_log(MLog *m) { - ceph_assert(lock.is_locked()); + ceph_assert(ceph_mutex_is_locked(lock)); ldout(cct, 10) << __func__ << " version " << m->version << dendl; if (log_last_version < m->version) { diff --git a/src/librados/RadosClient.h b/src/librados/RadosClient.h index 93f7f66e971..4d5dfa27542 100644 --- a/src/librados/RadosClient.h +++ b/src/librados/RadosClient.h @@ -16,9 +16,8 @@ #include "common/config_fwd.h" #include "common/Cond.h" -#include "common/Mutex.h" -#include "common/RWLock.h" #include "common/Timer.h" +#include "common/ceph_mutex.h" #include "common/ceph_time.h" #include "include/rados/librados.h" #include "include/rados/librados.hpp" @@ -68,8 +67,8 @@ private: Objecter *objecter; - Mutex lock; - Cond cond; + ceph::mutex lock = ceph::make_mutex("librados::RadosClient::lock"); + ceph::condition_variable cond; SafeTimer timer; int refcnt; diff --git a/src/librados/librados_cxx.cc b/src/librados/librados_cxx.cc index 53c24cf7f3c..96ab5e0f684 100644 --- a/src/librados/librados_cxx.cc +++ b/src/librados/librados_cxx.cc @@ -1744,9 +1744,9 @@ struct AioUnlockCompletion : public librados::ObjectOperationCompletion { rados_callback_t cb = completion->callback_complete; void *cb_arg = completion->callback_complete_arg; cb(completion, cb_arg); - completion->lock.Lock(); + completion->lock.lock(); completion->callback_complete = NULL; - completion->cond.Signal(); + completion->cond.notify_all(); completion->put_unlock(); } }; diff --git a/src/libradosstriper/MultiAioCompletionImpl.cc b/src/libradosstriper/MultiAioCompletionImpl.cc index f13d2c9525b..901bb136664 100644 --- a/src/libradosstriper/MultiAioCompletionImpl.cc +++ b/src/libradosstriper/MultiAioCompletionImpl.cc @@ -18,7 +18,7 @@ void libradosstriper::MultiAioCompletionImpl::complete_request(ssize_t r) { - lock.Lock(); + lock.lock(); if (rval >= 0) { if (r < 0 && r != -EEXIST) rval = r; @@ -35,7 +35,7 @@ void libradosstriper::MultiAioCompletionImpl::complete_request(ssize_t r) void libradosstriper::MultiAioCompletionImpl::safe_request(ssize_t r) { - lock.Lock(); + lock.lock(); if (rval >= 0) { if (r < 0 && r != -EEXIST) rval = r; @@ -50,14 +50,13 @@ void libradosstriper::MultiAioCompletionImpl::safe_request(ssize_t r) void libradosstriper::MultiAioCompletionImpl::finish_adding_requests() { - lock.Lock(); + std::scoped_lock l{lock}; ceph_assert(building); building = false; if (!pending_complete) complete(); if (!pending_safe) safe(); - lock.Unlock(); } void intrusive_ptr_add_ref(libradosstriper::MultiAioCompletionImpl* ptr) diff --git a/src/libradosstriper/MultiAioCompletionImpl.h b/src/libradosstriper/MultiAioCompletionImpl.h index 24188ab6e7d..32f7b9a84cf 100644 --- a/src/libradosstriper/MultiAioCompletionImpl.h +++ b/src/libradosstriper/MultiAioCompletionImpl.h @@ -15,15 +15,15 @@ #ifndef CEPH_LIBRADOSSTRIPERSTRIPER_MULTIAIOCOMPLETIONIMPL_H #define CEPH_LIBRADOSSTRIPERSTRIPER_MULTIAIOCOMPLETIONIMPL_H -#include "common/Cond.h" -#include "common/Mutex.h" - +#include +#include +#include "common/ceph_mutex.h" #include "include/radosstriper/libradosstriper.hpp" struct libradosstriper::MultiAioCompletionImpl { - Mutex lock; - Cond cond; + ceph::mutex lock = ceph::make_mutex("MultiAioCompletionImpl lock", false); + ceph::condition_variable cond; int ref, rval; int pending_complete, pending_safe; rados_callback_t callback_complete, callback_safe; @@ -32,8 +32,8 @@ struct libradosstriper::MultiAioCompletionImpl { bufferlist bl; /// only used for read case in C api of rados striper std::list bllist; /// keep temporary buffer lists used for destriping - MultiAioCompletionImpl() : lock("MultiAioCompletionImpl lock", false, false), - ref(1), rval(0), + MultiAioCompletionImpl() + : ref(1), rval(0), pending_complete(0), pending_safe(0), callback_complete(0), callback_safe(0), callback_complete_arg(0), callback_safe_arg(0), @@ -50,125 +50,102 @@ struct libradosstriper::MultiAioCompletionImpl { } int set_complete_callback(void *cb_arg, rados_callback_t cb) { - lock.Lock(); + std::scoped_lock l{lock}; callback_complete = cb; callback_complete_arg = cb_arg; - lock.Unlock(); return 0; } int set_safe_callback(void *cb_arg, rados_callback_t cb) { - lock.Lock(); + std::scoped_lock l{lock}; callback_safe = cb; callback_safe_arg = cb_arg; - lock.Unlock(); return 0; } int wait_for_complete() { - lock.Lock(); - while (pending_complete) - cond.Wait(lock); - lock.Unlock(); + std::unique_lock l{lock}; + cond.wait(l, [this] { return !pending_complete; }); return 0; } int wait_for_safe() { - lock.Lock(); - while (pending_safe) - cond.Wait(lock); - lock.Unlock(); + std::unique_lock l{lock}; + cond.wait(l, [this] { return !pending_safe; }); return 0; } bool is_complete() { - lock.Lock(); - int r = pending_complete; - lock.Unlock(); - return 0 == r; + std::scoped_lock l{lock}; + return pending_complete == 0; } bool is_safe() { - lock.Lock(); - int r = pending_safe; - lock.Unlock(); - return r == 0; + std::scoped_lock l{lock}; + return pending_safe == 0; } void wait_for_complete_and_cb() { - lock.Lock(); - while (pending_complete || callback_complete) - cond.Wait(lock); - lock.Unlock(); + std::unique_lock l{lock}; + cond.wait(l, [this] { return !pending_complete && !callback_complete; }); } void wait_for_safe_and_cb() { - lock.Lock(); - while (pending_safe || callback_safe) - cond.Wait(lock); - lock.Unlock(); + std::unique_lock l{lock}; + cond.wait(l, [this] { return !pending_safe && !callback_safe; }); } bool is_complete_and_cb() { - lock.Lock(); - bool r = ((0 == pending_complete) && !callback_complete); - lock.Unlock(); - return r; + std::scoped_lock l{lock}; + return ((0 == pending_complete) && !callback_complete); } bool is_safe_and_cb() { - lock.Lock(); - int r = ((0 == pending_safe) && !callback_safe); - lock.Unlock(); - return r; + std::scoped_lock l{lock}; + return ((0 == pending_safe) && !callback_safe); } int get_return_value() { - lock.Lock(); - int r = rval; - lock.Unlock(); - return r; + std::scoped_lock l{lock}; + return rval; } void get() { - lock.Lock(); + std::scoped_lock l{lock}; _get(); - lock.Unlock(); } void _get() { - ceph_assert(lock.is_locked()); + ceph_assert(ceph_mutex_is_locked(lock)); ceph_assert(ref > 0); ++ref; } void put() { - lock.Lock(); + lock.lock(); put_unlock(); } void put_unlock() { ceph_assert(ref > 0); int n = --ref; - lock.Unlock(); + lock.unlock(); if (!n) delete this; } void add_request() { - lock.Lock(); + std::scoped_lock l{lock}; pending_complete++; _get(); pending_safe++; _get(); - lock.Unlock(); } void add_safe_request() { - lock.Lock(); + std::scoped_lock l{lock}; pending_complete++; _get(); - lock.Unlock(); } void complete() { - ceph_assert(lock.is_locked()); + ceph_assert(ceph_mutex_is_locked(lock)); if (callback_complete) { callback_complete(this, callback_complete_arg); callback_complete = 0; } - cond.Signal(); + cond.notify_all(); } void safe() { - ceph_assert(lock.is_locked()); + ceph_assert(ceph_mutex_is_locked(lock)); if (callback_safe) { callback_safe(this, callback_safe_arg); callback_safe = 0; } - cond.Signal(); + cond.notify_all(); }; void complete_request(ssize_t r); diff --git a/src/libradosstriper/RadosStriperImpl.cc b/src/libradosstriper/RadosStriperImpl.cc index 1a3eb99f860..d2af7875848 100644 --- a/src/libradosstriper/RadosStriperImpl.cc +++ b/src/libradosstriper/RadosStriperImpl.cc @@ -438,7 +438,7 @@ struct RadosRemoveCompletionData : RefCountedObject { ///////////////////////// constructor ///////////////////////////// libradosstriper::RadosStriperImpl::RadosStriperImpl(librados::IoCtx& ioctx, librados::IoCtxImpl *ioctx_impl) : - m_refCnt(0),lock("RadosStriper Refcont", false, false), m_radosCluster(ioctx), m_ioCtx(ioctx), m_ioCtxImpl(ioctx_impl), + m_refCnt(0), m_radosCluster(ioctx), m_ioCtx(ioctx), m_ioCtxImpl(ioctx_impl), m_layout(default_file_layout) {} ///////////////////////// layout ///////////////////////////// @@ -771,10 +771,8 @@ int libradosstriper::RadosStriperImpl::aio_flush() if (ret < 0) return ret; //wait all CompletionData are released - lock.Lock(); - while (m_refCnt > 1) - cond.Wait(lock); - lock.Unlock(); + std::unique_lock l{lock}; + cond.wait(l, [this] {return m_refCnt <= 1;}); return ret; } diff --git a/src/libradosstriper/RadosStriperImpl.h b/src/libradosstriper/RadosStriperImpl.h index 6622471ed48..160db7b6f8d 100644 --- a/src/libradosstriper/RadosStriperImpl.h +++ b/src/libradosstriper/RadosStriperImpl.h @@ -111,18 +111,17 @@ struct RadosStriperImpl { // reference counting void get() { - lock.Lock(); + std::lock_guard l{lock}; m_refCnt ++ ; - lock.Unlock(); } void put() { bool deleteme = false; - lock.Lock(); + lock.lock(); m_refCnt --; if (m_refCnt == 0) deleteme = true; - cond.Signal(); - lock.Unlock(); + cond.notify_all(); + lock.unlock(); if (deleteme) delete this; } @@ -257,9 +256,9 @@ struct RadosStriperImpl { } // reference counting - Cond cond; + std::condition_variable cond; int m_refCnt; - Mutex lock; + std::mutex lock; // Context diff --git a/src/test/TestTimers.cc b/src/test/TestTimers.cc index 3a0e1163a0b..0d83c6fcdd0 100644 --- a/src/test/TestTimers.cc +++ b/src/test/TestTimers.cc @@ -34,7 +34,7 @@ public: void finish(int r) override { - lock_guard locker{array_lock}; + std::lock_guard locker{array_lock}; cout << "TestContext " << num << std::endl; test_array[array_idx++] = num; } -- 2.39.5