[util] switch to using std::shared_lock

Since Kudu switched to using C++17 long time ago, the home-grown kudu::shared_lock is no longer needed. Change-Id: Idcda724a3bdab86f593d0241e062dd40bcd26af1 Reviewed-on: http://gerrit.cloudera.org:8080/21349 Reviewed-by: Wang Xixu <[email protected]> Tested-by: Alexey Serbin <[email protected]> Reviewed-by: Abhishek Chennaka <[email protected]>
cutiechi · Apr 25, 2024 · a0a5230 · a0a5230
1 parent b236d53
commit a0a5230
Show file tree

Hide file tree

Showing 42 changed files with 134 additions and 114 deletions.
diff --git a/src/kudu/client/meta_cache.cc b/src/kudu/client/meta_cache.cc
@@ -23,6 +23,7 @@
 #include <mutex>
 #include <ostream>
 #include <set>
+#include <shared_mutex>
 #include <string>
 #include <type_traits>
 #include <utility>
@@ -79,6 +80,7 @@ using kudu::security::SignedTokenPB;
 using kudu::tserver::TabletServerAdminServiceProxy;
 using kudu::tserver::TabletServerServiceProxy;
 using std::set;
+using std::shared_lock;
 using std::shared_ptr;
 using std::string;
 using std::unique_ptr;

diff --git a/src/kudu/clock/builtin_ntp.cc b/src/kudu/clock/builtin_ntp.cc
@@ -31,7 +31,9 @@
 #include <memory>
 #include <mutex>
 #include <ostream>
+#include <shared_mutex>
 #include <string>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -150,6 +152,7 @@ using kudu::clock::internal::kIntervalNone;
 using kudu::clock::internal::RecordedResponse;
 using std::deque;
 using std::lock_guard;
+using std::shared_lock;
 using std::string;
 using std::unique_ptr;
 using std::vector;

diff --git a/src/kudu/common/generic_iterators.cc b/src/kudu/common/generic_iterators.cc
@@ -29,6 +29,7 @@
 #include <numeric>
 #include <optional>
 #include <ostream>
+#include <shared_mutex>
 #include <string>
 #include <type_traits>
 #include <typeinfo>
@@ -74,6 +75,7 @@ template <class T> struct compare;
 
 using std::deque;
 using std::get;
+using std::shared_lock;
 using std::sort;
 using std::string;
 using std::unique_ptr;

diff --git a/src/kudu/consensus/log.cc b/src/kudu/consensus/log.cc
@@ -23,6 +23,7 @@
 #include <memory>
 #include <mutex>
 #include <ostream>
+#include <shared_mutex>
 #include <type_traits>
 #include <utility>
 
@@ -179,6 +180,7 @@ DEFINE_validator(log_min_segments_to_retain, &ValidateLogsToRetain);
 using kudu::consensus::CommitMsg;
 using kudu::consensus::OpId;
 using kudu::consensus::ReplicateRefPtr;
+using std::shared_lock;
 using std::string;
 using std::unique_ptr;
 using std::vector;

diff --git a/src/kudu/consensus/log.h b/src/kudu/consensus/log.h
@@ -24,7 +24,9 @@
 #include <limits>
 #include <map>
 #include <memory>
+#include <shared_mutex>
 #include <string>
+#include <type_traits>
 #include <vector>
 
 #include <glog/logging.h>
