Thread lastAccessTimeSecs through BlockCache write path

Summary: This diff modifies the BlockCache write path to include the last access time in seconds. The `insert` function in several files (`BlockCache.cpp`, `Driver.h`, `EnginePair.h`, `BigHash.h`, and `NoopEngine.h`) is updated to take an additional `lastAccessTimeSecs` parameter. This change allows the DRAM cache to pass last accessed time to be stored in BlockCache. This is needed for TTA based item lifetime enforcement.

Reviewed By: byahn0996

Differential Revision: D94716016

fbshipit-source-id: 79665972400474355aa8ffc5761b04ba9195a53a

Author: pbhandar2

cachelib/allocator/nvmcache/NvmCache.h

@@ -1228,7 +1228,8 @@ void NvmCache<C>::put(Item& item, PutToken token) {
           }
           recordEvent(AllocatorApiEvent::NVM_INSERT, key.key(), eventRes);
           putCleanup();
-        });
+        },
+        item.getLastAccessTime());
 
     if (status == navy::Status::Ok) {
       guard.dismiss();

cachelib/navy/AbstractCache.h

@@ -67,7 +67,12 @@ class AbstractCache {
 
   // Inserts entry into cache.
   // Returns: Ok, Rejected, DeviceError
-  virtual Status insert(HashedKey key, BufferView value) = 0;
+  // TODO: For now passing lastAccessTimeSecs as a param. This is
+  // temporary until ItemMetadata lands. After that, we will pass
+  // ItemMetadata as a param.
+  virtual Status insert(HashedKey key,
+                        BufferView value,
+                        uint32_t lastAccessTimeSecs = 0) = 0;
 
   // Asynchronously inserts entry into the cache.
   // Invokes callback when done on a worker thread. Callback is optional.
@@ -78,7 +83,8 @@ class AbstractCache {
   // Returns: Ok, Rejected
   virtual Status insertAsync(HashedKey key,
                              BufferView value,
-                             InsertCallback cb) = 0;
+                             InsertCallback cb,
+                             uint32_t lastAccessTimeSecs = 0) = 0;
 
   // Looks up value. Returns non-null buffer if found.
   // Returns: Ok, NotFound, DeviceError

cachelib/navy/bighash/BigHash.cpp

@@ -292,7 +292,9 @@ bool BigHash::recover(RecordReader& rr) {
   return true;
 }
 
-Status BigHash::insert(HashedKey hk, BufferView value) {
+Status BigHash::insert(HashedKey hk,
+                       BufferView value,
+                       uint32_t /* lastAccessTimeSecs */) {
   const auto bid = getBucketId(hk);
   insertCount_.inc();
 

cachelib/navy/bighash/BigHash.h

@@ -116,7 +116,9 @@ class BigHash final : public Engine, folly::NonCopyableNonMovable {
 
   // Inserts key and value into BigHash. This will replace an existing
   // key if found. If it failed to write, it will return DeviceError.
-  Status insert(HashedKey hk, BufferView value) override;
+  Status insert(HashedKey hk,
+                BufferView value,
+                uint32_t lastAccessTimeSecs = 0) override;
 
   // Removes an entry from BigHash if found. Ok on success, NotFound on miss,
   // and DeviceError on error.

cachelib/navy/block_cache/BlockCache.cpp

@@ -207,7 +207,9 @@ uint32_t BlockCache::serializedSize(uint32_t keySize,
   return powTwoAlign(size, allocAlignSize_);
 }
 
-Status BlockCache::insert(HashedKey hk, BufferView value) {
+Status BlockCache::insert(HashedKey hk,
+                          BufferView value,
+                          uint32_t lastAccessTimeSecs) {
   auto start = getSteadyClock();
   SCOPE_EXIT {
     insertLatency_.trackValue(toMicros(getSteadyClock() - start).count());
@@ -222,7 +224,7 @@ Status BlockCache::insert(HashedKey hk, BufferView value) {
 
   // After allocation a region is opened for writing. Until we close it, the
   // region would not be reclaimed and index never gets an invalid entry.
-  writeEntry(addr, slotSize, hk, value);
+  writeEntry(addr, slotSize, hk, value, lastAccessTimeSecs);
   updateIndex(hk.keyHash(), slotSize, addr, /* allowReplace */ true);
   allocator_.close(std::move(desc));
   INJECT_PAUSE(pause_blockcache_insert_done);
@@ -1033,21 +1035,26 @@ BlockCache::allocateForInsert(const HashedKey& hk, const uint32_t valueSize) {
 }
 
 /* static */ BlockCache::EntryDesc* BlockCache::writeEntryDescAndKey(
-    Buffer& buffer, const HashedKey& hk, uint32_t valueSize) {
+    Buffer& buffer,
+    const HashedKey& hk,
+    uint32_t valueSize,
+    uint32_t lastAccessTimeSecs) {
   // Copy descriptor and the key to the end
   size_t descOffset = buffer.size() - sizeof(EntryDesc);
   auto desc = new (buffer.data() + descOffset)
-      EntryDesc(hk.key().size(), valueSize, hk.keyHash());
+      EntryDesc(hk.key().size(), valueSize, hk.keyHash(), lastAccessTimeSecs);
   buffer.copyFrom(descOffset - hk.key().size(), makeView(hk.key()));
   return desc;
 }
 
 void BlockCache::writeEntry(RelAddress addr,
                             uint32_t size,
                             HashedKey hk,
-                            BufferView value) {
+                            BufferView value,
+                            uint32_t lastAccessTimeSecs) {
   auto buffer = Buffer(size);
-  auto* desc = writeEntryDescAndKey(buffer, hk, value.size());
+  auto* desc =
+      writeEntryDescAndKey(buffer, hk, value.size(), lastAccessTimeSecs);
   if (checksumData_) {
     desc->cs = checksum(value);
   }

cachelib/navy/block_cache/BlockCache.h

@@ -143,7 +143,9 @@ class BlockCache final : public Engine {
   // @return  Status::Ok on success,
   //          Status::Rejected on error,
   //          Status::Retry on no space available for now.
-  Status insert(HashedKey hk, BufferView value) override;
+  Status insert(HashedKey hk,
+                BufferView value,
+                uint32_t lastAccessTimeSecs = 0) override;
 
   // Looks up a key in BlockCache.
   //
@@ -293,7 +295,8 @@ class BlockCache final : public Engine {
   // @param valueSize   size of the value to be inserted
   static EntryDesc* writeEntryDescAndKey(Buffer& buffer,
                                          const HashedKey& hk,
-                                         uint32_t valueSize);
+                                         uint32_t valueSize,
+                                         uint32_t lastAccessTimeSecs = 0);
 
   struct LookupData {
     Buffer buffer_;
@@ -316,7 +319,8 @@ class BlockCache final : public Engine {
   void writeEntry(RelAddress addr,
                   uint32_t size,
                   HashedKey hk,
-                  BufferView value);
+                  BufferView value,
+                  uint32_t lastAccessTimeSecs = 0);
   // @param ld          LookupData containing the entry metadata for reading
   // @param addrEnd     End of the entry since the item layout is backward
   // @param approxSize  Approximate size since we got this size from index

cachelib/navy/driver/Driver.cpp

@@ -110,14 +110,18 @@ uint64_t Driver::estimateWriteSize(HashedKey hk, BufferView value) const {
              : hk.key().size() + value.size();
 }
 
-Status Driver::insert(HashedKey key, BufferView value) {
+Status Driver::insert(HashedKey key,
+                      BufferView value,
+                      uint32_t lastAccessTimeSecs) {
   trace::Profiled<folly::fibers::Baton, "cachelib:navy:driver_insert"> done;
   Status cbStatus{Status::Ok};
-  auto status = insertAsync(key, value,
-                            [&done, &cbStatus](Status s, HashedKey /* key */) {
-                              cbStatus = s;
-                              done.post();
-                            });
+  auto status = insertAsync(
+      key, value,
+      [&done, &cbStatus](Status s, HashedKey /* key */) {
+        cbStatus = s;
+        done.post();
+      },
+      lastAccessTimeSecs);
   if (status != Status::Ok) {
     return status;
   }
@@ -171,7 +175,10 @@ bool Driver::admissionTest(HashedKey hk, BufferView value) const {
   return false;
 }
 
-Status Driver::insertAsync(HashedKey hk, BufferView value, InsertCallback cb) {
+Status Driver::insertAsync(HashedKey hk,
+                           BufferView value,
+                           InsertCallback cb,
+                           uint32_t lastAccessTimeSecs) {
   if (hk.key().size() > maxKeySize_) {
     rejectedCount_.inc();
     rejectedBytes_.add(hk.key().size() + value.size());
@@ -200,7 +207,8 @@ Status Driver::insertAsync(HashedKey hk, BufferView value, InsertCallback cb) {
         }
         parcelMemory_.sub(totalSize);
         concurrentInserts_.dec();
-      });
+      },
+      lastAccessTimeSecs);
   return Status::Ok;
 }
 

cachelib/navy/driver/Driver.h

@@ -86,7 +86,9 @@ class Driver final : public AbstractCache {
   // @param key    the item key
   // @param value  the item value
   // @return a status indicates success or failure, and the reason for failure
-  Status insert(HashedKey key, BufferView value) override;
+  Status insert(HashedKey key,
+                BufferView value,
+                uint32_t lastAccessTimeSecs = 0) override;
 
   // insert a key and value into the cache asynchronously.
   // @param key    the item key
@@ -96,7 +98,8 @@ class Driver final : public AbstractCache {
   //               reason for failure
   Status insertAsync(HashedKey key,
                      BufferView value,
-                     InsertCallback cb) override;
+                     InsertCallback cb,
+                     uint32_t lastAccessTimeSecs = 0) override;
 
   // lookup a key in the cache.
   // @param key    the item key to lookup