Wire AccessTimeMap persistence into NvmCache warm restart

Summary:
Enable end-to-end AccessTimeMap persistence by wiring persist/recover
into NvmCache's startup and shutdown paths:

- Constructor: store `shmManager_` from `navyPersistParams`. After
  `navyCache_` creation, call `accessTimeMap_->recover()` when not
  truncating and shm is available.
- shutDown(): call `accessTimeMap_->persist()` before
  `navyCache_->persist()` when `shmManager_` is available.

This is the "activation" diff — can be landed last and reverted
independently if issues arise.

Reviewed By: rlyerly

Differential Revision: D95409666

fbshipit-source-id: 45cb29fc737445766cfaf1c447acfc97ebfe40e5

Author: pbhandar2

cachelib/allocator/nvmcache/NvmCache.h

@@ -618,6 +618,10 @@ class NvmCache {
   // 0 means BigHash is not configured and all items go to BlockCache.
   const uint64_t smallItemMaxSize_;
 
+  // Non-owning pointer to the ShmManager used for ATM persistence.
+  // nullptr if shm persistence is not available.
+  ShmManager* shmManager_{nullptr};
+
   std::unique_ptr<cachelib::navy::AbstractCache> navyCache_;
 
   friend class tests::NvmCacheTest;
@@ -1103,7 +1107,10 @@ NvmCache<C>::NvmCache(C& c,
               : nullptr),
       smallItemMaxSize_(config_.navyConfig.isBigHashEnabled()
                             ? config_.navyConfig.bigHash().getSmallItemMaxSize()
-                            : 0) {
+                            : 0),
+      shmManager_(navyPersistParams.shmManager.has_value()
+                      ? &navyPersistParams.shmManager.value().get()
+                      : nullptr) {
   navyCache_ = createNavyCache(
       config_.navyConfig,
       checkExpired_,
@@ -1114,6 +1121,14 @@ NvmCache<C>::NvmCache(C& c,
       std::move(config.deviceEncryptor),
       itemDestructor_ ? true : false,
       navyPersistParams);
+
+  if (accessTimeMap_ && shmManager_) {
+    try {
+      accessTimeMap_->recover(*shmManager_);
+    } catch (const std::exception& e) {
+      XLOGF(ERR, "Failed to recover AccessTimeMap: {}", e.what());
+    }
+  }
 }
 
 template <typename C>
@@ -1683,6 +1698,16 @@ bool NvmCache<C>::shutDown() {
   navyEnabled_ = false;
   try {
     this->flushPendingOps();
+
+    // Persist ATM to shared memory before persisting navy cache
+    if (accessTimeMap_ && shmManager_) {
+      try {
+        accessTimeMap_->persist(*shmManager_);
+      } catch (const std::exception& e) {
+        XLOGF(ERR, "Failed to persist AccessTimeMap: {}", e.what());
+      }
+    }
+
     navyCache_->persist();
   } catch (const std::exception& e) {
     XLOG(ERR) << "Got error persisting cache: " << e.what();