Introduce a common Shared Cache cache interface (#8590)

Author: kunga

ydb/core/tablet_flat/shared_sausagecache.cpp

@@ -38,6 +38,8 @@ TSharedPageCacheCounters::TSharedPageCacheCounters(const TIntrusivePtr<::NMonito
 namespace NKikimr {
 namespace NTabletFlatExecutor {
 
+using namespace NCache;
+
 static bool Satisfies(NLog::EPriority priority = NLog::PRI_DEBUG) {
     if (NLog::TSettings *settings = TlsActivationContext->LoggerSettings())
         return settings->Satisfies(priority, NKikimrServices::TABLET_SAUSAGECACHE);
@@ -68,7 +70,6 @@ class TSharedPageCache : public TActorBootstrapped<TSharedPageCache> {
     {
         ui32 State : 4;
         ui32 CacheGeneration : 3;
-        ui32 InMemory : 1;
 
         const ui32 PageId;
         const size_t Size;
@@ -78,7 +79,6 @@ class TSharedPageCache : public TActorBootstrapped<TSharedPageCache> {
         TPage(ui32 pageId, size_t size, TCollection* collection)
             : State(PageStateNo)
             , CacheGeneration(TCacheCacheConfig::CacheGenNone)
-            , InMemory(false)
             , PageId(pageId)
             , Size(size)
             , Collection(collection)
@@ -178,7 +178,7 @@ class TSharedPageCache : public TActorBootstrapped<TSharedPageCache> {
     TRequestQueue ScanRequests;
 
     THolder<TSharedPageCacheConfig> Config;
-    TCacheCache<TPage, TPage::TWeight, TCacheCacheConfig::TDefaultGeneration<TPage>> Cache;
+    THolder<ICacheCache<TPage>> Cache;
 
     ui64 StatBioReqs = 0;
     ui64 StatHitPages = 0;
@@ -193,14 +193,18 @@ class TSharedPageCache : public TActorBootstrapped<TSharedPageCache> {
 
     ui64 MemLimitBytes;
 
+    void CreateCache() {
+        TCacheCacheConfig cacheCacheConfig(1, Config->Counters->FreshBytes, Config->Counters->StagingBytes, Config->Counters->WarmBytes);
+        Cache = MakeHolder<TCacheCache<TPage, TPage::TWeight, TCacheCacheConfig::TDefaultGeneration<TPage>>>(std::move(cacheCacheConfig));
+    }
+
     void ActualizeCacheSizeLimit() {
         ui64 limitBytes = Min(Config->LimitBytes.value_or(Max<ui64>()), MemLimitBytes);
 
         // limit of cache depends only on config and mem because passive pages may go in and out arbitrary
         // we may have some passive bytes, so if we fully fill this Cache we may exceed the limit
         // because of that DoGC should be called to ensure limits
-        // unlimited cache is banned
-        Cache.UpdateCacheSize(Max<ui64>(1, limitBytes));
+        Cache->UpdateCacheSize(limitBytes);
 
         if (Config->Counters) {
             Config->Counters->ConfigLimitBytes->Set(Config->LimitBytes.value_or(0));
@@ -219,7 +223,7 @@ class TSharedPageCache : public TActorBootstrapped<TSharedPageCache> {
         THashSet<TCollection*> recheck;
         while (GetStatAllBytes() > MemLimitBytes
                 || GetStatAllBytes() > Config->LimitBytes.value_or(Max<ui64>()) && StatActiveBytes > configActiveReservedBytes) {
-            auto page = Cache.EvictNext();
+            auto page = Cache->EvictNext();
             if (!page) {
                 break;
             }
@@ -366,7 +370,7 @@ class TSharedPageCache : public TActorBootstrapped<TSharedPageCache> {
                     ++*Config->Counters->CacheHitPages;
                     *Config->Counters->CacheHitBytes += page->Size;
                 }
-                Evict(Cache.Touch(page));
+                Evict(Cache->Touch(page));
                 break;
             case PageStateNo:
                 ++pagesToLoad;
@@ -648,7 +652,7 @@ class TSharedPageCache : public TActorBootstrapped<TSharedPageCache> {
                     AddActivePage(page);
                     [[fallthrough]];
                 case PageStateLoaded:
-                    Evict(Cache.Touch(page));
+                    Evict(Cache->Touch(page));
                     break;
                 default:
                     Y_ABORT("unknown load state");
@@ -749,7 +753,7 @@ class TSharedPageCache : public TActorBootstrapped<TSharedPageCache> {
 
                 page->Initialize(std::move(paged.Data));
                 BodyProvided(collection, paged.PageId, page);
-                Evict(Cache.Touch(page));
+                Evict(Cache->Touch(page));
             }
         }
 
@@ -882,7 +886,7 @@ class TSharedPageCache : public TActorBootstrapped<TSharedPageCache> {
         const TLogoBlobID &pageCollectionId = collectionIt->first;
 
         if (auto logl = Logger->Log(ELnLev::Debug))
-            logl << "droping pageCollection " << pageCollectionId;
+            logl << "dropping pageCollection " << pageCollectionId;
 
         for (auto &expe : collection.Expectants) {
             for (auto &xpair : expe.second.SourceRequests) {
@@ -901,7 +905,7 @@ class TSharedPageCache : public TActorBootstrapped<TSharedPageCache> {
         for (const auto &kv : collection.PageMap) {
             auto* page = kv.second.Get();
 
-            Cache.Evict(page);
+            Cache->Erase(page);
             page->CacheGeneration = TCacheCacheConfig::CacheGenNone;
 
             if (page->State == PageStateLoaded) {
@@ -1099,8 +1103,8 @@ class TSharedPageCache : public TActorBootstrapped<TSharedPageCache> {
 public:
     TSharedPageCache(THolder<TSharedPageCacheConfig> config)
         : Config(std::move(config))
-        , Cache(TCacheCacheConfig(1, Config->Counters->FreshBytes, Config->Counters->StagingBytes, Config->Counters->WarmBytes))
     {
+        CreateCache();
         AsyncRequests.Limit = Config->TotalAsyncQueueInFlyLimit;
         ScanRequests.Limit = Config->TotalScanQueueInFlyLimit;
     }

ydb/core/util/cache_cache.h

@@ -1,12 +1,13 @@
 #pragma once
 #include "defs.h"
+#include <ydb/core/util/cache_cache_iface.h>
 #include <ydb/core/util/queue_oneone_inplace.h>
 #include <library/cpp/monlib/counters/counters.h>
 #include <library/cpp/monlib/dynamic_counters/counters.h>
 #include <util/generic/ptr.h>
 #include <util/generic/intrlist.h>
 
-namespace NKikimr {
+namespace NKikimr::NCache {
 
 struct TCacheCacheConfig : public TAtomicRefCount<TCacheCacheConfig> {
     using TCounterPtr = ::NMonitoring::TDynamicCounters::TCounterPtr;
@@ -71,7 +72,7 @@ template <typename TItem
         , typename TWeight = TCacheCacheConfig::TDefaultWeight<TItem>
         , typename TGeneration = TCacheCacheConfig::TDefaultGeneration<TItem>
     >
-class TCacheCache {
+class TCacheCache : public ICacheCache<TItem> {
 public:
     TCacheCache(const TCacheCacheConfig &config)
         : Config(config)
@@ -80,7 +81,7 @@ class TCacheCache {
         , WarmWeight(0)
     {}
 
-    TItem* EvictNext() {
+    TItem* EvictNext() override {
         TItem* ret = nullptr;
 
         if (!StagingList.Empty()) {
@@ -101,7 +102,7 @@ class TCacheCache {
     }
 
     // returns evicted elements as list
-    TIntrusiveList<TItem> Touch(TItem *item) {
+    TIntrusiveList<TItem> Touch(TItem *item) override {
         TIntrusiveList<TItem> evictedList;
         TIntrusiveListItem<TItem> *xitem = item;
 
@@ -130,8 +131,7 @@ class TCacheCache {
         return evictedList;
     }
 
-    // evict and erase differs on Evicted handling
-    void Evict(TItem *item) {
+    void Erase(TItem *item) override {
         const TCacheCacheConfig::ECacheGeneration cacheGen = GenerationOp.Get(item);
         switch (cacheGen) {
         case TCacheCacheConfig::CacheGenNone:
@@ -153,43 +153,11 @@ class TCacheCache {
                 *Config.ReportedWarm = WarmWeight;
             break;
         default:
-            Y_DEBUG_ABORT("unknown cache generaton");
+            Y_DEBUG_ABORT("unknown cache generation");
         }
     }
 
-    void Erase(TItem *item) {
-        const TCacheCacheConfig::ECacheGeneration cacheGen = GenerationOp.Get(item);
-        switch (cacheGen) {
-        case TCacheCacheConfig::CacheGenNone:
-            break;
-        case TCacheCacheConfig::CacheGenEvicted:
-            item->Unlink();
-            GenerationOp.Set(item, TCacheCacheConfig::CacheGenNone);
-            break;
-        case TCacheCacheConfig::CacheGenFresh:
-            Unlink(item, FreshWeight);
-            if (Config.ReportedFresh)
-                *Config.ReportedFresh = FreshWeight;
-            break;
-        case TCacheCacheConfig::CacheGenStaging:
-            Unlink(item, StagingWeight);
-            if (Config.ReportedStaging)
-                *Config.ReportedStaging = StagingWeight;
-            break;
-        case TCacheCacheConfig::CacheGenWarm:
-            Unlink(item, WarmWeight);
-            if (Config.ReportedWarm)
-                *Config.ReportedWarm = WarmWeight;
-            break;
-        default:
-            Y_DEBUG_ABORT("unknown cache generaton");
-        }
-    }
-
-    void UpdateCacheSize(ui64 cacheSize) {
-        if (cacheSize == 0)
-            cacheSize = Max<ui64>();
-
+    void UpdateCacheSize(ui64 cacheSize) override {
         Config.SetLimit(cacheSize);
     }
 

ydb/core/util/cache_cache_iface.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "defs.h"
+
+namespace NKikimr::NCache {
+
+template <typename TItem>
+struct ICacheCache {
+    virtual TItem* EvictNext() Y_WARN_UNUSED_RESULT = 0;
+
+    // returns evicted elements as list
+    virtual TIntrusiveList<TItem> Touch(TItem *item) Y_WARN_UNUSED_RESULT = 0;
+
+    virtual void Erase(TItem *item) = 0;
+
+    // WARN: do not evict items
+    virtual void UpdateCacheSize(ui64 cacheSize) = 0;
+
+    virtual ~ICacheCache() = default;
+};
+
+}

ydb/core/util/cache_cache_ut.cpp

@@ -1,7 +1,7 @@
 #include "cache_cache.h"
 #include <library/cpp/testing/unittest/registar.h>
 
-namespace NKikimr {
+namespace NKikimr::NCache {
 
 Y_UNIT_TEST_SUITE(TCacheCacheTest) {