edit

hust-hhb · Jan 27, 2025 · 07a8f21 · 07a8f21
1 parent dd54682
commit 07a8f21
Show file tree

Hide file tree

Showing 13 changed files with 154 additions and 92 deletions.
diff --git a/be/src/cloud/cloud_storage_engine.cpp b/be/src/cloud/cloud_storage_engine.cpp
@@ -832,11 +832,17 @@ void CloudStorageEngine::_check_tablet_delete_bitmap_score_callback() {
             return;
         }
         uint64_t max_delete_bitmap_score = 0;
+        uint64_t max_base_rowset_delete_bitmap_score = 0;
         std::vector<CloudTabletSPtr> tablets;
-        tablet_mgr().get_topn_tablet_delete_bitmap_score(&max_delete_bitmap_score);
+        tablet_mgr().get_topn_tablet_delete_bitmap_score(&max_delete_bitmap_score,
+                                                         &max_base_rowset_delete_bitmap_score);
         if (max_delete_bitmap_score > 0) {
             _tablet_max_delete_bitmap_score_metrics->set_value(max_delete_bitmap_score);
         }
+        if (max_base_rowset_delete_bitmap_score > 0) {
+            _tablet_max_base_rowset_delete_bitmap_score_metrics->set_value(
+                    max_base_rowset_delete_bitmap_score);
+        }
     }
 }
 

diff --git a/be/src/cloud/cloud_tablet_mgr.cpp b/be/src/cloud/cloud_tablet_mgr.cpp
@@ -419,12 +419,14 @@ void CloudTabletMgr::get_tablet_info(int64_t num_tablets, std::vector<TabletInfo
     }
 }
 
-void CloudTabletMgr::get_topn_tablet_delete_bitmap_score(uint64_t* max_delete_bitmap_score) {
+void CloudTabletMgr::get_topn_tablet_delete_bitmap_score(
+        uint64_t* max_delete_bitmap_score, uint64_t* max_base_rowset_delete_bitmap_score) {
     int64_t max_delete_bitmap_score_tablet_id = 0;
     OlapStopWatch watch;
     uint64_t total_delete_map_count = 0;
+    int64_t max_base_rowset_delete_bitmap_score_tablet_id = 0;
     int n = config::check_tablet_delete_bitmap_score_top_n;
-    std::vector<std::pair<int64_t, int64_t>> buf;
+    std::vector<std::pair<std::shared_ptr<CloudTablet>, int64_t>> buf;
     buf.reserve(n + 1);
     auto handler = [&](const std::weak_ptr<CloudTablet>& tablet_wk) {
         auto t = tablet_wk.lock();
@@ -436,25 +438,31 @@ void CloudTabletMgr::get_topn_tablet_delete_bitmap_score(uint64_t* max_delete_bi
             max_delete_bitmap_score_tablet_id = t->tablet_id();
             *max_delete_bitmap_score = delete_bitmap_count;
         }
-        buf.emplace_back(t.get()->tablet_id(), delete_bitmap_count);
+        buf.emplace_back(std::move(t), delete_bitmap_count);
         std::sort(buf.begin(), buf.end(), [](auto& a, auto& b) { return a.second > b.second; });
         if (buf.size() > n) {
             buf.pop_back();
         }
     };
     auto weak_tablets = get_weak_tablets();
     std::for_each(weak_tablets.begin(), weak_tablets.end(), handler);
+    for (auto& [t, _] : buf) {
+        t->get_base_rowset_delete_bitmap_count(max_base_rowset_delete_bitmap_score,
+                                               &max_base_rowset_delete_bitmap_score_tablet_id);
+    }
     std::stringstream ss;
     for (auto& i : buf) {
-        ss << i.first << ":" << i.second << ",";
+        ss << i.first->tablet_id() << ":" << i.second << ",";
     }
     LOG(INFO) << "get_topn_tablet_delete_bitmap_score, n=" << n
               << ",tablet size=" << weak_tablets.size()
               << ",total_delete_map_count=" << total_delete_map_count
               << ",cost(us)=" << watch.get_elapse_time_us()
               << ",max_delete_bitmap_score=" << *max_delete_bitmap_score
               << ",max_delete_bitmap_score_tablet_id=" << max_delete_bitmap_score_tablet_id
-              << ",tablets=[" << ss.str() << "]";
+              << ",max_base_rowset_delete_bitmap_score=" << *max_base_rowset_delete_bitmap_score
+              << ",max_base_rowset_delete_bitmap_score_tablet_id="
+              << max_base_rowset_delete_bitmap_score_tablet_id << ",tablets=[" << ss.str() << "]";
 }
 
 } // namespace doris
