Get or update object TTL via object shared_ptr

Summary:
Add the following TTL-related APIs:
- getConfiguredTtlSec
- getExpiryTimeSec
- extendTtlSec
- updateExpiryTimeSec

Usage:
```
auto ptr = objcache->find<T>("key");
auto configuredTtl = objcache->getConfiguredTtl(ptr);
auto expiryTime = objcache->getExpiryTimeSec(ptr);
objcache->extendTtl(ptr, std::chrono::seconds(3));
objcache->updateExpiryTimeSec(ptr, newExpiryTimeSecs);

```

Reviewed By: therealgymmy, jaesoo-fb

Differential Revision: D43167879

fbshipit-source-id: 3b11fb0a2b9a3b5c38fcfd856ade100e6ae27470

Author: Jiayue Bao

cachelib/experimental/objcache2/ObjectCache.h

@@ -267,6 +267,63 @@ class ObjectCache : public ObjectCacheBase<AllocatorT> {
                : sizeController_->getCurrentEntriesLimit();
   }
 
+  // Get the expiry timestamp of the object
+  // @param  object   object shared pointer returned from ObjectCache APIs
+  //
+  // @return the expiry timestamp in seconds of the object
+  //         0 if object is nullptr
+  template <typename T>
+  uint32_t getExpiryTimeSec(const std::shared_ptr<T>& object) const {
+    if (object == nullptr) {
+      return 0;
+    }
+    return getReadHandleRefInternal<T>(object)->getExpiryTime();
+  }
+
+  // Get the configured TTL of the object
+  // @param  object   object shared pointer returned from ObjectCache APIs
+  //
+  // @return the configured TTL in seconds of the object
+  //         0 if object is nullptr
+  template <typename T>
+  std::chrono::seconds getConfiguredTtl(
+      const std::shared_ptr<T>& object) const {
+    if (object == nullptr) {
+      return std::chrono::seconds{0};
+    }
+    return getReadHandleRefInternal<T>(object)->getConfiguredTTL();
+  }
+
+  // Update the expiry timestamp of an object
+  //
+  // @param  object         object shared pointer returned from ObjectCache APIs
+  // @param  expiryTimeSecs the expiryTime in seconds to update
+  //
+  // @return boolean indicating whether expiry time was successfully updated
+  template <typename T>
+  bool updateExpiryTimeSec(std::shared_ptr<T>& object,
+                           uint32_t expiryTimeSecs) {
+    if (object == nullptr) {
+      return false;
+    }
+    return getWriteHandleRefInternal<T>(object)->updateExpiryTime(
+        expiryTimeSecs);
+  }
+
+  // Update expiry time to @ttl seconds from now.
+  //
+  // @param  object    object shared pointer returned from ObjectCache APIs
+  // @param  ttl       TTL in seconds (from now)
+  //
+  // @return boolean indicating whether TTL was successfully extended
+  template <typename T>
+  bool extendTtl(std::shared_ptr<T>& object, std::chrono::seconds ttl) {
+    if (object == nullptr) {
+      return false;
+    }
+    return getWriteHandleRefInternal<T>(object)->extendTTL(ttl);
+  }
+
  protected:
   // Serialize cache allocator config for exporting to Scuba
   std::map<std::string, std::string> serializeConfigParams() const override;
@@ -307,6 +364,28 @@ class ObjectCache : public ObjectCacheBase<AllocatorT> {
   bool stopSizeController(std::chrono::seconds timeout = std::chrono::seconds{
                               0});
 
+  // Get a ReadHandle reference from the object shared_ptr
+  template <typename T>
+  typename AllocatorT::ReadHandle& getReadHandleRefInternal(
+      const std::shared_ptr<T>& object) const {
+    auto* deleter = std::get_deleter<Deleter<T>>(object);
+    XDCHECK(deleter != nullptr);
+    auto& hdl = deleter->getReadHandleRef();
+    XDCHECK(hdl != nullptr);
+    return hdl;
+  }
+
+  // Get a WriteHandle reference from the object shared_ptr
+  template <typename T>
+  typename AllocatorT::WriteHandle& getWriteHandleRefInternal(
+      std::shared_ptr<T>& object) {
+    auto* deleter = std::get_deleter<Deleter<T>>(object);
+    XDCHECK(deleter != nullptr);
+    auto& hdl = deleter->getWriteHandleRef();
+    XDCHECK(hdl != nullptr);
+    return hdl;
+  }
+
   // Config passed to the cache.
   Config config_{};
 

cachelib/experimental/objcache2/tests/ObjectCacheTest.cpp

@@ -886,6 +886,69 @@ class ObjectCacheTest : public ::testing::Test {
     }
   }
 
