Tightened entry count estimation for Bucket cache

Author: SirTyson

src/bucket/BucketManager.cpp

@@ -1291,8 +1291,7 @@ BucketManager::assumeState(HistoryArchiveState const& has,
         mLiveBucketList->getLevel(i).setNext(nextFuture);
     }
 
-    mLiveBucketList->maybeInitializeCaches(
-        mConfig.maxAccountsInBucketListCache());
+    mLiveBucketList->maybeInitializeCaches(mConfig);
 
     if (restartMerges)
     {

src/bucket/LiveBucket.cpp

@@ -308,6 +308,17 @@ LiveBucket::apply(Application& app) const
     }
     counters.logInfo("direct", 0, app.getClock().now());
 }
+
+size_t
+LiveBucket::getMaxCacheSize() const
+{
+    if (!isEmpty())
+    {
+        return getIndex().getMaxCacheSize();
+    }
+
+    return 0;
+}
 #endif // BUILD_TESTS
 
 std::optional<std::pair<std::streamoff, std::streamoff>>
@@ -432,12 +443,11 @@ LiveBucket::getBucketVersion() const
 }
 
 void
-LiveBucket::maybeInitializeCache(size_t bucketListTotalAccounts,
-                                 size_t maxBucketListAccountsToCache) const
+LiveBucket::maybeInitializeCache(size_t totalBucketListAccountsSizeBytes,
+                                 Config const& cfg) const
 {
     releaseAssert(mIndex);
-    mIndex->maybeInitializeCache(bucketListTotalAccounts,
-                                 maxBucketListAccountsToCache);
+    mIndex->maybeInitializeCache(totalBucketListAccountsSizeBytes, cfg);
 }
 
 BucketEntryCounters const&

src/bucket/LiveBucket.h

@@ -83,6 +83,7 @@ class LiveBucket : public BucketBase<LiveBucket, LiveBucketIndex>,
     // entry in the database (respectively; if the entry is dead (a
     // tombstone), deletes the corresponding entry in the database.
     void apply(Application& app) const;
+    size_t getMaxCacheSize() const;
 #endif
 
     // Returns [lowerBound, upperBound) of file offsets for all offers in the
@@ -120,8 +121,12 @@ class LiveBucket : public BucketBase<LiveBucket, LiveBucketIndex>,
 
     uint32_t getBucketVersion() const;
 
-    void maybeInitializeCache(size_t bucketListTotalAccounts,
-                              size_t maxBucketListAccountsToCache) const;
+    // Initializes the random eviction cache if it has not already been
+    // initialized. totalBucketListAccountsSizeBytes is the total size, in
+    // bytes, of all BucketEntries in the BucketList that hold ACCOUNT entries,
+    // including INIT, LIVE and DEAD entries.
+    void maybeInitializeCache(size_t totalBucketListAccountsSizeBytes,
+                              Config const& cfg) const;
 
     BucketEntryCounters const& getBucketEntryCounters() const;
 

src/bucket/LiveBucketIndex.cpp

@@ -82,8 +82,8 @@ LiveBucketIndex::LiveBucketIndex(BucketManager const& bm, Archive& ar,
 }
 
 void
-LiveBucketIndex::maybeInitializeCache(size_t bucketListTotalAccounts,
-                                      size_t maxBucketListAccountsToCache) const
+LiveBucketIndex::maybeInitializeCache(size_t totalBucketListAccountsSizeBytes,
+                                      Config const& cfg) const
 {
     // Everything is already in memory, no need for a redundant cache.
     if (mInMemoryIndex)
@@ -109,19 +109,46 @@ LiveBucketIndex::maybeInitializeCache(size_t bucketListTotalAccounts,
         return;
     }
 
+    // Convert from MB to bytes, max size for entire BucketList cache
+    auto maxBucketListBytesToCache =
+        cfg.BUCKETLIST_DB_MEMORY_FOR_CACHING * 1024 * 1024;
+
     std::unique_lock<std::shared_mutex> lock(mCacheMutex);
-    if (bucketListTotalAccounts < maxBucketListAccountsToCache)
+    if (totalBucketListAccountsSizeBytes < maxBucketListBytesToCache)
     {
         // We can cache the entire bucket
-        mCache = std::make_unique<CacheT>(bucketListTotalAccounts);
+        mCache = std::make_unique<CacheT>(accountsInThisBucket);
     }
     else
     {
-        double percentAccountsInBucket =
-            static_cast<double>(accountsInThisBucket) / bucketListTotalAccounts;
-        auto cacheSize = static_cast<size_t>(bucketListTotalAccounts *
-                                             percentAccountsInBucket);
-        mCache = std::make_unique<CacheT>(cacheSize);
+        // The random eviction cache has an entry limit, but we expose a memory
+        // limit in the validator config. We can't do an exact 1 to 1 mapping
+        // because account entries have different sizes.
+        //
+        // First we take the fraction of the total BucketList size that this
+        // bucket occupies to figure out how much memory to allocate. Then we
+        // use the average account size to convert that to an entry count for
+        // the cache.
+
+        auto accountBytesInThisBucket =
+            mDiskIndex->getBucketEntryCounters().entryTypeSizes.at(
+                LedgerEntryTypeAndDurability::ACCOUNT);
+
+        double fractionOfTotalBucketListBytes =
+            static_cast<double>(accountBytesInThisBucket) /
+            totalBucketListAccountsSizeBytes;
+
+        size_t bytesAvailableForBucketCache = static_cast<size_t>(
+            maxBucketListBytesToCache * fractionOfTotalBucketListBytes);
+
+        double averageAccountSize =
+            static_cast<double>(accountBytesInThisBucket) /
+            accountsInThisBucket;
+
+        auto accountsToCache = static_cast<size_t>(
+            bytesAvailableForBucketCache / averageAccountSize);
+
+        mCache = std::make_unique<CacheT>(accountsToCache);
     }
 }
 
