Add configuration to enable access time map

Summary: Add config to enable accessTimeMap in Navy config.

Reviewed By: byahn0996

Differential Revision: D94727548

fbshipit-source-id: a0eaace3f3899c77adab5278279ff25e55a99583

Author: pbhandar2

cachelib/allocator/nvmcache/NavyConfig.h

@@ -899,6 +899,8 @@ class NavyConfig {
   uint64_t getMaxParcelMemoryMB() const { return maxParcelMemoryMB_; }
   bool getUseEstimatedWriteSize() const { return useEstimatedWriteSize_; }
   size_t getNumShards() const { return numShards_; }
+  bool getEnableAccessTimeMap() const { return enableAccessTimeMap_; }
+  size_t getAccessTimeMapMaxSize() const { return accessTimeMapMaxSize_; }
 
   // Setters:
   // Enable "dynamic_random" admission policy.
@@ -1042,6 +1044,12 @@ class NavyConfig {
     useEstimatedWriteSize_ = useEstimatedWriteSize;
   }
   void setNumShards(size_t numShards) noexcept { numShards_ = numShards; }
+  void setEnableAccessTimeMap(bool enable) noexcept {
+    enableAccessTimeMap_ = enable;
+  }
+  void setAccessTimeMapMaxSize(size_t maxSize) noexcept {
+    accessTimeMapMaxSize_ = maxSize;
+  }
 
   const std::vector<EnginesConfig>& enginesConfigs() const {
     return enginesConfigs_;
@@ -1139,6 +1147,10 @@ class NavyConfig {
   bool enableFDP_{false};
   // Number of nvm lock shards
   size_t numShards_{8192};
+  // Whether to enable the AccessTimeMap for tracking NVM item access times.
+  bool enableAccessTimeMap_{false};
+  // Maximum number of entries in the AccessTimeMap. 0 means unbounded.
+  size_t accessTimeMapMaxSize_{0};
 };
 } // namespace navy
 } // namespace cachelib

cachelib/allocator/nvmcache/NvmCache.h

@@ -28,6 +28,7 @@
 #include <stdexcept>
 #include <vector>
 
+#include "cachelib/allocator/nvmcache/AccessTimeMap.h"
 #include "cachelib/allocator/nvmcache/CacheApiWrapper.h"
 #include "cachelib/allocator/nvmcache/InFlightPuts.h"
 #include "cachelib/allocator/nvmcache/NavyConfig.h"