+  void testGetTtl() {
+    const uint32_t ttlSecs = 600;
+
+    ObjectCacheConfig config;
+    config.setCacheName("test").setCacheCapacity(10'000).setItemDestructor(
+        [&](ObjectCacheDestructorData data) { data.deleteObject<Foo>(); });
+    auto objcache = ObjectCache::create(config);
+
+    auto before = util::getCurrentTimeSec();
+    std::this_thread::sleep_for(std::chrono::seconds{3});
+    objcache->insertOrReplace("Foo", std::make_unique<Foo>(), 0 /*object size*/,
+                              ttlSecs);
+
+    // lookup via find API
+    auto found1 = objcache->template find<Foo>("Foo");
+    ASSERT_NE(nullptr, found1);
+
+    // get TTL info
+    EXPECT_EQ(ttlSecs, objcache->getConfiguredTtl(found1).count());
+    EXPECT_LE(before + ttlSecs, objcache->getExpiryTimeSec(found1));
+
+    // lookup via findToWrite API
+    auto found2 = objcache->template findToWrite<Foo>("Foo");
+    ASSERT_NE(nullptr, found2);
+
+    // get TTL info
+    EXPECT_EQ(ttlSecs, objcache->getConfiguredTtl(found2).count());
+    EXPECT_LE(before + ttlSecs, objcache->getExpiryTimeSec(found2));
+  }
+
+  void testUpdateTtl() {
+    const uint32_t ttlSecs = 600;
+
+    ObjectCacheConfig config;
+    config.setCacheName("test").setCacheCapacity(10'000).setItemDestructor(
+        [&](ObjectCacheDestructorData data) { data.deleteObject<Foo>(); });
+    auto objcache = ObjectCache::create(config);
+
+    auto insertionTime = util::getCurrentTimeSec();
+    objcache->insertOrReplace("Foo", std::make_unique<Foo>(), 0 /*object size*/,
+                              ttlSecs);
+
+    auto found = objcache->template find<Foo>("Foo");
+    ASSERT_NE(nullptr, found);
+
+    // get TTL info
+    EXPECT_EQ(ttlSecs, objcache->getConfiguredTtl(found).count());
+    EXPECT_LE(insertionTime + ttlSecs, objcache->getExpiryTimeSec(found));
+
+    // update expiry time
+    auto currExpTime = objcache->getExpiryTimeSec(found);
+    EXPECT_TRUE(objcache->updateExpiryTimeSec(found, currExpTime + ttlSecs));
+    EXPECT_EQ(2 * ttlSecs, objcache->getConfiguredTtl(found).count());
+    EXPECT_EQ(currExpTime + ttlSecs, objcache->getExpiryTimeSec(found));
+
+    // extend TTL
+    auto now = util::getCurrentTimeSec();
+    std::this_thread::sleep_for(std::chrono::seconds{3});
+    EXPECT_TRUE(objcache->extendTtl(found, std::chrono::seconds(3 * ttlSecs)));
+    EXPECT_LE(now + ttlSecs, objcache->getExpiryTimeSec(found));
+    EXPECT_LE(3 * ttlSecs, objcache->getConfiguredTtl(found).count());
+  }
+
   void testMultithreadReplace() {
     // Sanity test to see if insertOrReplace across multiple
     // threads are safe.
@@ -1079,6 +1142,32 @@ class ObjectCacheTest : public ::testing::Test {
       fs[i].join();
     }
   }
+
+  void testMultithreadUpdateTtl() {
+    // Sanity test to see if update TTL across multiple
+    // threads is safe.
+    ObjectCacheConfig config;
+    config.setCacheName("test").setCacheCapacity(10'000).setItemDestructor(
+        [&](ObjectCacheDestructorData data) { data.deleteObject<Foo>(); });
+    auto objcache = ObjectCache::create(config);
+    objcache->insertOrReplace("key", std::make_unique<Foo>(), 0, 60);
+
+    auto runUpdateTtlOps = [&] {
+      for (int i = 0; i < 2000; i++) {
+        auto found = objcache->template find<Foo>("key");
+        auto configuredTtlSecs = objcache->getConfiguredTtl(found).count();
+        objcache->extendTtl(found, std::chrono::seconds{configuredTtlSecs});
+      }
+    };
+
+    std::vector<std::thread> ts;
+    for (int i = 0; i < 10; i++) {
+      ts.push_back(std::thread{runUpdateTtlOps});
+    }
+    for (int i = 0; i < 10; i++) {
+      ts[i].join();
+    }
+  }
 };
 
 using AllocatorTypes = ::testing::Types<LruAllocator,
@@ -1117,6 +1206,9 @@ TYPED_TEST(ObjectCacheTest, PersistenceHighLoad) {
   this->testPersistenceHighLoad();
 }
 
+TYPED_TEST(ObjectCacheTest, GetTtl) { this->testGetTtl(); }
+TYPED_TEST(ObjectCacheTest, UpdateTtl) { this->testUpdateTtl(); }
+
 TYPED_TEST(ObjectCacheTest, MultithreadReplace) {
   this->testMultithreadReplace();
 }
@@ -1135,6 +1227,9 @@ TYPED_TEST(ObjectCacheTest, MultithreadFindAndEviction) {
 TYPED_TEST(ObjectCacheTest, MultithreadFindAndReplaceWith10Shards) {
   this->testMultithreadFindAndReplaceWith10Shards();
 }
+TYPED_TEST(ObjectCacheTest, MultithreadUpdateTtl) {
+  this->testMultithreadUpdateTtl();
+}
 
 using ObjectCache = ObjectCache<LruAllocator>;
 TEST(ObjectCacheTest, LruEviction) {