Shared Cache: remove ECacheTier::None (#20607)

Author: lex007in

ydb/core/tablet_flat/shared_cache_counters.cpp

@@ -39,16 +39,4 @@ TSharedPageCacheCounters::TCounterPtr TSharedPageCacheCounters::ReplacementPolic
     return Counters->GetCounter(TStringBuilder() << "ReplacementPolicySize/" << policy);
 }
 
-TSharedPageCacheCounters::TCounterPtr TSharedPageCacheCounters::ActivePagesTier(ECacheTier tier) {
-    return Counters->GetCounter(TStringBuilder() << "Tier" << tier << "ActivePages");
-}
-
-TSharedPageCacheCounters::TCounterPtr TSharedPageCacheCounters::ActiveBytesTier(ECacheTier tier) {
-    return Counters->GetCounter(TStringBuilder() << "Tier" << tier << "ActiveBytes");
-}
-
-TSharedPageCacheCounters::TCounterPtr TSharedPageCacheCounters::LimitBytesTier(ECacheTier tier) {
-    return Counters->GetCounter(TStringBuilder() << "Tier" << tier << "LimitBytes");
-}
-
 } // namespace NKikimr::NSharedCache

ydb/core/tablet_flat/shared_cache_counters.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "shared_cache_tiers.h"
 #include <ydb/core/protos/shared_cache.pb.h>
 #include <ydb/core/util/cache_cache.h>
 
@@ -48,10 +47,6 @@ struct TSharedPageCacheCounters final : public TAtomicRefCount<TSharedPageCacheC
     explicit TSharedPageCacheCounters(const TIntrusivePtr<::NMonitoring::TDynamicCounters>& counters);
 
     TCounterPtr ReplacementPolicySize(TReplacementPolicy policy);
-
-    TCounterPtr ActivePagesTier(ECacheTier tier);
-    TCounterPtr ActiveBytesTier(ECacheTier tier);
-    TCounterPtr LimitBytesTier(ECacheTier tier);
 };
 
 } // namespace NKikimr::NSharedCache

ydb/core/tablet_flat/shared_cache_tiered.h

