Update access time map during DRAM evict of NVM clean item

Summary: Update the AccessTimeMap when we evict an nvm clean item which doesn't have to be rewritten to flash. This is done so that we preserve the last accessed timestamp of the item while not having to rewrite it to flash.

Reviewed By: rlyerly

Differential Revision: D96002667

fbshipit-source-id: 568b903c5c3839850de275bf9a2bf2f75ab5b05d

Author: pbhandar2

cachelib/allocator/CacheAllocator.h

@@ -3951,6 +3951,14 @@ CacheAllocator<CacheTrait>::getNextCandidate(PoolId pid,
   } else {
     recordEvent(AllocatorApiEvent::DRAM_EVICT, candidate->getKey(),
                 AllocatorApiResult::EVICTED, candidate);
+    // When this item has an unmodified copy still present in BlockCache
+    // (large items only), record its latest DRAM access time in the Access
+    // Time Map as the value in the copy in BlockCache can be stale.
+    if (nvmCache_ && candidate->isNvmClean() && !candidate->isNvmEvicted() &&
+        candidate->isNvmLargeItem()) {
+      HashedKey hk{candidate->getKey()};
+      nvmCache_->updateAccessTime(hk, candidate->getLastAccessTime());
+    }
   }
   return {candidate, toRecycle};
 }

cachelib/allocator/nvmcache/NvmCache.h

@@ -304,6 +304,12 @@ class NvmCache {
   // and the item is present in NVM (NvmClean set and NvmEvicted flag unset).
   void markNvmItemRemovedLocked(HashedKey hk);
 
+  void updateAccessTime(HashedKey hk, uint32_t accessTimeSecs) {
+    if (accessTimeMap_) {
+      accessTimeMap_->set(hk.keyHash(), accessTimeSecs);
+    }
+  }
+
  private:
   // Helper function to record event with NvmItem metadata
   // @param event    The allocator API event type

cachelib/allocator/nvmcache/tests/NvmCacheTests.cpp

@@ -3014,6 +3014,89 @@ TEST_F(NvmCacheTest, NvmLargeItemFlagOnPromotion) {
   EXPECT_FALSE(testNvmLargeItemFlag("bh", 50, 'S'));
 }
 
+TEST_F(NvmCacheTest, AccessTimeMapPopulatedOnDramEviction) {
+  const int nKeys = 5;
+  const uint32_t allocSize = 15 * 1024;
+
+  insertPromoteAndEvictNvmCleanItems("atm_multi", allocSize, nKeys, allocSize);
+
+  // ATM should now have entries for the NvmClean items that were evicted
+  // from DRAM (BlockCache items only).
+  auto* atm = this->getAccessTimeMap();
+  auto now = util::getCurrentTimeSec();
+  int populated = 0;
+  for (int i = 0; i < nKeys; i++) {
+    auto key = folly::sformat("atm_multi_{}", i);
+    HashedKey hk{key};
+    auto ts = atm->get(hk.keyHash());
+    if (ts != std::nullopt) {
+      EXPECT_GT(*ts, 0);
+      EXPECT_LE(*ts, now);
+      ++populated;
+    }
+  }
+  EXPECT_GT(populated, 0);
+}
+
+TEST_F(NvmCacheTest, AccessTimeMapNotUpdatedForBigHashItems) {
+  // Enable truncation so small items route to BigHash instead of BlockCache.
+  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};
+  this->makeCache();
+
+  const int nKeys = 5;
+  const uint32_t allocSize = 50;
+  const uint32_t fillerSize = 15 * 1024;
+
+  insertPromoteAndEvictNvmCleanItems("bh", allocSize, nKeys, fillerSize);
+
+  // ATM should NOT have entries for the BigHash items — the isNvmLargeItem()
+  // bit is not set for BigHash items, preventing updateAccessTime().
+  auto* atm = this->getAccessTimeMap();
+  for (int i = 0; i < nKeys; i++) {
+    auto key = folly::sformat("bh_{}", i);
+    HashedKey hk{key};
+    auto ts = atm->get(hk.keyHash());
+    EXPECT_EQ(std::nullopt, ts)
+        << "BigHash item " << key << " should not be in ATM";
+  }
+}
+
+TEST_F(NvmCacheTest, AccessTimeMapNotUpdatedOnRegularEviction) {
+  auto& nvm = this->cache();
+  auto pid = this->poolId();
+  const uint32_t allocSize = 15 * 1024;
+  const uint32_t numKeysPerRegion =
+      config_.blockCache().getRegionSize() / allocSize;
+
+  auto* atm = this->getAccessTimeMap();
+  ASSERT_NE(nullptr, atm);
+  EXPECT_EQ(0, atm->size());
+
+  // Insert many fresh items (never been to NVM, so NOT NvmClean).
+  // Evictions of these items go through the NVM put path, not
+  // the updateAccessTime path.
+  for (int i = 0; i < 1024; i++) {
+    auto key = folly::sformat("regular_{}", i);
+    auto it = nvm.allocate(pid, key, allocSize);
+    ASSERT_NE(nullptr, it);
+    cache_->insertOrReplace(it);
+    if (i % numKeysPerRegion == 0) {
+      nvm.flushNvmCache();
+    }
+  }
+  nvm.flushNvmCache();
+  ASSERT_GT(this->evictionCount(), 0);
+
+  // Non-NvmClean evictions should NOT populate the AccessTimeMap.
+  EXPECT_EQ(0, atm->size());
+}
 } // namespace tests
 } // namespace cachelib
 } // namespace facebook