@@ -360,6 +387,18 @@ LiveBucketIndex::operator==(LiveBucketIndex const& in) const
 
     return true;
 }
+
+size_t
+LiveBucketIndex::getMaxCacheSize() const
+{
+    if (shouldUseCache())
+    {
+        std::shared_lock<std::shared_mutex> lock(mCacheMutex);
+        return mCache->maxSize();
+    }
+
+    return 0;
+}
 #endif
 
 template LiveBucketIndex::LiveBucketIndex(BucketManager const& bm,

src/bucket/LiveBucketIndex.h

@@ -113,8 +113,12 @@ class LiveBucketIndex : public NonMovableOrCopyable
     // expose a memory limit in the validator config. To account for this, we
     // check what percentage of the total number of accounts are in this bucket
     // and allocate space accordingly.
-    void maybeInitializeCache(size_t bucketListTotalAccounts,
-                              size_t maxBucketListAccountsToCache) const;
+    //
+    // bucketListTotalAccountSizeBytes is the total size, in bytes, of all
+    // BucketEntries in the BucketList that hold ACCOUNT entries, including
+    // INIT, LIVE and DEAD entries.
+    void maybeInitializeCache(size_t bucketListTotalAccountSizeBytes,
+                              Config const& cfg) const;
 
     // Returns true if LedgerEntryType not supported by BucketListDB
     static bool typeNotSupported(LedgerEntryType t);
@@ -142,8 +146,7 @@ class LiveBucketIndex : public NonMovableOrCopyable
     void markBloomMiss() const;
 #ifdef BUILD_TESTS
     bool operator==(LiveBucketIndex const& in) const;
-
-    void clearCache() const;
+    size_t getMaxCacheSize() const;
 #endif
 };
 }

src/bucket/LiveBucketList.cpp

@@ -23,7 +23,7 @@ LiveBucketList::addBatch(Application& app, uint32_t currLedger,
                      liveEntries, deadEntries);
 
     // Initialize caches for any new buckets we might have added
-    maybeInitializeCaches(app.getConfig().maxAccountsInBucketListCache());
+    maybeInitializeCaches(app.getConfig());
 }
 
 BucketEntryCounters
@@ -34,7 +34,7 @@ LiveBucketList::sumBucketEntryCounters() const
     {
         for (auto const& b : {lev.getCurr(), lev.getSnap()})
         {
-            if (b->isIndexed())
+            if (!b->isEmpty())
             {
                 auto c = b->getBucketEntryCounters();
                 counters += c;
@@ -45,25 +45,24 @@ LiveBucketList::sumBucketEntryCounters() const
 }
 
 void
-LiveBucketList::maybeInitializeCaches(size_t maxBucketListAccountsToCache) const
+LiveBucketList::maybeInitializeCaches(Config const& cfg) const
 {
     auto blCounters = sumBucketEntryCounters();
-    size_t totalAccounts =
-        blCounters.entryTypeCounts.at(LedgerEntryTypeAndDurability::ACCOUNT);
+    size_t totalAccountsSize =
+        blCounters.entryTypeSizes.at(LedgerEntryTypeAndDurability::ACCOUNT);
+
     for (uint32_t i = 0; i < kNumLevels; ++i)
     {
         auto curr = mLevels[i].getCurr();
         if (!curr->isEmpty())
         {
-            curr->maybeInitializeCache(totalAccounts,
-                                       maxBucketListAccountsToCache);
+            curr->maybeInitializeCache(totalAccountsSize, cfg);
         }
 
         auto snap = mLevels[i].getSnap();
         if (!snap->isEmpty())
         {
-            snap->maybeInitializeCache(totalAccounts,
-                                       maxBucketListAccountsToCache);
+            snap->maybeInitializeCache(totalAccountsSize, cfg);
         }
     }
 }

src/bucket/LiveBucketList.h

@@ -53,7 +53,7 @@ class LiveBucketList : public BucketListBase<LiveBucket>
 
     // Initializes any uninitialized caches in the BucketIndex. Should be called
     // after every time buckets may have changed in the LiveBucketList.
-    void maybeInitializeCaches(size_t maxBucketListAccountsToCache) const;
+    void maybeInitializeCaches(Config const& cfg) const;
 };
 
 }