@@ -589,6 +590,18 @@ class NvmCache {
   // finished.
   std::vector<folly::F14FastSet<std::string>> itemRemoved_;
 
+  // Tracks the most recent DRAM last-access timestamp for items in NVM.
+  // It is best offered and not updated on every DRAM access so could sometime
+  // have stale value which represents the promotion timestamp.
+  // Populated on DRAM eviction of NvmClean BlockCache items;
+  // consumed during BlockCache region reclaim to write fresh timestamps.
+  std::unique_ptr<AccessTimeMap> accessTimeMap_;
+
+  // BigHash small-item threshold from NavyConfig. Items with
+  // key.size() + nvmBufferSize <= this threshold go to BigHash.
+  // 0 means BigHash is not configured and all items go to BlockCache.
+  const uint64_t smallItemMaxSize_;
+
   std::unique_ptr<cachelib::navy::AbstractCache> navyCache_;
 
   friend class tests::NvmCacheTest;
@@ -1058,7 +1071,15 @@ NvmCache<C>::NvmCache(C& c,
       tombstones_(numShards_),
       itemDestructor_(itemDestructor),
       itemDestructorMutex_(numShards_),
-      itemRemoved_(numShards_) {
+      itemRemoved_(numShards_),
+      accessTimeMap_(
+          config_.navyConfig.getEnableAccessTimeMap()
+              ? std::make_unique<AccessTimeMap>(
+                    numShards_, config_.navyConfig.getAccessTimeMapMaxSize())
+              : nullptr),
+      smallItemMaxSize_(config_.navyConfig.isBigHashEnabled()
+                            ? config_.navyConfig.bigHash().getSmallItemMaxSize()
+                            : 0) {
   navyCache_ = createNavyCache(
       config_.navyConfig,
       checkExpired_,
@@ -1644,6 +1665,9 @@ template <typename C>
 util::StatsMap NvmCache<C>::getStatsMap() const {
   util::StatsMap statsMap;
   navyCache_->getCounters(statsMap.createCountVisitor());
+  if (accessTimeMap_) {
+    accessTimeMap_->getCounters(statsMap.createCountVisitor());
+  }
   statsMap.insertCount("items_tracked_for_destructor", getNvmItemRemovedSize());
   return statsMap;
 }

cachelib/allocator/nvmcache/tests/NvmCacheTests.cpp

@@ -1893,6 +1893,16 @@ TEST_F(NvmCacheTest, NavyStats) {
   // item destructor
   EXPECT_TRUE(cs("items_tracked_for_destructor"));
 
+  // AccessTimeMap stats
+  EXPECT_TRUE(cs("navy_atm_sets"));
+  EXPECT_TRUE(cs("navy_atm_gets"));
+  EXPECT_TRUE(cs("navy_atm_get_and_removes"));
+  EXPECT_TRUE(cs("navy_atm_removes"));
+  EXPECT_TRUE(cs("navy_atm_hits"));
+  EXPECT_TRUE(cs("navy_atm_misses"));
+  EXPECT_TRUE(cs("navy_atm_evictions"));
+  EXPECT_TRUE(cs("navy_atm_size"));
+
   // there should be no additional stats
   if (nvmStats.size()) {
     for (auto kv : nvmStats) {

cachelib/allocator/tests/NvmTestUtils.h

@@ -36,6 +36,7 @@ inline NavyConfig getNvmTestConfig(const std::string& cacheDir) {
       .setSizePctAndMaxItemSize(50, 100)
       .setBucketSize(1024)
       .setBucketBfSize(8);
+  config.setEnableAccessTimeMap(true);
   return config;
 }
 

cachelib/cachebench/cache/Cache.h

@@ -717,6 +717,10 @@ Cache<Allocator>::Cache(const CacheConfig& config,
     }
     nvmConfig.navyConfig.setMaxConcurrentInserts(
         config_.navyMaxConcurrentInserts);
+    nvmConfig.navyConfig.setEnableAccessTimeMap(
+        config_.navyEnableAccessTimeMap);
+    nvmConfig.navyConfig.setAccessTimeMapMaxSize(
+        config_.navyAccessTimeMapMaxSize);
 
     nvmConfig.truncateItemToOriginalAllocSizeInNvm =
         config_.truncateItemToOriginalAllocSizeInNvm;

cachelib/cachebench/util/CacheConfig.cpp

@@ -88,6 +88,8 @@ CacheConfig::CacheConfig(const folly::dynamic& configJson) {
   JSONSetVal(configJson, navyEncryption);
   JSONSetVal(configJson, deviceMaxWriteSize);
   JSONSetVal(configJson, deviceEnableFDP);
+  JSONSetVal(configJson, navyEnableAccessTimeMap);
+  JSONSetVal(configJson, navyAccessTimeMapMaxSize);
 
   JSONSetVal(configJson, memoryOnlyTTL);
 
@@ -112,7 +114,7 @@ CacheConfig::CacheConfig(const folly::dynamic& configJson) {
   // if you added new fields to the configuration, update the JSONSetVal
   // to make them available for the json configs and increment the size
   // below
-  checkCorrectSize<CacheConfig, 792>();
+  checkCorrectSize<CacheConfig, 800>();
 
   if (numPools != poolSizes.size()) {
     throw std::invalid_argument(folly::sformat(

cachelib/cachebench/util/CacheConfig.h

@@ -246,6 +246,11 @@ struct CacheConfig : public JSONConfig {
   // Enable the FDP Data placement mode in the device, if it is capable.
   bool deviceEnableFDP{false};
 
+  // Whether to enable the AccessTimeMap for tracking NVM item access times.
+  bool navyEnableAccessTimeMap{false};
+  // Maximum entries in the AccessTimeMap. 0 means unbounded.
+  size_t navyAccessTimeMapMaxSize{0};
+
   // Don't write to flash if cache TTL is smaller than this value.
   // Not used when its value is 0.  In seconds.
   uint32_t memoryOnlyTTL{0};