cachelib/allocator/nvmcache/tests/NvmTestBase.h

@@ -19,6 +19,7 @@
 #include <gtest/gtest.h>
 
 #include "cachelib/allocator/CacheAllocator.h"
+#include "cachelib/allocator/nvmcache/AccessTimeMap.h"
 #include "cachelib/allocator/nvmcache/NavyConfig.h"
 #include "cachelib/common/Utils.h"
 
@@ -132,6 +133,64 @@ class NvmCacheTest : public testing::Test {
     return cache_ ? cache_->nvmCache_.get() : nullptr;
   }
 
+  AccessTimeMap* getAccessTimeMap() {
+    auto* nvm = getNvmCache();
+    return nvm ? nvm->accessTimeMap_.get() : nullptr;
+  }
+
+  // Helper: insert items, push to NVM, remove from RAM, promote (verify
+  // NvmClean), then evict from DRAM by inserting fillers. Used by ATM tests
+  // that share this common setup/eviction flow. Caller handles any non-default
+  // cache setup beforehand and final ATM assertions afterward.
+  void insertPromoteAndEvictNvmCleanItems(const std::string& keyPrefix,
+                                          uint32_t itemAllocSize,
+                                          int nKeys,
+                                          uint32_t fillerAllocSize) {
+    auto& nvm = cache();
+    auto pid = poolId();
+
+    for (int i = 0; i < nKeys; i++) {
+      auto key = folly::sformat("{}_{}", keyPrefix, i);
+      auto it = nvm.allocate(pid, key, itemAllocSize);
+      ASSERT_NE(nullptr, it);
+      nvm.insertOrReplace(it);
+      ASSERT_TRUE(pushToNvmCacheFromRamForTesting(key));
+    }
+    nvm.flushNvmCache();
+
+    for (int i = 0; i < nKeys; i++) {
+      removeFromRamForTesting(folly::sformat("{}_{}", keyPrefix, i));
+    }
+
+    auto* atm = getAccessTimeMap();
+    ASSERT_NE(nullptr, atm);
+    EXPECT_EQ(0, atm->size());
+
+    for (int i = 0; i < nKeys; i++) {
+      auto key = folly::sformat("{}_{}", keyPrefix, i);
+      auto hdl = fetch(key, false /* ramOnly */);
+      ASSERT_NE(nullptr, hdl);
+      ASSERT_TRUE(hdl->isNvmClean());
+    }
+
+    EXPECT_EQ(0, atm->size());
+
+    const uint32_t numKeysPerRegion =
+        config_.blockCache().getRegionSize() / fillerAllocSize;
+    auto evictBefore = evictionCount();
+    for (int i = 0; i < 1024; i++) {
+      auto key = folly::sformat("filler_{}", i);
+      auto it = nvm.allocate(pid, key, fillerAllocSize);
+      ASSERT_NE(nullptr, it);
+      cache_->insertOrReplace(it);
+      if (i % numKeysPerRegion == 0) {
+        nvm.flushNvmCache();
+      }
+    }
+    nvm.flushNvmCache();
+    ASSERT_GT(evictionCount(), evictBefore);
+  }
+
   std::unique_ptr<NvmItem> makeNvmItem(const Item& item) {
     return getNvmCache()->makeNvmItem(item);
   }