[Enhancement] add metric for page_cache (#63905)

Signed-off-by: Murphy <mofei@starrocks.com>

be/src/cache/mem_cache/local_mem_cache_engine.h

@@ -107,6 +107,15 @@ public:
     // Get the cache hit count.
     virtual size_t hit_count() const = 0;
 
+    // Get the insert count.
+    virtual size_t insert_count() const = 0;
+
+    // Get the insert evict count.
+    virtual size_t insert_evict_count() const = 0;
+
+    // Get the release evict count.
+    virtual size_t release_evict_count() const = 0;
+
     // Remove all cache entries that are not actively in use.
     virtual Status prune() = 0;
 };

be/src/cache/mem_cache/lrucache_engine.cpp

@@ -111,6 +111,18 @@ size_t LRUCacheEngine::hit_count() const {
     return _cache->get_hit_count();
 }
 
+size_t LRUCacheEngine::insert_count() const {
+    return _cache->get_insert_count();
+}
+
+size_t LRUCacheEngine::insert_evict_count() const {
+    return _cache->get_insert_evict_count();
+}
+
+size_t LRUCacheEngine::release_evict_count() const {
+    return _cache->get_release_evict_count();
+}
+
 bool LRUCacheEngine::_check_write(size_t charge, const MemCacheWriteOptions& options) const {
     if (options.evict_probability >= 100) {
         return true;

be/src/cache/mem_cache/lrucache_engine.h

@@ -57,6 +57,12 @@ public:
 
     size_t hit_count() const override;
 
+    size_t insert_count() const override;
+
+    size_t insert_evict_count() const override;
+
+    size_t release_evict_count() const override;
+
     Status prune() override;
 
 private:

be/src/cache/mem_cache/page_cache.cpp

@@ -49,6 +49,9 @@ std::atomic<size_t> StoragePageCacheMetrics::released_page_handle_count{};
 
 METRIC_DEFINE_UINT_GAUGE(page_cache_lookup_count, MetricUnit::OPERATIONS);
 METRIC_DEFINE_UINT_GAUGE(page_cache_hit_count, MetricUnit::OPERATIONS);
+METRIC_DEFINE_UINT_GAUGE(page_cache_insert_count, MetricUnit::OPERATIONS);
+METRIC_DEFINE_UINT_GAUGE(page_cache_insert_evict_count, MetricUnit::OPERATIONS);
+METRIC_DEFINE_UINT_GAUGE(page_cache_release_evict_count, MetricUnit::OPERATIONS);
 METRIC_DEFINE_UINT_GAUGE(page_cache_capacity, MetricUnit::BYTES);
 METRIC_DEFINE_UINT_GAUGE(page_cache_pinned_count, MetricUnit::BYTES);
 
@@ -61,6 +64,22 @@ void StoragePageCache::init_metrics() {
     StarRocksMetrics::instance()->metrics()->register_hook(
             "page_cache_hit_count", [this]() { page_cache_hit_count.set_value(get_hit_count()); });
 
+    StarRocksMetrics::instance()->metrics()->register_metric("page_cache_insert_count", &page_cache_insert_count);
+    StarRocksMetrics::instance()->metrics()->register_hook(
+            "page_cache_insert_count", [this]() { page_cache_insert_count.set_value(get_insert_count()); });
+
+    StarRocksMetrics::instance()->metrics()->register_metric("page_cache_insert_evict_count",
+                                                             &page_cache_insert_evict_count);
+    StarRocksMetrics::instance()->metrics()->register_hook("page_cache_insert_evict_count", [this]() {
+        page_cache_insert_evict_count.set_value(get_insert_evict_count());
+    });
+
+    StarRocksMetrics::instance()->metrics()->register_metric("page_cache_release_evict_count",
+                                                             &page_cache_release_evict_count);
+    StarRocksMetrics::instance()->metrics()->register_hook("page_cache_release_evict_count", [this]() {
+        page_cache_release_evict_count.set_value(get_release_evict_count());
+    });
+
     StarRocksMetrics::instance()->metrics()->register_metric("page_cache_capacity", &page_cache_capacity);
     StarRocksMetrics::instance()->metrics()->register_hook("page_cache_capacity",
                                                            [this]() { page_cache_capacity.set_value(get_capacity()); });
@@ -91,6 +110,18 @@ uint64_t StoragePageCache::get_hit_count() const {
     return _cache->hit_count();
 }
 
+uint64_t StoragePageCache::get_insert_count() const {
+    return _cache->insert_count();
+}
+
+uint64_t StoragePageCache::get_insert_evict_count() const {
+    return _cache->insert_evict_count();
+}
+
+uint64_t StoragePageCache::get_release_evict_count() const {
+    return _cache->release_evict_count();
+}
+
 bool StoragePageCache::adjust_capacity(int64_t delta, size_t min_capacity) {
     Status st = _cache->adjust_mem_quota(delta, min_capacity);
     if (!st.ok()) {

be/src/cache/mem_cache/page_cache.h

@@ -103,6 +103,12 @@ public:
 
     uint64_t get_hit_count() const;
 
+    uint64_t get_insert_count() const;
+
+    uint64_t get_insert_evict_count() const;
+
+    uint64_t get_release_evict_count() const;
+
     bool adjust_capacity(int64_t delta, size_t min_capacity = 0);
 
     void prune();

be/src/util/lru_cache.cpp

@@ -203,6 +203,21 @@ uint64_t LRUCache::get_hit_count() const {
     return _hit_count;
 }
 
+uint64_t LRUCache::get_insert_count() const {
+    std::lock_guard l(_mutex);
+    return _insert_count;
+}
+
+uint64_t LRUCache::get_insert_evict_count() const {
+    std::lock_guard l(_mutex);
+    return _insert_evict_count;
+}
+
+uint64_t LRUCache::get_release_evict_count() const {
+    std::lock_guard l(_mutex);
+    return _release_evict_count;
+}
+
 size_t LRUCache::get_usage() const {
     std::lock_guard l(_mutex);
     return _usage;
@@ -250,6 +265,8 @@ void LRUCache::release(Cache::Handle* handle) {
                 _unref(e);
                 _usage -= e->charge;
                 last_ref = true;
+                // Track evictions caused by release
+                ++_release_evict_count;
             } else {
                 // put it to LRU free list
                 _lru_append(&_lru, e);
@@ -314,9 +331,19 @@ Cache::Handle* LRUCache::insert(const CacheKey& key, uint32_t hash, void* value,
     {
         std::lock_guard l(_mutex);
 
+        // Track insert count
+        ++_insert_count;
+
         // Free the space following strict LRU policy until enough space
         // is freed or the lru list is empty
+        size_t evicted_count_before = last_ref_list.size();
         _evict_from_lru(kv_mem_size, &last_ref_list);
+        size_t evicted_count_after = last_ref_list.size();
+
+        // Track evictions caused by insert
+        if (evicted_count_after > evicted_count_before) {
+            _insert_evict_count += (evicted_count_after - evicted_count_before);
+        }
 
         // insert into the cache
         // note that the cache might get larger than its capacity if not enough
@@ -496,6 +523,18 @@ size_t ShardedLRUCache::get_hit_count() const {
     return _get_stat(&LRUCache::get_hit_count);
 }
 
+size_t ShardedLRUCache::get_insert_count() const {
+    return _get_stat(&LRUCache::get_insert_count);
+}
+
+size_t ShardedLRUCache::get_insert_evict_count() const {
+    return _get_stat(&LRUCache::get_insert_evict_count);
+}
+
+size_t ShardedLRUCache::get_release_evict_count() const {
+    return _get_stat(&LRUCache::get_release_evict_count);
+}
+
 void ShardedLRUCache::get_cache_status(rapidjson::Document* document) {
     size_t shard_count = sizeof(_shards) / sizeof(LRUCache);
 

be/src/util/lru_cache.h

@@ -183,6 +183,9 @@ public:
     virtual size_t get_memory_usage() const = 0;
     virtual size_t get_lookup_count() const = 0;
     virtual size_t get_hit_count() const = 0;
+    virtual size_t get_insert_count() const = 0;
+    virtual size_t get_insert_evict_count() const = 0;
+    virtual size_t get_release_evict_count() const = 0;
 
     //  Decrease or increase cache capacity.
     virtual bool adjust_capacity(int64_t delta, size_t min_capacity = 0) = 0;
@@ -278,6 +281,9 @@ public:
 
     uint64_t get_lookup_count() const;
     uint64_t get_hit_count() const;
+    uint64_t get_insert_count() const;
+    uint64_t get_insert_evict_count() const;
+    uint64_t get_release_evict_count() const;
     size_t get_usage() const;
     size_t get_capacity() const;
     static size_t key_handle_size(const CacheKey& key) { return sizeof(LRUHandle) - 1 + key.size(); }
@@ -305,6 +311,9 @@ private:
 
     uint64_t _lookup_count{0};
     uint64_t _hit_count{0};
+    uint64_t _insert_count{0};
+    uint64_t _insert_evict_count{0};
+    uint64_t _release_evict_count{0};
 };
 
 static const int kNumShardBits = 5;
@@ -330,6 +339,9 @@ public:
     size_t get_capacity() const override;
     size_t get_lookup_count() const override;
     size_t get_hit_count() const override;
+    size_t get_insert_count() const override;
+    size_t get_insert_evict_count() const override;
+    size_t get_release_evict_count() const override;
     bool adjust_capacity(int64_t delta, size_t min_capacity = 0) override;
 
 private:

docs/en/administration/management/monitoring/metrics.md

@@ -1077,6 +1077,21 @@ For more information on how to build a monitoring service for your StarRocks clu
 - Unit: Count
 - Description: Total number of hits in the storage page cache.
 
+### page_cache_insert_count
+
+- Unit: Count
+- Description: Total number of insert operations in the storage page cache.
+
+### page_cache_insert_evict_count
+
+- Unit: Count
+- Description: Total number of cache entries evicted during insert operations due to capacity constraints.
+
+### page_cache_release_evict_count
+
+- Unit: Count
+- Description: Total number of cache entries evicted during release operations when cache usage exceeds capacity.
+
 ### bytes_read_total (Deprecated)
 
 ### update_rowset_commit_request_total

docs/ja/administration/management/monitoring/metrics.md

@@ -1076,6 +1076,21 @@ StarRocks クラスタのモニタリングサービスの構築方法につい
 - 単位: Count
 - 説明: ストレージページキャッシュのヒット総数。
 
+### page_cache_insert_count
+
+- 単位: Count
+- 説明: ストレージページキャッシュの挿入操作総数。
+
+### page_cache_insert_evict_count
+
+- 単位: Count
+- 説明: 容量制限により、挿入操作中にエビクトされたキャッシュエントリの総数。
+
+### page_cache_release_evict_count
+
+- 単位: Count
+- 説明: キャッシュ使用量が容量を超えた場合、リリース操作中にエビクトされたキャッシュエントリの総数。
+
 ### bytes_read_total (Deprecated)
 
 ### update_rowset_commit_request_total

docs/zh/administration/management/monitoring/metrics.md

@@ -1076,6 +1076,21 @@ displayed_sidebar: docs
 - 单位：个
 - 描述：Storage Page Cache 中的命中总次数。
 
+### page_cache_insert_count
+
+- 单位：个
+- 描述：Storage Page Cache 中的插入操作总次数。
+
+### page_cache_insert_evict_count
+
+- 单位：个
+- 描述：由于容量限制，在插入操作期间被淘汰的缓存项总次数。
+
+### page_cache_release_evict_count
+
+- 单位：个
+- 描述：当缓存使用量超过容量时，在释放操作期间被淘汰的缓存项总次数。
+
 ### bytes_read_total（已弃用）
 
 ### update_rowset_commit_request_total