diff --git a/be/src/cloud/cloud_tablet_mgr.h b/be/src/cloud/cloud_tablet_mgr.h
@@ -82,7 +82,8 @@ class CloudTabletMgr {
 
     void get_tablet_info(int64_t num_tablets, std::vector<TabletInfo>* tablets_info);
 
-    void get_topn_tablet_delete_bitmap_score(uint64_t* max_delete_bitmap_score);
+    void get_topn_tablet_delete_bitmap_score(uint64_t* max_delete_bitmap_score,
+                                             uint64_t* max_base_rowset_delete_bitmap_score);
 
 private:
     CloudStorageEngine& _engine;

diff --git a/be/src/common/config.cpp b/be/src/common/config.cpp
@@ -1407,7 +1407,7 @@ DEFINE_mBool(enable_sleep_between_delete_cumu_compaction, "false");
 
 DEFINE_mInt32(compaction_num_per_round, "1");
 
-DEFINE_mInt32(check_tablet_delete_bitmap_interval_seconds, "60");
+DEFINE_mInt32(check_tablet_delete_bitmap_interval_seconds, "300");
 DEFINE_mInt32(check_tablet_delete_bitmap_score_top_n, "10");
 DEFINE_mBool(enable_check_tablet_delete_bitmap_score, "true");
 

diff --git a/be/src/olap/base_tablet.cpp b/be/src/olap/base_tablet.cpp
@@ -1895,11 +1895,10 @@ void BaseTablet::get_base_rowset_delete_bitmap_count(
                 break;
             }
             base_found = true;
-            DeleteBitmap subset_map(this->tablet_id());
-            this->tablet_meta()->delete_bitmap().subset(
-                    {rowset->rowset_id(), 0, 0}, {rowset->rowset_id(), UINT32_MAX, UINT64_MAX},
-                    &subset_map);
-            uint64_t base_rowset_delete_bitmap_count = subset_map.get_delete_bitmap_count();
+            uint64_t base_rowset_delete_bitmap_count =
+                    this->tablet_meta()->delete_bitmap().get_count_with_range(
+                            {rowset->rowset_id(), 0, 0},
+                            {rowset->rowset_id(), UINT32_MAX, UINT64_MAX});
             if (base_rowset_delete_bitmap_count > *max_base_rowset_delete_bitmap_score) {
                 *max_base_rowset_delete_bitmap_score = base_rowset_delete_bitmap_count;
                 *max_base_rowset_delete_bitmap_score_tablet_id = this->tablet_id();

diff --git a/be/src/olap/olap_server.cpp b/be/src/olap/olap_server.cpp
@@ -1656,11 +1656,17 @@ void StorageEngine::_check_tablet_delete_bitmap_score_callback() {
             return;
         }
         uint64_t max_delete_bitmap_score = 0;
+        uint64_t max_base_rowset_delete_bitmap_score = 0;
         std::vector<CloudTabletSPtr> tablets;
-        _tablet_manager.get()->get_topn_tablet_delete_bitmap_score(&max_delete_bitmap_score);
+        _tablet_manager.get()->get_topn_tablet_delete_bitmap_score(
+                &max_delete_bitmap_score, &max_base_rowset_delete_bitmap_score);
         if (max_delete_bitmap_score > 0) {
             _tablet_max_delete_bitmap_score_metrics->set_value(max_delete_bitmap_score);
         }
+        if (max_base_rowset_delete_bitmap_score > 0) {
+            _tablet_max_base_rowset_delete_bitmap_score_metrics->set_value(
+                    max_base_rowset_delete_bitmap_score);
+        }
     }
 }
 

diff --git a/be/src/olap/storage_engine.cpp b/be/src/olap/storage_engine.cpp
@@ -105,6 +105,8 @@ BaseStorageEngine::BaseStorageEngine(Type type, const UniqueId& backend_uid)
             static_cast<int64_t>(MemInfo::soft_mem_limit() * config::schema_change_mem_limit_frac);
     _tablet_max_delete_bitmap_score_metrics =
             std::make_shared<bvar::Status<size_t>>("tablet_max", "delete_bitmap_score", 0);
+    _tablet_max_base_rowset_delete_bitmap_score_metrics = std::make_shared<bvar::Status<size_t>>(
+            "tablet_max_base_rowset", "delete_bitmap_score", 0);
 }
 
 BaseStorageEngine::~BaseStorageEngine() = default;

