You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kudu.apache.org by al...@apache.org on 2024/12/30 16:02:24 UTC
(kudu) 02/04: [common] remove std::unique_lock template parameter
This is an automated email from the ASF dual-hosted git repository.
alexey pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/kudu.git
commit a24fd5bb1a7434b8f8230121ba3e2145c1b8205b
Author: Alexey Serbin <al...@apache.org>
AuthorDate: Fri Dec 20 21:56:41 2024 -0800
[common] remove std::unique_lock template parameter
As of C++17, it's no longer necessary to specify the template
parameter explicitly when the compiler can deduce it from the
constructor's arguments. This patch removes all instances of this
for std::unique_lock.
There are no functional modifications in this changelist.
Change-Id: If989375d0f7eb14edd149c9cd9ff976c11bea421
Reviewed-on: http://gerrit.cloudera.org:8080/22257
Tested-by: Kudu Jenkins
Reviewed-by: Marton Greber <gr...@gmail.com>
Reviewed-by: Gabriella Lotz <lo...@gmail.com>
---
src/kudu/client/authz_token_cache.cc | 2 +-
src/kudu/client/batcher.cc | 4 +-
src/kudu/client/client-internal.cc | 2 +-
src/kudu/client/meta_cache.cc | 2 +-
src/kudu/clock/hybrid_clock.cc | 2 +-
src/kudu/consensus/consensus_peers.cc | 4 +-
src/kudu/consensus/consensus_queue.cc | 2 +-
src/kudu/consensus/log_cache.cc | 4 +-
src/kudu/consensus/raft_consensus.cc | 62 ++++++++++++------------
src/kudu/consensus/raft_consensus.h | 3 --
src/kudu/consensus/raft_consensus_quorum-test.cc | 6 +--
src/kudu/fs/block_manager-stress-test.cc | 2 +-
src/kudu/fs/fs_manager.h | 8 ++-
src/kudu/fs/log_block_manager.cc | 2 +-
src/kudu/integration-tests/authz_token-itest.cc | 7 ++-
src/kudu/master/catalog_manager.h | 3 +-
src/kudu/rpc/periodic.cc | 2 +-
src/kudu/rpc/reactor.cc | 2 +-
src/kudu/rpc/reactor.h | 3 +-
src/kudu/rpc/rpcz_store.cc | 2 +-
src/kudu/rpc/service_queue.cc | 2 +-
src/kudu/security/token_signer.cc | 2 +-
src/kudu/tablet/mvcc.h | 3 +-
src/kudu/tablet/ops/alter_schema_op.cc | 6 ++-
src/kudu/tablet/ops/op_driver.cc | 2 +-
src/kudu/tablet/ops/participant_op.cc | 4 +-
src/kudu/tablet/ops/write_op.cc | 8 +--
src/kudu/tablet/rowset.h | 2 +-
src/kudu/tablet/tablet.cc | 12 ++---
src/kudu/tablet/tablet_metadata.cc | 2 +-
src/kudu/tablet/tablet_metadata.h | 3 +-
src/kudu/tablet/tablet_replica.cc | 2 +-
src/kudu/tablet/tablet_replica_mm_ops.cc | 4 +-
src/kudu/tablet/txn_participant.cc | 2 +-
src/kudu/tools/rebalancer_tool.cc | 2 +-
src/kudu/transactions/txn_status_manager.cc | 6 +--
src/kudu/tserver/scanners.h | 2 +-
src/kudu/tserver/ts_tablet_manager.cc | 2 +-
src/kudu/util/kernel_stack_watchdog.cc | 2 +-
src/kudu/util/oid_generator.h | 4 +-
src/kudu/util/rw_mutex-test.cc | 2 +-
41 files changed, 94 insertions(+), 104 deletions(-)
diff --git a/src/kudu/client/authz_token_cache.cc b/src/kudu/client/authz_token_cache.cc
index 64d8aa07f..9a1ad49a9 100644
--- a/src/kudu/client/authz_token_cache.cc
+++ b/src/kudu/client/authz_token_cache.cc
@@ -121,7 +121,7 @@ void AuthzTokenCache::RetrieveNewAuthzToken(const KuduTable* table,
DCHECK(table);
DCHECK(deadline.Initialized());
const string& table_id = table->id();
- std::unique_lock<simple_spinlock> l(rpc_lock_);
+ std::unique_lock l(rpc_lock_);
// If there already exists an RPC for this table; attach the callback.
auto* rpc_and_cbs = FindOrNull(authz_rpcs_, table_id);
if (rpc_and_cbs) {
diff --git a/src/kudu/client/batcher.cc b/src/kudu/client/batcher.cc
index 762e9b0af..b4490f4d5 100644
--- a/src/kudu/client/batcher.cc
+++ b/src/kudu/client/batcher.cc
@@ -632,7 +632,7 @@ Batcher::Batcher(KuduClient* client,
}
void Batcher::Abort() {
- std::unique_lock<simple_spinlock> l(lock_);
+ std::unique_lock l(lock_);
state_ = kAborted;
vector<InFlightOp*> to_abort;
@@ -811,7 +811,7 @@ void Batcher::TabletLookupFinished(InFlightOp* op, const Status& s) {
// Acquire the batcher lock early to atomically:
// 1. Test if the batcher was aborted, and
// 2. Change the op state.
- std::unique_lock<simple_spinlock> l(lock_);
+ std::unique_lock l(lock_);
if (IsAbortedUnlocked()) {
VLOG(1) << "Aborted batch: TabletLookupFinished for " << op->ToString();
diff --git a/src/kudu/client/client-internal.cc b/src/kudu/client/client-internal.cc
index 9a2237e53..fbd6048b1 100644
--- a/src/kudu/client/client-internal.cc
+++ b/src/kudu/client/client-internal.cc
@@ -863,7 +863,7 @@ void KuduClient::Data::ConnectToClusterAsync(KuduClient* client,
// this information in parallel, since the requests should end up with the
// same result. Instead, simply piggy-back onto the existing request by adding
// our the callback to leader_master_callbacks_{any_creds,primary_creds}_.
- std::unique_lock<simple_spinlock> l(leader_master_lock_);
+ std::unique_lock l(leader_master_lock_);
// Optimize sending out a new request in the presence of already existing
// requests to the leader master. Depending on the credentials policy for the
diff --git a/src/kudu/client/meta_cache.cc b/src/kudu/client/meta_cache.cc
index 25aca9b6b..a880fdbcd 100644
--- a/src/kudu/client/meta_cache.cc
+++ b/src/kudu/client/meta_cache.cc
@@ -155,7 +155,7 @@ void RemoteTabletServer::DnsResolutionFinished(const HostPort& hp,
void RemoteTabletServer::InitProxy(KuduClient* client, const StatusCallback& cb) {
HostPort hp;
{
- std::unique_lock<simple_spinlock> l(lock_);
+ std::unique_lock l(lock_);
if (proxy_) {
// Already have a proxy created.
diff --git a/src/kudu/clock/hybrid_clock.cc b/src/kudu/clock/hybrid_clock.cc
index da4660fc9..812759182 100644
--- a/src/kudu/clock/hybrid_clock.cc
+++ b/src/kudu/clock/hybrid_clock.cc
@@ -726,7 +726,7 @@ Status HybridClock::WalltimeWithError(uint64_t* now_usec, uint64_t* error_usec)
} else {
// We failed to read the clock. Extrapolate the new time based on our
// last successful read.
- std::unique_lock<decltype(last_clock_read_lock_)> l(last_clock_read_lock_);
+ std::unique_lock l(last_clock_read_lock_);
if (!is_extrapolating_) {
is_extrapolating_ = true;
extrapolating_->set_value(is_extrapolating_);
diff --git a/src/kudu/consensus/consensus_peers.cc b/src/kudu/consensus/consensus_peers.cc
index aebb07968..9fa2bb39e 100644
--- a/src/kudu/consensus/consensus_peers.cc
+++ b/src/kudu/consensus/consensus_peers.cc
@@ -190,7 +190,7 @@ Status Peer::SignalRequest(bool even_if_queue_empty) {
}
void Peer::SendNextRequest(bool even_if_queue_empty) {
- std::unique_lock<simple_spinlock> l(peer_lock_);
+ std::unique_lock l(peer_lock_);
if (PREDICT_FALSE(closed_)) {
return;
}
@@ -439,7 +439,7 @@ Status Peer::PrepareTabletCopyRequest() {
void Peer::ProcessTabletCopyResponse() {
// If the peer is already closed return.
- std::unique_lock<simple_spinlock> lock(peer_lock_);
+ std::unique_lock lock(peer_lock_);
if (PREDICT_FALSE(closed_)) {
return;
}
diff --git a/src/kudu/consensus/consensus_queue.cc b/src/kudu/consensus/consensus_queue.cc
index 4f279a8fe..90d1c7930 100644
--- a/src/kudu/consensus/consensus_queue.cc
+++ b/src/kudu/consensus/consensus_queue.cc
@@ -403,7 +403,7 @@ Status PeerMessageQueue::AppendOperations(vector<ReplicateRefPtr> msgs,
const StatusCallback& log_append_callback) {
DFAKE_SCOPED_LOCK(append_fake_lock_);
- std::unique_lock<simple_spinlock> lock(queue_lock_);
+ std::unique_lock lock(queue_lock_);
OpId last_id = msgs.back()->get()->id();
diff --git a/src/kudu/consensus/log_cache.cc b/src/kudu/consensus/log_cache.cc
index 7702843c1..77e66f8bb 100644
--- a/src/kudu/consensus/log_cache.cc
+++ b/src/kudu/consensus/log_cache.cc
@@ -164,7 +164,7 @@ Status LogCache::AppendOperations(vector<ReplicateRefPtr> msgs,
const int64_t first_idx_in_batch = msgs.front()->get()->id().index();
const int64_t last_idx_in_batch = msgs.back()->get()->id().index();
- std::unique_lock<simple_spinlock> l(lock_);
+ std::unique_lock l(lock_);
// If we're not appending a consecutive op we're likely overwriting and
// need to replace operations in the cache.
if (first_idx_in_batch != next_sequential_op_index_) {
@@ -299,7 +299,7 @@ Status LogCache::ReadOps(int64_t after_op_index,
int64_t remaining_space = max_size_bytes;
int64_t next_index = after_op_index + 1;
- std::unique_lock<simple_spinlock> l(lock_);
+ std::unique_lock l(lock_);
while (remaining_space > 0 && next_index < next_sequential_op_index_) {
// If the messages the peer needs haven't been loaded into the queue yet,
// load them.
diff --git a/src/kudu/consensus/raft_consensus.cc b/src/kudu/consensus/raft_consensus.cc
index 6be58bbf8..f496d90ca 100644
--- a/src/kudu/consensus/raft_consensus.cc
+++ b/src/kudu/consensus/raft_consensus.cc
@@ -209,7 +209,7 @@ RaftConsensus::RaftConsensus(
}
Status RaftConsensus::Init() {
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
DCHECK_EQ(kNew, state_) << State_Name(state_);
RETURN_NOT_OK(cmeta_manager_->Load(options_.tablet_id, &cmeta_));
SetStateUnlocked(kInitialized);
@@ -332,7 +332,7 @@ Status RaftConsensus::Start(const ConsensusBootstrapInfo& info,
{
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
CHECK_EQ(kInitialized, state_) << LogPrefixUnlocked() << "Illegal state for Start(): "
<< State_Name(state_);
@@ -415,7 +415,7 @@ Status RaftConsensus::EmulateElectionForTests() {
"tablet", options_.tablet_id);
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
RETURN_NOT_OK(CheckRunningUnlocked());
LOG_WITH_PREFIX_UNLOCKED(INFO) << "Emulating election...";
@@ -466,7 +466,7 @@ Status RaftConsensus::StartElection(ElectionMode mode, ElectionReason reason) {
scoped_refptr<LeaderElection> election;
{
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
RETURN_NOT_OK(CheckRunningUnlocked());
RaftPeerPB::Role active_role = cmeta_->active_role();
@@ -574,7 +574,7 @@ Status RaftConsensus::WaitUntilLeader(const MonoDelta& timeout) {
Status RaftConsensus::StepDown(LeaderStepDownResponsePB* resp) {
TRACE_EVENT0("consensus", "RaftConsensus::StepDown");
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
DCHECK((queue_->IsInLeaderMode() && cmeta_->active_role() == RaftPeerPB::LEADER) ||
(!queue_->IsInLeaderMode() && cmeta_->active_role() != RaftPeerPB::LEADER));
RETURN_NOT_OK(CheckRunningUnlocked());
@@ -600,7 +600,7 @@ Status RaftConsensus::TransferLeadership(const optional<string>& new_leader_uuid
LeaderStepDownResponsePB* resp) {
TRACE_EVENT0("consensus", "RaftConsensus::TransferLeadership");
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
LOG_WITH_PREFIX_UNLOCKED(INFO) << "Received request to transfer leadership"
<< (new_leader_uuid ?
Substitute(" to TS $0", *new_leader_uuid) :
@@ -763,7 +763,7 @@ Status RaftConsensus::Replicate(const scoped_refptr<ConsensusRound>& round) {
std::lock_guard lock(update_lock_);
{
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
RETURN_NOT_OK(CheckSafeToReplicateUnlocked(*round->replicate_msg()));
RETURN_NOT_OK(round->CheckBoundTerm(CurrentTermUnlocked()));
RETURN_NOT_OK(AppendNewRoundToQueueUnlocked(round));
@@ -896,7 +896,7 @@ void RaftConsensus::NotifyCommitIndex(int64_t commit_index) {
"commit_index", commit_index);
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
// We will process commit notifications while shutting down because a replica
// which has initiated a Prepare() / Replicate() may eventually commit even if
// its state has changed after the initial Append() / Update().
@@ -921,7 +921,7 @@ void RaftConsensus::NotifyTermChange(int64_t term) {
"term", term);
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
Status s = CheckRunningUnlocked();
if (PREDICT_FALSE(!s.ok())) {
LOG_WITH_PREFIX_UNLOCKED(WARNING) << "Unable to handle notification of new term "
@@ -947,7 +947,7 @@ void RaftConsensus::NotifyFailedFollower(const string& uuid,
RaftConfigPB committed_config;
{
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
int64_t current_term = CurrentTermUnlocked();
if (current_term != term) {
LOG_WITH_PREFIX_UNLOCKED(INFO) << fail_msg << "Notified about a follower failure in "
@@ -1016,7 +1016,7 @@ void RaftConsensus::TryPromoteNonVoterTask(const string& peer_uuid) {
int64_t current_committed_config_index;
{
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
if (cmeta_->has_pending_config()) {
LOG_WITH_PREFIX_UNLOCKED(INFO) << msg << "there is already a config change operation "
@@ -1065,7 +1065,7 @@ void RaftConsensus::TryPromoteNonVoterTask(const string& peer_uuid) {
void RaftConsensus::TryStartElectionOnPeerTask(const string& peer_uuid) {
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
// Double-check that the peer is a voter in the active config.
if (!IsRaftConfigVoter(peer_uuid, cmeta_->ActiveConfig())) {
LOG_WITH_PREFIX_UNLOCKED(INFO) << "Not signalling peer " << peer_uuid
@@ -1132,7 +1132,7 @@ Status RaftConsensus::StartFollowerOpUnlocked(const ReplicateRefPtr& msg) {
bool RaftConsensus::IsSingleVoterConfig() const {
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
return cmeta_->CountVotersInConfig(COMMITTED_CONFIG) == 1 &&
cmeta_->IsVoterInConfig(peer_uuid(), COMMITTED_CONFIG);
}
@@ -1470,7 +1470,7 @@ Status RaftConsensus::UpdateReplica(const ConsensusRequestPB* request,
auto& messages = deduped_req.messages;
{
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
RETURN_NOT_OK(CheckRunningUnlocked());
if (!cmeta_->IsMemberInConfig(peer_uuid(), ACTIVE_CONFIG)) {
LOG_WITH_PREFIX_UNLOCKED(INFO) << "Allowing update even though not a member of the config";
@@ -1747,7 +1747,7 @@ Status RaftConsensus::RequestVote(const VoteRequestPB* request,
// We must acquire the update lock in order to ensure that this vote action
// takes place between requests.
// Lock ordering: update_lock_ must be acquired before lock_.
- std::unique_lock<simple_spinlock> update_guard(update_lock_, std::defer_lock);
+ std::unique_lock update_guard(update_lock_, std::defer_lock);
if (PREDICT_TRUE(FLAGS_enable_leader_failure_detection)) {
update_guard.try_lock();
} else {
@@ -1765,7 +1765,7 @@ Status RaftConsensus::RequestVote(const VoteRequestPB* request,
// Acquire the replica state lock so we can read / modify the consensus state.
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
// Ensure our lifecycle state is compatible with voting.
// If RaftConsensus is running, we use the latest OpId from the WAL to vote.
@@ -1900,7 +1900,7 @@ Status RaftConsensus::BulkChangeConfig(const BulkChangeConfigRequestPB& req,
"tablet", options_.tablet_id);
{
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
RETURN_NOT_OK(CheckRunningUnlocked());
RETURN_NOT_OK(CheckActiveLeaderUnlocked());
RETURN_NOT_OK(CheckNoConfigChangePendingUnlocked());
@@ -2107,7 +2107,7 @@ Status RaftConsensus::UnsafeChangeConfig(
// Take the snapshot of the replica state and queue state so that
// we can stick them in the consensus update request later.
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
current_term = CurrentTermUnlocked();
committed_config = cmeta_->CommittedConfig();
if (cmeta_->has_pending_config()) {
@@ -2228,7 +2228,7 @@ void RaftConsensus::Stop() {
"tablet", options_.tablet_id);
{
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
const State state = state_;
if (state == kStopping || state == kStopped || state == kShutdown) {
return;
@@ -2252,7 +2252,7 @@ void RaftConsensus::Stop() {
{
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
if (pending_) {
CHECK_OK(pending_->CancelPendingOps());
}
@@ -2288,7 +2288,7 @@ void RaftConsensus::Shutdown() {
Stop();
{
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
SetStateUnlocked(kShutdown);
}
shutdown_ = true;
@@ -2317,7 +2317,7 @@ Status RaftConsensus::StartConsensusOnlyRoundUnlocked(const ReplicateRefPtr& msg
Status RaftConsensus::AdvanceTermForTests(int64_t new_term) {
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
CHECK_OK(CheckRunningUnlocked());
return HandleTermAdvanceUnlocked(new_term);
}
@@ -2469,7 +2469,7 @@ Status RaftConsensus::RequestVoteRespondVoteGranted(const VoteRequestPB* request
RaftPeerPB::Role RaftConsensus::role() const {
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
return cmeta_->active_role();
}
@@ -2479,7 +2479,7 @@ RaftConsensus::RoleAndMemberType RaftConsensus::GetRoleAndMemberType() const {
auto member_type = RaftPeerPB::UNKNOWN_MEMBER_TYPE;
const auto& local_peer_uuid = peer_uuid();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
for (const auto& peer : cmeta_->ActiveConfig().peers()) {
if (peer.permanent_uuid() == local_peer_uuid) {
member_type = peer.member_type();
@@ -2491,7 +2491,7 @@ RaftConsensus::RoleAndMemberType RaftConsensus::GetRoleAndMemberType() const {
}
int64_t RaftConsensus::CurrentTerm() const {
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
return CurrentTermUnlocked();
}
@@ -2606,7 +2606,7 @@ const string& RaftConsensus::tablet_id() const {
Status RaftConsensus::ConsensusState(ConsensusStatePB* cstate,
IncludeHealthReport report_health) const {
ThreadRestrictions::AssertWaitAllowed();
- UniqueLock l(lock_);
+ std::unique_lock l(lock_);
if (state_ == kShutdown) {
return Status::IllegalState("Tablet replica is shutdown");
}
@@ -2637,7 +2637,7 @@ Status RaftConsensus::ConsensusState(ConsensusStatePB* cstate,
RaftConfigPB RaftConsensus::CommittedConfig() const {
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
return cmeta_->CommittedConfig();
}
@@ -2688,7 +2688,7 @@ void RaftConsensus::DoElectionCallback(ElectionReason reason, const ElectionResu
const char* election_type = was_pre_election ? "pre-election" : "election";
ThreadRestrictions::AssertWaitAllowed();
- UniqueLock l(lock_);
+ std::unique_lock l(lock_);
// Record the duration of the election regardless of the outcome.
auto update_metrics = MakeScopedCleanup([&]() {
@@ -2815,7 +2815,7 @@ void RaftConsensus::DoElectionCallback(ElectionReason reason, const ElectionResu
optional<OpId> RaftConsensus::GetLastOpId(OpIdType type) {
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
return GetLastOpIdUnlocked(type);
}
@@ -3232,7 +3232,7 @@ const ConsensusOptions& RaftConsensus::GetOptions() const {
string RaftConsensus::LogPrefix() const {
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
return LogPrefixUnlocked();
}
@@ -3250,7 +3250,7 @@ string RaftConsensus::LogPrefixUnlocked() const {
string RaftConsensus::ToString() const {
ThreadRestrictions::AssertWaitAllowed();
- LockGuard l(lock_);
+ std::lock_guard l(lock_);
return ToStringUnlocked();
}
diff --git a/src/kudu/consensus/raft_consensus.h b/src/kudu/consensus/raft_consensus.h
index 6f26faf50..921d9210d 100644
--- a/src/kudu/consensus/raft_consensus.h
+++ b/src/kudu/consensus/raft_consensus.h
@@ -477,9 +477,6 @@ class RaftConsensus : public std::enable_shared_from_this<RaftConsensus>,
std::string OpsRangeString() const;
};
- using LockGuard = std::lock_guard<simple_spinlock>;
- using UniqueLock = std::unique_lock<simple_spinlock>;
-
// Returns string description for State enum value.
static const char* State_Name(State state);
diff --git a/src/kudu/consensus/raft_consensus_quorum-test.cc b/src/kudu/consensus/raft_consensus_quorum-test.cc
index ee613e1fd..67ebe7458 100644
--- a/src/kudu/consensus/raft_consensus_quorum-test.cc
+++ b/src/kudu/consensus/raft_consensus_quorum-test.cc
@@ -702,7 +702,7 @@ TEST_F(RaftConsensusQuorumTest, TestConsensusContinuesIfAMinorityFallsBehind) {
shared_ptr<RaftConsensus> follower0;
CHECK_OK(peers_->GetPeerByIdx(kFollower0Idx, &follower0));
- RaftConsensus::LockGuard l(follower0->lock_);
+ std::lock_guard l(follower0->lock_);
// If the locked replica would stop consensus we would hang here
// as we wait for operations to be replicated to a majority.
@@ -740,11 +740,11 @@ TEST_F(RaftConsensusQuorumTest, TestConsensusStopsIfAMajorityFallsBehind) {
// and never letting them go.
shared_ptr<RaftConsensus> follower0;
CHECK_OK(peers_->GetPeerByIdx(kFollower0Idx, &follower0));
- RaftConsensus::LockGuard l_0(follower0->lock_);
+ std::lock_guard l_0(follower0->lock_);
shared_ptr<RaftConsensus> follower1;
CHECK_OK(peers_->GetPeerByIdx(kFollower1Idx, &follower1));
- RaftConsensus::LockGuard l_1(follower1->lock_);
+ std::lock_guard l_1(follower1->lock_);
// Append a single message to the queue
ASSERT_OK(AppendDummyMessage(kLeaderIdx, &round));
diff --git a/src/kudu/fs/block_manager-stress-test.cc b/src/kudu/fs/block_manager-stress-test.cc
index fecb97cf6..031006c3b 100644
--- a/src/kudu/fs/block_manager-stress-test.cc
+++ b/src/kudu/fs/block_manager-stress-test.cc
@@ -441,7 +441,7 @@ void BlockManagerStressTest<T>::DeleterThread() {
shared_ptr<BlockDeletionTransaction> deletion_transaction =
this->bm_->NewDeletionTransaction();
{
- std::unique_lock<simple_spinlock> l(lock_);
+ std::unique_lock l(lock_);
// If we only have a small number of live blocks, don't delete any.
// This ensures that, when we restart, we always have a reasonable
// amount of data -- otherwise the deletion threads are likely to
diff --git a/src/kudu/fs/fs_manager.h b/src/kudu/fs/fs_manager.h
index d0f94383b..7c288f05f 100644
--- a/src/kudu/fs/fs_manager.h
+++ b/src/kudu/fs/fs_manager.h
@@ -628,10 +628,8 @@ class FsManager {
static const char *kInstanceMetadataFileName;
static const char *kConsensusMetadataDirName;
- typedef rw_spinlock LockType;
-
// Lock protecting the env_map_ below.
- mutable LockType env_lock_;
+ mutable rw_spinlock env_lock_;
// The environment to be used for all filesystem operations.
// Different tenant use different env.
typedef std::map<std::string, std::shared_ptr<Env>> EnvMap;
@@ -662,13 +660,13 @@ class FsManager {
// Shared by all the block managers.
scoped_refptr<fs::FsErrorManager> error_manager_;
// Lock protecting 'dd_manager_map_' below.
- mutable LockType ddm_lock_;
+ mutable rw_spinlock ddm_lock_;
typedef scoped_refptr<fs::DataDirManager> ScopedDDManagerPtr;
typedef std::map<std::string, ScopedDDManagerPtr> DataDirManagerMap;
DataDirManagerMap dd_manager_map_;
// Lock protecting 'block_manager_map_'.
- mutable LockType bm_lock_;
+ mutable rw_spinlock bm_lock_;
typedef scoped_refptr<fs::BlockManager> ScopedBlockManagerPtr;
typedef std::map<std::string, ScopedBlockManagerPtr> BlockManagerMap;
BlockManagerMap block_manager_map_;
diff --git a/src/kudu/fs/log_block_manager.cc b/src/kudu/fs/log_block_manager.cc
index 2c7bc12c6..e3e05462b 100644
--- a/src/kudu/fs/log_block_manager.cc
+++ b/src/kudu/fs/log_block_manager.cc
@@ -1091,7 +1091,7 @@ void LogBlockContainerNativeMeta::CompactMetadata() {
SCOPED_LOG_SLOW_EXECUTION(WARNING, 5, Substitute("CompactMetadata $0", ToString()));
// Skip compacting if lock failed to reduce overhead, metadata is on compacting or will be
// compacted next time.
- std::unique_lock<RWMutex> l(metadata_compact_lock_, std::try_to_lock);
+ std::unique_lock l(metadata_compact_lock_, std::try_to_lock);
if (!l.owns_lock()) {
return;
}
diff --git a/src/kudu/integration-tests/authz_token-itest.cc b/src/kudu/integration-tests/authz_token-itest.cc
index ddc9dccaa..7898390ea 100644
--- a/src/kudu/integration-tests/authz_token-itest.cc
+++ b/src/kudu/integration-tests/authz_token-itest.cc
@@ -22,6 +22,7 @@
#include <ostream>
#include <string>
#include <thread>
+#include <type_traits>
#include <utility>
#include <vector>
@@ -62,6 +63,7 @@ using std::string;
using std::thread;
using std::unique_ptr;
using std::vector;
+using strings::Substitute;
DECLARE_bool(master_support_authz_tokens);
DECLARE_bool(tserver_enforce_access_control);
@@ -76,8 +78,6 @@ METRIC_DECLARE_histogram(handler_latency_kudu_master_MasterService_GetTableSchem
namespace kudu {
-class RWMutex;
-
using cluster::InternalMiniCluster;
using cluster::InternalMiniClusterOptions;
using client::AuthenticationCredentialsPB;
@@ -97,7 +97,6 @@ using security::SignedTokenPB;
using security::TablePrivilegePB;
using security::TokenSigner;
using security::TokenSigningPrivateKeyPB;
-using strings::Substitute;
namespace {
@@ -426,7 +425,7 @@ TEST_F(AuthzTokenTest, TestSingleMasterUnavailable) {
// Take the leader lock on the master, which will prevent successful attempts
// to get a new token, but will allow retries.
- std::unique_lock<RWMutex> leader_lock(
+ std::unique_lock leader_lock(
cluster_->mini_master()->master()->catalog_manager()->leader_lock_);
// After a while, the client operation will time out.
diff --git a/src/kudu/master/catalog_manager.h b/src/kudu/master/catalog_manager.h
index 5acfd526c..0d6848749 100644
--- a/src/kudu/master/catalog_manager.h
+++ b/src/kudu/master/catalog_manager.h
@@ -1358,8 +1358,7 @@ class CatalogManager : public tserver::TabletReplicaLookupIf {
// easy to make a "gettable set".
// Lock protecting the various maps and sets below.
- typedef rw_spinlock LockType;
- mutable LockType lock_;
+ mutable rw_spinlock lock_;
// Table maps: table-id -> TableInfo and normalized-table-name -> TableInfo
TableInfoMap table_ids_map_;
diff --git a/src/kudu/rpc/periodic.cc b/src/kudu/rpc/periodic.cc
index 21631f1f0..c4d02a9a8 100644
--- a/src/kudu/rpc/periodic.cc
+++ b/src/kudu/rpc/periodic.cc
@@ -74,7 +74,7 @@ PeriodicTimer::~PeriodicTimer() {
}
void PeriodicTimer::Start(optional<MonoDelta> next_task_delta) {
- std::unique_lock<simple_spinlock> l(lock_);
+ std::unique_lock l(lock_);
if (!started_) {
started_ = true;
SnoozeUnlocked(std::move(next_task_delta));
diff --git a/src/kudu/rpc/reactor.cc b/src/kudu/rpc/reactor.cc
index 5a0378680..114a8fba0 100644
--- a/src/kudu/rpc/reactor.cc
+++ b/src/kudu/rpc/reactor.cc
@@ -954,7 +954,7 @@ void Reactor::QueueCancellation(shared_ptr<OutboundCall> call) {
void Reactor::ScheduleReactorTask(ReactorTask* task) {
bool was_empty;
{
- std::unique_lock<LockType> l(lock_);
+ std::unique_lock l(lock_);
if (PREDICT_FALSE(closing_)) {
// We guarantee the reactor lock is not taken when calling Abort().
l.unlock();
diff --git a/src/kudu/rpc/reactor.h b/src/kudu/rpc/reactor.h
index 8944a2b2d..a74b37846 100644
--- a/src/kudu/rpc/reactor.h
+++ b/src/kudu/rpc/reactor.h
@@ -405,8 +405,7 @@ class Reactor {
private:
friend class ReactorThread;
- typedef simple_spinlock LockType;
- mutable LockType lock_;
+ mutable simple_spinlock lock_;
// parent messenger
std::shared_ptr<Messenger> messenger_;
diff --git a/src/kudu/rpc/rpcz_store.cc b/src/kudu/rpc/rpcz_store.cc
index 97e28b2f6..8bbbfd17f 100644
--- a/src/kudu/rpc/rpcz_store.cc
+++ b/src/kudu/rpc/rpcz_store.cc
@@ -165,7 +165,7 @@ void MethodSampler::SampleCall(InboundCall* call) {
int64_t us_since_trace = now - bucket->last_sample_time;
if (us_since_trace > kSampleIntervalUs) {
{
- std::unique_lock<simple_spinlock> lock(bucket->sample_lock, std::try_to_lock);
+ std::unique_lock lock(bucket->sample_lock, std::try_to_lock);
// If another thread is already taking a sample, it's not worth waiting.
if (!lock.owns_lock()) {
return;
diff --git a/src/kudu/rpc/service_queue.cc b/src/kudu/rpc/service_queue.cc
index fe7356775..a3259a621 100644
--- a/src/kudu/rpc/service_queue.cc
+++ b/src/kudu/rpc/service_queue.cc
@@ -76,7 +76,7 @@ bool LifoServiceQueue::BlockingGet(std::unique_ptr<InboundCall>* out) {
QueueStatus LifoServiceQueue::Put(InboundCall* call,
std::optional<InboundCall*>* evicted) {
- std::unique_lock<simple_spinlock> l(lock_);
+ std::unique_lock l(lock_);
if (PREDICT_FALSE(shutdown_)) {
return QUEUE_SHUTDOWN;
}
diff --git a/src/kudu/security/token_signer.cc b/src/kudu/security/token_signer.cc
index 319e76e75..8306f13a7 100644
--- a/src/kudu/security/token_signer.cc
+++ b/src/kudu/security/token_signer.cc
@@ -207,7 +207,7 @@ Status TokenSigner::CheckNeedKey(unique_ptr<TokenSigningPrivateKey>* tsk) const
CHECK(tsk);
const int64_t now = WallTime_Now();
- unique_lock<RWMutex> l(lock_);
+ unique_lock l(lock_);
if (tsk_deque_.empty()) {
// No active key: need a new one.
const int64_t key_seq_num = last_key_seq_num_ + 1;
diff --git a/src/kudu/tablet/mvcc.h b/src/kudu/tablet/mvcc.h
index 88352dc58..045581c5c 100644
--- a/src/kudu/tablet/mvcc.h
+++ b/src/kudu/tablet/mvcc.h
@@ -426,8 +426,7 @@ class MvccManager {
// finishes applying or aborts.
void AdvanceEarliestInFlightTimestamp();
- typedef simple_spinlock LockType;
- mutable LockType lock_;
+ mutable simple_spinlock lock_;
// The kLatest snapshot that gets updated with op timestamps as MVCC ops
// start and complete through the lifespan of this MvccManager.
diff --git a/src/kudu/tablet/ops/alter_schema_op.cc b/src/kudu/tablet/ops/alter_schema_op.cc
index cec6585a9..ba32b18ec 100644
--- a/src/kudu/tablet/ops/alter_schema_op.cc
+++ b/src/kudu/tablet/ops/alter_schema_op.cc
@@ -61,13 +61,15 @@ using tserver::TabletServerErrorPB;
void AlterSchemaOpState::AcquireSchemaLock(rw_semaphore* l) {
TRACE("Acquiring schema lock in exclusive mode");
- schema_lock_ = std::unique_lock<rw_semaphore>(*l);
+ decltype(schema_lock_) tmp(*l);
+ schema_lock_.swap(tmp);
TRACE("Acquired schema lock");
}
void AlterSchemaOpState::ReleaseSchemaLock() {
CHECK(schema_lock_.owns_lock());
- schema_lock_ = std::unique_lock<rw_semaphore>();
+ decltype(schema_lock_) tmp;
+ schema_lock_.swap(tmp);
TRACE("Released schema lock");
}
diff --git a/src/kudu/tablet/ops/op_driver.cc b/src/kudu/tablet/ops/op_driver.cc
index 41cae488a..b081f624f 100644
--- a/src/kudu/tablet/ops/op_driver.cc
+++ b/src/kudu/tablet/ops/op_driver.cc
@@ -497,7 +497,7 @@ void OpDriver::Abort(const Status& status) {
Status OpDriver::ApplyAsync() {
{
- std::unique_lock<simple_spinlock> lock(lock_);
+ std::unique_lock lock(lock_);
DCHECK_EQ(prepare_state_, PREPARED);
if (op_status_.ok()) {
DCHECK_EQ(replication_state_, REPLICATED);
diff --git a/src/kudu/tablet/ops/participant_op.cc b/src/kudu/tablet/ops/participant_op.cc
index 598b88043..8b9f0a45b 100644
--- a/src/kudu/tablet/ops/participant_op.cc
+++ b/src/kudu/tablet/ops/participant_op.cc
@@ -64,7 +64,6 @@ using std::unique_ptr;
using strings::Substitute;
namespace kudu {
-class rw_semaphore;
namespace tablet {
@@ -88,7 +87,8 @@ void ParticipantOpState::AcquireTxnAndLock() {
void ParticipantOpState::ReleaseTxn() {
if (txn_lock_.owns_lock()) {
- txn_lock_ = std::unique_lock<rw_semaphore>();
+ decltype(txn_lock_) tmp;
+ txn_lock_.swap(tmp);
}
txn_.reset();
TRACE("Released txn lock");
diff --git a/src/kudu/tablet/ops/write_op.cc b/src/kudu/tablet/ops/write_op.cc
index dba3108c1..2b99abe69 100644
--- a/src/kudu/tablet/ops/write_op.cc
+++ b/src/kudu/tablet/ops/write_op.cc
@@ -430,8 +430,8 @@ void WriteOpState::set_txn_rowsets(const scoped_refptr<TxnRowSets>& rowsets) {
void WriteOpState::AcquireSchemaLock(rw_semaphore* schema_lock) {
TRACE("Acquiring schema lock in shared mode");
- shared_lock temp(*schema_lock);
- schema_lock_.swap(temp);
+ decltype(schema_lock_) tmp(*schema_lock);
+ schema_lock_.swap(tmp);
TRACE("Acquired schema lock");
}
@@ -449,8 +449,8 @@ Status WriteOpState::AcquireTxnLockCheckOpen(scoped_refptr<Txn> txn) {
}
void WriteOpState::ReleaseSchemaLock() {
- shared_lock<rw_semaphore> temp;
- schema_lock_.swap(temp);
+ decltype(schema_lock_) tmp;
+ schema_lock_.swap(tmp);
TRACE("Released schema lock");
}
diff --git a/src/kudu/tablet/rowset.h b/src/kudu/tablet/rowset.h
index 229af3928..c483e127d 100644
--- a/src/kudu/tablet/rowset.h
+++ b/src/kudu/tablet/rowset.h
@@ -310,7 +310,7 @@ class RowSet {
// the compaction selection has finished because only one thread
// makes compaction selection at a time on a given Tablet due to
// Tablet::compact_select_lock_.
- std::unique_lock<std::mutex> try_lock(*compact_flush_lock(), std::try_to_lock);
+ std::unique_lock try_lock(*compact_flush_lock(), std::try_to_lock);
return try_lock.owns_lock() && !has_been_compacted();
}
diff --git a/src/kudu/tablet/tablet.cc b/src/kudu/tablet/tablet.cc
index bb96b1af7..81a2ba223 100644
--- a/src/kudu/tablet/tablet.cc
+++ b/src/kudu/tablet/tablet.cc
@@ -1660,7 +1660,7 @@ Status Tablet::ReplaceMemRowSetsUnlocked(RowSetsInCompactionOrFlush* new_mrss,
// Mark the memrowsets as locked, so compactions won't consider it
// for inclusion in any concurrent compactions.
for (auto& mrs : *old_mrss) {
- std::unique_lock<std::mutex> ms_lock(*mrs->compact_flush_lock(), std::try_to_lock);
+ std::unique_lock ms_lock(*mrs->compact_flush_lock(), std::try_to_lock);
CHECK(ms_lock.owns_lock());
new_mrss->AddRowSet(mrs, std::move(ms_lock));
}
@@ -1861,7 +1861,7 @@ Status Tablet::PickRowSetsToCompact(RowSetsInCompactionOrFlush *picked,
// compaction from selecting this same rowset, and also ensures that
// we don't select a rowset which is currently in the middle of being
// flushed.
- std::unique_lock<std::mutex> lock(*rs->compact_flush_lock(), std::try_to_lock);
+ std::unique_lock lock(*rs->compact_flush_lock(), std::try_to_lock);
CHECK(lock.owns_lock()) << rs->ToString() << " appeared available for "
"compaction when inputs were selected, but was unable to lock its "
"compact_flush_lock to prepare for compaction.";
@@ -2864,7 +2864,7 @@ Status Tablet::CompactWorstDeltas(RowSet::DeltaCompactionType type) {
if (!rs) {
return Status::OK();
}
- lock = std::unique_lock<std::mutex>(*rs->compact_flush_lock(), std::try_to_lock);
+ lock = std::unique_lock(*rs->compact_flush_lock(), std::try_to_lock);
CHECK(lock.owns_lock());
}
@@ -2892,7 +2892,7 @@ double Tablet::GetPerfImprovementForBestDeltaCompact(RowSet::DeltaCompactionType
double Tablet::GetPerfImprovementForBestDeltaCompactUnlocked(RowSet::DeltaCompactionType type,
shared_ptr<RowSet>* rs) const {
#ifndef NDEBUG
- std::unique_lock<std::mutex> cs_lock(compact_select_lock_, std::try_to_lock);
+ std::unique_lock cs_lock(compact_select_lock_, std::try_to_lock);
CHECK(!cs_lock.owns_lock());
#endif
scoped_refptr<TabletComponents> comps;
@@ -3069,7 +3069,7 @@ Status Tablet::DeleteAncientDeletedRowsets() {
if (deleted_and_empty) {
// If we intend on deleting the rowset, take its lock so concurrent
// compactions don't try to select it for compactions.
- std::unique_lock<std::mutex> l(*rowset->compact_flush_lock(), std::try_to_lock);
+ std::unique_lock l(*rowset->compact_flush_lock(), std::try_to_lock);
CHECK(l.owns_lock());
to_delete.emplace_back(rowset);
rowset_locks.emplace_back(std::move(l));
@@ -3108,7 +3108,7 @@ Status Tablet::DeleteAncientUndoDeltas(int64_t* blocks_deleted, int64_t* bytes_d
if (!rowset->IsAvailableForCompaction()) {
continue;
}
- std::unique_lock<std::mutex> lock(*rowset->compact_flush_lock(), std::try_to_lock);
+ std::unique_lock lock(*rowset->compact_flush_lock(), std::try_to_lock);
CHECK(lock.owns_lock()) << rowset->ToString() << " unable to lock compact_flush_lock";
rowsets_to_gc_undos.push_back(rowset);
rowset_locks.push_back(std::move(lock));
diff --git a/src/kudu/tablet/tablet_metadata.cc b/src/kudu/tablet/tablet_metadata.cc
index 2dfea8d6e..027c2af8c 100644
--- a/src/kudu/tablet/tablet_metadata.cc
+++ b/src/kudu/tablet/tablet_metadata.cc
@@ -597,7 +597,7 @@ void TabletMetadata::PinFlush() {
}
Status TabletMetadata::UnPinFlush() {
- std::unique_lock<LockType> l(data_lock_);
+ std::unique_lock l(data_lock_);
CHECK_GT(num_flush_pins_, 0);
num_flush_pins_--;
if (needs_flush_) {
diff --git a/src/kudu/tablet/tablet_metadata.h b/src/kudu/tablet/tablet_metadata.h
index 5eeb362c4..d87991a11 100644
--- a/src/kudu/tablet/tablet_metadata.h
+++ b/src/kudu/tablet/tablet_metadata.h
@@ -414,8 +414,7 @@ class TabletMetadata : public RefCountedThreadSafe<TabletMetadata> {
State state_;
// Lock protecting the underlying data.
- typedef simple_spinlock LockType;
- mutable LockType data_lock_;
+ mutable simple_spinlock data_lock_;
// Lock protecting flushing the data to disk.
// If taken together with 'data_lock_', must be acquired first.
diff --git a/src/kudu/tablet/tablet_replica.cc b/src/kudu/tablet/tablet_replica.cc
index bc90e1169..e89d3c65e 100644
--- a/src/kudu/tablet/tablet_replica.cc
+++ b/src/kudu/tablet/tablet_replica.cc
@@ -321,7 +321,7 @@ const consensus::RaftConfigPB TabletReplica::RaftConfig() const {
void TabletReplica::Stop() {
{
- std::unique_lock<simple_spinlock> lock(lock_);
+ std::unique_lock lock(lock_);
if (state_ == STOPPING || state_ == STOPPED ||
state_ == SHUTDOWN || state_ == FAILED) {
lock.unlock();
diff --git a/src/kudu/tablet/tablet_replica_mm_ops.cc b/src/kudu/tablet/tablet_replica_mm_ops.cc
index 2998664cf..48bf6cf49 100644
--- a/src/kudu/tablet/tablet_replica_mm_ops.cc
+++ b/src/kudu/tablet/tablet_replica_mm_ops.cc
@@ -175,8 +175,8 @@ void FlushMRSOp::UpdateStats(MaintenanceOpStats* stats) {
}
{
- std::unique_lock<Semaphore> lock(tablet_replica_->tablet()->rowsets_flush_sem_,
- std::defer_lock);
+ std::unique_lock lock(tablet_replica_->tablet()->rowsets_flush_sem_,
+ std::defer_lock);
stats->set_runnable(lock.try_lock());
}
diff --git a/src/kudu/tablet/txn_participant.cc b/src/kudu/tablet/txn_participant.cc
index cc89ff577..c6b687b1e 100644
--- a/src/kudu/tablet/txn_participant.cc
+++ b/src/kudu/tablet/txn_participant.cc
@@ -66,7 +66,7 @@ Txn::~Txn() {
}
void Txn::AcquireWriteLock(std::unique_lock<rw_semaphore>* txn_lock) {
- std::unique_lock<rw_semaphore> l(state_lock_);
+ std::unique_lock l(state_lock_);
*txn_lock = std::move(l);
}
diff --git a/src/kudu/tools/rebalancer_tool.cc b/src/kudu/tools/rebalancer_tool.cc
index 0af0324da..30f4ca543 100644
--- a/src/kudu/tools/rebalancer_tool.cc
+++ b/src/kudu/tools/rebalancer_tool.cc
@@ -838,7 +838,7 @@ Status RebalancerTool::GetClusterRawInfo(const optional<string>& location,
}
Status RebalancerTool::RefreshKsckResults() {
- std::unique_lock<std::mutex> refresh_guard(ksck_refresh_lock_);
+ std::unique_lock refresh_guard(ksck_refresh_lock_);
if (ksck_refreshing_) {
// Other thread is already refreshing the ksck info.
ksck_refresh_cv_.wait(refresh_guard, [this]{ return !ksck_refreshing_; });
diff --git a/src/kudu/transactions/txn_status_manager.cc b/src/kudu/transactions/txn_status_manager.cc
index 3942f9f3e..ddbd68e37 100644
--- a/src/kudu/transactions/txn_status_manager.cc
+++ b/src/kudu/transactions/txn_status_manager.cc
@@ -1069,7 +1069,7 @@ Status TxnStatusManager::BeginCommitTransaction(int64_t txn_id, const string& us
if (PREDICT_TRUE(FLAGS_txn_schedule_background_tasks)) {
auto participant_ids = txn->GetParticipantIds();
- std::unique_lock<simple_spinlock> l(lock_);
+ std::unique_lock l(lock_);
auto [map_iter, emplaced] = commits_in_flight_.emplace(txn_id,
new CommitTasks(txn_id, std::move(participant_ids),
txn_client, commit_pool_, this));
@@ -1204,7 +1204,7 @@ Status TxnStatusManager::BeginAbortTransaction(int64_t txn_id,
// (and have removed the commit tasks), while at the same time, we've
// just served a client-initiated abort and so the state is already
// ABORT_IN_PROGRESS. If so, we should start abort tasks.
- std::unique_lock<simple_spinlock> l(lock_);
+ std::unique_lock l(lock_);
if (PREDICT_FALSE(!ContainsKey(commits_in_flight_, txn_id))) {
auto participant_ids = txn->GetParticipantIds();
auto tasks = EmplaceOrDie(&commits_in_flight_, txn_id,
@@ -1233,7 +1233,7 @@ Status TxnStatusManager::BeginAbortTransaction(int64_t txn_id,
if (PREDICT_TRUE(FLAGS_txn_schedule_background_tasks)) {
auto participant_ids = txn->GetParticipantIds();
- std::unique_lock<simple_spinlock> l(lock_);
+ std::unique_lock l(lock_);
auto [map_iter, emplaced] = commits_in_flight_.emplace(txn_id,
new CommitTasks(txn_id, std::move(participant_ids),
txn_client, commit_pool_, this));
diff --git a/src/kudu/tserver/scanners.h b/src/kudu/tserver/scanners.h
index 7dbebe950..7d82edb6d 100644
--- a/src/kudu/tserver/scanners.h
+++ b/src/kudu/tserver/scanners.h
@@ -340,7 +340,7 @@ class Scanner {
// Return the delta from the last time this scan was updated to 'now'.
MonoDelta TimeSinceLastAccess(const MonoTime& now) const {
- std::unique_lock<Mutex> l(lock_, std::try_to_lock);
+ std::unique_lock l(lock_, std::try_to_lock);
if (l.owns_lock()) {
return now - last_access_time_;
}
diff --git a/src/kudu/tserver/ts_tablet_manager.cc b/src/kudu/tserver/ts_tablet_manager.cc
index 30715d70e..b56524dde 100644
--- a/src/kudu/tserver/ts_tablet_manager.cc
+++ b/src/kudu/tserver/ts_tablet_manager.cc
@@ -2048,7 +2048,7 @@ Status TSTabletManager::WaitForNoTransitionsForTests(const MonoDelta& timeout) c
void TSTabletManager::UpdateTabletStatsIfNecessary() {
// Only one thread is allowed to update at the same time.
- std::unique_lock<rw_spinlock> try_lock(lock_update_, std::try_to_lock);
+ std::unique_lock try_lock(lock_update_, std::try_to_lock);
if (!try_lock.owns_lock()) {
return;
}
diff --git a/src/kudu/util/kernel_stack_watchdog.cc b/src/kudu/util/kernel_stack_watchdog.cc
index 3946757c2..93dd6e382 100644
--- a/src/kudu/util/kernel_stack_watchdog.cc
+++ b/src/kudu/util/kernel_stack_watchdog.cc
@@ -106,7 +106,7 @@ void KernelStackWatchdog::Unregister() {
std::unique_ptr<TLS> tls(tls_);
{
- std::unique_lock<Mutex> l(unregister_lock_, std::try_to_lock);
+ std::unique_lock l(unregister_lock_, std::try_to_lock);
lock_guard l2(tls_lock_);
CHECK(tls_by_tid_.erase(tid));
if (!l.owns_lock()) {
diff --git a/src/kudu/util/oid_generator.h b/src/kudu/util/oid_generator.h
index c9015cbf5..24eb9135a 100644
--- a/src/kudu/util/oid_generator.h
+++ b/src/kudu/util/oid_generator.h
@@ -53,10 +53,8 @@ class ObjectIdGenerator {
private:
DISALLOW_COPY_AND_ASSIGN(ObjectIdGenerator);
- typedef simple_spinlock LockType;
-
// Protects 'oid_generator_'.
- LockType oid_lock_;
+ simple_spinlock oid_lock_;
// Generates new UUIDs.
boost::uuids::random_generator oid_generator_;
diff --git a/src/kudu/util/rw_mutex-test.cc b/src/kudu/util/rw_mutex-test.cc
index 24b2592be..6d1e3b13a 100644
--- a/src/kudu/util/rw_mutex-test.cc
+++ b/src/kudu/util/rw_mutex-test.cc
@@ -73,7 +73,7 @@ TEST_P(RWMutexTest, TestDeadlocks) {
});
threads.emplace_back([&](){
while (!done.Load()) {
- unique_lock<RWMutex> l(lock_, try_to_lock);
+ unique_lock l(lock_, try_to_lock);
if (l.owns_lock()) {
number_of_writes++;
}