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
The following commit(s) were added to refs/heads/master by this push:
new 72b3bf4 replace shared_ptr(new T) with make_shared<T>()
72b3bf4 is described below
commit 72b3bf43e577fb060fed6e0e05b47ed24e237ac5
Author: Alexey Serbin <[email protected]>
AuthorDate: Fri May 22 12:59:21 2020 -0700
replace shared_ptr(new T) with make_shared<T>()
This patch replaces std::shared_ptr(new T(...)) pattern with
std::make_share<T>(...). The motivation of this changelist was to
reduce number of allocation in the heap. For details, see 'Notes'
section at https://en.cppreference.com/w/cpp/memory/shared_ptr/make_shared
I didn't touch sp::shared_ptr-related pieces in KuduClient to avoid
template meta-programming: not sure it's worth it.
I also did other minor changes regarding 'using std::make_shared', etc.
Change-Id: I9bcca0287d484472f7cc616f553060fe83faab1a
Reviewed-on: http://gerrit.cloudera.org:8080/15981
Reviewed-by: Andrew Wong <[email protected]>
Tested-by: Andrew Wong <[email protected]>
---
src/kudu/consensus/consensus_peers.cc | 15 +-
src/kudu/consensus/consensus_peers.h | 8 +-
src/kudu/hms/hms_client.cc | 2 +-
src/kudu/integration-tests/cluster_verifier.cc | 2 +-
src/kudu/master/placement_policy-test.cc | 2 +-
src/kudu/mini-cluster/internal_mini_cluster.cc | 3 +-
src/kudu/tablet/cfile_set.cc | 7 +-
src/kudu/tablet/cfile_set.h | 14 +-
src/kudu/tablet/deltamemstore.cc | 8 +-
src/kudu/tablet/deltamemstore.h | 11 +-
src/kudu/tablet/diskrowset.cc | 9 +-
src/kudu/tablet/diskrowset.h | 14 +-
src/kudu/tablet/memrowset.cc | 5 +-
src/kudu/tablet/memrowset.h | 11 +-
src/kudu/tablet/rowset_tree-test.cc | 21 +--
src/kudu/tablet/tablet-test.cc | 178 ++++++++++-----------
src/kudu/tablet/tablet.cc | 34 ++--
src/kudu/tools/ksck-test.cc | 23 +--
src/kudu/tools/ksck_remote.cc | 11 +-
src/kudu/tools/tool_action_cluster.cc | 5 +-
src/kudu/tserver/tablet_server-test.cc | 7 +-
.../tserver/tablet_server_authorization-test.cc | 38 +++--
src/kudu/util/make_shared.h | 2 +-
src/kudu/util/test_graph.cc | 15 +-
src/kudu/util/test_graph.h | 16 +-
src/kudu/util/threadpool-test.cc | 7 +-
26 files changed, 241 insertions(+), 227 deletions(-)
diff --git a/src/kudu/consensus/consensus_peers.cc
b/src/kudu/consensus/consensus_peers.cc
index 2d9c116..099468a 100644
--- a/src/kudu/consensus/consensus_peers.cc
+++ b/src/kudu/consensus/consensus_peers.cc
@@ -112,13 +112,14 @@ Status Peer::NewRemotePeer(RaftPeerPB peer_pb,
shared_ptr<Messenger> messenger,
shared_ptr<Peer>* peer) {
- shared_ptr<Peer> new_peer(new Peer(std::move(peer_pb),
- std::move(tablet_id),
- std::move(leader_uuid),
- queue,
- raft_pool_token,
- std::move(proxy),
- std::move(messenger)));
+ auto new_peer(Peer::make_shared(
+ std::move(peer_pb),
+ std::move(tablet_id),
+ std::move(leader_uuid),
+ queue,
+ raft_pool_token,
+ std::move(proxy),
+ std::move(messenger)));
RETURN_NOT_OK(new_peer->Init());
*peer = std::move(new_peer);
return Status::OK();
diff --git a/src/kudu/consensus/consensus_peers.h
b/src/kudu/consensus/consensus_peers.h
index 887b147..1df1a4c 100644
--- a/src/kudu/consensus/consensus_peers.h
+++ b/src/kudu/consensus/consensus_peers.h
@@ -31,6 +31,7 @@
#include "kudu/rpc/response_callback.h"
#include "kudu/rpc/rpc_controller.h"
#include "kudu/util/locks.h"
+#include "kudu/util/make_shared.h"
#include "kudu/util/net/net_util.h"
#include "kudu/util/status.h"
@@ -65,7 +66,9 @@ class PeerProxy;
// object, and performed on a thread pool (since it may do IO). When a
// response is received, the peer updates the PeerMessageQueue
// using PeerMessageQueue::ResponseFromPeer(...) on the same thread pool.
-class Peer : public std::enable_shared_from_this<Peer> {
+class Peer :
+ public std::enable_shared_from_this<Peer>,
+ public enable_make_shared<Peer> {
public:
// Initializes a peer and start sending periodic heartbeats.
Status Init();
@@ -115,7 +118,7 @@ class Peer : public std::enable_shared_from_this<Peer> {
std::shared_ptr<rpc::Messenger> messenger,
std::shared_ptr<Peer>* peer);
- private:
+ protected:
Peer(RaftPeerPB peer_pb,
std::string tablet_id,
std::string leader_uuid,
@@ -124,6 +127,7 @@ class Peer : public std::enable_shared_from_this<Peer> {
std::unique_ptr<PeerProxy> proxy,
std::shared_ptr<rpc::Messenger> messenger);
+ private:
void SendNextRequest(bool even_if_queue_empty);
// Signals that a response was received from the peer.
diff --git a/src/kudu/hms/hms_client.cc b/src/kudu/hms/hms_client.cc
index 9f37528..e945861 100644
--- a/src/kudu/hms/hms_client.cc
+++ b/src/kudu/hms/hms_client.cc
@@ -391,7 +391,7 @@ Status HmsClient::GetPartitions(const string& database_name,
Status HmsClient::DeserializeJsonTable(Slice json, hive::Table* table) {
- shared_ptr<TMemoryBuffer> membuffer(new TMemoryBuffer(json.size()));
+ auto membuffer(std::make_shared<TMemoryBuffer>(json.size()));
membuffer->write(json.data(), json.size());
TJSONProtocol protocol(membuffer);
HMS_RET_NOT_OK(table->read(&protocol), "failed to deserialize JSON table");
diff --git a/src/kudu/integration-tests/cluster_verifier.cc
b/src/kudu/integration-tests/cluster_verifier.cc
index dea427a..b03b63a 100644
--- a/src/kudu/integration-tests/cluster_verifier.cc
+++ b/src/kudu/integration-tests/cluster_verifier.cc
@@ -104,7 +104,7 @@ Status ClusterVerifier::RunKsck() {
}
std::shared_ptr<KsckCluster> cluster;
RETURN_NOT_OK(RemoteKsckCluster::Build(hp_strs, &cluster));
- std::shared_ptr<Ksck> ksck(new Ksck(cluster));
+ auto ksck(std::make_shared<Ksck>(cluster));
// Some unit tests create or remove replicas of tablets, which
// we shouldn't consider fatal.
diff --git a/src/kudu/master/placement_policy-test.cc
b/src/kudu/master/placement_policy-test.cc
index 90ea547..f48e8c3 100644
--- a/src/kudu/master/placement_policy-test.cc
+++ b/src/kudu/master/placement_policy-test.cc
@@ -103,7 +103,7 @@ class PlacementPolicyTest : public ::testing::Test {
for (const auto& location_info : cluster_info) {
const auto& ts_infos = location_info.tablet_servers;
for (const auto& ts : ts_infos) {
- shared_ptr<TSDescriptor> tsd(new TSDescriptor(ts.id));
+ auto tsd(TSDescriptor::make_shared(ts.id));
tsd->set_num_live_replicas(ts.replica_num);
tsd->location_.emplace(location_info.id);
tsd->set_num_live_replicas_by_dimension(ts.replica_num_by_dimension);
diff --git a/src/kudu/mini-cluster/internal_mini_cluster.cc
b/src/kudu/mini-cluster/internal_mini_cluster.cc
index 830eb43..3069353 100644
--- a/src/kudu/mini-cluster/internal_mini_cluster.cc
+++ b/src/kudu/mini-cluster/internal_mini_cluster.cc
@@ -146,7 +146,8 @@ Status InternalMiniCluster::StartMasters() {
<< HostPort::ToCommaSeparatedString(master_rpc_addrs);
for (int i = 0; i < num_masters; i++) {
- shared_ptr<MiniMaster> mini_master(new MiniMaster(GetMasterFsRoot(i),
master_rpc_addrs[i]));
+ auto mini_master(std::make_shared<MiniMaster>(
+ GetMasterFsRoot(i), master_rpc_addrs[i]));
if (num_masters > 1) {
mini_master->SetMasterAddresses(master_rpc_addrs);
}
diff --git a/src/kudu/tablet/cfile_set.cc b/src/kudu/tablet/cfile_set.cc
index fa27226..8c09ba9 100644
--- a/src/kudu/tablet/cfile_set.cc
+++ b/src/kudu/tablet/cfile_set.cc
@@ -122,9 +122,10 @@ Status CFileSet::Open(shared_ptr<RowSetMetadata>
rowset_metadata,
shared_ptr<MemTracker> cfile_reader_tracker,
const IOContext* io_context,
shared_ptr<CFileSet>* cfile_set) {
- shared_ptr<CFileSet> cfs(new CFileSet(std::move(rowset_metadata),
- std::move(bloomfile_tracker),
- std::move(cfile_reader_tracker)));
+ auto cfs(CFileSet::make_shared(
+ std::move(rowset_metadata),
+ std::move(bloomfile_tracker),
+ std::move(cfile_reader_tracker)));
RETURN_NOT_OK(cfs->DoOpen(io_context));
cfile_set->swap(cfs);
diff --git a/src/kudu/tablet/cfile_set.h b/src/kudu/tablet/cfile_set.h
index a34dd21..1b06df0 100644
--- a/src/kudu/tablet/cfile_set.h
+++ b/src/kudu/tablet/cfile_set.h
@@ -37,6 +37,7 @@
#include "kudu/gutil/map-util.h"
#include "kudu/gutil/port.h"
#include "kudu/tablet/rowset_metadata.h"
+#include "kudu/util/make_shared.h"
#include "kudu/util/status.h"
namespace boost {
@@ -69,7 +70,9 @@ struct ProbeStats;
//
// All of these files have the same number of rows, and thus the positional
// indexes can be used to seek to corresponding entries in each.
-class CFileSet : public std::enable_shared_from_this<CFileSet> {
+class CFileSet :
+ public std::enable_shared_from_this<CFileSet>,
+ public enable_make_shared<CFileSet> {
public:
class Iterator;
@@ -128,15 +131,16 @@ class CFileSet : public
std::enable_shared_from_this<CFileSet> {
virtual ~CFileSet();
+ protected:
+ CFileSet(std::shared_ptr<RowSetMetadata> rowset_metadata,
+ std::shared_ptr<MemTracker> bloomfile_tracker,
+ std::shared_ptr<MemTracker> cfile_reader_tracker);
+
private:
friend class Iterator;
DISALLOW_COPY_AND_ASSIGN(CFileSet);
- CFileSet(std::shared_ptr<RowSetMetadata> rowset_metadata,
- std::shared_ptr<MemTracker> bloomfile_tracker,
- std::shared_ptr<MemTracker> cfile_reader_tracker);
-
Status DoOpen(const fs::IOContext* io_context);
Status OpenBloomReader(const fs::IOContext* io_context);
Status LoadMinMaxKeys(const fs::IOContext* io_context);
diff --git a/src/kudu/tablet/deltamemstore.cc b/src/kudu/tablet/deltamemstore.cc
index 0309ca6..3575a3c 100644
--- a/src/kudu/tablet/deltamemstore.cc
+++ b/src/kudu/tablet/deltamemstore.cc
@@ -60,11 +60,9 @@ Status DeltaMemStore::Create(int64_t id,
LogAnchorRegistry* log_anchor_registry,
shared_ptr<MemTracker> parent_tracker,
shared_ptr<DeltaMemStore>* dms) {
- shared_ptr<DeltaMemStore> local_dms(new DeltaMemStore(id, rs_id,
- log_anchor_registry,
-
std::move(parent_tracker)));
-
- dms->swap(local_dms);
+ auto local_dms(DeltaMemStore::make_shared(
+ id, rs_id, log_anchor_registry, std::move(parent_tracker)));
+ *dms = std::move(local_dms);
return Status::OK();
}
diff --git a/src/kudu/tablet/deltamemstore.h b/src/kudu/tablet/deltamemstore.h
index 49dfaa1..a7822a5 100644
--- a/src/kudu/tablet/deltamemstore.h
+++ b/src/kudu/tablet/deltamemstore.h
@@ -36,6 +36,7 @@
#include "kudu/tablet/delta_store.h"
#include "kudu/util/atomic.h"
#include "kudu/util/locks.h"
+#include "kudu/util/make_shared.h"
#include "kudu/util/memory/arena.h"
#include "kudu/util/status.h"
@@ -72,7 +73,8 @@ struct DMSTreeTraits : public btree::BTreeTraits {
// modified columns.
class DeltaMemStore : public DeltaStore,
- public std::enable_shared_from_this<DeltaMemStore> {
+ public std::enable_shared_from_this<DeltaMemStore>,
+ public enable_make_shared<DeltaMemStore> {
public:
static Status Create(int64_t id, int64_t rs_id,
log::LogAnchorRegistry* log_anchor_registry,
@@ -158,14 +160,15 @@ class DeltaMemStore : public DeltaStore,
boost::none : boost::make_optional(highest_timestamp_);
}
- private:
- friend class DMSIterator;
-
+ protected:
DeltaMemStore(int64_t id,
int64_t rs_id,
log::LogAnchorRegistry* log_anchor_registry,
std::shared_ptr<MemTracker> parent_tracker);
+ private:
+ friend class DMSIterator;
+
const DMSTree& tree() const {
return tree_;
}
diff --git a/src/kudu/tablet/diskrowset.cc b/src/kudu/tablet/diskrowset.cc
index c0068b4..a761c48 100644
--- a/src/kudu/tablet/diskrowset.cc
+++ b/src/kudu/tablet/diskrowset.cc
@@ -507,13 +507,10 @@ Status DiskRowSet::Open(const shared_ptr<RowSetMetadata>&
rowset_metadata,
const TabletMemTrackers& mem_trackers,
const IOContext* io_context,
shared_ptr<DiskRowSet> *rowset) {
- shared_ptr<DiskRowSet> rs(new DiskRowSet(rowset_metadata,
- log_anchor_registry,
- mem_trackers));
-
+ auto rs(DiskRowSet::make_shared(
+ rowset_metadata, log_anchor_registry, mem_trackers));
RETURN_NOT_OK(rs->Open(io_context));
-
- rowset->swap(rs);
+ *rowset = std::move(rs);
return Status::OK();
}
diff --git a/src/kudu/tablet/diskrowset.h b/src/kudu/tablet/diskrowset.h
index 5e27adf..709bee2 100644
--- a/src/kudu/tablet/diskrowset.h
+++ b/src/kudu/tablet/diskrowset.h
@@ -46,6 +46,7 @@
#include "kudu/util/bloom_filter.h"
#include "kudu/util/faststring.h"
#include "kudu/util/locks.h"
+#include "kudu/util/make_shared.h"
#include "kudu/util/status.h"
namespace kudu {
@@ -306,7 +307,9 @@ struct DiskRowSetSpace {
class MajorDeltaCompaction;
-class DiskRowSet : public RowSet {
+class DiskRowSet :
+ public RowSet,
+ public enable_make_shared<DiskRowSet> {
public:
static const char *kMinKeyMetaEntryName;
static const char *kMaxKeyMetaEntryName;
@@ -446,6 +449,11 @@ class DiskRowSet : public RowSet {
virtual Status DebugDump(std::vector<std::string> *lines) override;
+ protected:
+ DiskRowSet(std::shared_ptr<RowSetMetadata> rowset_metadata,
+ log::LogAnchorRegistry* log_anchor_registry,
+ TabletMemTrackers mem_trackers);
+
private:
FRIEND_TEST(TabletHistoryGcTest, TestMajorDeltaCompactionOnSubsetOfColumns);
FRIEND_TEST(TestCompaction, TestOneToOne);
@@ -455,10 +463,6 @@ class DiskRowSet : public RowSet {
friend class CompactionInput;
friend class Tablet;
- DiskRowSet(std::shared_ptr<RowSetMetadata> rowset_metadata,
- log::LogAnchorRegistry* log_anchor_registry,
- TabletMemTrackers mem_trackers);
-
Status Open(const fs::IOContext* io_context);
// Create a new major delta compaction object to compact the specified
columns.
diff --git a/src/kudu/tablet/memrowset.cc b/src/kudu/tablet/memrowset.cc
index 8a1db29..d4a4a05 100644
--- a/src/kudu/tablet/memrowset.cc
+++ b/src/kudu/tablet/memrowset.cc
@@ -94,10 +94,9 @@ Status MemRowSet::Create(int64_t id,
LogAnchorRegistry* log_anchor_registry,
shared_ptr<MemTracker> parent_tracker,
shared_ptr<MemRowSet>* mrs) {
- shared_ptr<MemRowSet> local_mrs(new MemRowSet(
+ auto local_mrs(MemRowSet::make_shared(
id, schema, log_anchor_registry, std::move(parent_tracker)));
-
- mrs->swap(local_mrs);
+ *mrs = std::move(local_mrs);
return Status::OK();
}
diff --git a/src/kudu/tablet/memrowset.h b/src/kudu/tablet/memrowset.h
index 75a549c..5b67666 100644
--- a/src/kudu/tablet/memrowset.h
+++ b/src/kudu/tablet/memrowset.h
@@ -42,6 +42,7 @@
#include "kudu/tablet/rowset_metadata.h"
#include "kudu/util/atomic.h"
#include "kudu/util/faststring.h"
+#include "kudu/util/make_shared.h"
#include "kudu/util/memory/arena.h"
#include "kudu/util/monotime.h"
#include "kudu/util/slice.h"
@@ -203,7 +204,8 @@ struct MSBTreeTraits : public btree::BTreeTraits {
//
// The data is kept sorted.
class MemRowSet : public RowSet,
- public std::enable_shared_from_this<MemRowSet> {
+ public std::enable_shared_from_this<MemRowSet>,
+ public enable_make_shared<MemRowSet> {
public:
class Iterator;
@@ -423,14 +425,15 @@ class MemRowSet : public RowSet,
Status MinorCompactDeltaStores(
const fs::IOContext* /*io_context*/) override { return Status::OK(); }
- private:
- friend class Iterator;
-
+ protected:
MemRowSet(int64_t id,
const Schema &schema,
log::LogAnchorRegistry* log_anchor_registry,
std::shared_ptr<MemTracker> parent_tracker);
+ private:
+ friend class Iterator;
+
// Perform a "Reinsert" -- handle an insertion into a row which was
previously
// inserted and deleted, but still has an entry in the MemRowSet.
Status Reinsert(Timestamp timestamp,
diff --git a/src/kudu/tablet/rowset_tree-test.cc
b/src/kudu/tablet/rowset_tree-test.cc
index 62e7281..8c861268 100644
--- a/src/kudu/tablet/rowset_tree-test.cc
+++ b/src/kudu/tablet/rowset_tree-test.cc
@@ -42,6 +42,7 @@
#include "kudu/util/test_macros.h"
#include "kudu/util/test_util.h"
+using std::make_shared;
using std::shared_ptr;
using std::string;
using std::unordered_set;
@@ -62,8 +63,8 @@ static RowSetVector GenerateRandomRowSets(int num_sets) {
int min = rand() % 9000;
int max = min + 1000;
- vec.push_back(shared_ptr<RowSet>(new MockDiskRowSet(StringPrintf("%04d",
min),
- StringPrintf("%04d",
max))));
+ vec.push_back(make_shared<MockDiskRowSet>(
+ StringPrintf("%04d", min), StringPrintf("%04d", max)));
}
return vec;
}
@@ -72,10 +73,10 @@ static RowSetVector GenerateRandomRowSets(int num_sets) {
TEST_F(TestRowSetTree, TestTree) {
RowSetVector vec;
- vec.push_back(shared_ptr<RowSet>(new MockDiskRowSet("0", "5")));
- vec.push_back(shared_ptr<RowSet>(new MockDiskRowSet("3", "5")));
- vec.push_back(shared_ptr<RowSet>(new MockDiskRowSet("5", "9")));
- vec.push_back(shared_ptr<RowSet>(new MockMemRowSet()));
+ vec.push_back(make_shared<MockDiskRowSet>("0", "5"));
+ vec.push_back(make_shared<MockDiskRowSet>("3", "5"));
+ vec.push_back(make_shared<MockDiskRowSet>("5", "9"));
+ vec.push_back(make_shared<MockMemRowSet>());
RowSetTree tree;
ASSERT_OK(tree.Reset(vec));
@@ -360,11 +361,11 @@ TEST_F(TestRowSetTree, TestEndpointsConsistency) {
RowSetVector vec = GenerateRandomRowSets(kNumRowSets);
// Add pathological one-key rows
for (int i = 0; i < 10; ++i) {
- vec.push_back(shared_ptr<RowSet>(new MockDiskRowSet(StringPrintf("%04d",
11000),
- StringPrintf("%04d",
11000))));
+ vec.push_back(make_shared<MockDiskRowSet>(
+ StringPrintf("%04d", 11000), StringPrintf("%04d", 11000)));
}
- vec.push_back(shared_ptr<RowSet>(new MockDiskRowSet(StringPrintf("%04d",
12000),
- StringPrintf("%04d",
12000))));
+ vec.push_back(make_shared<MockDiskRowSet>(
+ StringPrintf("%04d", 12000), StringPrintf("%04d", 12000)));
// Make tree
RowSetTree tree;
ASSERT_OK(tree.Reset(vec));
diff --git a/src/kudu/tablet/tablet-test.cc b/src/kudu/tablet/tablet-test.cc
index ce4778e..52569bd 100644
--- a/src/kudu/tablet/tablet-test.cc
+++ b/src/kudu/tablet/tablet-test.cc
@@ -77,6 +77,9 @@ DEFINE_int32(testiterator_num_inserts, 1000,
DEFINE_int32(testcompaction_num_rows, 1000,
"Number of rows per rowset in TestCompaction");
+using kudu::cfile::ReaderOptions;
+using kudu::fs::ReadableBlock;
+using std::make_shared;
using std::shared_ptr;
using std::string;
using std::unique_ptr;
@@ -85,9 +88,6 @@ using std::vector;
namespace kudu {
namespace tablet {
-using cfile::ReaderOptions;
-using fs::ReadableBlock;
-
template<class SETUP>
class TestTablet : public TabletTestBase<SETUP> {
typedef SETUP Type;
@@ -586,9 +586,9 @@ TYPED_TEST(TestTablet, TestRowIteratorOrdered) {
ASSERT_EQ(rowsPerBlock, block.nrows()) << "unexpected number of rows
returned";
for (int j = 0; j < rowsPerBlock; j++) {
RowBlockRow row = block.row(j);
- shared_ptr<faststring> encoded(new faststring());
+ auto encoded(make_shared<faststring>());
this->client_schema_.EncodeComparableKey(row, encoded.get());
- rows.push_back(encoded);
+ rows.push_back(std::move(encoded));
}
}
// Verify the collected rows, checking that they are sorted.
@@ -955,7 +955,7 @@ TYPED_TEST(TestTablet, TestCountLiveRowsAfterShutdown) {
NO_FATALS(this->CheckLiveRowsCount(max_rows));
// Save the tablet's reference.
- std::shared_ptr<Tablet> tablet = this->tablet();
+ shared_ptr<Tablet> tablet = this->tablet();
// Shutdown the tablet.
NO_FATALS(this->tablet()->Shutdown());
@@ -1065,7 +1065,7 @@ TYPED_TEST(TestTablet, TestFlushWithConcurrentMutation) {
// Inject hooks which mutate those rows and add more rows at
// each key stage of flushing.
- shared_ptr<MyFlushHooks<TestFixture> > hooks(new
MyFlushHooks<TestFixture>(this, false));
+ auto hooks(make_shared<MyFlushHooks<TestFixture>>(this, false));
this->tablet()->SetFlushHooksForTests(hooks);
this->tablet()->SetFlushCompactCommonHooksForTests(hooks);
@@ -1135,7 +1135,7 @@ TYPED_TEST(TestTablet,
TestCompactionWithConcurrentMutation) {
// Rows 20-26 inclusive will be inserted during the flush.
- shared_ptr<MyCompactHooks<TestFixture> > hooks(new
MyCompactHooks<TestFixture>(this, true));
+ auto hooks(make_shared<MyCompactHooks<TestFixture>>(this, true));
this->tablet()->SetCompactionHooksForTests(hooks);
this->tablet()->SetFlushCompactCommonHooksForTests(hooks);
@@ -1262,58 +1262,58 @@ TEST_F(TestTabletStringKey, TestSplitKeyRange) {
RowSetVector old_rowset = comps->rowsets->all_rowsets();
RowSetVector new_rowset = {
- std::make_shared<MockDiskRowSet>("0", "9", 9000, 90),
- std::make_shared<MockDiskRowSet>("2", "5", 3000, 30),
- std::make_shared<MockDiskRowSet>("5", "6", 1000, 10)
+ make_shared<MockDiskRowSet>("0", "9", 9000, 90),
+ make_shared<MockDiskRowSet>("2", "5", 3000, 30),
+ make_shared<MockDiskRowSet>("5", "6", 1000, 10)
};
tablet->AtomicSwapRowSets(old_rowset, new_rowset);
{
- std::vector<KeyRange> result = {
- KeyRange("", "2", 2000),
- KeyRange("2", "5", 6000),
- KeyRange("5", "6", 2000),
- KeyRange("6", "", 3000)
+ vector<KeyRange> result = {
+ KeyRange("", "2", 2000),
+ KeyRange("2", "5", 6000),
+ KeyRange("5", "6", 2000),
+ KeyRange("6", "", 3000)
};
- std::vector<ColumnId> col_ids;
- std::vector<KeyRange> range;
+ vector<ColumnId> col_ids;
+ vector<KeyRange> range;
tablet->SplitKeyRange(nullptr, nullptr, col_ids, 3000, &range);
AssertChunks(result, range);
}
// target chunk size less than the min interval size
{
- std::vector<KeyRange> result = {
- KeyRange("", "2", 2000),
- KeyRange("2", "5", 6000),
- KeyRange("5", "6", 2000),
- KeyRange("6", "", 3000)
+ vector<KeyRange> result = {
+ KeyRange("", "2", 2000),
+ KeyRange("2", "5", 6000),
+ KeyRange("5", "6", 2000),
+ KeyRange("6", "", 3000)
};
- std::vector<ColumnId> col_ids;
- std::vector<KeyRange> range;
+ vector<ColumnId> col_ids;
+ vector<KeyRange> range;
tablet->SplitKeyRange(nullptr, nullptr, col_ids, 900, &range);
AssertChunks(result, range);
}
// target chunk size greater than the max interval size
{
- std::vector<KeyRange> result = {
- KeyRange("", "", 13000)
+ vector<KeyRange> result = {
+ KeyRange("", "", 13000)
};
- std::vector<ColumnId> col_ids;
- std::vector<KeyRange> range;
+ vector<ColumnId> col_ids;
+ vector<KeyRange> range;
tablet->SplitKeyRange(nullptr, nullptr, col_ids, 20000, &range);
AssertChunks(result, range);
}
// test split key range with column
{
- std::vector<KeyRange> result = {
- KeyRange("", "2", 40),
- KeyRange("2", "5", 120),
- KeyRange("5", "6", 40),
- KeyRange("6", "", 60)
+ vector<KeyRange> result = {
+ KeyRange("", "2", 40),
+ KeyRange("2", "5", 120),
+ KeyRange("5", "6", 40),
+ KeyRange("6", "", 60)
};
- std::vector<ColumnId> col_ids;
+ vector<ColumnId> col_ids;
col_ids.emplace_back(0);
col_ids.emplace_back(1);
- std::vector<KeyRange> range;
+ vector<KeyRange> range;
tablet->SplitKeyRange(nullptr, nullptr, col_ids, 60, &range);
AssertChunks(result, range);
}
@@ -1339,35 +1339,35 @@ TEST_F(TestTabletStringKey, TestSplitKeyRange) {
ASSERT_OK(EncodedKey::DecodeEncodedString(this->schema_, &arena,
u_encoded, &u_enc_key));
// split key range in [1, 4)
{
- std::vector<KeyRange> result = {
- KeyRange("1", "2", 1000),
- KeyRange("2", "4", 4000)
+ vector<KeyRange> result = {
+ KeyRange("1", "2", 1000),
+ KeyRange("2", "4", 4000)
};
- std::vector<ColumnId> col_ids;
- std::vector<KeyRange> range;
+ vector<ColumnId> col_ids;
+ vector<KeyRange> range;
tablet->SplitKeyRange(l_enc_key.get(), u_enc_key.get(), col_ids, 2000,
&range);
AssertChunks(result, range);
}
// split key range in [min, 4)
{
- std::vector<KeyRange> result = {
- KeyRange("", "2", 2000),
- KeyRange("2", "4", 4000)
+ vector<KeyRange> result = {
+ KeyRange("", "2", 2000),
+ KeyRange("2", "4", 4000)
};
- std::vector<ColumnId> col_ids;
- std::vector<KeyRange> range;
+ vector<ColumnId> col_ids;
+ vector<KeyRange> range;
tablet->SplitKeyRange(nullptr, u_enc_key.get(), col_ids, 2000, &range);
AssertChunks(result, range);
}
// split key range in [4, max)
{
- std::vector<KeyRange> result = {
- KeyRange("4", "5", 2000),
- KeyRange("5", "6", 2000),
- KeyRange("6", "", 3000)
+ vector<KeyRange> result = {
+ KeyRange("4", "5", 2000),
+ KeyRange("5", "6", 2000),
+ KeyRange("6", "", 3000)
};
- std::vector<ColumnId> col_ids;
- std::vector<KeyRange> range;
+ vector<ColumnId> col_ids;
+ vector<KeyRange> range;
tablet->SplitKeyRange(u_enc_key.get(), nullptr, col_ids, 2000, &range);
AssertChunks(result, range);
}
@@ -1385,11 +1385,11 @@ TEST_F(TestTabletStringKey,
TestSplitKeyRangeWithZeroRowSets) {
RowSetVector new_rowset = {};
tablet->AtomicSwapRowSets(old_rowset, new_rowset);
{
- std::vector<KeyRange> result = {
- KeyRange("", "", 0)
+ vector<KeyRange> result = {
+ KeyRange("", "", 0)
};
- std::vector<ColumnId> col_ids;
- std::vector<KeyRange> range;
+ vector<ColumnId> col_ids;
+ vector<KeyRange> range;
tablet->SplitKeyRange(nullptr, nullptr, col_ids, 3000, &range);
AssertChunks(result, range);
}
@@ -1404,15 +1404,15 @@ TEST_F(TestTabletStringKey,
TestSplitKeyRangeWithOneRowSet) {
RowSetVector old_rowset = comps->rowsets->all_rowsets();
RowSetVector new_rowset = {
- std::make_shared<MockDiskRowSet>("0", "9", 9000, 90)
+ make_shared<MockDiskRowSet>("0", "9", 9000, 90)
};
tablet->AtomicSwapRowSets(old_rowset, new_rowset);
{
- std::vector<KeyRange> result = {
- KeyRange("", "", 9000)
+ vector<KeyRange> result = {
+ KeyRange("", "", 9000)
};
- std::vector<ColumnId> col_ids;
- std::vector<KeyRange> range;
+ vector<ColumnId> col_ids;
+ vector<KeyRange> range;
tablet->SplitKeyRange(nullptr, nullptr, col_ids, 3000, &range);
AssertChunks(result, range);
}
@@ -1427,20 +1427,20 @@ TEST_F(TestTabletStringKey,
TestSplitKeyRangeWithNonOverlappingRowSets) {
tablet->GetComponents(&comps);
RowSetVector old_rowset = comps->rowsets->all_rowsets();
RowSetVector without_gaps_rowset = {
- std::make_shared<MockDiskRowSet>("0", "2", 2000, 20),
- std::make_shared<MockDiskRowSet>("2", "5", 3000, 30),
- std::make_shared<MockDiskRowSet>("5", "6", 1000, 10),
- std::make_shared<MockDiskRowSet>("6", "9", 3000, 30)
+ make_shared<MockDiskRowSet>("0", "2", 2000, 20),
+ make_shared<MockDiskRowSet>("2", "5", 3000, 30),
+ make_shared<MockDiskRowSet>("5", "6", 1000, 10),
+ make_shared<MockDiskRowSet>("6", "9", 3000, 30)
};
tablet->AtomicSwapRowSets(old_rowset, without_gaps_rowset);
{
- std::vector<KeyRange> result = {
- KeyRange("", "2", 2000),
- KeyRange("2", "5", 3000),
- KeyRange("5", "", 4000)
+ vector<KeyRange> result = {
+ KeyRange("", "2", 2000),
+ KeyRange("2", "5", 3000),
+ KeyRange("5", "", 4000)
};
- std::vector<ColumnId> col_ids;
- std::vector<KeyRange> range;
+ vector<ColumnId> col_ids;
+ vector<KeyRange> range;
tablet->SplitKeyRange(nullptr, nullptr, col_ids, 3000, &range);
AssertChunks(result, range);
}
@@ -1449,18 +1449,18 @@ TEST_F(TestTabletStringKey,
TestSplitKeyRangeWithNonOverlappingRowSets) {
tablet->GetComponents(&comps);
old_rowset = comps->rowsets->all_rowsets();
RowSetVector with_gaps_rowset = {
- std::make_shared<MockDiskRowSet>("0", "2", 2000, 20),
- std::make_shared<MockDiskRowSet>("5", "6", 1000, 10),
- std::make_shared<MockDiskRowSet>("6", "9", 3000, 30)
+ make_shared<MockDiskRowSet>("0", "2", 2000, 20),
+ make_shared<MockDiskRowSet>("5", "6", 1000, 10),
+ make_shared<MockDiskRowSet>("6", "9", 3000, 30)
};
tablet->AtomicSwapRowSets(old_rowset, with_gaps_rowset);
{
- std::vector<KeyRange> result = {
- KeyRange("", "6", 3000),
- KeyRange("6", "", 3000)
+ vector<KeyRange> result = {
+ KeyRange("", "6", 3000),
+ KeyRange("6", "", 3000)
};
- std::vector<ColumnId> col_ids;
- std::vector<KeyRange> range;
+ vector<ColumnId> col_ids;
+ vector<KeyRange> range;
tablet->SplitKeyRange(nullptr, nullptr, col_ids, 3000, &range);
AssertChunks(result, range);
}
@@ -1475,20 +1475,20 @@ TEST_F(TestTabletStringKey,
TestSplitKeyRangeWithMinimumValueRowSet) {
tablet->GetComponents(&comps);
RowSetVector old_rowset = comps->rowsets->all_rowsets();
RowSetVector without_gaps_rowset = {
- std::make_shared<MockDiskRowSet>("", "2", 2500, 20),
- std::make_shared<MockDiskRowSet>("2", "5", 3000, 30),
- std::make_shared<MockDiskRowSet>("5", "6", 1000, 10),
- std::make_shared<MockDiskRowSet>("6", "9", 3000, 30)
+ make_shared<MockDiskRowSet>("", "2", 2500, 20),
+ make_shared<MockDiskRowSet>("2", "5", 3000, 30),
+ make_shared<MockDiskRowSet>("5", "6", 1000, 10),
+ make_shared<MockDiskRowSet>("6", "9", 3000, 30)
};
tablet->AtomicSwapRowSets(old_rowset, without_gaps_rowset);
{
- std::vector<KeyRange> result = {
- KeyRange("", "2", 2500),
- KeyRange("2", "5", 3000),
- KeyRange("5", "", 4000)
+ vector<KeyRange> result = {
+ KeyRange("", "2", 2500),
+ KeyRange("2", "5", 3000),
+ KeyRange("5", "", 4000)
};
- std::vector<ColumnId> col_ids;
- std::vector<KeyRange> range;
+ vector<ColumnId> col_ids;
+ vector<KeyRange> range;
tablet->SplitKeyRange(nullptr, nullptr, col_ids, 3000, &range);
AssertChunks(result, range);
}
diff --git a/src/kudu/tablet/tablet.cc b/src/kudu/tablet/tablet.cc
index cd57dcc..8aedf8a 100644
--- a/src/kudu/tablet/tablet.cc
+++ b/src/kudu/tablet/tablet.cc
@@ -180,6 +180,7 @@ using kudu::clock::HybridClock;
using kudu::fs::IOContext;
using kudu::log::LogAnchorRegistry;
using std::endl;
+using std::make_shared;
using std::ostream;
using std::pair;
using std::shared_ptr;
@@ -305,18 +306,19 @@ Status Tablet::Open() {
rowsets_opened.push_back(rowset);
}
- shared_ptr<RowSetTree> new_rowset_tree(new RowSetTree());
- CHECK_OK(new_rowset_tree->Reset(rowsets_opened));
-
- // Now that the current state is loaded, create the new MemRowSet with the
next id.
- shared_ptr<MemRowSet> new_mrs;
- RETURN_NOT_OK(MemRowSet::Create(next_mrs_id_++, *schema(),
- log_anchor_registry_.get(),
- mem_trackers_.tablet_tracker,
- &new_mrs));
{
+ auto new_rowset_tree(make_shared<RowSetTree>());
+ CHECK_OK(new_rowset_tree->Reset(rowsets_opened));
+
+ // Now that the current state is loaded, create the new MemRowSet with the
next id.
+ shared_ptr<MemRowSet> new_mrs;
+ RETURN_NOT_OK(MemRowSet::Create(next_mrs_id_++, *schema(),
+ log_anchor_registry_.get(),
+ mem_trackers_.tablet_tracker,
+ &new_mrs));
std::lock_guard<rw_spinlock> lock(component_lock_);
- components_ = new TabletComponents(new_mrs, new_rowset_tree);
+ components_.reset(new TabletComponents(
+ std::move(new_mrs), std::move(new_rowset_tree)));
}
// Compute the initial average rowset height.
@@ -1071,11 +1073,10 @@ void Tablet::AtomicSwapRowSetsUnlocked(const
RowSetVector &to_remove,
const RowSetVector &to_add) {
DCHECK(component_lock_.is_locked());
- shared_ptr<RowSetTree> new_tree(new RowSetTree());
- ModifyRowSetTree(*components_->rowsets,
- to_remove, to_add, new_tree.get());
+ auto new_tree(make_shared<RowSetTree>());
+ ModifyRowSetTree(*components_->rowsets, to_remove, to_add, new_tree.get());
- components_ = new TabletComponents(components_->memrowset, new_tree);
+ components_ = new TabletComponents(components_->memrowset,
std::move(new_tree));
}
Status Tablet::DoMajorDeltaCompaction(const vector<ColumnId>& col_ids,
@@ -1165,14 +1166,13 @@ Status
Tablet::ReplaceMemRowSetUnlocked(RowSetsInCompaction *compaction,
log_anchor_registry_.get(),
mem_trackers_.tablet_tracker,
&new_mrs));
- shared_ptr<RowSetTree> new_rst(new RowSetTree());
+ auto new_rst(make_shared<RowSetTree>());
ModifyRowSetTree(*components_->rowsets,
RowSetVector(), // remove nothing
{ *old_ms }, // add the old MRS
new_rst.get());
-
// Swap it in
- components_ = new TabletComponents(new_mrs, new_rst);
+ components_.reset(new TabletComponents(std::move(new_mrs),
std::move(new_rst)));
return Status::OK();
}
diff --git a/src/kudu/tools/ksck-test.cc b/src/kudu/tools/ksck-test.cc
index 5e9ffd0..643d401 100644
--- a/src/kudu/tools/ksck-test.cc
+++ b/src/kudu/tools/ksck-test.cc
@@ -75,6 +75,7 @@ using kudu::cluster_summary::TabletSummary;
using kudu::server::GetFlagsResponsePB;
using kudu::tablet::TabletDataState;
+using std::make_shared;
using std::ostringstream;
using std::shared_ptr;
using std::static_pointer_cast;
@@ -279,7 +280,7 @@ class KsckTest : public KuduTest {
for (int i = 0; i < 3; i++) {
const string uuid = Substitute("master-id-$0", i);
const string addr = Substitute("master-$0", i);
- auto master = std::make_shared<MockKsckMaster>(addr, uuid,
IsGetFlagsAvailable());
+ auto master = make_shared<MockKsckMaster>(addr, uuid,
IsGetFlagsAvailable());
master->cstate_ = cstate;
cluster_->masters_.push_back(master);
}
@@ -287,7 +288,7 @@ class KsckTest : public KuduTest {
KsckCluster::TSMap tablet_servers;
for (int i = 0; i < 3; i++) {
string name = Substitute("ts-id-$0", i);
- auto ts = std::make_shared<MockKsckTabletServer>(name,
IsGetFlagsAvailable());
+ auto ts = make_shared<MockKsckTabletServer>(name, IsGetFlagsAvailable());
InsertOrDie(&tablet_servers, ts->uuid(), ts);
}
cluster_->tablet_servers_.swap(tablet_servers);
@@ -334,7 +335,7 @@ class KsckTest : public KuduTest {
CreateDefaultAssignmentPlan(1);
auto table = CreateAndAddTable("test", 1);
- shared_ptr<KsckTablet> tablet(new KsckTablet(table.get(), "tablet-id-1"));
+ auto tablet(make_shared<KsckTablet>(table.get(), "tablet-id-1"));
CreateAndFillTablet(tablet, 1, true, true);
table->set_tablets({ tablet });
}
@@ -348,10 +349,10 @@ class KsckTest : public KuduTest {
vector<shared_ptr<KsckTablet>> tablets;
for (int i = 0; i < num_tablets; i++) {
- shared_ptr<KsckTablet> tablet(new KsckTablet(
+ auto tablet(make_shared<KsckTablet>(
table.get(), Substitute("$0tablet-id-$1", tablet_id_prefix, i)));
CreateAndFillTablet(tablet, num_replicas, true, true);
- tablets.push_back(tablet);
+ tablets.push_back(std::move(tablet));
}
table->set_tablets(tablets);
}
@@ -364,10 +365,10 @@ class KsckTest : public KuduTest {
vector<shared_ptr<KsckTablet>> tablets;
for (int i = 0; i < num_tablets; i++) {
- shared_ptr<KsckTablet> tablet(new KsckTablet(
+ auto tablet(make_shared<KsckTablet>(
table.get(), Substitute("tablet-id-$0", i)));
CreateAndFillTablet(tablet, num_replicas, true, i != 0);
- tablets.push_back(tablet);
+ tablets.push_back(std::move(tablet));
}
table->set_tablets(tablets);
}
@@ -378,14 +379,14 @@ class KsckTest : public KuduTest {
auto table = CreateAndAddTable("test", 3);
- shared_ptr<KsckTablet> tablet(new KsckTablet(table.get(), "tablet-id-1"));
+ auto tablet(make_shared<KsckTablet>(table.get(), "tablet-id-1"));
CreateAndFillTablet(tablet, 2, false, true);
table->set_tablets({ tablet });
}
shared_ptr<KsckTable> CreateAndAddTable(const string& id_and_name, int
num_replicas) {
- shared_ptr<KsckTable> table(new KsckTable(id_and_name, id_and_name,
- Schema(), num_replicas));
+ auto table(make_shared<KsckTable>(
+ id_and_name, id_and_name, Schema(), num_replicas));
cluster_->tables_.push_back(table);
return table;
}
@@ -1831,7 +1832,7 @@ TEST_F(KsckTest, TestChecksumWithAllPeersUnhealthy) {
const char* const new_uuid = "new";
EmplaceOrDie(&cluster_->tablet_servers_,
new_uuid,
- std::make_shared<MockKsckTabletServer>(new_uuid,
IsGetFlagsAvailable()));
+ make_shared<MockKsckTabletServer>(new_uuid,
IsGetFlagsAvailable()));
// The checksum should fail for tablet because none of its replicas are
// available to provide a timestamp.
diff --git a/src/kudu/tools/ksck_remote.cc b/src/kudu/tools/ksck_remote.cc
index 7627aca..18fe7b2 100644
--- a/src/kudu/tools/ksck_remote.cc
+++ b/src/kudu/tools/ksck_remote.cc
@@ -95,6 +95,7 @@ using kudu::rpc::RpcController;
using kudu::server::GenericServiceProxy;
using kudu::server::GetFlagsRequestPB;
using kudu::server::GetFlagsResponsePB;
+using std::make_shared;
using std::shared_ptr;
using std::string;
using std::unique_ptr;
@@ -570,7 +571,7 @@ Status RemoteKsckCluster::RetrieveTabletServers() {
continue;
}
HostPort hp = HostPortFromPB(ts_pb.registration().rpc_addresses(0));
- auto ts = std::make_shared<RemoteKsckTabletServer>(uuid, hp, messenger_,
ts_pb.location());
+ auto ts = make_shared<RemoteKsckTabletServer>(uuid, hp, messenger_,
ts_pb.location());
RETURN_NOT_OK(ts->Init());
EmplaceOrUpdate(&tablet_servers, uuid, std::move(ts));
}
@@ -609,11 +610,9 @@ Status RemoteKsckCluster::RetrieveTablesList() {
table_name, s.ToString());
return;
}
- shared_ptr<KsckTable> table(new KsckTable(t->id(),
- table_name,
-
KuduSchema::ToSchema(t->schema()),
- t->num_replicas()));
{
+ auto table(make_shared<KsckTable>(
+ t->id(), table_name, KuduSchema::ToSchema(t->schema()),
t->num_replicas()));
std::lock_guard<simple_spinlock> l(tables_lock);
tables.emplace_back(std::move(table));
}
@@ -667,7 +666,7 @@ Status RemoteKsckCluster::RetrieveTabletsList(const
shared_ptr<KsckTable>& table
new KsckTablet(table.get(), t->tablet().id()));
vector<shared_ptr<KsckTabletReplica>> replicas;
for (const auto* r : t->tablet().replicas()) {
- replicas.push_back(std::make_shared<KsckTabletReplica>(
+ replicas.push_back(make_shared<KsckTabletReplica>(
r->ts().uuid(), r->is_leader(), ReplicaController::is_voter(*r)));
}
tablet->set_replicas(std::move(replicas));
diff --git a/src/kudu/tools/tool_action_cluster.cc
b/src/kudu/tools/tool_action_cluster.cc
index 5c45c70..66fd411 100644
--- a/src/kudu/tools/tool_action_cluster.cc
+++ b/src/kudu/tools/tool_action_cluster.cc
@@ -49,6 +49,7 @@
using kudu::rebalance::Rebalancer;
using std::cout;
using std::endl;
+using std::make_shared;
using std::make_tuple;
using std::shared_ptr;
using std::string;
@@ -185,7 +186,7 @@ Status RunKsck(const RunnerContext& context) {
"unable to build KsckCluster");
cluster->set_table_filters(Split(FLAGS_tables, ",", strings::SkipEmpty()));
cluster->set_tablet_id_filters(Split(FLAGS_tablets, ",",
strings::SkipEmpty()));
- shared_ptr<Ksck> ksck(new Ksck(cluster));
+ auto ksck(make_shared<Ksck>(cluster));
ksck->set_print_sections(Split(FLAGS_sections, ",", strings::SkipEmpty()));
@@ -230,7 +231,7 @@ Status EvaluateMoveSingleReplicasFlag(const vector<string>&
master_addresses,
shared_ptr<KsckCluster> cluster;
RETURN_NOT_OK_PREPEND(RemoteKsckCluster::Build(master_addresses, &cluster),
"unable to build KsckCluster");
- shared_ptr<Ksck> ksck(new Ksck(cluster));
+ auto ksck(make_shared<Ksck>(cluster));
// Ignoring the result of the Ksck::Run() method: it's possible the cluster
// is not completely healthy but rebalancing can proceed; for example,
diff --git a/src/kudu/tserver/tablet_server-test.cc
b/src/kudu/tserver/tablet_server-test.cc
index e20fda9..8f28627 100644
--- a/src/kudu/tserver/tablet_server-test.cc
+++ b/src/kudu/tserver/tablet_server-test.cc
@@ -137,6 +137,7 @@ using kudu::tablet::Tablet;
using kudu::tablet::TabletReplica;
using kudu::tablet::TabletStatePB;
using kudu::tablet::TabletSuperBlockPB;
+using std::make_shared;
using std::map;
using std::pair;
using std::set;
@@ -1567,7 +1568,7 @@ TEST_F(TabletServerTest,
TestRecoveryWithMutationsWhileFlushing) {
InsertTestRowsRemote(1, 7);
- shared_ptr<MyCommonHooks> hooks(new MyCommonHooks(this));
+ auto hooks(make_shared<MyCommonHooks>(this));
tablet_replica_->tablet()->SetFlushHooksForTests(hooks);
tablet_replica_->tablet()->SetCompactionHooksForTests(hooks);
@@ -1607,7 +1608,7 @@ TEST_F(TabletServerTest,
TestRecoveryWithMutationsWhileFlushingAndCompacting) {
InsertTestRowsRemote(1, 7);
- shared_ptr<MyCommonHooks> hooks(new MyCommonHooks(this));
+ auto hooks(make_shared<MyCommonHooks>(this));
tablet_replica_->tablet()->SetFlushHooksForTests(hooks);
tablet_replica_->tablet()->SetCompactionHooksForTests(hooks);
@@ -4012,7 +4013,7 @@ TEST_F(TabletServerTest, TestKudu120PreRequisites) {
// Add a hook so that we can make the log wait right after an append
// (before the callback is triggered).
log::Log* log = tablet_replica_->log();
- shared_ptr<DelayFsyncLogHook> log_hook(new DelayFsyncLogHook);
+ auto log_hook(make_shared<DelayFsyncLogHook>());
log->SetLogFaultHooksForTests(log_hook);
// Now start an op (delete) and stop just before commit.
diff --git a/src/kudu/tserver/tablet_server_authorization-test.cc
b/src/kudu/tserver/tablet_server_authorization-test.cc
index c4178c4..c61d978 100644
--- a/src/kudu/tserver/tablet_server_authorization-test.cc
+++ b/src/kudu/tserver/tablet_server_authorization-test.cc
@@ -74,8 +74,23 @@
#include "kudu/util/test_macros.h"
#include "kudu/util/test_util.h"
+using kudu::pb_util::SecureShortDebugString;
+using kudu::rpc::ErrorStatusPB;
+using kudu::rpc::RpcController;
+using kudu::security::ColumnPrivilegePB;
+using kudu::security::PrivateKey;
+using kudu::security::SignedTokenPB;
+using kudu::security::TablePrivilegePB;
+using kudu::security::TokenSigner;
+using kudu::security::TokenSigningPrivateKeyPB;
+using kudu::security::TokenSigningPublicKeyPB;
+using kudu::security::TokenVerifier;
+using kudu::tablet::TabletReplica;
+using kudu::tablet::WritePrivileges;
+using kudu::tablet::WritePrivilegeToString;
+using kudu::tablet::WritePrivilegeType;
+using std::make_shared;
using std::set;
-using std::shared_ptr;
using std::string;
using std::unique_ptr;
using std::unordered_map;
@@ -87,23 +102,6 @@ DECLARE_bool(tserver_enforce_access_control);
DECLARE_double(tserver_inject_invalid_authz_token_ratio);
namespace kudu {
-
-using pb_util::SecureShortDebugString;
-using rpc::ErrorStatusPB;
-using rpc::RpcController;
-using security::ColumnPrivilegePB;
-using security::PrivateKey;
-using security::SignedTokenPB;
-using security::TablePrivilegePB;
-using security::TokenSigner;
-using security::TokenSigningPrivateKeyPB;
-using security::TokenSigningPublicKeyPB;
-using security::TokenVerifier;
-using tablet::TabletReplica;
-using tablet::WritePrivileges;
-using tablet::WritePrivilegeToString;
-using tablet::WritePrivilegeType;
-
namespace tserver {
namespace {
@@ -211,7 +209,7 @@ class AuthzTabletServerTestBase : public
TabletServerTestBase {
proxy_->set_user_credentials(user);
TokenSigningPrivateKeyPB tsk = GetTokenSigningPrivateKey(1);
- shared_ptr<TokenVerifier> verifier(new TokenVerifier());
+ auto verifier(make_shared<TokenVerifier>());
// These tests aren't targeted at testing expiration, so pass in arbitrary
// expiration values.
signer_.reset(new TokenSigner(3600, 3600, 3600, verifier));
@@ -283,7 +281,7 @@ TEST_P(AuthzTabletServerTest, TestInvalidAuthzTokens) {
token_creators.emplace_back([&] {
LOG(INFO) << "Generating expired authz token";
TokenSigningPrivateKeyPB tsk = GetTokenSigningPrivateKey(2);
- shared_ptr<TokenVerifier> verifier(new TokenVerifier());
+ auto verifier(make_shared<TokenVerifier>());
TokenSigner expired_signer(3600, /*authz_token_validity_seconds=*/1, 3600,
verifier);
CHECK_OK(expired_signer.ImportKeys({ tsk }));
vector<TokenSigningPublicKeyPB> expired_public_keys =
verifier->ExportKeys();
diff --git a/src/kudu/util/make_shared.h b/src/kudu/util/make_shared.h
index 649cae7..a857274 100644
--- a/src/kudu/util/make_shared.h
+++ b/src/kudu/util/make_shared.h
@@ -20,7 +20,7 @@
#include <memory>
#include <utility>
-// It isn't possible to use 'std::make_shared' on a class with private or
protected
+// It isn't possible to use 'std::make_shared' on a class with protected
// constructors. Using friends as a workaround worked in some earlier
libc++/libstdcxx
// versions, but in the latest versions there are some static_asserts that
seem to defeat
// this trickery. So, instead, we rely on the "curiously recurring template
pattern" (CRTP)
diff --git a/src/kudu/util/test_graph.cc b/src/kudu/util/test_graph.cc
index 73b1642..44b28a1 100644
--- a/src/kudu/util/test_graph.cc
+++ b/src/kudu/util/test_graph.cc
@@ -56,16 +56,16 @@ TimeSeriesCollector::~TimeSeriesCollector() {
}
}
-shared_ptr<TimeSeries> TimeSeriesCollector::GetTimeSeries(const string &key) {
+shared_ptr<TimeSeries> TimeSeriesCollector::GetTimeSeries(const string& key) {
MutexLock l(series_lock_);
SeriesMap::const_iterator it = series_map_.find(key);
- if (it == series_map_.end()) {
- shared_ptr<TimeSeries> ts(new TimeSeries());
- series_map_[key] = ts;
- return ts;
- } else {
+ if (it != series_map_.end()) {
return (*it).second;
}
+
+ auto ts(std::make_shared<TimeSeries>());
+ series_map_[key] = ts;
+ return ts;
}
void TimeSeriesCollector::StartDumperThread() {
@@ -102,7 +102,7 @@ void TimeSeriesCollector::DumperThread() {
}
void TimeSeriesCollector::BuildMetricsString(
- WallTime time_since_start, faststring *dst_buf) const {
+ WallTime time_since_start, faststring* dst_buf) const {
MutexLock l(series_lock_);
dst_buf->append(StringPrintf("{ \"scope\": \"%s\", \"time\": %.3f",
@@ -115,5 +115,4 @@ void TimeSeriesCollector::BuildMetricsString(
dst_buf->append("}");
}
-
} // namespace kudu
diff --git a/src/kudu/util/test_graph.h b/src/kudu/util/test_graph.h
index 3f1c70a..c073629 100644
--- a/src/kudu/util/test_graph.h
+++ b/src/kudu/util/test_graph.h
@@ -34,20 +34,18 @@ class faststring; // NOLINT
class TimeSeries {
public:
+ TimeSeries() :
+ val_(0) {
+ }
+
void AddValue(double val);
void SetValue(double val);
double value() const;
private:
- friend class TimeSeriesCollector;
-
DISALLOW_COPY_AND_ASSIGN(TimeSeries);
- TimeSeries() :
- val_(0)
- {}
-
mutable simple_spinlock lock_;
double val_;
};
@@ -59,7 +57,7 @@ class TimeSeriesCollector {
~TimeSeriesCollector();
- std::shared_ptr<TimeSeries> GetTimeSeries(const std::string &key);
+ std::shared_ptr<TimeSeries> GetTimeSeries(const std::string& key);
void StartDumperThread();
void StopDumperThread();
@@ -67,11 +65,11 @@ class TimeSeriesCollector {
DISALLOW_COPY_AND_ASSIGN(TimeSeriesCollector);
void DumperThread();
- void BuildMetricsString(WallTime time_since_start, faststring *dst_buf)
const;
+ void BuildMetricsString(WallTime time_since_start, faststring* dst_buf)
const;
std::string scope_;
- typedef std::unordered_map<std::string, std::shared_ptr<TimeSeries> >
SeriesMap;
+ typedef std::unordered_map<std::string, std::shared_ptr<TimeSeries>>
SeriesMap;
SeriesMap series_map_;
mutable Mutex series_lock_;
diff --git a/src/kudu/util/threadpool-test.cc b/src/kudu/util/threadpool-test.cc
index b8faac4..93806f8 100644
--- a/src/kudu/util/threadpool-test.cc
+++ b/src/kudu/util/threadpool-test.cc
@@ -55,6 +55,7 @@
#include "kudu/util/trace.h"
using std::atomic;
+using std::make_shared;
using std::shared_ptr;
using std::string;
using std::thread;
@@ -494,7 +495,7 @@ TEST_F(ThreadPoolTest, TestSlowDestructor) {
// itself, so that the delay is incurred by that thread and not the task
// submission thread. Without C++14 capture-by-move semantics we have to
// work a little bit harder to accomplish that.
- shared_ptr<SlowDestructorRunnable> task(new SlowDestructorRunnable());
+ auto task = make_shared<SlowDestructorRunnable>();
auto wrapper = [task]() { task->Run(); };
task.reset();
ASSERT_OK(pool_->Submit(std::move(wrapper)));
@@ -552,7 +553,7 @@ TEST_P(ThreadPoolTestTokenTypes,
TestTokenSubmitsProcessedConcurrently) {
SCOPED_CLEANUP({
alarm(0); // Disable alarm on test exit.
});
- shared_ptr<Barrier> b = std::make_shared<Barrier>(kNumTokens + 1);
+ auto b = make_shared<Barrier>(kNumTokens + 1);
for (int i = 0; i < kNumTokens; i++) {
tokens.emplace_back(pool_->NewToken(GetParam()));
ASSERT_OK(tokens.back()->Submit([b]() {
@@ -575,7 +576,7 @@ TEST_F(ThreadPoolTest, TestTokenSubmitsNonSequential) {
SCOPED_CLEANUP({
alarm(0); // Disable alarm on test exit.
});
- shared_ptr<Barrier> b = std::make_shared<Barrier>(kNumSubmissions + 1);
+ auto b = make_shared<Barrier>(kNumSubmissions + 1);
unique_ptr<ThreadPoolToken> t =
pool_->NewToken(ThreadPool::ExecutionMode::CONCURRENT);
for (int i = 0; i < kNumSubmissions; i++) {
ASSERT_OK(t->Submit([b]() {
