diff --git a/be/src/olap/cumulative_compaction.cpp b/be/src/olap/cumulative_compaction.cpp index c6bf9f8a6457ca..dcbe3d2be56086 100755 --- a/be/src/olap/cumulative_compaction.cpp +++ b/be/src/olap/cumulative_compaction.cpp @@ -60,7 +60,7 @@ OLAPStatus CumulativeCompaction::compact() { _state = CompactionState::SUCCESS; // 5. set cumulative point - _tablet->cumulative_compaction_policy()->update_cumulative_point(_input_rowsets, _output_rowset, + _tablet->cumulative_compaction_policy()->update_cumulative_point(_tablet.get(), _input_rowsets, _output_rowset, _last_delete_version); LOG(INFO) << "after cumulative compaction, current cumulative point is " << _tablet->cumulative_layer_point() << ", tablet=" << _tablet->full_name(); @@ -87,7 +87,8 @@ OLAPStatus CumulativeCompaction::pick_rowsets_to_compact() { size_t compaction_score = 0; int transient_size = _tablet->cumulative_compaction_policy()->pick_input_rowsets( - candidate_rowsets, config::max_cumulative_compaction_num_singleton_deltas, + _tablet.get(), candidate_rowsets, + config::max_cumulative_compaction_num_singleton_deltas, config::min_cumulative_compaction_num_singleton_deltas, &_input_rowsets, &_last_delete_version, &compaction_score); diff --git a/be/src/olap/cumulative_compaction_policy.cpp b/be/src/olap/cumulative_compaction_policy.cpp index 33fef2334f3c29..2e28c58af57dec 100644 --- a/be/src/olap/cumulative_compaction_policy.cpp +++ b/be/src/olap/cumulative_compaction_policy.cpp @@ -25,9 +25,9 @@ namespace doris { SizeBasedCumulativeCompactionPolicy::SizeBasedCumulativeCompactionPolicy( - std::shared_ptr tablet, int64_t size_based_promotion_size, double size_based_promotion_ratio, + int64_t size_based_promotion_size, double size_based_promotion_ratio, int64_t size_based_promotion_min_size, int64_t size_based_compaction_lower_bound_size) - : CumulativeCompactionPolicy(tablet), + : CumulativeCompactionPolicy(), _size_based_promotion_size(size_based_promotion_size), _size_based_promotion_ratio(size_based_promotion_ratio), _size_based_promotion_min_size(size_based_promotion_min_size), @@ -42,7 +42,7 @@ SizeBasedCumulativeCompactionPolicy::SizeBasedCumulativeCompactionPolicy( } } -void SizeBasedCumulativeCompactionPolicy::calculate_cumulative_point( +void SizeBasedCumulativeCompactionPolicy::calculate_cumulative_point(Tablet* tablet, const std::vector& all_metas, int64_t current_cumulative_point, int64_t* ret_cumulative_point) { *ret_cumulative_point = Tablet::K_INVALID_CUMULATIVE_POINT; @@ -82,7 +82,7 @@ void SizeBasedCumulativeCompactionPolicy::calculate_cumulative_point( break; } - bool is_delete = _tablet->version_for_delete_predicate(rs->version()); + bool is_delete = tablet->version_for_delete_predicate(rs->version()); // break the loop if segments in this rowset is overlapping, or is a singleton. if (!is_delete && (rs->is_segments_overlapping() || rs->is_singleton_delta())) { @@ -101,7 +101,7 @@ void SizeBasedCumulativeCompactionPolicy::calculate_cumulative_point( } VLOG(3) << "cumulative compaction size_based policy, calculate cumulative point value = " << *ret_cumulative_point << ", calc promotion size value = " << promotion_size - << " tablet = " << _tablet->full_name(); + << " tablet = " << tablet->full_name(); } void SizeBasedCumulativeCompactionPolicy::_calc_promotion_size(RowsetMetaSharedPtr base_rowset_meta, @@ -123,19 +123,18 @@ void SizeBasedCumulativeCompactionPolicy::_refresh_tablet_size_based_promotion_s _tablet_size_based_promotion_size = promotion_size; } -void SizeBasedCumulativeCompactionPolicy::update_cumulative_point( +void SizeBasedCumulativeCompactionPolicy::update_cumulative_point(Tablet* tablet, const std::vector& input_rowsets, RowsetSharedPtr output_rowset, Version& last_delete_version) { - // if rowsets have delete version, move to the last directly if (last_delete_version.first != -1) { - _tablet->set_cumulative_layer_point(output_rowset->end_version() + 1); + tablet->set_cumulative_layer_point(output_rowset->end_version() + 1); } else { // if rowsets have not delete version, check output_rowset total disk size // satisfies promotion size. size_t total_size = output_rowset->rowset_meta()->total_disk_size(); if (total_size >= _tablet_size_based_promotion_size) { - _tablet->set_cumulative_layer_point(output_rowset->end_version() + 1); + tablet->set_cumulative_layer_point(output_rowset->end_version() + 1); } } } @@ -201,6 +200,7 @@ void SizeBasedCumulativeCompactionPolicy::calc_cumulative_compaction_score( } int SizeBasedCumulativeCompactionPolicy::pick_input_rowsets( + Tablet* tablet, const std::vector& candidate_rowsets, const int64_t max_compaction_score, const int64_t min_compaction_score, std::vector* input_rowsets, Version* last_delete_version, size_t* compaction_score) { @@ -211,7 +211,7 @@ int SizeBasedCumulativeCompactionPolicy::pick_input_rowsets( for (size_t i = 0; i < candidate_rowsets.size(); ++i) { RowsetSharedPtr rowset = candidate_rowsets[i]; // check whether this rowset is delete version - if (_tablet->version_for_delete_predicate(rowset->version())) { + if (tablet->version_for_delete_predicate(rowset->version())) { *last_delete_version = rowset->version(); if (!input_rowsets->empty()) { // we meet a delete version, and there were other versions before. @@ -273,7 +273,7 @@ int SizeBasedCumulativeCompactionPolicy::pick_input_rowsets( LOG(INFO) << "cumulative compaction size_based policy, compaction_score = " << *compaction_score << ", total_size = " << total_size << ", calc promotion size value = " << promotion_size - << ", tablet = " << _tablet->full_name() << ", input_rowset size " + << ", tablet = " << tablet->full_name() << ", input_rowset size " << input_rowsets->size(); // empty return @@ -309,15 +309,16 @@ int SizeBasedCumulativeCompactionPolicy::_level_size(const int64_t size) { return 0; } -void NumBasedCumulativeCompactionPolicy::update_cumulative_point( +void NumBasedCumulativeCompactionPolicy::update_cumulative_point(Tablet* tablet, const std::vector& input_rowsets, RowsetSharedPtr _output_rowset, Version& last_delete_version) { // use the version after end version of the last input rowsets to update cumulative point int64_t cumulative_point = input_rowsets.back()->end_version() + 1; - _tablet->set_cumulative_layer_point(cumulative_point); + tablet->set_cumulative_layer_point(cumulative_point); } int NumBasedCumulativeCompactionPolicy::pick_input_rowsets( + Tablet* tablet, const std::vector& candidate_rowsets, const int64_t max_compaction_score, const int64_t min_compaction_score, std::vector* input_rowsets, Version* last_delete_version, size_t* compaction_score) { @@ -326,7 +327,7 @@ int NumBasedCumulativeCompactionPolicy::pick_input_rowsets( for (size_t i = 0; i < candidate_rowsets.size(); ++i) { RowsetSharedPtr rowset = candidate_rowsets[i]; // check whether this rowset is delete version - if (_tablet->version_for_delete_predicate(rowset->version())) { + if (tablet->version_for_delete_predicate(rowset->version())) { *last_delete_version = rowset->version(); if (!input_rowsets->empty()) { // we meet a delete version, and there were other versions before. @@ -384,7 +385,8 @@ void NumBasedCumulativeCompactionPolicy::calc_cumulative_compaction_score(const } } -void NumBasedCumulativeCompactionPolicy::calculate_cumulative_point(const std::vector& all_metas, +void NumBasedCumulativeCompactionPolicy::calculate_cumulative_point(Tablet* tablet, + const std::vector& all_metas, int64_t current_cumulative_point, int64_t* ret_cumulative_point) { *ret_cumulative_point = Tablet::K_INVALID_CUMULATIVE_POINT; @@ -437,20 +439,19 @@ void CumulativeCompactionPolicy::pick_candicate_rowsets(int64_t skip_window_sec, } -std::unique_ptr CumulativeCompactionPolicyFactory::create_cumulative_compaction_policy(std::string type, - std::shared_ptr tablet) { +std::unique_ptr CumulativeCompactionPolicyFactory::create_cumulative_compaction_policy(std::string type) { CompactionPolicy policy_type; _parse_cumulative_compaction_policy(type, &policy_type); if (policy_type == NUM_BASED_POLICY) { - return std::unique_ptr(new NumBasedCumulativeCompactionPolicy(tablet)); + return std::unique_ptr(new NumBasedCumulativeCompactionPolicy()); } else if(policy_type == SIZE_BASED_POLICY) { - return std::unique_ptr(new SizeBasedCumulativeCompactionPolicy(tablet)); + return std::unique_ptr(new SizeBasedCumulativeCompactionPolicy()); } - return std::unique_ptr(new NumBasedCumulativeCompactionPolicy(tablet)); + return std::unique_ptr(new NumBasedCumulativeCompactionPolicy()); } void CumulativeCompactionPolicyFactory::_parse_cumulative_compaction_policy(std::string type, CompactionPolicy *policy_type) { @@ -462,7 +463,8 @@ void CumulativeCompactionPolicyFactory::_parse_cumulative_compaction_policy(std: else if (type == CUMULATIVE_SIZE_BASED_POLICY) { *policy_type = SIZE_BASED_POLICY; } else { - LOG(FATAL) << "parse cumulative compaction policy error " << type; + LOG(WARNING) << "parse cumulative compaction policy error " << type << ", default use " << CUMULATIVE_NUM_BASED_POLICY; + *policy_type = NUM_BASED_POLICY; } } } \ No newline at end of file diff --git a/be/src/olap/cumulative_compaction_policy.h b/be/src/olap/cumulative_compaction_policy.h index 6103cc9d06433c..51c41a20782798 100644 --- a/be/src/olap/cumulative_compaction_policy.h +++ b/be/src/olap/cumulative_compaction_policy.h @@ -53,7 +53,7 @@ class CumulativeCompactionPolicy { /// Constructor function of CumulativeCompactionPolicy, /// it needs tablet pointer to access tablet method. /// param tablet, the shared pointer of tablet - CumulativeCompactionPolicy(std::shared_ptr tablet) : _tablet(tablet){} + CumulativeCompactionPolicy() {} /// Destructor function of CumulativeCompactionPolicy. virtual ~CumulativeCompactionPolicy() {} @@ -74,30 +74,31 @@ class CumulativeCompactionPolicy { /// param skip_window_sec, it means skipping the rowsets which use create time plus skip_window_sec is greater than now. /// param rs_version_map, mapping from version to rowset /// param cumulative_point, current cumulative point of tablet - /// return candidate_rowsets, the container of candidate rowsets + /// return candidate_rowsets, the container of candidate rowsets virtual void pick_candicate_rowsets( int64_t skip_window_sec, const std::unordered_map& rs_version_map, int64_t cumulative_point, std::vector* candidate_rowsets); - + /// Pick input rowsets from candidate rowsets for compaction. This function is pure virtual function. /// Its implemention depands on concrete compaction policy. /// param candidate_rowsets, the candidate_rowsets vector container to pick input rowsets /// return input_rowsets, the vector container as return /// return last_delete_version, if has delete rowset, record the delete version from input_rowsets /// return compaction_score, calculate the compaction score of picked input rowset - virtual int pick_input_rowsets(const std::vector& candidate_rowsets, - const int64_t max_compaction_score, - const int64_t min_compaction_score, - std::vector* input_rowsets, - Version* last_delete_version, size_t* compaction_score) = 0; + virtual int pick_input_rowsets(Tablet* tablet, + const std::vector& candidate_rowsets, + const int64_t max_compaction_score, + const int64_t min_compaction_score, + std::vector* input_rowsets, + Version* last_delete_version, size_t* compaction_score) = 0; /// Update tablet's cumulative point after cumulative compaction finished. This function is pure virtual function. /// Each derived has its own update policy which deponds on its concrete algorithm. When the cumulative point moves /// after output rowset, then output rowset will do base compaction next time. /// param input_rowsets, the picked input rowset to do compaction just now /// param output_rowset, the result rowset after compaction - virtual void update_cumulative_point(const std::vector& input_rowsets, + virtual void update_cumulative_point(Tablet* tablet, const std::vector& input_rowsets, RowsetSharedPtr output_rowset, Version& last_delete_version) = 0; @@ -108,13 +109,11 @@ class CumulativeCompactionPolicy { /// param all_rowsets, all rowsets in the tablet /// param current_cumulative_point, current cumulative position /// return cumulative_point, the result of calculating cumulative point position - virtual void calculate_cumulative_point(const std::vector& all_rowsets, + virtual void calculate_cumulative_point(Tablet* tablet, + const std::vector& all_rowsets, int64_t current_cumulative_point, int64_t* cumulative_point) = 0; -protected: - /// tablet pointer - std::shared_ptr _tablet; }; /// Num based cumulative compcation policy implemention. Num based policy which derives CumulativeCompactionPolicy is early @@ -126,8 +125,8 @@ class NumBasedCumulativeCompactionPolicy final : public CumulativeCompactionPoli /// Constructor function of NumBasedCumulativeCompactionPolicy, /// it needs tablet pointer to access tablet method. /// param tablet, the shared pointer of tablet - NumBasedCumulativeCompactionPolicy(std::shared_ptr tablet) - : CumulativeCompactionPolicy(tablet){} + NumBasedCumulativeCompactionPolicy() + : CumulativeCompactionPolicy(){} /// Destructor function of NumBasedCumulativeCompactionPolicy. ~NumBasedCumulativeCompactionPolicy() {} @@ -135,23 +134,22 @@ class NumBasedCumulativeCompactionPolicy final : public CumulativeCompactionPoli /// Num based cumulative compaction policy implements pick input rowsets function. /// Its main policy is picking rowsets from candidate rowsets by comparing accumulative compaction_score and /// max_cumulative_compaction_num_singleton_deltas or checking whether there is delete version rowset. - int pick_input_rowsets(const std::vector& candidate_rowsets, - const int64_t max_compaction_score, - const int64_t min_compaction_score, - std::vector* input_rowsets, - Version* last_delete_version, size_t* compaction_score) override; + int pick_input_rowsets(Tablet* tablet, const std::vector& candidate_rowsets, + const int64_t max_compaction_score, const int64_t min_compaction_score, + std::vector* input_rowsets, + Version* last_delete_version, size_t* compaction_score) override; /// Num based cumulative compaction policy implements update cumulative point function. /// Its main policy is using the last input version to update the cumulative point. It aims that every rowsets only /// do compact once. - void update_cumulative_point(const std::vector& input_rowsets, + void update_cumulative_point(Tablet* tablet, const std::vector& input_rowsets, RowsetSharedPtr _output_rowset, Version& last_delete_version) override; /// Num based cumulative compaction policy implements calculate cumulative point function. /// When the first time the tablet does compact, this calculation is executed. Its main policy is to find first rowset /// which is segments_overlapping type, it represent this rowset is not compacted and use this version as cumulative point. - void calculate_cumulative_point(const std::vector& all_rowsets, + void calculate_cumulative_point(Tablet* tablet, const std::vector& all_rowsets, int64_t current_cumulative_point, int64_t* cumulative_point) override; @@ -175,7 +173,6 @@ class SizeBasedCumulativeCompactionPolicy final : public CumulativeCompactionPol /// it needs tablet pointer to access tablet method. /// param tablet, the shared pointer of tablet SizeBasedCumulativeCompactionPolicy( - std::shared_ptr tablet, int64_t size_based_promotion_size = config::cumulative_size_based_promotion_size_mbytes * 1024 * 1024, double size_based_promotion_ratio = @@ -191,7 +188,7 @@ class SizeBasedCumulativeCompactionPolicy final : public CumulativeCompactionPol /// SizeBased cumulative compaction policy implements calculate cumulative point function. /// When the first time the tablet does compact, this calculation is executed. Its main policy is to find first rowset /// which does not satifie the promotion conditions. - void calculate_cumulative_point(const std::vector& all_rowsets, + void calculate_cumulative_point(Tablet* tablet, const std::vector& all_rowsets, int64_t current_cumulative_point, int64_t* cumulative_point) override; @@ -199,16 +196,15 @@ class SizeBasedCumulativeCompactionPolicy final : public CumulativeCompactionPol /// Its main policy is picking rowsets from candidate rowsets by comparing accumulative compaction_score, /// max_cumulative_compaction_num_singleton_deltas or checking whether there is delete version rowset, /// and choose those rowset in the same level to do cumulative compaction. - int pick_input_rowsets(const std::vector& candidate_rowsets, - const int64_t max_compaction_score, - const int64_t min_compaction_score, - std::vector* input_rowsets, - Version* last_delete_version, size_t* compaction_score) override; + int pick_input_rowsets(Tablet* tablet, const std::vector& candidate_rowsets, + const int64_t max_compaction_score, const int64_t min_compaction_score, + std::vector* input_rowsets, + Version* last_delete_version, size_t* compaction_score) override; /// SizeBased cumulative compaction policy implements update cumulative point function. /// Its main policy is judging the output rowset size whether satifies the promotion size. /// If it satified, this policy will update the cumulative point. - void update_cumulative_point(const std::vector& input_rowsets, + void update_cumulative_point(Tablet* tablet, const std::vector& input_rowsets, RowsetSharedPtr _output_rowset, Version& last_delete_version); /// Num based cumulative compaction policy implements calc cumulative compaction score function. @@ -251,7 +247,7 @@ class CumulativeCompactionPolicyFactory { /// Static factory function. It can product diffrent policy according to the `policy` parameter and use tablet ptr /// to construct the policy. Now it can product size based and num based policies. static std::unique_ptr create_cumulative_compaction_policy( - std::string policy, std::shared_ptr tablet); + std::string policy); private: /// It is a static function to help to check the policy config and convert to CompactionPolicy enum variable diff --git a/be/src/olap/tablet.cpp b/be/src/olap/tablet.cpp index ca309a43375119..a382420f5ca079 100644 --- a/be/src/olap/tablet.cpp +++ b/be/src/olap/tablet.cpp @@ -72,11 +72,10 @@ OLAPStatus Tablet::_init_once_action() { VLOG(3) << "begin to load tablet. tablet=" << full_name() << ", version_size=" << _tablet_meta->version_count(); - std::shared_ptr this_ptr = std::dynamic_pointer_cast(shared_from_this()); // init cumulative compaction policy by type _cumulative_compaction_policy = CumulativeCompactionPolicyFactory::create_cumulative_compaction_policy( - _cumulative_compaction_type, this_ptr); + _cumulative_compaction_type); for (const auto& rs_meta : _tablet_meta->all_rs_metas()) { Version version = rs_meta->version(); @@ -784,7 +783,7 @@ void Tablet::calculate_cumulative_point() { WriteLock wrlock(&_meta_lock); int64_t ret_cumulative_point; - _cumulative_compaction_policy->calculate_cumulative_point( + _cumulative_compaction_policy->calculate_cumulative_point(this, _tablet_meta->all_rs_metas(), _cumulative_point, &ret_cumulative_point); if(ret_cumulative_point == K_INVALID_CUMULATIVE_POINT) { diff --git a/be/test/olap/CMakeLists.txt b/be/test/olap/CMakeLists.txt index 0a34af3be72aae..8bc7010dac08a3 100644 --- a/be/test/olap/CMakeLists.txt +++ b/be/test/olap/CMakeLists.txt @@ -39,6 +39,7 @@ ADD_BE_TEST(file_helper_test) ADD_BE_TEST(file_utils_test) ADD_BE_TEST(delete_handler_test) ADD_BE_TEST(column_reader_test) +ADD_BE_TEST(cumulative_compaction_policy_test) ADD_BE_TEST(schema_change_test) ADD_BE_TEST(row_cursor_test) ADD_BE_TEST(skiplist_test) diff --git a/be/test/olap/cumulative_compaction_policy_test.cpp b/be/test/olap/cumulative_compaction_policy_test.cpp index 3792a1d4132c58..3fab6f70c0af22 100644 --- a/be/test/olap/cumulative_compaction_policy_test.cpp +++ b/be/test/olap/cumulative_compaction_policy_test.cpp @@ -264,7 +264,7 @@ TEST_F(TestNumBasedCumulativeCompactionPolicy, pick_input_rowsets_normal) { _tablet->init(); _tablet->calculate_cumulative_point(); - NumBasedCumulativeCompactionPolicy policy(_tablet.get()); + NumBasedCumulativeCompactionPolicy policy; std::vector candidate_rowsets; _tablet->pick_candicate_rowsets_to_cumulative_compaction(1000, &candidate_rowsets); @@ -272,7 +272,7 @@ TEST_F(TestNumBasedCumulativeCompactionPolicy, pick_input_rowsets_normal) { std::vector input_rowsets; Version last_delete_version{-1, -1}; size_t compaction_score = 0; - policy.pick_input_rowsets(candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, + policy.pick_input_rowsets(_tablet.get(), candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, &compaction_score); ASSERT_EQ(2, input_rowsets.size()); @@ -294,7 +294,7 @@ TEST_F(TestNumBasedCumulativeCompactionPolicy, pick_input_rowsets_delete) { _tablet->init(); _tablet->calculate_cumulative_point(); - NumBasedCumulativeCompactionPolicy policy(_tablet.get()); + NumBasedCumulativeCompactionPolicy policy; std::vector candidate_rowsets; _tablet->pick_candicate_rowsets_to_cumulative_compaction(1000, &candidate_rowsets); @@ -303,7 +303,7 @@ TEST_F(TestNumBasedCumulativeCompactionPolicy, pick_input_rowsets_delete) { Version last_delete_version{-1, -1}; size_t compaction_score = 0; - policy.pick_input_rowsets(candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, + policy.pick_input_rowsets(_tablet.get(), candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, &compaction_score); ASSERT_EQ(1, input_rowsets.size()); @@ -768,7 +768,7 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_normal) { std::vector input_rowsets; Version last_delete_version{-1, -1}; size_t compaction_score = 0; - _tablet->_cumulative_compaction_policy->pick_input_rowsets( + _tablet->_cumulative_compaction_policy->pick_input_rowsets(_tablet.get(), candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, &compaction_score); ASSERT_EQ(4, input_rowsets.size()); @@ -797,7 +797,7 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_big_base) { std::vector input_rowsets; Version last_delete_version{-1, -1}; size_t compaction_score = 0; - _tablet->_cumulative_compaction_policy->pick_input_rowsets( + _tablet->_cumulative_compaction_policy->pick_input_rowsets(_tablet.get(), candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, &compaction_score); ASSERT_EQ(3, input_rowsets.size()); @@ -826,7 +826,7 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_promotion) { std::vector input_rowsets; Version last_delete_version{-1, -1}; size_t compaction_score = 0; - _tablet->_cumulative_compaction_policy->pick_input_rowsets( + _tablet->_cumulative_compaction_policy->pick_input_rowsets(_tablet.get(), candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, &compaction_score); ASSERT_EQ(2, input_rowsets.size()); @@ -855,7 +855,7 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_not_same_leve std::vector input_rowsets; Version last_delete_version{-1, -1}; size_t compaction_score = 0; - _tablet->_cumulative_compaction_policy->pick_input_rowsets( + _tablet->_cumulative_compaction_policy->pick_input_rowsets(_tablet.get(), candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, &compaction_score); ASSERT_EQ(4, input_rowsets.size()); @@ -884,7 +884,7 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_empty) { std::vector input_rowsets; Version last_delete_version{-1, -1}; size_t compaction_score = 0; - _tablet->_cumulative_compaction_policy->pick_input_rowsets( + _tablet->_cumulative_compaction_policy->pick_input_rowsets(_tablet.get(), candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, &compaction_score); ASSERT_EQ(0, input_rowsets.size()); @@ -913,7 +913,7 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_not_reach_min std::vector input_rowsets; Version last_delete_version{-1, -1}; size_t compaction_score = 0; - _tablet->_cumulative_compaction_policy->pick_input_rowsets( + _tablet->_cumulative_compaction_policy->pick_input_rowsets(_tablet.get(), candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, &compaction_score); ASSERT_EQ(0, input_rowsets.size()); @@ -943,7 +943,7 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_delete) { Version last_delete_version{-1, -1}; size_t compaction_score = 0; - _tablet->_cumulative_compaction_policy->pick_input_rowsets( + _tablet->_cumulative_compaction_policy->pick_input_rowsets(_tablet.get(), candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, &compaction_score); ASSERT_EQ(2, input_rowsets.size()); diff --git a/be/test/olap/tablet_test.cpp b/be/test/olap/tablet_test.cpp index e01e3b9f964aa6..e0cd77d2b8d1b3 100755 --- a/be/test/olap/tablet_test.cpp +++ b/be/test/olap/tablet_test.cpp @@ -182,7 +182,6 @@ TEST_F(TestTablet, delete_expired_stale_rowset) { _tablet_meta->add_rs_meta(rowset); } - TabletSharedPtr _tablet(new Tablet(_tablet_meta, nullptr)); _tablet->init(); @@ -195,6 +194,7 @@ TEST_F(TestTablet, delete_expired_stale_rowset) { _tablet->delete_expired_stale_rowset(); ASSERT_EQ(0, _tablet->_timestamped_version_tracker._stale_version_path_map.size()); + _tablet.reset(); } }