Refactor Cache::Erase return value

Author: mm304321141

cache/cache_test.cc

@@ -115,8 +115,8 @@ class CacheTest : public testing::TestWithParam<std::string> {
                   &CacheTest::Deleter);
   }
 
-  void Erase(std::shared_ptr<Cache> cache, int key) {
-    cache->Erase(EncodeKey(key));
+  bool Erase(std::shared_ptr<Cache> cache, int key) {
+    return cache->Erase(EncodeKey(key));
   }
 
   int Lookup(int key) { return Lookup(cache_, key); }
@@ -125,15 +125,15 @@ class CacheTest : public testing::TestWithParam<std::string> {
     Insert(cache_, key, value, charge);
   }
 
-  void Erase(int key) { Erase(cache_, key); }
+  bool Erase(int key) { return Erase(cache_, key); }
 
   int Lookup2(int key) { return Lookup(cache2_, key); }
 
   void Insert2(int key, int value, int charge = 1) {
     Insert(cache2_, key, value, charge);
   }
 
-  void Erase2(int key) { Erase(cache2_, key); }
+  bool Erase2(int key) { return Erase(cache2_, key); }
 };
 CacheTest* CacheTest::current_;
 

cache/clock_cache.cc

@@ -261,7 +261,7 @@ class ClockCacheShard : public CacheShard {
   virtual bool Ref(Cache::Handle* handle) override;
   virtual bool Release(Cache::Handle* handle,
                        bool force_erase = false) override;
-  virtual void Erase(const Slice& key, uint32_t hash) override;
+  virtual bool Erase(const Slice& key, uint32_t hash) override;
   bool EraseAndConfirm(const Slice& key, uint32_t hash,
                        CleanupContext* context);
   virtual size_t GetUsage() const override;
@@ -647,10 +647,11 @@ bool ClockCacheShard::Release(Cache::Handle* h, bool force_erase) {
   return erased;
 }
 
-void ClockCacheShard::Erase(const Slice& key, uint32_t hash) {
+bool ClockCacheShard::Erase(const Slice& key, uint32_t hash) {
   CleanupContext context;
-  EraseAndConfirm(key, hash, &context);
+  bool ret EraseAndConfirm(key, hash, &context);
   Cleanup(context);
+  return ret;
 }
 
 bool ClockCacheShard::EraseAndConfirm(const Slice& key, uint32_t hash,

cache/lirs_cache.cc

@@ -407,7 +407,7 @@ Status LIRSCacheShard::Insert(const Slice& key, uint32_t hash, void* value,
   return s;
 }
 
-void LIRSCacheShard::Erase(const Slice& key, uint32_t hash) {
+bool LIRSCacheShard::Erase(const Slice& key, uint32_t hash) {
   LIRSHandle* e;
   bool last_reference = false;
   {
@@ -430,6 +430,7 @@ void LIRSCacheShard::Erase(const Slice& key, uint32_t hash) {
   if (last_reference) {
     e->Free();
   }
+  return e != nullptr;
 }
 
 size_t LIRSCacheShard::GetUsage() const {

cache/lirs_cache.h

@@ -106,7 +106,7 @@ class ALIGN_AS(CACHE_LINE_SIZE) LIRSCacheShard : public CacheShard {
   virtual bool Ref(Cache::Handle* handle) override;
   virtual bool Release(Cache::Handle* handle,
                        bool force_erase = false) override;
-  virtual void Erase(const Slice& key, uint32_t hash) override;
+  virtual bool Erase(const Slice& key, uint32_t hash) override;
 
   virtual size_t GetUsage() const override;
   virtual size_t GetPinnedUsage() const override;

cache/lru_cache.cc

@@ -438,7 +438,7 @@ Status LRUCacheShardTemplate<CacheMonitor>::Insert(
 }
 
 template <class CacheMonitor>
-void LRUCacheShardTemplate<CacheMonitor>::Erase(const Slice& key,
+bool LRUCacheShardTemplate<CacheMonitor>::Erase(const Slice& key,
                                                 uint32_t hash) {
   LRUHandle* e;
   bool last_reference = false;
@@ -462,6 +462,7 @@ void LRUCacheShardTemplate<CacheMonitor>::Erase(const Slice& key,
   if (last_reference) {
     e->Free();
   }
+  return e != nullptr;
 }
 
 template <class CacheMonitor>

cache/lru_cache.h

@@ -209,7 +209,7 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShardTemplate : public CacheMonitor,
   virtual bool Ref(Cache::Handle* handle) override;
   virtual bool Release(Cache::Handle* handle,
                        bool force_erase = false) override;
-  virtual void Erase(const Slice& key, uint32_t hash) override;
+  virtual bool Erase(const Slice& key, uint32_t hash) override;
 
   // Although in some platforms the update of size_t is atomic, to make sure
   // GetUsage() and GetPinnedUsage() work correctly under any platform, we'll

cache/lru_cache_test.cc

@@ -89,7 +89,7 @@ class LRUCacheTest : public testing::Test,
     return cache_->Lookup(key, 0 /*hash*/);
   }
 
-  void Erase(const std::string& key) { cache_->Erase(key, 0 /*hash*/); }
+  bool Erase(const std::string& key) { return cache_->Erase(key, 0 /*hash*/); }
 
   void ValidateLRUList(std::vector<std::string> keys,
                        size_t num_high_pri_pool_keys = 0) {

cache/sharded_cache.cc

@@ -71,9 +71,9 @@ bool ShardedCache::Release(Handle* handle, bool force_erase) {
   return GetShard(Shard(hash))->Release(handle, force_erase);
 }
 
-void ShardedCache::Erase(const Slice& key) {
+bool ShardedCache::Erase(const Slice& key) {
   uint32_t hash = HashSlice(key);
-  GetShard(Shard(hash))->Erase(key, hash);
+  return GetShard(Shard(hash))->Erase(key, hash);
 }
 
 uint64_t ShardedCache::NewId() {

cache/sharded_cache.h

@@ -32,7 +32,7 @@ class CacheShard {
   virtual Cache::Handle* Lookup(const Slice& key, uint32_t hash) = 0;
   virtual bool Ref(Cache::Handle* handle) = 0;
   virtual bool Release(Cache::Handle* handle, bool force_erase = false) = 0;
-  virtual void Erase(const Slice& key, uint32_t hash) = 0;
+  virtual bool Erase(const Slice& key, uint32_t hash) = 0;
   virtual void SetCapacity(size_t capacity) = 0;
   virtual void SetStrictCapacityLimit(bool strict_capacity_limit) = 0;
   virtual size_t GetUsage() const = 0;
@@ -68,7 +68,7 @@ class ShardedCache : public Cache {
   virtual Handle* Lookup(const Slice& key, Statistics* stats) override;
   virtual bool Ref(Handle* handle) override;
   virtual bool Release(Handle* handle, bool force_erase = false) override;
-  virtual void Erase(const Slice& key) override;
+  virtual bool Erase(const Slice& key) override;
   virtual uint64_t NewId() override;
   virtual size_t GetCapacity() const override;
   virtual bool HasStrictCapacityLimit() const override;

include/rocksdb/cache.h

@@ -221,7 +221,8 @@ class Cache {
   // If the cache contains entry for key, erase it.  Note that the
   // underlying entry will be kept around until all existing handles
   // to it have been released.
-  virtual void Erase(const Slice& key) = 0;
+  // Return false if erase a non-exists key
+  virtual bool Erase(const Slice& key) = 0;
   // Return a new numeric id.  May be used by multiple clients who are
   // sharding the same cache to partition the key space.  Typically the
   // client will allocate a new id at startup and prepend the id to