use a bit in CacheItem to indicate if it is a large item

Summary:
During NVM promotion in NvmCache::createItem(), we set the kNvmLargeItem flag on the DRAM item to track whether its NVM copy lives in BlockCache or BigHash. This flag is later used at DRAM eviction time (e.g., to populate the AccessTimeMap for BlockCache items).

The size check that determines this — smallItemMaxSize_ == 0 || key.size() + nvmItem.totalSize() > smallItemMaxSize_ — was duplicated in both branches of createItem() (the makeObjCb path and the standard memcpy path). This duplicates the routing logic from EnginePair::isItemLarge() and is easy to get out of sync if the threshold semantics ever change.

Extract the check into a private isNvmItemLarge(key, nvmItem) helper with a comment explaining how it mirrors the Navy-side routing: EnginePair::isItemLarge() compares key.size() + value.size() against smallItemMaxSize_, and since the put() path passes toIOBuf(nvmItem) to Navy, value.size() == nvmItem.totalSize().

Reviewed By: rlyerly

Differential Revision: D98267676

fbshipit-source-id: f54d9a35d9fbff5a30807f6bea4991beab1bac6e

Author: pbhandar2

cachelib/allocator/CacheItem.h

@@ -252,6 +252,13 @@ class CACHELIB_PACKED_ATTR CacheItem {
   void unmarkNvmEvicted() noexcept;
   bool isNvmEvicted() const noexcept;
 
+  /**
+   * Track whether the item was routed to BlockCache (large item) in NVM.
+   * Set during NVM promotion when the exact NVM buffer size is known.
+   */
+  void markNvmLargeItem() noexcept;
+  bool isNvmLargeItem() const noexcept;
+
   /**
    * Function to set the timestamp for when to expire an item
    *
@@ -735,13 +742,14 @@ std::string CacheItem<CacheTrait>::toString() const {
         "isInMMContainer={}:isAccessible={}:isMarkedForEviction={}:"
         "isMoving={}:references={}:ctime="
         "{}:"
-        "expTime={}:updateTime={}:isNvmClean={}:isNvmEvicted={}:hasChainedItem="
+        "expTime={}:updateTime={}:isNvmClean={}:isNvmEvicted={}:"
+        "isNvmLargeItem={}:hasChainedItem="
         "{}",
         this, getRefCountAndFlagsRaw(), getSize(),
         folly::humanify(getKey().str()), folly::hexlify(getKey()),
         isInMMContainer(), isAccessible(), isMarkedForEviction(), isMoving(),
         getRefCount(), getCreationTime(), getExpiryTime(), getLastAccessTime(),
-        isNvmClean(), isNvmEvicted(), hasChainedItem());
+        isNvmClean(), isNvmEvicted(), isNvmLargeItem(), hasChainedItem());
   }
 }
 
@@ -866,6 +874,16 @@ bool CacheItem<CacheTrait>::isNvmEvicted() const noexcept {
   return ref_.isNvmEvicted();
 }
 
+template <typename CacheTrait>
+void CacheItem<CacheTrait>::markNvmLargeItem() noexcept {
+  ref_.markNvmLargeItem();
+}
+
+template <typename CacheTrait>
+bool CacheItem<CacheTrait>::isNvmLargeItem() const noexcept {
+  return ref_.isNvmLargeItem();
+}
+
 template <typename CacheTrait>
 void CacheItem<CacheTrait>::markIsChainedItem() noexcept {
   XDCHECK(!hasChainedItem());

cachelib/allocator/Refcount.h

@@ -116,6 +116,10 @@ class FOLLY_PACK_ATTR RefcountWithFlags {
     // unevictable in the past.
     kUnevictable_NOOP,
 
+    // Item was routed to BlockCache (large item) in NVM.
+    // Set during NVM promotion when the exact NVM buffer size is known.
+    kNvmLargeItem,
+
     // Unused. This is just to indciate the maximum number of flags
     kFlagMax,
   };
@@ -422,6 +426,13 @@ class FOLLY_PACK_ATTR RefcountWithFlags {
   void unmarkNvmEvicted() noexcept { return unSetFlag<kNvmEvicted>(); }
   bool isNvmEvicted() const noexcept { return isFlagSet<kNvmEvicted>(); }
 
+  /**
+   * Track whether the item was routed to BlockCache (large item) in NVM.
+   * Set during NVM promotion when the exact NVM buffer size is known.
+   */
+  void markNvmLargeItem() noexcept { return setFlag<kNvmLargeItem>(); }
+  bool isNvmLargeItem() const noexcept { return isFlagSet<kNvmLargeItem>(); }
+
   // Whether or not an item is completely drained of access
   // Refcount is 0 and the item is not linked, accessible, nor exclusive
   bool isDrained() const noexcept { return getRefWithAccessAndAdmin() == 0; }

cachelib/allocator/nvmcache/NvmCache.h

@@ -1430,11 +1430,17 @@ typename NvmCache<C>::WriteHandle NvmCache<C>::createItem(
     // not visible to other threads).
     it.unmarkNascent();
     it->markNvmClean();
+    if (isNvmItemLarge(key, nvmItem)) {
+      it->markNvmLargeItem();
+    }
   } else {
     XDCHECK_LE(pBlob.data.size(), getStorageSizeInNvm(*it));
     XDCHECK_LE(pBlob.origAllocSize, pBlob.data.size());
     ::memcpy(it->getMemory(), pBlob.data.data(), pBlob.data.size());
     it->markNvmClean();
+    if (isNvmItemLarge(key, nvmItem)) {
+      it->markNvmLargeItem();
+    }
 
     // if we have more, then we need to allocate them as chained items and add
     // them in the same order. To do that, we need to add them from the inverse

cachelib/allocator/nvmcache/tests/NvmCacheTests.cpp

@@ -2978,6 +2978,42 @@ TEST_F(NvmCacheTest, NvmHitTTATracking) {
   // 6. Verify TTA was tracked (>= 1 second)
   EXPECT_GE(stats.nvmHitTTASecs.p50, 1);
 }
+TEST_F(NvmCacheTest, NvmLargeItemFlagOnPromotion) {
+  // Verify that the NvmLargeItem flag is set correctly on promotion:
+  // - Items routed to BlockCache (large) should have the flag set.
+  // - Items routed to BigHash (small) should NOT have the flag set.
+  this->config_.setSimpleFile(cacheDir_ + "/navy", 200 * 1024ULL * 1024ULL,
+                              true /* truncateFile */);
+  LruAllocator::NvmCacheConfig nvmConfig;
+  nvmConfig.navyConfig = this->config_;
+  nvmConfig.truncateItemToOriginalAllocSizeInNvm = true;
+  auto& config = this->getConfig();
+  config.enableNvmCache(nvmConfig);
+  this->poolAllocsizes_ = {20 * 1024};
+  auto& cache = this->makeCache();
+  auto pid = this->poolId();
+
+  auto testNvmLargeItemFlag = [&](const std::string& key, uint32_t valSize,
+                                  char fillChar) -> bool {
+    {
+      auto it = cache.allocate(pid, key, valSize);
+      EXPECT_NE(nullptr, it);
+      ::memset(it->getMemory(), fillChar, it->getSize());
+      cache.insertOrReplace(it);
+    }
+    EXPECT_TRUE(this->pushToNvmCacheFromRamForTesting(key));
+    cache.flushNvmCache();
+    this->removeFromRamForTesting(key);
+    auto hdl = this->fetch(key, false /* ramOnly */);
+    EXPECT_NE(nullptr, hdl);
+    EXPECT_TRUE(hdl->isNvmClean());
+    return hdl->isNvmLargeItem();
+  };
+
+  EXPECT_TRUE(testNvmLargeItemFlag("bc", 15 * 1024, 'L'));
+  EXPECT_FALSE(testNvmLargeItemFlag("bh", 50, 'S'));
+}
+
 } // namespace tests
 } // namespace cachelib
 } // namespace facebook