NextGraph
/
rocksdb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Improve comments for some files (#9793)

Browse Source 
Summary:
Update the comments, e.g. fixing typo, formatting, etc.

Pull Request resolved: https://github.com/facebook/rocksdb/pull/9793

Reviewed By: jay-zhuang

Differential Revision: D35323989

Pulled By: gitbw95

fbshipit-source-id: 4a72fc02b67abaae8be0d1439b68f9967a68052d
main
Bo Wang 3 years ago committed by Facebook GitHub Bot
parent f246e56d0a
commit bcabee737f
5 changed files with 92 additions and 111 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 65
      cache/lru_cache.cc
  2. 36
      cache/lru_cache.h
  3. 13
      db/db_filesnapshot.cc
  4. 28
      include/rocksdb/cache.h
  5. 61
      tools/db_bench_tool.cc

65
cache/lru_cache.cc vendored
Unescape View File

@ -76,13 +76,12 @@ LRUHandle** LRUHandleTable::FindPointer(const Slice& key, uint32_t hash) {
void LRUHandleTable::Resize() { void LRUHandleTable::Resize() {
if (length_bits_ >= max_length_bits_) { if (length_bits_ >= max_length_bits_) {
// Due to reaching limit of hash information, if we made the table // Due to reaching limit of hash information, if we made the table bigger,
// bigger, we would allocate more addresses but only the same // we would allocate more addresses but only the same number would be used.
// number would be used.
return; return;
} }
if (length_bits_ >= 31) { if (length_bits_ >= 31) {
// Avoid undefined behavior shifting uint32_t by 32 // Avoid undefined behavior shifting uint32_t by 32.
return; return;
} }
@ -125,7 +124,7 @@ LRUCacheShard::LRUCacheShard(
mutex_(use_adaptive_mutex), mutex_(use_adaptive_mutex),
secondary_cache_(secondary_cache) { secondary_cache_(secondary_cache) {
set_metadata_charge_policy(metadata_charge_policy); set_metadata_charge_policy(metadata_charge_policy);
// Make empty circular linked list // Make empty circular linked list.
lru_.next = &lru_; lru_.next = &lru_;
lru_.prev = &lru_; lru_.prev = &lru_;
lru_low_pri_ = &lru_; lru_low_pri_ = &lru_;
@ -138,7 +137,7 @@ void LRUCacheShard::EraseUnRefEntries() {
MutexLock l(&mutex_); MutexLock l(&mutex_);
while (lru_.next != &lru_) { while (lru_.next != &lru_) {
LRUHandle* old = lru_.next; LRUHandle* old = lru_.next;
// LRU list contains only elements which can be evicted // LRU list contains only elements which can be evicted.
assert(old->InCache() && !old->HasRefs()); assert(old->InCache() && !old->HasRefs());
LRU_Remove(old); LRU_Remove(old);
table_.Remove(old->key(), old->hash); table_.Remove(old->key(), old->hash);
@ -168,7 +167,7 @@ void LRUCacheShard::ApplyToSomeEntries(
assert(average_entries_per_lock > 0); assert(average_entries_per_lock > 0);
// Assuming we are called with same average_entries_per_lock repeatedly, // Assuming we are called with same average_entries_per_lock repeatedly,
// this simplifies some logic (index_end will not overflow) // this simplifies some logic (index_end will not overflow).
assert(average_entries_per_lock < length || *state == 0); assert(average_entries_per_lock < length || *state == 0);
uint32_t index_begin = *state >> (32 - length_bits); uint32_t index_begin = *state >> (32 - length_bits);
@ -274,7 +273,7 @@ void LRUCacheShard::EvictFromLRU(size_t charge,
autovector<LRUHandle*>* deleted) { autovector<LRUHandle*>* deleted) {
while ((usage_ + charge) > capacity_ && lru_.next != &lru_) { while ((usage_ + charge) > capacity_ && lru_.next != &lru_) {
LRUHandle* old = lru_.next; LRUHandle* old = lru_.next;
// LRU list contains only elements which can be evicted // LRU list contains only elements which can be evicted.
assert(old->InCache() && !old->HasRefs()); assert(old->InCache() && !old->HasRefs());
LRU_Remove(old); LRU_Remove(old);
table_.Remove(old->key(), old->hash); table_.Remove(old->key(), old->hash);
@ -295,8 +294,8 @@ void LRUCacheShard::SetCapacity(size_t capacity) {
EvictFromLRU(0, &last_reference_list); EvictFromLRU(0, &last_reference_list);
} }
// Try to insert the evicted entries into tiered cache // Try to insert the evicted entries into tiered cache.
// Free the entries outside of mutex for performance reasons // Free the entries outside of mutex for performance reasons.
for (auto entry : last_reference_list) { for (auto entry : last_reference_list) {
if (secondary_cache_ && entry->IsSecondaryCacheCompatible() && if (secondary_cache_ && entry->IsSecondaryCacheCompatible() &&
!entry->IsPromoted()) { !entry->IsPromoted()) {
@ -322,7 +321,7 @@ Status LRUCacheShard::InsertItem(LRUHandle* e, Cache::Handle** handle,
MutexLock l(&mutex_); MutexLock l(&mutex_);
// Free the space following strict LRU policy until enough space // Free the space following strict LRU policy until enough space
// is freed or the lru list is empty // is freed or the lru list is empty.
EvictFromLRU(total_charge, &last_reference_list); EvictFromLRU(total_charge, &last_reference_list);
if ((usage_ + total_charge) > capacity_ && if ((usage_ + total_charge) > capacity_ &&
@ -349,7 +348,7 @@ Status LRUCacheShard::InsertItem(LRUHandle* e, Cache::Handle** handle,
assert(old->InCache()); assert(old->InCache());
old->SetInCache(false); old->SetInCache(false);
if (!old->HasRefs()) { if (!old->HasRefs()) {
// old is on LRU because it's in cache and its reference count is 0 // old is on LRU because it's in cache and its reference count is 0.
LRU_Remove(old); LRU_Remove(old);
size_t old_total_charge = size_t old_total_charge =
old->CalcTotalCharge(metadata_charge_policy_); old->CalcTotalCharge(metadata_charge_policy_);
@ -361,7 +360,7 @@ Status LRUCacheShard::InsertItem(LRUHandle* e, Cache::Handle** handle,
if (handle == nullptr) { if (handle == nullptr) {
LRU_Insert(e); LRU_Insert(e);
} else { } else {
// If caller already holds a ref, no need to take one here // If caller already holds a ref, no need to take one here.
if (!e->HasRefs()) { if (!e->HasRefs()) {
e->Ref(); e->Ref();
} }
@ -370,8 +369,8 @@ Status LRUCacheShard::InsertItem(LRUHandle* e, Cache::Handle** handle,
} }
} }
// Try to insert the evicted entries into the secondary cache // Try to insert the evicted entries into the secondary cache.
// Free the entries here outside of mutex for performance reasons // Free the entries here outside of mutex for performance reasons.
for (auto entry : last_reference_list) { for (auto entry : last_reference_list) {
if (secondary_cache_ && entry->IsSecondaryCacheCompatible() && if (secondary_cache_ && entry->IsSecondaryCacheCompatible() &&
!entry->IsPromoted()) { !entry->IsPromoted()) {
@ -404,7 +403,7 @@ void LRUCacheShard::Promote(LRUHandle* e) {
Status s = InsertItem(e, &handle, /*free_handle_on_fail=*/false); Status s = InsertItem(e, &handle, /*free_handle_on_fail=*/false);
if (!s.ok()) { if (!s.ok()) {
// Item is in memory, but not accounted against the cache capacity. // Item is in memory, but not accounted against the cache capacity.
// When the handle is released, the item should get deleted // When the handle is released, the item should get deleted.
assert(!e->InCache()); assert(!e->InCache());
} }
} else { } else {
@ -437,8 +436,8 @@ Cache::Handle* LRUCacheShard::Lookup(
} }
// If handle table lookup failed, then allocate a handle outside the // If handle table lookup failed, then allocate a handle outside the
// mutex if we're going to lookup in the secondary cache // mutex if we're going to lookup in the secondary cache.
// Only support synchronous for now // Only support synchronous for now.
// TODO: Support asynchronous lookup in secondary cache // TODO: Support asynchronous lookup in secondary cache
if (!e && secondary_cache_ && helper && helper->saveto_cb) { if (!e && secondary_cache_ && helper && helper->saveto_cb) {
// For objects from the secondary cache, we expect the caller to provide // For objects from the secondary cache, we expect the caller to provide
@ -469,7 +468,7 @@ Cache::Handle* LRUCacheShard::Lookup(
if (wait) { if (wait) {
Promote(e); Promote(e);
if (!e->value) { if (!e->value) {
// The secondary cache returned a handle, but the lookup failed // The secondary cache returned a handle, but the lookup failed.
e->Unref(); e->Unref();
e->Free(); e->Free();
e = nullptr; e = nullptr;
@ -479,7 +478,7 @@ Cache::Handle* LRUCacheShard::Lookup(
} }
} else { } else {
// If wait is false, we always return a handle and let the caller // If wait is false, we always return a handle and let the caller
// release the handle after checking for success or failure // release the handle after checking for success or failure.
e->SetIncomplete(true); e->SetIncomplete(true);
// This may be slightly inaccurate, if the lookup eventually fails. // This may be slightly inaccurate, if the lookup eventually fails.
// But the probability is very low. // But the probability is very low.
@ -494,7 +493,7 @@ Cache::Handle* LRUCacheShard::Lookup(
bool LRUCacheShard::Ref(Cache::Handle* h) { bool LRUCacheShard::Ref(Cache::Handle* h) {
LRUHandle* e = reinterpret_cast<LRUHandle*>(h); LRUHandle* e = reinterpret_cast<LRUHandle*>(h);
MutexLock l(&mutex_); MutexLock l(&mutex_);
// To create another reference - entry must be already externally referenced // To create another reference - entry must be already externally referenced.
assert(e->HasRefs()); assert(e->HasRefs());
e->Ref(); e->Ref();
return true; return true;
@ -517,15 +516,15 @@ bool LRUCacheShard::Release(Cache::Handle* handle, bool erase_if_last_ref) {
MutexLock l(&mutex_); MutexLock l(&mutex_);
last_reference = e->Unref(); last_reference = e->Unref();
if (last_reference && e->InCache()) { if (last_reference && e->InCache()) {
// The item is still in cache, and nobody else holds a reference to it // The item is still in cache, and nobody else holds a reference to it.
if (usage_ > capacity_ || erase_if_last_ref) { if (usage_ > capacity_ || erase_if_last_ref) {
// The LRU list must be empty since the cache is full // The LRU list must be empty since the cache is full.
assert(lru_.next == &lru_ || erase_if_last_ref); assert(lru_.next == &lru_ || erase_if_last_ref);
// Take this opportunity and remove the item // Take this opportunity and remove the item.
table_.Remove(e->key(), e->hash); table_.Remove(e->key(), e->hash);
e->SetInCache(false); e->SetInCache(false);
} else { } else {
// Put the item back on the LRU list, and don't free it // Put the item back on the LRU list, and don't free it.
LRU_Insert(e); LRU_Insert(e);
last_reference = false; last_reference = false;
} }
@ -542,7 +541,7 @@ bool LRUCacheShard::Release(Cache::Handle* handle, bool erase_if_last_ref) {
} }
} }
// Free the entry here outside of mutex for performance reasons // Free the entry here outside of mutex for performance reasons.
if (last_reference) { if (last_reference) {
e->Free(); e->Free();
} }
@ -554,8 +553,8 @@ Status LRUCacheShard::Insert(const Slice& key, uint32_t hash, void* value,
void (*deleter)(const Slice& key, void* value), void (*deleter)(const Slice& key, void* value),
const Cache::CacheItemHelper* helper, const Cache::CacheItemHelper* helper,
Cache::Handle** handle, Cache::Priority priority) { Cache::Handle** handle, Cache::Priority priority) {
// Allocate the memory here outside of the mutex // Allocate the memory here outside of the mutex.
// If the cache is full, we'll have to release it // If the cache is full, we'll have to release it.
// It shouldn't happen very often though. // It shouldn't happen very often though.
LRUHandle* e = reinterpret_cast<LRUHandle*>( LRUHandle* e = reinterpret_cast<LRUHandle*>(
new char[sizeof(LRUHandle) - 1 + key.size()]); new char[sizeof(LRUHandle) - 1 + key.size()]);
@ -603,8 +602,8 @@ void LRUCacheShard::Erase(const Slice& key, uint32_t hash) {
} }
} }
// Free the entry here outside of mutex for performance reasons // Free the entry here outside of mutex for performance reasons.
// last_reference will only be true if e != nullptr // last_reference will only be true if e != nullptr.
if (last_reference) { if (last_reference) {
e->Free(); e->Free();
} }
@ -705,7 +704,7 @@ uint32_t LRUCache::GetHash(Handle* handle) const {
} }
void LRUCache::DisownData() { void LRUCache::DisownData() {
// Leak data only if that won't generate an ASAN/valgrind warning // Leak data only if that won't generate an ASAN/valgrind warning.
if (!kMustFreeHeapAllocations) { if (!kMustFreeHeapAllocations) {
shards_ = nullptr; shards_ = nullptr;
num_shards_ = 0; num_shards_ = 0;
@ -765,10 +764,10 @@ std::shared_ptr<Cache> NewLRUCache(
CacheMetadataChargePolicy metadata_charge_policy, CacheMetadataChargePolicy metadata_charge_policy,
const std::shared_ptr<SecondaryCache>& secondary_cache) { const std::shared_ptr<SecondaryCache>& secondary_cache) {
if (num_shard_bits >= 20) { if (num_shard_bits >= 20) {
return nullptr; // the cache cannot be sharded into too many fine pieces return nullptr; // The cache cannot be sharded into too many fine pieces.
} }
if (high_pri_pool_ratio < 0.0 || high_pri_pool_ratio > 1.0) { if (high_pri_pool_ratio < 0.0 || high_pri_pool_ratio > 1.0) {
// invalid high_pri_pool_ratio // Invalid high_pri_pool_ratio
return nullptr; return nullptr;
} }
if (num_shard_bits < 0) { if (num_shard_bits < 0) {

36
cache/lru_cache.h vendored
Unescape View File

@ -81,11 +81,11 @@ struct LRUHandle {
IN_HIGH_PRI_POOL = (1 << 2), IN_HIGH_PRI_POOL = (1 << 2),
// Whether this entry has had any lookups (hits). // Whether this entry has had any lookups (hits).
HAS_HIT = (1 << 3), HAS_HIT = (1 << 3),
// Can this be inserted into the secondary cache // Can this be inserted into the secondary cache.
IS_SECONDARY_CACHE_COMPATIBLE = (1 << 4), IS_SECONDARY_CACHE_COMPATIBLE = (1 << 4),
// Is the handle still being read from a lower tier // Is the handle still being read from a lower tier.
IS_PENDING = (1 << 5), IS_PENDING = (1 << 5),
// Has the item been promoted from a lower tier // Has the item been promoted from a lower tier.
IS_PROMOTED = (1 << 6), IS_PROMOTED = (1 << 6),
}; };
@ -208,7 +208,7 @@ struct LRUHandle {
delete[] reinterpret_cast<char*>(this); delete[] reinterpret_cast<char*>(this);
} }
// Calculate the memory usage by metadata // Calculate the memory usage by metadata.
inline size_t CalcTotalCharge( inline size_t CalcTotalCharge(
CacheMetadataChargePolicy metadata_charge_policy) { CacheMetadataChargePolicy metadata_charge_policy) {
size_t meta_charge = 0; size_t meta_charge = 0;
@ -216,7 +216,7 @@ struct LRUHandle {
#ifdef ROCKSDB_MALLOC_USABLE_SIZE #ifdef ROCKSDB_MALLOC_USABLE_SIZE
meta_charge += malloc_usable_size(static_cast<void*>(this)); meta_charge += malloc_usable_size(static_cast<void*>(this));
#else #else
// This is the size that is used when a new handle is created // This is the size that is used when a new handle is created.
meta_charge += sizeof(LRUHandle) - 1 + key_length; meta_charge += sizeof(LRUHandle) - 1 + key_length;
#endif #endif
} }
@ -272,10 +272,10 @@ class LRUHandleTable {
// a linked list of cache entries that hash into the bucket. // a linked list of cache entries that hash into the bucket.
std::unique_ptr<LRUHandle*[]> list_; std::unique_ptr<LRUHandle*[]> list_;
// Number of elements currently in the table // Number of elements currently in the table.
uint32_t elems_; uint32_t elems_;
// Set from max_upper_hash_bits (see constructor) // Set from max_upper_hash_bits (see constructor).
const int max_length_bits_; const int max_length_bits_;
}; };
@ -291,7 +291,7 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
// Separate from constructor so caller can easily make an array of LRUCache // Separate from constructor so caller can easily make an array of LRUCache
// if current usage is more than new capacity, the function will attempt to // if current usage is more than new capacity, the function will attempt to
// free the needed space // free the needed space.
virtual void SetCapacity(size_t capacity) override; virtual void SetCapacity(size_t capacity) override;
// Set the flag to reject insertion if cache if full. // Set the flag to reject insertion if cache if full.
@ -314,8 +314,7 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
assert(helper); assert(helper);
return Insert(key, hash, value, charge, nullptr, helper, handle, priority); return Insert(key, hash, value, charge, nullptr, helper, handle, priority);
} }
// If helper_cb is null, the values of the following arguments don't // If helper_cb is null, the values of the following arguments don't matter.
// matter
virtual Cache::Handle* Lookup(const Slice& key, uint32_t hash, virtual Cache::Handle* Lookup(const Slice& key, uint32_t hash,
const ShardedCache::CacheItemHelper* helper, const ShardedCache::CacheItemHelper* helper,
const ShardedCache::CreateCallback& create_cb, const ShardedCache::CreateCallback& create_cb,
@ -354,8 +353,8 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
void TEST_GetLRUList(LRUHandle** lru, LRUHandle** lru_low_pri); void TEST_GetLRUList(LRUHandle** lru, LRUHandle** lru_low_pri);
// Retrieves number of elements in LRU, for unit test purpose only // Retrieves number of elements in LRU, for unit test purpose only.
// not threadsafe // Not threadsafe.
size_t TEST_GetLRUSize(); size_t TEST_GetLRUSize();
// Retrieves high pri pool ratio // Retrieves high pri pool ratio
@ -365,7 +364,8 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
friend class LRUCache; friend class LRUCache;
// Insert an item into the hash table and, if handle is null, insert into // Insert an item into the hash table and, if handle is null, insert into
// the LRU list. Older items are evicted as necessary. If the cache is full // the LRU list. Older items are evicted as necessary. If the cache is full
// and free_handle_on_fail is true, the item is deleted and handle is set to. // and free_handle_on_fail is true, the item is deleted and handle is set to
// nullptr.
Status InsertItem(LRUHandle* item, Cache::Handle** handle, Status InsertItem(LRUHandle* item, Cache::Handle** handle,
bool free_handle_on_fail); bool free_handle_on_fail);
Status Insert(const Slice& key, uint32_t hash, void* value, size_t charge, Status Insert(const Slice& key, uint32_t hash, void* value, size_t charge,
@ -389,7 +389,7 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
// Free some space following strict LRU policy until enough space // Free some space following strict LRU policy until enough space
// to hold (usage_ + charge) is freed or the lru list is empty // to hold (usage_ + charge) is freed or the lru list is empty
// This function is not thread safe - it needs to be executed while // This function is not thread safe - it needs to be executed while
// holding the mutex_ // holding the mutex_.
void EvictFromLRU(size_t charge, autovector<LRUHandle*>* deleted); void EvictFromLRU(size_t charge, autovector<LRUHandle*>* deleted);
// Initialized before use. // Initialized before use.
@ -429,10 +429,10 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
// ------------vvvvvvvvvvvvv----------- // ------------vvvvvvvvvvvvv-----------
LRUHandleTable table_; LRUHandleTable table_;
// Memory size for entries residing in the cache // Memory size for entries residing in the cache.
size_t usage_; size_t usage_;
// Memory size for entries residing only in the LRU list // Memory size for entries residing only in the LRU list.
size_t lru_usage_; size_t lru_usage_;
// mutex_ protects the following state. // mutex_ protects the following state.
@ -467,9 +467,9 @@ class LRUCache
virtual void DisownData() override; virtual void DisownData() override;
virtual void WaitAll(std::vector<Handle*>& handles) override; virtual void WaitAll(std::vector<Handle*>& handles) override;
// Retrieves number of elements in LRU, for unit test purpose only // Retrieves number of elements in LRU, for unit test purpose only.
size_t TEST_GetLRUSize(); size_t TEST_GetLRUSize();
// Retrieves high pri pool ratio // Retrieves high pri pool ratio.
double GetHighPriPoolRatio(); double GetHighPriPoolRatio();
private: private:

13
db/db_filesnapshot.cc
Unescape View File

@ -96,7 +96,7 @@ Status DBImpl::GetLiveFiles(std::vector<std::string>& ret,
3); // for CURRENT + MANIFEST + OPTIONS 3); // for CURRENT + MANIFEST + OPTIONS
// create names of the live files. The names are not absolute // create names of the live files. The names are not absolute
// paths, instead they are relative to dbname_; // paths, instead they are relative to dbname_.
for (const auto& table_file_number : live_table_files) { for (const auto& table_file_number : live_table_files) {
ret.emplace_back(MakeTableFileName("", table_file_number)); ret.emplace_back(MakeTableFileName("", table_file_number));
} }
@ -166,7 +166,7 @@ Status DBImpl::GetCurrentWalFile(std::unique_ptr<LogFile>* current_log_file) {
Status DBImpl::GetLiveFilesStorageInfo( Status DBImpl::GetLiveFilesStorageInfo(
const LiveFilesStorageInfoOptions& opts, const LiveFilesStorageInfoOptions& opts,
std::vector<LiveFileStorageInfo>* files) { std::vector<LiveFileStorageInfo>* files) {
// To avoid returning partial results, only move to ouput on success // To avoid returning partial results, only move results to files on success.
assert(files); assert(files);
files->clear(); files->clear();
std::vector<LiveFileStorageInfo> results; std::vector<LiveFileStorageInfo> results;
@ -180,7 +180,7 @@ Status DBImpl::GetLiveFilesStorageInfo(
if (opts.wal_size_for_flush == port::kMaxUint64) { if (opts.wal_size_for_flush == port::kMaxUint64) {
flush_memtable = false; flush_memtable = false;
} else if (opts.wal_size_for_flush > 0) { } else if (opts.wal_size_for_flush > 0) {
// If out standing log files are small, we skip the flush. // If the outstanding log files are small, we skip the flush.
s = GetSortedWalFiles(live_wal_files); s = GetSortedWalFiles(live_wal_files);
if (!s.ok()) { if (!s.ok()) {
@ -313,8 +313,7 @@ Status DBImpl::GetLiveFilesStorageInfo(
info.relative_filename = kCurrentFileName; info.relative_filename = kCurrentFileName;
info.directory = GetName(); info.directory = GetName();
info.file_type = kCurrentFile; info.file_type = kCurrentFile;
// CURRENT could be replaced so we have to record the contents we want // CURRENT could be replaced so we have to record the contents as needed.
// for it
info.replacement_contents = manifest_fname + "\n"; info.replacement_contents = manifest_fname + "\n";
info.size = manifest_fname.size() + 1; info.size = manifest_fname.size() + 1;
if (opts.include_checksum_info) { if (opts.include_checksum_info) {
@ -356,7 +355,7 @@ Status DBImpl::GetLiveFilesStorageInfo(
TEST_SYNC_POINT("CheckpointImpl::CreateCustomCheckpoint:AfterGetLive1"); TEST_SYNC_POINT("CheckpointImpl::CreateCustomCheckpoint:AfterGetLive1");
TEST_SYNC_POINT("CheckpointImpl::CreateCustomCheckpoint:AfterGetLive2"); TEST_SYNC_POINT("CheckpointImpl::CreateCustomCheckpoint:AfterGetLive2");
// if we have more than one column family, we need to also get WAL files // If we have more than one column family, we also need to get WAL files.
if (s.ok()) { if (s.ok()) {
s = GetSortedWalFiles(live_wal_files); s = GetSortedWalFiles(live_wal_files);
} }
@ -394,7 +393,7 @@ Status DBImpl::GetLiveFilesStorageInfo(
} }
if (s.ok()) { if (s.ok()) {
// Only move output on success // Only move results to output on success.
*files = std::move(results); *files = std::move(results);
} }
return s; return s;

28
include/rocksdb/cache.h
Unescape View File

@ -52,9 +52,8 @@ struct LRUCacheOptions {
// Capacity of the cache. // Capacity of the cache.
size_t capacity = 0; size_t capacity = 0;
// Cache is sharded into 2^num_shard_bits shards, // Cache is sharded into 2^num_shard_bits shards, by hash of key.
// by hash of key. Refer to NewLRUCache for further // Refer to NewLRUCache for further information.
// information.
int num_shard_bits = -1; int num_shard_bits = -1;
// If strict_capacity_limit is set, // If strict_capacity_limit is set,
@ -91,7 +90,7 @@ struct LRUCacheOptions {
CacheMetadataChargePolicy metadata_charge_policy = CacheMetadataChargePolicy metadata_charge_policy =
kDefaultCacheMetadataChargePolicy; kDefaultCacheMetadataChargePolicy;
// A SecondaryCache instance to use a the non-volatile tier // A SecondaryCache instance to use a the non-volatile tier.
std::shared_ptr<SecondaryCache> secondary_cache; std::shared_ptr<SecondaryCache> secondary_cache;
LRUCacheOptions() {} LRUCacheOptions() {}
@ -328,8 +327,8 @@ class Cache {
/** /**
* Release a mapping returned by a previous Lookup(). A released entry might * Release a mapping returned by a previous Lookup(). A released entry might
* still remain in cache in case it is later looked up by others. If * still remain in cache in case it is later looked up by others. If
* erase_if_last_ref is set then it also erase it from the cache if there is * erase_if_last_ref is set then it also erases it from the cache if there is
* no other reference to it. Erasing it should call the deleter function that * no other reference to it. Erasing it should call the deleter function that
* was provided when the entry was inserted. * was provided when the entry was inserted.
* *
@ -345,7 +344,7 @@ class Cache {
// REQUIRES: handle must have been returned by a method on *this. // REQUIRES: handle must have been returned by a method on *this.
virtual void* Value(Handle* handle) = 0; virtual void* Value(Handle* handle) = 0;
// If the cache contains entry for key, erase it. Note that the // If the cache contains the entry for the key, erase it. Note that the
// underlying entry will be kept around until all existing handles // underlying entry will be kept around until all existing handles
// to it have been released. // to it have been released.
virtual void Erase(const Slice& key) = 0; virtual void Erase(const Slice& key) = 0;
@ -369,19 +368,19 @@ class Cache {
// full capacity. // full capacity.
virtual bool HasStrictCapacityLimit() const = 0; virtual bool HasStrictCapacityLimit() const = 0;
// returns the maximum configured capacity of the cache // Returns the maximum configured capacity of the cache
virtual size_t GetCapacity() const = 0; virtual size_t GetCapacity() const = 0;
// returns the memory size for the entries residing in the cache. // Returns the memory size for the entries residing in the cache.
virtual size_t GetUsage() const = 0; virtual size_t GetUsage() const = 0;
// returns the memory size for a specific entry in the cache. // Returns the memory size for a specific entry in the cache.
virtual size_t GetUsage(Handle* handle) const = 0; virtual size_t GetUsage(Handle* handle) const = 0;
// returns the memory size for the entries in use by the system // Returns the memory size for the entries in use by the system
virtual size_t GetPinnedUsage() const = 0; virtual size_t GetPinnedUsage() const = 0;
// returns the charge for the specific entry in the cache. // Returns the charge for the specific entry in the cache.
virtual size_t GetCharge(Handle* handle) const = 0; virtual size_t GetCharge(Handle* handle) const = 0;
// Returns the deleter for the specified entry. This might seem useless // Returns the deleter for the specified entry. This might seem useless
@ -440,9 +439,8 @@ class Cache {
// The Insert and Lookup APIs below are intended to allow cached objects // The Insert and Lookup APIs below are intended to allow cached objects
// to be demoted/promoted between the primary block cache and a secondary // to be demoted/promoted between the primary block cache and a secondary
// cache. The secondary cache could be a non-volatile cache, and will // cache. The secondary cache could be a non-volatile cache, and will
// likely store the object in a different representation more suitable // likely store the object in a different representation. They rely on a
// for on disk storage. They rely on a per object CacheItemHelper to do // per object CacheItemHelper to do the conversions.
// the conversions.
// The secondary cache may persist across process and system restarts, // The secondary cache may persist across process and system restarts,
// and may even be moved between hosts. Therefore, the cache key must // and may even be moved between hosts. Therefore, the cache key must
// be repeatable across restarts/reboots, and globally unique if // be repeatable across restarts/reboots, and globally unique if

61
tools/db_bench_tool.cc
Unescape View File

@ -244,10 +244,9 @@ IF_ROCKSDB_LITE("",
) )
"\tgetmergeoperands -- Insert lots of merge records which are a list of " "\tgetmergeoperands -- Insert lots of merge records which are a list of "
"sorted ints for a key and then compare performance of lookup for another " "sorted ints for a key and then compare performance of lookup for another "
"key " "key by doing a Get followed by binary searching in the large sorted list "
"by doing a Get followed by binary searching in the large sorted list vs " "vs doing a GetMergeOperands and binary searching in the operands which "
"doing a GetMergeOperands and binary searching in the operands which are" "are sorted sub-lists. The MergeOperator used is sortlist.h\n"
"sorted sub-lists. The MergeOperator used is sortlist.h\n"
"\treadrandomoperands -- read random keys using `GetMergeOperands()`. An " "\treadrandomoperands -- read random keys using `GetMergeOperands()`. An "
"operation includes a rare but possible retry in case it got " "operation includes a rare but possible retry in case it got "
"`Status::Incomplete()`. This happens upon encountering more keys than " "`Status::Incomplete()`. This happens upon encountering more keys than "
@ -356,18 +355,14 @@ DEFINE_double(
"Used in 'filluniquerandom' benchmark: for each write operation, " "Used in 'filluniquerandom' benchmark: for each write operation, "
"we give a probability to perform an overwrite instead. The key used for " "we give a probability to perform an overwrite instead. The key used for "
"the overwrite is randomly chosen from the last 'overwrite_window_size' " "the overwrite is randomly chosen from the last 'overwrite_window_size' "
"keys " "keys previously inserted into the DB. "
"previously inserted into the DB. "
"Valid overwrite_probability values: [0.0, 1.0]."); "Valid overwrite_probability values: [0.0, 1.0].");
DEFINE_uint32(overwrite_window_size, 1, DEFINE_uint32(overwrite_window_size, 1,
"Used in 'filluniquerandom' benchmark. For each write " "Used in 'filluniquerandom' benchmark. For each write operation,"
"operation, when " " when the overwrite_probability flag is set by the user, the "
"the overwrite_probability flag is set by the user, the key used " "key used to perform an overwrite is randomly chosen from the "
"to perform " "last 'overwrite_window_size' keys previously inserted into DB. "
"an overwrite is randomly chosen from the last "
"'overwrite_window_size' keys "
"previously inserted into the DB. "
"Warning: large values can affect throughput. " "Warning: large values can affect throughput. "
"Valid overwrite_window_size values: [1, kMaxUint32]."); "Valid overwrite_window_size values: [1, kMaxUint32].");
@ -567,7 +562,7 @@ DEFINE_bool(use_lru_secondary_cache, false,
"Use the LRUSecondaryCache as the secondary cache."); "Use the LRUSecondaryCache as the secondary cache.");
DEFINE_int64(lru_secondary_cache_size, 8 << 20, // 8MB DEFINE_int64(lru_secondary_cache_size, 8 << 20, // 8MB
"Number of bytes to use as a cache of data"); "Number of bytes to use as a cache of data.");
DEFINE_int32(lru_secondary_cache_numshardbits, 6, DEFINE_int32(lru_secondary_cache_numshardbits, 6,
"Number of shards for the block cache" "Number of shards for the block cache"
@ -838,18 +833,15 @@ DEFINE_string(max_bytes_for_level_multiplier_additional, "",
DEFINE_int32(level0_stop_writes_trigger, DEFINE_int32(level0_stop_writes_trigger,
ROCKSDB_NAMESPACE::Options().level0_stop_writes_trigger, ROCKSDB_NAMESPACE::Options().level0_stop_writes_trigger,
"Number of files in level-0" "Number of files in level-0 that will trigger put stop.");
" that will trigger put stop.");
DEFINE_int32(level0_slowdown_writes_trigger, DEFINE_int32(level0_slowdown_writes_trigger,
ROCKSDB_NAMESPACE::Options().level0_slowdown_writes_trigger, ROCKSDB_NAMESPACE::Options().level0_slowdown_writes_trigger,
"Number of files in level-0" "Number of files in level-0 that will slow down writes.");
" that will slow down writes.");
DEFINE_int32(level0_file_num_compaction_trigger, DEFINE_int32(level0_file_num_compaction_trigger,
ROCKSDB_NAMESPACE::Options().level0_file_num_compaction_trigger, ROCKSDB_NAMESPACE::Options().level0_file_num_compaction_trigger,
"Number of files in level-0" "Number of files in level-0 when compactions start.");
" when compactions start");
DEFINE_uint64(periodic_compaction_seconds, DEFINE_uint64(periodic_compaction_seconds,
ROCKSDB_NAMESPACE::Options().periodic_compaction_seconds, ROCKSDB_NAMESPACE::Options().periodic_compaction_seconds,
@ -913,8 +905,7 @@ DEFINE_int64(writes_per_range_tombstone, 0,
DEFINE_int64(range_tombstone_width, 100, "Number of keys in tombstone's range"); DEFINE_int64(range_tombstone_width, 100, "Number of keys in tombstone's range");
DEFINE_int64(max_num_range_tombstones, 0, DEFINE_int64(max_num_range_tombstones, 0,
"Maximum number of range tombstones " "Maximum number of range tombstones to insert.");
"to insert.");
DEFINE_bool(expand_range_tombstones, false, DEFINE_bool(expand_range_tombstones, false,
"Expand range tombstone into sequential regular tombstones."); "Expand range tombstone into sequential regular tombstones.");
@ -1128,8 +1119,7 @@ DEFINE_bool(file_checksum, false,
DEFINE_bool(rate_limit_auto_wal_flush, false, DEFINE_bool(rate_limit_auto_wal_flush, false,
"When true use Env::IO_USER priority level to charge internal rate " "When true use Env::IO_USER priority level to charge internal rate "
"limiter for automatic WAL flush (`Options::manual_wal_flush` == " "limiter for automatic WAL flush (`Options::manual_wal_flush` == "
"false) after the user " "false) after the user write operation.");
"write operation");
DEFINE_bool(async_io, false, DEFINE_bool(async_io, false,
"When set true, RocksDB does asynchronous reads for internal auto " "When set true, RocksDB does asynchronous reads for internal auto "
@ -1218,8 +1208,7 @@ DEFINE_int32(table_cache_numshardbits, 4, "");
#ifndef ROCKSDB_LITE #ifndef ROCKSDB_LITE
DEFINE_string(env_uri, "", DEFINE_string(env_uri, "",
"URI for registry Env lookup. Mutually exclusive" "URI for registry Env lookup. Mutually exclusive with --fs_uri");
" with --fs_uri");
DEFINE_string(fs_uri, "", DEFINE_string(fs_uri, "",
"URI for registry Filesystem lookup. Mutually exclusive" "URI for registry Filesystem lookup. Mutually exclusive"
" with --env_uri." " with --env_uri."
@ -1313,8 +1302,7 @@ DEFINE_uint64(write_thread_slow_yield_usec, 3,
DEFINE_uint64(rate_limiter_bytes_per_sec, 0, "Set options.rate_limiter value."); DEFINE_uint64(rate_limiter_bytes_per_sec, 0, "Set options.rate_limiter value.");
DEFINE_int64(rate_limiter_refill_period_us, 100 * 1000, DEFINE_int64(rate_limiter_refill_period_us, 100 * 1000,
"Set refill period on " "Set refill period on rate limiter.");
"rate limiter.");
DEFINE_bool(rate_limiter_auto_tuned, false, DEFINE_bool(rate_limiter_auto_tuned, false,
"Enable dynamic adjustment of rate limit according to demand for " "Enable dynamic adjustment of rate limit according to demand for "
@ -1362,14 +1350,11 @@ DEFINE_double(keyrange_dist_d, 0.0,
"f(x)=a*exp(b*x)+c*exp(d*x)"); "f(x)=a*exp(b*x)+c*exp(d*x)");
DEFINE_int64(keyrange_num, 1, DEFINE_int64(keyrange_num, 1,
"The number of key ranges that are in the same prefix " "The number of key ranges that are in the same prefix "
"group, each prefix range will have its key access " "group, each prefix range will have its key access distribution");
"distribution");
DEFINE_double(key_dist_a, 0.0, DEFINE_double(key_dist_a, 0.0,
"The parameter 'a' of key access distribution model " "The parameter 'a' of key access distribution model f(x)=a*x^b");
"f(x)=a*x^b");
DEFINE_double(key_dist_b, 0.0, DEFINE_double(key_dist_b, 0.0,
"The parameter 'b' of key access distribution model " "The parameter 'b' of key access distribution model f(x)=a*x^b");
"f(x)=a*x^b");
DEFINE_double(value_theta, 0.0, DEFINE_double(value_theta, 0.0,
"The parameter 'theta' of Generized Pareto Distribution " "The parameter 'theta' of Generized Pareto Distribution "
"f(x)=(1/sigma)*(1+k*(x-theta)/sigma)^-(1/k+1)"); "f(x)=(1/sigma)*(1+k*(x-theta)/sigma)^-(1/k+1)");
@ -1897,7 +1882,7 @@ struct DBWithColumnFamilies {
} }
}; };
// a class that reports stats to CSV file // A class that reports stats to CSV file.
class ReporterAgent { class ReporterAgent {
public: public:
ReporterAgent(Env* env, const std::string& fname, ReporterAgent(Env* env, const std::string& fname,
@ -2082,7 +2067,7 @@ class Stats {
if (other.start_ < start_) start_ = other.start_; if (other.start_ < start_) start_ = other.start_;
if (other.finish_ > finish_) finish_ = other.finish_; if (other.finish_ > finish_) finish_ = other.finish_;
// Just keep the messages from one thread // Just keep the messages from one thread.
if (message_.empty()) message_ = other.message_; if (message_.empty()) message_ = other.message_;
} }
@ -2139,7 +2124,7 @@ class Stats {
} }
void ResetLastOpTime() { void ResetLastOpTime() {
// Set to now to avoid latency from calls to SleepForMicroseconds // Set to now to avoid latency from calls to SleepForMicroseconds.
last_op_finish_ = clock_->NowMicros(); last_op_finish_ = clock_->NowMicros();
} }
@ -2186,7 +2171,7 @@ class Stats {
if (FLAGS_stats_interval_seconds && if (FLAGS_stats_interval_seconds &&
usecs_since_last < (FLAGS_stats_interval_seconds * 1000000)) { usecs_since_last < (FLAGS_stats_interval_seconds * 1000000)) {
// Don't check again for this many operations // Don't check again for this many operations.
next_report_ += FLAGS_stats_interval; next_report_ += FLAGS_stats_interval;
} else { } else {

Write Preview
Loading…
Cancel
Save