Get cache size from leveldb for mutable cache (#1215)

Old approach with evaluating cache size is quite inefficient and causes
slowdowns for the users. Instead evaluating initial cache size with a
leveldb routine GetApproximateSize(). Performance improvement here is
open now up to x200-x300 times faster. Broken cache size could be also
checked without any memory consumption spikes.

Relates-To: OLPSUP-14421
Signed-off-by: Andrey Kashcheev <[email protected]>

Author: andrey-kashcheev

olp-cpp-sdk-core/src/cache/DefaultCacheImpl.cpp

@@ -501,16 +501,15 @@ void DefaultCacheImpl::InitializeLru() {
   if (!mutable_cache_) {
     return;
   }
+
+  OLP_SDK_LOG_INFO_F(kLogTag, "Initializing mutable LRU cache");
+
   mutable_cache_data_size_ = 0;
-  if (mutable_cache_ && settings_.max_disk_storage != kMaxDiskSize &&
-      settings_.eviction_policy == EvictionPolicy::kLeastRecentlyUsed) {
-    mutable_cache_lru_ =
-        std::make_unique<DiskLruCache>(settings_.max_disk_storage);
-    OLP_SDK_LOG_INFO_F(kLogTag, "Initializing mutable lru cache.");
-  }
+
+  mutable_cache_lru_ =
+      std::make_unique<DiskLruCache>(settings_.max_disk_storage);
 
   const auto start = std::chrono::steady_clock::now();
-  auto count = 0u;
   auto it = mutable_cache_->NewIterator(leveldb::ReadOptions());
 
   for (it->SeekToFirst(); it->Valid(); it->Next()) {
@@ -519,14 +518,13 @@ void DefaultCacheImpl::InitializeLru() {
 
     // Here we count both expiry keys and regular keys
     mutable_cache_data_size_ += key.size() + value.size();
-    if (AddKeyLru(key, value)) {
-      ++count;
-    }
+
+    AddKeyLru(key, value);
   }
 
   OLP_SDK_LOG_INFO_F(
-      kLogTag, "Cache initialized, items=%" PRIu32 ", time=%" PRId64 " ms",
-      count, GetElapsedTime(start));
+      kLogTag, "LRU cache initialized, items=%zu, time=%" PRId64 " ms",
+      mutable_cache_lru_->Size(), GetElapsedTime(start));
 }
 
 bool DefaultCacheImpl::RemoveKeyLru(const std::string& key) {
@@ -870,7 +868,12 @@ DefaultCache::StorageOpenResult DefaultCacheImpl::SetupMutableCache() {
     }
   }
 
-  InitializeLru();
+  if (settings_.max_disk_storage != kMaxDiskSize &&
+      settings_.eviction_policy == EvictionPolicy::kLeastRecentlyUsed) {
+    InitializeLru();
+  } else {
+    mutable_cache_data_size_ = mutable_cache_->Size();
+  }
 
   return DefaultCache::Success;
 }

olp-cpp-sdk-core/tests/cache/DefaultCacheImplTest.cpp

@@ -34,13 +34,27 @@ namespace cache = olp::cache;
 using CacheType = cache::DefaultCache::CacheType;
 
 class DefaultCacheImplTest : public ::testing::Test {
+ public:
   void SetUp() override {
-    // Restore permisions in case if cache_path_ is not writable
+    // Restore permissions in case if cache_path_ is not writable
     helpers::MakeDirectoryContentReadonly(cache_path_, false);
   }
 
   void TearDown() override { olp::utils::Dir::Remove(cache_path_); }
 
+  uint64_t GetCacheSizeOnDisk() {
+    const std::string ldb_ext = ".ldb";
+    return olp::utils::Dir::Size(cache_path_, [&](const std::string& path) {
+      // Taking into account only ldb files.
+      // Other files: lock, logs, manifest are quite small (~100KB on >1GB db)
+      // but on a compacted cache they could take more than a few megabytes
+      if (path.length() <= ldb_ext.length()) {
+        return false;
+      }
+      return path.substr(path.length() - ldb_ext.length()) == ldb_ext;
+    });
+  }
+
  protected:
   const std::string cache_path_ =
       olp::utils::Dir::TempDirectory() + "/unittest";
@@ -570,12 +584,11 @@ TEST_F(DefaultCacheImplTest, MutableCacheSize) {
 
     cache.Put(key, data_string, [=]() { return data_string; },
               (std::numeric_limits<time_t>::max)());
-    const auto data_size = key.size() + data_string.size();
     cache.Close();
     EXPECT_EQ(0u, cache.Size(CacheType::kMutable));
 
     cache.Open();
-    EXPECT_EQ(data_size, cache.Size(CacheType::kMutable));
+    EXPECT_EQ(GetCacheSizeOnDisk(), cache.Size(CacheType::kMutable));
 
     cache.Clear();
     EXPECT_EQ(0u, cache.Size(CacheType::kMutable));
@@ -1283,16 +1296,7 @@ TEST_F(DefaultCacheImplTest, ProtectedCacheSize) {
     settings.disk_path_mutable = boost::none;
   }
 
-  const std::string ldb_ext = ".ldb";
-  const uint64_t actual_size_on_disk =
-      olp::utils::Dir::Size(cache_path_, [&](const std::string& path) {
-        // Taking into account only ldb files.
-        // Other files: lock, logs, manifest are quite small (~100KB on >1GB db)
-        if (path.length() <= ldb_ext.length()) {
-          return false;
-        }
-        return path.substr(path.length() - ldb_ext.length()) == ldb_ext;
-      });
+  const uint64_t actual_size_on_disk = GetCacheSizeOnDisk();
   ASSERT_NE(actual_size_on_disk, 0);
 
   settings.disk_path_protected = cache_path_;