@@ -10,115 +10,20 @@ namespace NKikimr::NSharedCache {
     class TTieredCache {
         using TCounterPtr = ::NMonitoring::TDynamicCounters::TCounterPtr;
         using TReplacementPolicy = NKikimrSharedCache::TReplacementPolicy;
-
-        class TCacheTier {
-        public:
-            template <typename TCacheBuilder>
-            TCacheTier(ui64 limit, TCacheBuilder createCache, ECacheTier tier, TReplacementPolicy policy, TSharedPageCacheCounters& cacheCounters)
-                : Cache(TSwitchableCache<TPage, TPageTraits>(limit, createCache(), cacheCounters.ReplacementPolicySize(policy)))
-                , Tier(tier)
-                , ActivePagesCounter(cacheCounters.ActivePagesTier(tier))
-                , ActiveBytesCounter(cacheCounters.ActiveBytesTier(tier))
-                , LimitBytesCounter(cacheCounters.LimitBytesTier(tier))
-            {
-                LimitBytesCounter->Set(limit);
-            }
-
-            TIntrusiveList<TPage> Switch(THolder<ICacheCache<TPage>>&& cache, TCounterPtr sizeCounter) Y_WARN_UNUSED_RESULT {
-                return ProcessEvicted(Cache.Switch(std::move(cache), std::move(sizeCounter)));
-            }
-
-            TIntrusiveList<TPage> EvictNext() Y_WARN_UNUSED_RESULT {
-                return ProcessEvicted(Cache.EvictNext());
-            }
-
-            TIntrusiveList<TPage> Touch(TPage *page) Y_WARN_UNUSED_RESULT {
-                ECacheTier tier = TPageTraits::GetTier(page);
-                if (tier == ECacheTier::None) {
-                    tier = Tier;
-                    TPageTraits::SetTier(page, tier);
-                    ActivePagesCounter->Inc();
-                    ActiveBytesCounter->Add(TPageTraits::GetSize(page));
-                }
-                return ProcessEvicted(Cache.Touch(page));
-            }
-
-            void Erase(TPage *page) {
-                ActivePagesCounter->Dec();
-                ActiveBytesCounter->Sub(TPageTraits::GetSize(page));
-                TPageTraits::SetTier(page, ECacheTier::None);
-                Cache.Erase(page);
-            }
-
-            void UpdateLimit(ui64 limit) {
-                Cache.UpdateLimit(limit);
-                LimitBytesCounter->Set(limit);
-            }
-
-            ui64 GetSize() const {
-                return Cache.GetSize();
-            }
-
-            TString Dump() const {
-                return TStringBuilder() << Tier << "Tier: " << Cache.Dump();
-            }
-
-        private:
-
-            TIntrusiveList<TPage> ProcessEvicted(TIntrusiveList<TPage>&& evictedList) Y_WARN_UNUSED_RESULT {
-                if (evictedList.Empty()) {
-                    return evictedList;
-                }
-
-                ui64 evictedPages = 0;
-                ui64 evictedSize = 0;
-
-                for (auto& page_ : evictedList) {
-                    TPage* page = &page_;
-                    TPageTraits::SetTier(page, ECacheTier::None);
-                    ++evictedPages;
-                    evictedSize += TPageTraits::GetSize(page);
-                }
-
-                ActivePagesCounter->Sub(evictedPages);
-                ActiveBytesCounter->Sub(evictedSize);
-
-                return evictedList;
-            }
-
-        private:
-            TSwitchableCache<TPage, TPageTraits> Cache;
-            ECacheTier Tier;
-            TCounterPtr ActivePagesCounter;
-            TCounterPtr ActiveBytesCounter;
-            TCounterPtr LimitBytesCounter;
-        };
+        using TCache = TSwitchableCache<TPage, TPageTraits>;
 
     public:
         template <typename TCacheBuilder>
         TTieredCache(ui64 limit, TCacheBuilder createCache, TReplacementPolicy policy, TSharedPageCacheCounters& cacheCounters)
             : CacheTiers(::Reserve(2))
         {
-            CacheTiers.emplace_back(limit, createCache, ECacheTier::Regular, policy, cacheCounters);
+            CacheTiers.emplace_back(limit, createCache(), cacheCounters.ReplacementPolicySize(policy));
             RegularTier = &CacheTiers.back();
 
-            CacheTiers.emplace_back(0, createCache, ECacheTier::TryKeepInMemory, policy, cacheCounters);
+            CacheTiers.emplace_back(0, createCache(), cacheCounters.ReplacementPolicySize(policy));
             TryInMemoryTier = &CacheTiers.back();
         }
 
-        TIntrusiveList<TPage> TryMove(TPage *page, ECacheTier targetTier) Y_WARN_UNUSED_RESULT {
-            ECacheTier sourceTier = TPageTraits::GetTier(page);
-            Y_ENSURE(targetTier != ECacheTier::None);
-
-            if (sourceTier == ECacheTier::None || sourceTier == targetTier) {
-                // nothing to move
-                return {};
-            }
-
-            CacheTiers[static_cast<size_t>(sourceTier)].Erase(page);
-            return CacheTiers[static_cast<size_t>(targetTier)].Touch(page);
-        }
-
         template <typename TCacheBuilder>
         TIntrusiveList<TPage> Switch(TCacheBuilder createCache, TCounterPtr sizeCounter) Y_WARN_UNUSED_RESULT {
             TIntrusiveList<TPage> evictedList;
@@ -140,29 +45,11 @@ namespace NKikimr::NSharedCache {
 
         TIntrusiveList<TPage> Touch(TPage *page) Y_WARN_UNUSED_RESULT {
             ECacheTier tier = TPageTraits::GetTier(page);
-            if (tier == ECacheTier::None) {
-                return RegularTier->Touch(page);
-            }
             return CacheTiers[static_cast<size_t>(tier)].Touch(page);
         }
 
-        TIntrusiveList<TPage> MoveTouch(TPage *page, ECacheTier targetTier) Y_WARN_UNUSED_RESULT {
-            ECacheTier sourceTier = TPageTraits::GetTier(page);
-            Y_ENSURE(targetTier != ECacheTier::None);
-
-            if (sourceTier != ECacheTier::None && sourceTier != targetTier) {
-                CacheTiers[static_cast<size_t>(sourceTier)].Erase(page);
-            }
-
-            return CacheTiers[static_cast<size_t>(targetTier)].Touch(page);
-        }
-
         void Erase(TPage *page) {
             ECacheTier tier = TPageTraits::GetTier(page);
-            if (tier == ECacheTier::None) {
-                return;
-            }
-
             CacheTiers[static_cast<size_t>(tier)].Erase(page);
         }
 
@@ -184,22 +71,22 @@ namespace NKikimr::NSharedCache {
             TStringBuilder result;
             bool first = true;
 
-            for (const auto& cacheTier : CacheTiers) {
+            for (size_t i = 0; i < CacheTiers.size(); ++i) {
                 if (first) {
                     first = false;
                 } else {
                     result << "; ";
                 }
-                result << cacheTier.Dump();
+                result << static_cast<ECacheTier>(i) << "Tier: " << CacheTiers[i].Dump();
             }
 
             return result;
         }
 
     private:
-        TVector<TCacheTier> CacheTiers;
-        TCacheTier* RegularTier;
-        TCacheTier* TryInMemoryTier;
+        TVector<TCache> CacheTiers;
+        TCache* RegularTier;
+        TCache* TryInMemoryTier;
     };
 
 } // namespace NKikimr::NSharedCache