@@ -162,7 +164,7 @@ class SegmentAllocator {
   FRIEND_TEST(LogTest, TestAutoStopIdleAppendThread);
   FRIEND_TEST(LogTest, TestWriteAndReadToAndFromInProgressSegment);
   SegmentAllocationState allocation_state() {
-    shared_lock<RWMutex> l(allocation_lock_);
+    std::shared_lock<RWMutex> l(allocation_lock_);
     return allocation_state_;
   }
 

diff --git a/src/kudu/fs/data_dirs.cc b/src/kudu/fs/data_dirs.cc
@@ -26,7 +26,9 @@
 #include <ostream>
 #include <random>
 #include <set>
+#include <shared_mutex>
 #include <string>
+#include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
@@ -126,14 +128,9 @@ METRIC_DEFINE_gauge_uint64(server, data_dirs_full,
 DECLARE_bool(enable_data_block_fsync);
 DECLARE_string(block_manager);
 
-namespace kudu {
-
-namespace fs {
-
-using internal::DataDirGroup;
+using kudu::fs::internal::DataDirGroup;
 using std::default_random_engine;
-using std::pair;
-using std::set;
+using std::shared_lock;
 using std::shuffle;
 using std::string;
 using std::unique_ptr;
@@ -143,6 +140,8 @@ using std::vector;
 using strings::Substitute;
 using strings::SubstituteAndAppend;
 
+namespace kudu {
+namespace fs {
 
 ////////////////////////////////////////////////////////////
 // DataDirMetrics

diff --git a/src/kudu/fs/dir_manager.cc b/src/kudu/fs/dir_manager.cc
@@ -17,14 +17,14 @@
 
 #include "kudu/fs/dir_manager.h"
 
-#include <errno.h>
-
 #include <algorithm>
+#include <cerrno>
 #include <functional>
 #include <iterator>
 #include <memory>
 #include <ostream>
 #include <set>
+#include <shared_mutex>
 #include <string>
 #include <unordered_set>
 #include <utility>
@@ -58,6 +58,7 @@
 #include "kudu/util/threadpool.h"
 
 using std::set;
+using std::shared_lock;
 using std::shared_ptr;
 using std::string;
 using std::unique_ptr;

diff --git a/src/kudu/fs/dir_manager.h b/src/kudu/fs/dir_manager.h
@@ -24,7 +24,9 @@
 #include <mutex>
 #include <optional>
 #include <set>
+#include <shared_mutex>
 #include <string>
+#include <type_traits>
 #include <unordered_map>
 #include <vector>
 
@@ -305,12 +307,12 @@ class DirManager {
   bool IsTabletInFailedDir(const std::string& tablet_id) const;
 
   std::set<int> GetFailedDirs() const {
-    shared_lock<rw_spinlock> group_lock(dir_group_lock_.get_lock());
+    std::shared_lock<rw_spinlock> group_lock(dir_group_lock_.get_lock());
     return failed_dirs_;
   }
 
   bool AreAllDirsFailed() const {
-    shared_lock<rw_spinlock> group_lock(dir_group_lock_.get_lock());
+    std::shared_lock<rw_spinlock> group_lock(dir_group_lock_.get_lock());
     return failed_dirs_.size() == dirs_.size();
   }
 

diff --git a/src/kudu/fs/fs_manager.cc b/src/kudu/fs/fs_manager.cc
@@ -23,6 +23,8 @@
 #include <initializer_list>
 #include <iostream>
 #include <mutex>
+#include <shared_mutex>
+#include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
@@ -186,6 +188,7 @@ using kudu::security::DefaultKeyProvider;
 using kudu::security::RangerKMSKeyProvider;
 using std::optional;
 using std::ostream;
+using std::shared_lock;
 using std::shared_ptr;
 using std::string;
 using std::unique_ptr;
@@ -730,8 +733,7 @@ Status FsManager::InitAndOpenBlockManager(FsReport* report,
   return Status::OK();
 }
 
-void FsManager::CopyMetadata(
-    unique_ptr<InstanceMetadataPB>* metadata) {
+void FsManager::CopyMetadata(unique_ptr<InstanceMetadataPB>* metadata) {
   shared_lock<rw_spinlock> md_lock(metadata_rwlock_.get_lock());
   (*metadata)->CopyFrom(*metadata_);
 }

diff --git a/src/kudu/fs/log_block_manager.cc b/src/kudu/fs/log_block_manager.cc
@@ -31,6 +31,7 @@
 #include <optional>
 #include <ostream>
 #include <set>
+#include <shared_mutex>
 #include <string>
 #include <type_traits>
 #include <unordered_map>
@@ -228,6 +229,7 @@ using std::accumulate;
 using std::map;
 using std::optional;
 using std::set;
+using std::shared_lock;
 using std::shared_ptr;
 using std::string;
 using std::unique_ptr;

diff --git a/src/kudu/master/catalog_manager.cc b/src/kudu/master/catalog_manager.cc
@@ -54,6 +54,7 @@
 #include <optional>
 #include <ostream>
 #include <set>
+#include <shared_mutex>
 #include <string>
 #include <type_traits>
 #include <unordered_map>
@@ -494,6 +495,7 @@ using std::nullopt;
 using std::optional;
 using std::pair;
 using std::set;
+using std::shared_lock;
 using std::shared_ptr;
 using std::string;
 using std::unique_ptr;

diff --git a/src/kudu/master/catalog_manager.h b/src/kudu/master/catalog_manager.h
@@ -28,7 +28,9 @@
 #include <mutex>
 #include <optional>
 #include <set>
+#include <shared_mutex>
 #include <string>
+#include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
@@ -392,7 +394,7 @@ class TableInfo : public RefCountedThreadSafe<TableInfo> {
 
   // Returns a snapshot copy of the table info's tablet map.
   TabletInfoMap tablet_map() const {
-    shared_lock<rw_spinlock> l(lock_);
+    std::shared_lock<rw_spinlock> l(lock_);
     TabletInfoMap ret;
     for (const auto& e : tablet_map_) {
       ret.emplace(e.first, make_scoped_refptr(e.second));
@@ -402,7 +404,7 @@ class TableInfo : public RefCountedThreadSafe<TableInfo> {
 
   // Returns the number of tablets.
   int num_tablets() const {
-    shared_lock<rw_spinlock> l(lock_);
+    std::shared_lock<rw_spinlock> l(lock_);
     return tablet_map_.size();
   }
 
@@ -615,7 +617,7 @@ class CatalogManager : public tserver::TabletReplicaLookupIf {
 
    private:
     CatalogManager* catalog_;
-    shared_lock<RWMutex> leader_shared_lock_;
+    std::shared_lock<RWMutex> leader_shared_lock_;
     Status catalog_status_;
     Status leader_status_;
     int64_t initial_term_;

diff --git a/src/kudu/master/location_cache.cc b/src/kudu/master/location_cache.cc
@@ -19,7 +19,9 @@
 
 #include <cstdio>
 #include <mutex>
+#include <shared_mutex>
 #include <string>
+#include <type_traits>
 #include <unordered_map>
 #include <utility>
 #include <vector>
@@ -48,6 +50,7 @@ METRIC_DEFINE_counter(server, location_mapping_cache_queries,
                       "Number of queries to the location mapping cache",
                       kudu::MetricLevel::kDebug);
 
+using std::shared_lock;
 using std::string;
 using std::vector;
 using strings::Substitute;

diff --git a/src/kudu/master/ts_descriptor.cc b/src/kudu/master/ts_descriptor.cc
@@ -21,6 +21,7 @@
 #include <mutex>
 #include <optional>
 #include <ostream>
+#include <shared_mutex>
 #include <unordered_set>
 #include <utility>
 #include <vector>
@@ -55,6 +56,7 @@ TAG_FLAG(tserver_last_replica_creations_halflife_ms, hidden);
 using kudu::pb_util::SecureDebugString;
 using kudu::pb_util::SecureShortDebugString;
 using std::optional;
+using std::shared_lock;
 using std::shared_ptr;
 using std::string;
 using std::vector;

diff --git a/src/kudu/master/ts_descriptor.h b/src/kudu/master/ts_descriptor.h
@@ -20,6 +20,7 @@
 #include <memory>
 #include <mutex>
 #include <optional>
+#include <shared_mutex>
 #include <string>
 #include <type_traits>  // IWYU pragma: keep
 #include <unordered_map>
@@ -206,7 +207,7 @@ class TSDescriptor : public enable_make_shared<TSDescriptor> {
   // If dimension is none, return the total number of replicas in the tablet server.
   // Otherwise, return the number of replicas in the dimension.
   int num_live_replicas(const std::optional<std::string>& dimension = std::nullopt) const {
-    shared_lock<rw_spinlock> l(lock_);
+    std::shared_lock<rw_spinlock> l(lock_);
     if (dimension) {
       int32_t num_live_tablets = 0;
       if (num_live_tablets_by_dimension_) {
@@ -220,18 +221,18 @@ class TSDescriptor : public enable_make_shared<TSDescriptor> {
   // Return the number of live replicas (i.e. running or bootstrapping)
   // in the given range for the given table.
   int num_live_replicas_by_range(const std::string& range_key, const std::string& table_id) const {
-    shared_lock<rw_spinlock> l(lock_);
+    std::shared_lock<rw_spinlock> l(lock_);
     int32_t num_live_tablets_by_range = 0;
-    if (ContainsKey(num_live_tablets_by_range_per_table_, table_id)) {
-      auto ranges = FindOrDie(num_live_tablets_by_range_per_table_, table_id);
-      ignore_result(FindCopy(ranges, range_key, &num_live_tablets_by_range));
+    if (const auto* ranges = FindOrNull(
+          num_live_tablets_by_range_per_table_, table_id); ranges != nullptr) {
+      ignore_result(FindCopy(*ranges, range_key, &num_live_tablets_by_range));
     }
     return num_live_tablets_by_range;
   }
 
   // Return the number of live replicas (i.e. running or bootstrapping) in the given table.
   int num_live_replicas_by_table(const std::string& table_id) const {
-    shared_lock<rw_spinlock> l(lock_);
+    std::shared_lock<rw_spinlock> l(lock_);
     int32_t num_live_tablets_by_table = 0;
     if (ContainsKey(num_live_tablets_by_range_per_table_, table_id)) {
       auto ranges = FindOrDie(num_live_tablets_by_range_per_table_, table_id);
@@ -246,7 +247,7 @@ class TSDescriptor : public enable_make_shared<TSDescriptor> {
   // since the location could change at any time if the tablet server
   // re-registers.
   std::optional<std::string> location() const {
-    shared_lock<rw_spinlock> l(lock_);
+    std::shared_lock<rw_spinlock> l(lock_);
     return location_;
   }
 

diff --git a/src/kudu/master/ts_manager.cc b/src/kudu/master/ts_manager.cc
@@ -25,6 +25,7 @@
 #include <mutex>
 #include <optional>
 #include <ostream>
+#include <shared_mutex>
 #include <type_traits>
 #include <utility>
 
@@ -63,6 +64,7 @@ METRIC_DEFINE_gauge_int32(server, cluster_replica_skew,
 using kudu::pb_util::SecureShortDebugString;
 using std::lock_guard;
 using std::unordered_set;
+using std::shared_lock;
 using std::shared_ptr;
 using std::string;
 using strings::Substitute;

diff --git a/src/kudu/rpc/messenger.cc b/src/kudu/rpc/messenger.cc
@@ -21,6 +21,7 @@
 #include <functional>
 #include <mutex>
 #include <ostream>
+#include <shared_mutex>
 #include <string>
 #include <type_traits>
 #include <utility>
@@ -66,6 +67,7 @@ METRIC_DEFINE_gauge_int32(server, rpc_pending_connections,
 using kudu::security::RpcAuthentication;
 using kudu::security::RpcEncryption;
 using std::string;
+using std::shared_lock;
 using std::shared_ptr;
 using std::unique_ptr;
 using strings::Substitute;