expose tta through the handle

Summary:
The diff adds TTA to read handles.

We cannot rely on using lastAccessedTimestamp to compute TTA. The timestamp is bookkeeping for replacement policy and will represent the most recent update to the list which is caused by the user's request. This means users cannot know what is the TTA since it doesn't know what the last accessed timestamp before their request was.

Reviewed By: rlyerly

Differential Revision: D98871729

fbshipit-source-id: 5f149e35483014fe5b4c7f5c28f7eb3350459ad2

Author: pbhandar2

cachelib/allocator/CacheAllocator.h

@@ -4361,6 +4361,10 @@ CacheAllocator<CacheTrait>::findInternalWithExpiration(
   if (needToBumpStats) {
     recordEvent(event, key, AllocatorApiResult::FOUND, handle);
   }
+  auto lastAccess = handle->getLastAccessTime();
+  if (lastAccess > 0) {
+    handle.setTTASecs(util::getCurrentTimeSec() - lastAccess);
+  }
   return handle;
 }
 

cachelib/allocator/Handle.h

@@ -101,7 +101,8 @@ struct ReadHandleImpl {
       : alloc_(other.alloc_),
         it_(other.releaseItem()),
         waitContext_(std::move(other.waitContext_)),
-        flags_(other.getFlags()) {}
+        flags_(other.getFlags()),
+        ttaSecs_(other.ttaSecs_) {}
 
   FOLLY_ALWAYS_INLINE ReadHandleImpl& operator=(
       ReadHandleImpl&& other) noexcept {
@@ -222,6 +223,13 @@ struct ReadHandleImpl {
     return getFlags() & static_cast<uint8_t>(HandleFlags::kExpired);
   }
 
+  // Return the time-to-access (TTA) in seconds — the time between the
+  // previous access and the find()/peek() that returned this handle.
+  // Returns 0 for newly allocated items.
+  uint32_t getTTASecs() const {
+    return waitContext_ ? waitContext_->getTTASecs() : ttaSecs_;
+  }
+
   // blocks until `isReady() == true`.
   void wait() const noexcept {
     if (isReady()) {
@@ -274,6 +282,7 @@ struct ReadHandleImpl {
     }
 
     uint8_t getFlags() const { return flags_; }
+    uint32_t getTTASecs() const { return ttaSecs_; }
 
     // Assumes ownership of the item managed by hdl
     // and invokes the onReadyCallback_
@@ -322,6 +331,7 @@ struct ReadHandleImpl {
       SCOPE_EXIT { hdl.release(); };
 
       flags_ = hdl.getFlags();
+      ttaSecs_ = hdl.ttaSecs_;
       auto it = hdl.getInternal();
       it_.store(it, std::memory_order_release);
       // Handles are fulfilled by threads different from the owners. Adjust
@@ -416,7 +426,8 @@ struct ReadHandleImpl {
     ReadyCallback onReadyCallback_; //< callback invoked when "ready"
     std::atomic<Item*> it_{reinterpret_cast<Item*>(kItemNotReady)}; //< The item
     uint8_t flags_{}; //< flags associated with the handle generated by NvmCache
-    CacheT& alloc_;   //< allocator instance
+    uint32_t ttaSecs_{0}; //< time-to-access in seconds
+    CacheT& alloc_;       //< allocator instance
   };
 
   // Set the onReady callback which should be invoked once the item is ready.
@@ -468,11 +479,15 @@ struct ReadHandleImpl {
   void markWentToNvm() {
     flags_ |= static_cast<uint8_t>(HandleFlags::kWentToNvm);
   }
+  void setTTASecs(uint32_t tta) { ttaSecs_ = tta; }
 
   uint8_t getFlags() const {
     return waitContext_ ? waitContext_->getFlags() : flags_;
   }
-  void cloneFlags(const ReadHandleImpl& other) { flags_ = other.getFlags(); }
+  void cloneFlags(const ReadHandleImpl& other) {
+    flags_ = other.getFlags();
+    ttaSecs_ = other.getTTASecs();
+  }
 
   Item* releaseItem() noexcept { return std::exchange(it_, nullptr); }
 
@@ -531,6 +546,7 @@ struct ReadHandleImpl {
   std::shared_ptr<ItemWaitContext> waitContext_;
 
   mutable uint8_t flags_{};
+  uint32_t ttaSecs_{0};
 
   // Only CacheAllocator and NvmCache can create non-default constructed handles
   friend CacheT;

cachelib/allocator/nvmcache/NvmCache.h

@@ -1393,6 +1393,7 @@ void NvmCache<C>::onGetComplete(GetCtx& ctx,
   if (latestLastAccessTimeSecs > 0) {
     auto ttaSecs = util::getCurrentTimeSec() - latestLastAccessTimeSecs;
     stats().nvmHitTTASecs_.trackValue(ttaSecs);
+    it.setTTASecs(static_cast<uint32_t>(ttaSecs));
   }
 
   // by the time we filled from navy, another thread inserted in RAM. We