kv/rocksdb_cache: implement methods required by rocksdb v6.22.1

rocksdb v6.22.1 added couple pure methods, so let's implement them.

Signed-off-by: Kefu Chai <kchai@redhat.com>

diff --git a/src/kv/rocksdb_cache/BinnedLRUCache.cc b/src/kv/rocksdb_cache/BinnedLRUCache.cc
index 75e890200a32b8b6281e8ad597be2585e2bb3b9b..47c56e2ddd76987f8b673ff5e71353facb8dc429 100644 (file)
--- a/src/kv/rocksdb_cache/BinnedLRUCache.cc
+++ b/src/kv/rocksdb_cache/BinnedLRUCache.cc
@@ -151,13 +151,20 @@ void BinnedLRUCacheShard::EraseUnRefEntries() {
   }
 }
 
-void BinnedLRUCacheShard::ApplyToAllCacheEntries(void (*callback)(void*, size_t),
-                                           bool thread_safe) {
+void BinnedLRUCacheShard::ApplyToAllCacheEntries(
+  const std::function<void(const rocksdb::Slice& key,
+                           void* value,
+                           size_t charge,
+                           DeleterFn)>& callback,
+  bool thread_safe)
+{
   if (thread_safe) {
     mutex_.lock();
   }
   table_.ApplyToAllCacheEntries(
-      [callback](BinnedLRUHandle* h) { callback(h->value, h->charge); });
+    [callback](BinnedLRUHandle* h) {
+      callback(h->key(), h->value, h->charge, h->deleter);
+    });
   if (thread_safe) {
     mutex_.unlock();
   }
@@ -464,6 +471,12 @@ std::string BinnedLRUCacheShard::GetPrintableOptions() const {
   return std::string(buffer);
 }
 
+DeleterFn BinnedLRUCacheShard::GetDeleter(rocksdb::Cache::Handle* h) const
+{
+  auto* handle = reinterpret_cast<BinnedLRUHandle*>(h);
+  return handle->deleter;
+}
+
 BinnedLRUCache::BinnedLRUCache(CephContext *c, 
                                size_t capacity, 
                                int num_shard_bits,
@@ -519,6 +532,13 @@ void BinnedLRUCache::DisownData() {
 #endif  // !__SANITIZE_ADDRESS__
 }
 
+#if (ROCKSDB_MAJOR >= 6 && ROCKSDB_MINOR >= 22)
+DeleterFn BinnedLRUCache::GetDeleter(Handle* handle) const
+{
+  return reinterpret_cast<const BinnedLRUHandle*>(handle)->deleter;
+}
+#endif
+
 size_t BinnedLRUCache::TEST_GetLRUSize() {
   size_t lru_size_of_all_shards = 0;
   for (int i = 0; i < num_shards_; i++) {

diff --git a/src/kv/rocksdb_cache/BinnedLRUCache.h b/src/kv/rocksdb_cache/BinnedLRUCache.h
index 621c2849b60957e2f3f91a4d811ab1ac994f5977..88bf4502e89271da19c1bbf160dd5bcca7d0006a 100644 (file)
--- a/src/kv/rocksdb_cache/BinnedLRUCache.h
+++ b/src/kv/rocksdb_cache/BinnedLRUCache.h
@@ -205,13 +205,19 @@ class alignas(CACHE_LINE_SIZE) BinnedLRUCacheShard : public CacheShard {
   virtual size_t GetUsage() const override;
   virtual size_t GetPinnedUsage() const override;
 
-  virtual void ApplyToAllCacheEntries(void (*callback)(void*, size_t),
-                                      bool thread_safe) override;
+  virtual void ApplyToAllCacheEntries(
+    const std::function<void(const rocksdb::Slice& key,
+                             void* value,
+                             size_t charge,
+                             DeleterFn)>& callback,
+    bool thread_safe) override;
 
   virtual void EraseUnRefEntries() override;
 
   virtual std::string GetPrintableOptions() const override;
 
+  virtual DeleterFn GetDeleter(rocksdb::Cache::Handle* handle) const override;
+
   void TEST_GetLRUList(BinnedLRUHandle** lru, BinnedLRUHandle** lru_low_pri);
 
   //  Retrieves number of elements in LRU, for unit test purpose only
@@ -304,7 +310,9 @@ class BinnedLRUCache : public ShardedCache {
   virtual size_t GetCharge(Handle* handle) const override;
   virtual uint32_t GetHash(Handle* handle) const override;
   virtual void DisownData() override;
-
+#if (ROCKSDB_MAJOR >= 6 && ROCKSDB_MINOR >= 22)
+  virtual DeleterFn GetDeleter(Handle* handle) const override;
+#endif
   //  Retrieves number of elements in LRU, for unit test purpose only
   size_t TEST_GetLRUSize();
   // Sets the high pri pool ratio

diff --git a/src/kv/rocksdb_cache/ShardedCache.cc b/src/kv/rocksdb_cache/ShardedCache.cc
index ef3b3b98a85ccfcc0a2c3248e4089ba92e196219..6cbd89ad6472ced18213cf3da219dba462f2ac36 100644 (file)
--- a/src/kv/rocksdb_cache/ShardedCache.cc
+++ b/src/kv/rocksdb_cache/ShardedCache.cc
@@ -109,13 +109,36 @@ size_t ShardedCache::GetPinnedUsage() const {
   return usage;
 }
 
+#if (ROCKSDB_MAJOR >= 6 && ROCKSDB_MINOR >= 22)
+DeleterFn ShardedCache::GetDeleter(Handle* handle) const
+{
+  uint32_t hash = GetHash(handle);
+  return GetShard(Shard(hash))->GetDeleter(handle);
+}
+
+void ShardedCache::ApplyToAllEntries(
+    const std::function<void(const rocksdb::Slice& key, void* value, size_t charge,
+                             DeleterFn deleter)>& callback,
+    const ApplyToAllEntriesOptions& opts)
+{
+  int num_shards = 1 << num_shard_bits_;
+  for (int s = 0; s < num_shards; s++) {
+    GetShard(s)->ApplyToAllCacheEntries(callback, true /* thread_safe */);
+  }
+}
+#else
 void ShardedCache::ApplyToAllCacheEntries(void (*callback)(void*, size_t),
                                           bool thread_safe) {
   int num_shards = 1 << num_shard_bits_;
   for (int s = 0; s < num_shards; s++) {
-    GetShard(s)->ApplyToAllCacheEntries(callback, thread_safe);
+    GetShard(s)->ApplyToAllCacheEntries(
+      [callback](const rocksdb::Slice&, void* value, size_t charge, DeleterFn) {
+        callback(value, charge);
+      },
+      thread_safe);
   }
 }
+#endif
 
 void ShardedCache::EraseUnRefEntries() {
   int num_shards = 1 << num_shard_bits_;

diff --git a/src/kv/rocksdb_cache/ShardedCache.h b/src/kv/rocksdb_cache/ShardedCache.h
index 94d77759ad5997da708311494654beebe11e53f7..f98421a09a33a29a8312bf7a0b2d4baf80d227f1 100644 (file)
--- a/src/kv/rocksdb_cache/ShardedCache.h
+++ b/src/kv/rocksdb_cache/ShardedCache.h
@@ -14,6 +14,7 @@
 #include <string>
 #include <mutex>
 
+#include "rocksdb/version.h"
 #include "rocksdb/cache.h"
 #include "include/ceph_hash.h"
 #include "common/PriorityCache.h"
@@ -45,10 +46,15 @@ class CacheShard {
   virtual void SetStrictCapacityLimit(bool strict_capacity_limit) = 0;
   virtual size_t GetUsage() const = 0;
   virtual size_t GetPinnedUsage() const = 0;
-  virtual void ApplyToAllCacheEntries(void (*callback)(void*, size_t),
-                                      bool thread_safe) = 0;
+  virtual void ApplyToAllCacheEntries(
+    const std::function<void(const rocksdb::Slice& key,
+                             void* value,
+                             size_t charge,
+                             DeleterFn)>& callback,
+    bool thread_safe) = 0;
   virtual void EraseUnRefEntries() = 0;
   virtual std::string GetPrintableOptions() const { return ""; }
+  virtual DeleterFn GetDeleter(rocksdb::Cache::Handle* handle) const = 0;
 };
 
 // Generic cache interface which shards cache by hash of keys. 2^num_shard_bits
@@ -77,9 +83,19 @@ class ShardedCache : public rocksdb::Cache, public PriorityCache::PriCache {
   virtual size_t GetUsage(rocksdb::Cache::Handle* handle) const override;
   virtual size_t GetPinnedUsage() const override;
   virtual size_t GetCharge(Handle* handle) const = 0;
+#if (ROCKSDB_MAJOR >= 6 && ROCKSDB_MINOR >= 22)
+  virtual DeleterFn GetDeleter(Handle* handle) const override;
+#endif
   virtual void DisownData() override = 0;
+#if (ROCKSDB_MAJOR >= 6 && ROCKSDB_MINOR >= 22)
+  virtual void ApplyToAllEntries(
+      const std::function<void(const rocksdb::Slice& key, void* value, size_t charge,
+                               DeleterFn deleter)>& callback,
+      const ApplyToAllEntriesOptions& opts) override;
+#else
   virtual void ApplyToAllCacheEntries(void (*callback)(void*, size_t),
                                       bool thread_safe) override;
+#endif
   virtual void EraseUnRefEntries() override;
   virtual std::string GetPrintableOptions() const override;
   virtual CacheShard* GetShard(int shard) = 0;