ceph/src/kv/rocksdb_cache/ShardedCache.cc

   1 // Copyright (c) 2018-Present Red Hat Inc.  All rights reserved.
   2 //
   3 // Copyright (c) 2011-2018, Facebook, Inc.  All rights reserved.
   4 // This source code is licensed under both the GPLv2 and Apache 2.0 License
   5 //
   6 // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
   7 // Use of this source code is governed by a BSD-style license that can be
   8 // found in the LICENSE file. See the AUTHORS file for names of contributors.
   9
  10 #ifndef __STDC_FORMAT_MACROS
  11 #define __STDC_FORMAT_MACROS
  12 #endif
  13
  14 #include "ShardedCache.h"
  15
  16 #include <string>
  17
  18 namespace rocksdb_cache {
  19
  20 ShardedCache::ShardedCache(size_t capacity, int num_shard_bits,
  21                            bool strict_capacity_limit)
  22     : num_shard_bits_(num_shard_bits),
  23       capacity_(capacity),
  24       strict_capacity_limit_(strict_capacity_limit),
  25       last_id_(1) {}
  26
  27 void ShardedCache::SetCapacity(size_t capacity) {
  28   int num_shards = 1 << num_shard_bits_;
  29   const size_t per_shard = (capacity + (num_shards - 1)) / num_shards;
  30   std::lock_guard<std::mutex> l(capacity_mutex_);
  31   for (int s = 0; s < num_shards; s++) {
  32     GetShard(s)->SetCapacity(per_shard);
  33   }
  34   capacity_ = capacity;
  35 }
  36
  37 void ShardedCache::SetStrictCapacityLimit(bool strict_capacity_limit) {
  38   int num_shards = 1 << num_shard_bits_;
  39   std::lock_guard<std::mutex> l(capacity_mutex_);
  40   for (int s = 0; s < num_shards; s++) {
  41     GetShard(s)->SetStrictCapacityLimit(strict_capacity_limit);
  42   }
  43   strict_capacity_limit_ = strict_capacity_limit;
  44 }
  45
  46 rocksdb::Status ShardedCache::Insert(const rocksdb::Slice& key, void* value, size_t charge,
  47                             void (*deleter)(const rocksdb::Slice& key, void* value),
  48                             rocksdb::Cache::Handle** handle, Priority priority) {
  49   uint32_t hash = HashSlice(key);
  50   return GetShard(Shard(hash))
  51       ->Insert(key, hash, value, charge, deleter, handle, priority);
  52 }
  53
  54 rocksdb::Cache::Handle* ShardedCache::Lookup(const rocksdb::Slice& key, rocksdb::Statistics* /*stats*/) {
  55   uint32_t hash = HashSlice(key);
  56   return GetShard(Shard(hash))->Lookup(key, hash);
  57 }
  58
  59 bool ShardedCache::Ref(rocksdb::Cache::Handle* handle) {
  60   uint32_t hash = GetHash(handle);
  61   return GetShard(Shard(hash))->Ref(handle);
  62 }
  63
  64 bool ShardedCache::Release(rocksdb::Cache::Handle* handle, bool force_erase) {
  65   uint32_t hash = GetHash(handle);
  66   return GetShard(Shard(hash))->Release(handle, force_erase);
  67 }
  68
  69 void ShardedCache::Erase(const rocksdb::Slice& key) {
  70   uint32_t hash = HashSlice(key);
  71   GetShard(Shard(hash))->Erase(key, hash);
  72 }
  73
  74 uint64_t ShardedCache::NewId() {
  75   return last_id_.fetch_add(1, std::memory_order_relaxed);
  76 }
  77
  78 size_t ShardedCache::GetCapacity() const {
  79   std::lock_guard<std::mutex> l(capacity_mutex_);
  80   return capacity_;
  81 }
  82
  83 bool ShardedCache::HasStrictCapacityLimit() const {
  84   std::lock_guard<std::mutex> l(capacity_mutex_);
  85   return strict_capacity_limit_;
  86 }
  87
  88 size_t ShardedCache::GetUsage() const {
  89   // We will not lock the cache when getting the usage from shards.
  90   int num_shards = 1 << num_shard_bits_;
  91   size_t usage = 0;
  92   for (int s = 0; s < num_shards; s++) {
  93     usage += GetShard(s)->GetUsage();
  94   }
  95   return usage;
  96 }
  97
  98 size_t ShardedCache::GetUsage(rocksdb::Cache::Handle* handle) const {
  99   return GetCharge(handle);
 100 }
 101
 102 size_t ShardedCache::GetPinnedUsage() const {
 103   // We will not lock the cache when getting the usage from shards.
 104   int num_shards = 1 << num_shard_bits_;
 105   size_t usage = 0;
 106   for (int s = 0; s < num_shards; s++) {
 107     usage += GetShard(s)->GetPinnedUsage();
 108   }
 109   return usage;
 110 }
 111
 112 void ShardedCache::ApplyToAllCacheEntries(void (*callback)(void*, size_t),
 113                                           bool thread_safe) {
 114   int num_shards = 1 << num_shard_bits_;
 115   for (int s = 0; s < num_shards; s++) {
 116     GetShard(s)->ApplyToAllCacheEntries(callback, thread_safe);
 117   }
 118 }
 119
 120 void ShardedCache::EraseUnRefEntries() {
 121   int num_shards = 1 << num_shard_bits_;
 122   for (int s = 0; s < num_shards; s++) {
 123     GetShard(s)->EraseUnRefEntries();
 124   }
 125 }
 126
 127 std::string ShardedCache::GetPrintableOptions() const {
 128   std::string ret;
 129   ret.reserve(20000);
 130   const int kBufferSize = 200;
 131   char buffer[kBufferSize];
 132   {
 133     std::lock_guard<std::mutex> l(capacity_mutex_);
 134     snprintf(buffer, kBufferSize, "    capacity : %" ROCKSDB_PRIszt "\n",
 135              capacity_);
 136     ret.append(buffer);
 137     snprintf(buffer, kBufferSize, "    num_shard_bits : %d\n", num_shard_bits_);
 138     ret.append(buffer);
 139     snprintf(buffer, kBufferSize, "    strict_capacity_limit : %d\n",
 140              strict_capacity_limit_);
 141     ret.append(buffer);
 142   }
 143   ret.append(GetShard(0)->GetPrintableOptions());
 144   return ret;
 145 }
 146 int GetDefaultCacheShardBits(size_t capacity) {
 147   int num_shard_bits = 0;
 148   size_t min_shard_size = 512L * 1024L;  // Every shard is at least 512KB.
 149   size_t num_shards = capacity / min_shard_size;
 150   while (num_shards >>= 1) {
 151     if (++num_shard_bits >= 6) {
 152       // No more than 6.
 153       return num_shard_bits;
 154     }
 155   }
 156   return num_shard_bits;
 157 }
 158
 159 }  // namespace rocksdb_cache