diff --git a/be/src/olap/storage_engine.h b/be/src/olap/storage_engine.h
@@ -171,6 +171,7 @@ class BaseStorageEngine {
     std::shared_ptr<StreamLoadRecorder> _stream_load_recorder;
 
     std::shared_ptr<bvar::Status<size_t>> _tablet_max_delete_bitmap_score_metrics;
+    std::shared_ptr<bvar::Status<size_t>> _tablet_max_base_rowset_delete_bitmap_score_metrics;
 };
 
 class CompactionSubmitRegistry {

diff --git a/be/src/olap/tablet_manager.cpp b/be/src/olap/tablet_manager.cpp
@@ -1764,12 +1764,14 @@ bool TabletManager::update_tablet_partition_id(::doris::TPartitionId partition_i
     return true;
 }
 
-void TabletManager::get_topn_tablet_delete_bitmap_score(uint64_t* max_delete_bitmap_score) {
+void TabletManager::get_topn_tablet_delete_bitmap_score(
+        uint64_t* max_delete_bitmap_score, uint64_t* max_base_rowset_delete_bitmap_score) {
     int64_t max_delete_bitmap_score_tablet_id = 0;
+    int64_t max_base_rowset_delete_bitmap_score_tablet_id = 0;
     OlapStopWatch watch;
     uint64_t total_delete_map_count = 0;
     int n = config::check_tablet_delete_bitmap_score_top_n;
-    std::vector<std::pair<int64_t, int64_t>> buf;
+    std::vector<std::pair<std::shared_ptr<Tablet>, int64_t>> buf;
     buf.reserve(n + 1);
     auto handler = [&](const TabletSharedPtr& tablet) {
         uint64_t delete_bitmap_count =
@@ -1779,24 +1781,30 @@ void TabletManager::get_topn_tablet_delete_bitmap_score(uint64_t* max_delete_bit
             max_delete_bitmap_score_tablet_id = tablet->tablet_id();
             *max_delete_bitmap_score = delete_bitmap_count;
         }
-        buf.emplace_back(tablet->tablet_id(), delete_bitmap_count);
+        buf.emplace_back(std::move(tablet), delete_bitmap_count);
         std::sort(buf.begin(), buf.end(), [](auto& a, auto& b) { return a.second > b.second; });
         if (buf.size() > n) {
             buf.pop_back();
         }
     };
     for_each_tablet(handler, filter_all_tablets);
+    for (auto& [t, _] : buf) {
+        t->get_base_rowset_delete_bitmap_count(max_base_rowset_delete_bitmap_score,
+                                               &max_base_rowset_delete_bitmap_score_tablet_id);
+    }
     std::stringstream ss;
     for (auto& i : buf) {
-        ss << i.first << ":" << i.second << ",";
+        ss << i.first->tablet_id() << ":" << i.second << ",";
     }
     LOG(INFO) << "get_topn_tablet_delete_bitmap_score, n=" << n
               << ",tablet size=" << _tablets_shards.size()
               << ",total_delete_map_count=" << total_delete_map_count
               << ",cost(us)=" << watch.get_elapse_time_us()
               << ",max_delete_bitmap_score=" << *max_delete_bitmap_score
               << ",max_delete_bitmap_score_tablet_id=" << max_delete_bitmap_score_tablet_id
-              << ",tablets=[" << ss.str() << "]";
+              << ",max_base_rowset_delete_bitmap_score=" << *max_base_rowset_delete_bitmap_score
+              << ",max_base_rowset_delete_bitmap_score_tablet_id="
+              << max_base_rowset_delete_bitmap_score_tablet_id << ",tablets=[" << ss.str() << "]";
 }
 
 } // end namespace doris
diff --git a/be/src/olap/tablet_manager.h b/be/src/olap/tablet_manager.h
@@ -178,7 +178,8 @@ class TabletManager {
     bool update_tablet_partition_id(::doris::TPartitionId partition_id,
                                     ::doris::TTabletId tablet_id);
 
-    void get_topn_tablet_delete_bitmap_score(uint64_t* max_delete_bitmap_score);
+    void get_topn_tablet_delete_bitmap_score(uint64_t* max_delete_bitmap_score,
+                                             uint64_t* max_base_rowset_delete_bitmap_score);
 
 private:
     // Add a tablet pointer to StorageEngine

diff --git a/be/src/olap/tablet_meta.cpp b/be/src/olap/tablet_meta.cpp
@@ -1186,6 +1186,20 @@ void DeleteBitmap::subset(const BitmapKey& start, const BitmapKey& end,
     }
 }
 
+size_t DeleteBitmap::get_count_with_range(const BitmapKey& start, const BitmapKey& end) const {
+    DCHECK(start < end);
+    size_t count = 0;
+    std::shared_lock l(lock);
+    for (auto it = delete_bitmap.lower_bound(start); it != delete_bitmap.end(); ++it) {
+        auto& [k, bm] = *it;
+        if (k >= end) {
+            break;
+        }
+        count++;
+    }
+    return count;
+}
+
 void DeleteBitmap::merge(const BitmapKey& bmk, const roaring::Roaring& segment_delete_bitmap) {
     std::lock_guard l(lock);
     auto [iter, succ] = delete_bitmap.emplace(bmk, segment_delete_bitmap);

diff --git a/be/src/olap/tablet_meta.h b/be/src/olap/tablet_meta.h
@@ -501,6 +501,14 @@ class DeleteBitmap {
     void subset(const BitmapKey& start, const BitmapKey& end,
                 DeleteBitmap* subset_delete_map) const;
 
+    /**
+     * Gets count of delete_bitmap with given range [start, end)
+     *
+     * @parma start start
+     * @parma end end
+     */
+    size_t get_count_with_range(const BitmapKey& start, const BitmapKey& end) const;
+
     /**
      * Merges the given segment delete bitmap into *this
      *