mirror of
https://github.com/facebook/rocksdb.git
synced 2024-11-29 00:34:03 +00:00
7555243bcf
Summary: The motivations for this change include * Free up space in ClockHandle so that we can add data for secondary cache handling while still keeping within single cache line (64 byte) size. * This change frees up space by eliminating the need for the `hash` field by making the fixed-size key itself a hash, using a 128-bit bijective (lossless) hash. * Generally more customizability of ShardedCache (such as hashing) without worrying about virtual call overheads * ShardedCache now uses static polymorphism (template) instead of dynamic polymorphism (virtual overrides) for the CacheShard. No obvious performance benefit is seen from the change (as mostly expected; most calls to virtual functions in CacheShard could already be optimized to static calls), but offers more flexibility without incurring the runtime cost of adhering to a common interface (without type parameters or static callbacks). * You'll also notice less `reinterpret_cast`ing and other boilerplate in the Cache implementations, as this can go in ShardedCache. More detail: * Don't have LRUCacheShard maintain `std::shared_ptr<SecondaryCache>` copies (extra refcount) when LRUCache can be in charge of keeping a `shared_ptr`. * Renamed `capacity_mutex_` to `config_mutex_` to better represent the scope of what it guards. * Some preparation for 64-bit hash and indexing in LRUCache, but didn't include the full change because of slight performance regression. Pull Request resolved: https://github.com/facebook/rocksdb/pull/10801 Test Plan: Unit test updates were non-trivial because of major changes to the ClockCacheShard interface in handling of key vs. hash. Performance: Create with `TEST_TMPDIR=/dev/shm ./db_bench -benchmarks=fillrandom -num=30000000 -disable_wal=1 -bloom_bits=16` Test with ``` TEST_TMPDIR=/dev/shm ./db_bench -benchmarks=readrandom[-X1000] -readonly -num=30000000 -bloom_bits=16 -cache_index_and_filter_blocks=1 -cache_size=610000000 -duration 20 -threads=16 ``` Before: `readrandom [AVG 150 runs] : 321147 (± 253) ops/sec` After: `readrandom [AVG 150 runs] : 321530 (± 326) ops/sec` So possibly ~0.1% improvement. And with `-cache_type=hyper_clock_cache`: Before: `readrandom [AVG 30 runs] : 614126 (± 7978) ops/sec` After: `readrandom [AVG 30 runs] : 645349 (± 8087) ops/sec` So roughly 5% improvement! Reviewed By: anand1976 Differential Revision: D40252236 Pulled By: pdillinger fbshipit-source-id: ff8fc70ef569585edc95bcbaaa0386f61355ae5b
101 lines
3 KiB
C++
101 lines
3 KiB
C++
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
|
// This source code is licensed under both the GPLv2 (found in the
|
|
// COPYING file in the root directory) and Apache 2.0 License
|
|
// (found in the LICENSE.Apache file in the root directory).
|
|
//
|
|
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
|
|
|
#include "cache/sharded_cache.h"
|
|
|
|
#include <algorithm>
|
|
#include <cstdint>
|
|
#include <memory>
|
|
|
|
#include "util/hash.h"
|
|
#include "util/math.h"
|
|
#include "util/mutexlock.h"
|
|
|
|
namespace ROCKSDB_NAMESPACE {
|
|
|
|
ShardedCacheBase::ShardedCacheBase(size_t capacity, int num_shard_bits,
|
|
bool strict_capacity_limit,
|
|
std::shared_ptr<MemoryAllocator> allocator)
|
|
: Cache(std::move(allocator)),
|
|
last_id_(1),
|
|
shard_mask_((uint32_t{1} << num_shard_bits) - 1),
|
|
strict_capacity_limit_(strict_capacity_limit),
|
|
capacity_(capacity) {}
|
|
|
|
size_t ShardedCacheBase::ComputePerShardCapacity(size_t capacity) const {
|
|
uint32_t num_shards = GetNumShards();
|
|
return (capacity + (num_shards - 1)) / num_shards;
|
|
}
|
|
|
|
size_t ShardedCacheBase::GetPerShardCapacity() const {
|
|
return ComputePerShardCapacity(GetCapacity());
|
|
}
|
|
|
|
uint64_t ShardedCacheBase::NewId() {
|
|
return last_id_.fetch_add(1, std::memory_order_relaxed);
|
|
}
|
|
|
|
size_t ShardedCacheBase::GetCapacity() const {
|
|
MutexLock l(&config_mutex_);
|
|
return capacity_;
|
|
}
|
|
|
|
bool ShardedCacheBase::HasStrictCapacityLimit() const {
|
|
MutexLock l(&config_mutex_);
|
|
return strict_capacity_limit_;
|
|
}
|
|
|
|
size_t ShardedCacheBase::GetUsage(Handle* handle) const {
|
|
return GetCharge(handle);
|
|
}
|
|
|
|
std::string ShardedCacheBase::GetPrintableOptions() const {
|
|
std::string ret;
|
|
ret.reserve(20000);
|
|
const int kBufferSize = 200;
|
|
char buffer[kBufferSize];
|
|
{
|
|
MutexLock l(&config_mutex_);
|
|
snprintf(buffer, kBufferSize, " capacity : %" ROCKSDB_PRIszt "\n",
|
|
capacity_);
|
|
ret.append(buffer);
|
|
snprintf(buffer, kBufferSize, " num_shard_bits : %d\n",
|
|
GetNumShardBits());
|
|
ret.append(buffer);
|
|
snprintf(buffer, kBufferSize, " strict_capacity_limit : %d\n",
|
|
strict_capacity_limit_);
|
|
ret.append(buffer);
|
|
}
|
|
snprintf(buffer, kBufferSize, " memory_allocator : %s\n",
|
|
memory_allocator() ? memory_allocator()->Name() : "None");
|
|
ret.append(buffer);
|
|
AppendPrintableOptions(ret);
|
|
return ret;
|
|
}
|
|
|
|
int GetDefaultCacheShardBits(size_t capacity, size_t min_shard_size) {
|
|
int num_shard_bits = 0;
|
|
size_t num_shards = capacity / min_shard_size;
|
|
while (num_shards >>= 1) {
|
|
if (++num_shard_bits >= 6) {
|
|
// No more than 6.
|
|
return num_shard_bits;
|
|
}
|
|
}
|
|
return num_shard_bits;
|
|
}
|
|
|
|
int ShardedCacheBase::GetNumShardBits() const {
|
|
return BitsSetToOne(shard_mask_);
|
|
}
|
|
|
|
uint32_t ShardedCacheBase::GetNumShards() const { return shard_mask_ + 1; }
|
|
|
|
} // namespace ROCKSDB_NAMESPACE
|