mirror of
https://github.com/facebook/rocksdb.git
synced 2024-11-28 05:43:50 +00:00
3070ed9021
Summary: This diff provides the basic interface definitions of persistent read cache system PersistentCacheOptions captures the persistent read cache options used to configure and control the system PersistentCacheTier provides the basic building block for constructing tiered cache PersistentTieredCache provides a logical abstraction of tiers of cache layered over one another Test Plan: Compile Reviewers: sdong Subscribers: andrewkr, dhruba, leveldb Differential Revision: https://reviews.facebook.net/D57051
112 lines
2.6 KiB
C++
112 lines
2.6 KiB
C++
// Copyright (c) 2013, Facebook, Inc. All rights reserved.
|
|
// This source code is licensed under the BSD-style license found in the
|
|
// LICENSE file in the root directory of this source tree. An additional grant
|
|
// of patent rights can be found in the PATENTS file in the same directory.
|
|
//
|
|
#ifndef ROCKSDB_LITE
|
|
|
|
#include "utilities/persistent_cache/persistent_cache_tier.h"
|
|
|
|
#include <string>
|
|
|
|
namespace rocksdb {
|
|
|
|
//
|
|
// PersistentCacheTier implementation
|
|
//
|
|
Status PersistentCacheTier::Open() {
|
|
if (next_tier_) {
|
|
return next_tier_->Open();
|
|
}
|
|
return Status::OK();
|
|
}
|
|
|
|
Status PersistentCacheTier::Close() {
|
|
if (next_tier_) {
|
|
return next_tier_->Close();
|
|
}
|
|
return Status::OK();
|
|
}
|
|
|
|
void PersistentCacheTier::Flush() {
|
|
if (next_tier_) {
|
|
next_tier_->Flush();
|
|
}
|
|
}
|
|
|
|
bool PersistentCacheTier::Reserve(const size_t size) {
|
|
// default implementation is a pass through
|
|
return true;
|
|
}
|
|
|
|
bool PersistentCacheTier::Erase(const Slice& key) {
|
|
// default implementation is a pass through since not all cache tiers might
|
|
// support erase
|
|
return true;
|
|
}
|
|
|
|
std::string PersistentCacheTier::PrintStats() {
|
|
if (next_tier_) {
|
|
return next_tier_->PrintStats();
|
|
}
|
|
return std::string();
|
|
}
|
|
|
|
//
|
|
// PersistentTieredCache implementation
|
|
//
|
|
PersistentTieredCache::~PersistentTieredCache() { assert(tiers_.empty()); }
|
|
|
|
Status PersistentTieredCache::Open() {
|
|
assert(!tiers_.empty());
|
|
return tiers_.front()->Open();
|
|
}
|
|
|
|
Status PersistentTieredCache::Close() {
|
|
assert(!tiers_.empty());
|
|
Status status = tiers_.front()->Close();
|
|
if (status.ok()) {
|
|
tiers_.clear();
|
|
}
|
|
return status;
|
|
}
|
|
|
|
void PersistentTieredCache::Flush() {
|
|
assert(!tiers_.empty());
|
|
tiers_.front()->Flush();
|
|
}
|
|
|
|
bool PersistentTieredCache::Erase(const Slice& key) {
|
|
assert(!tiers_.empty());
|
|
return tiers_.front()->Erase(key);
|
|
}
|
|
|
|
std::string PersistentTieredCache::PrintStats() {
|
|
assert(!tiers_.empty());
|
|
return tiers_.front()->PrintStats();
|
|
}
|
|
|
|
Status PersistentTieredCache::Insert(const Slice& page_key, const char* data,
|
|
const size_t size) {
|
|
assert(!tiers_.empty());
|
|
return tiers_.front()->Insert(page_key, data, size);
|
|
}
|
|
|
|
Status PersistentTieredCache::Lookup(const Slice& page_key,
|
|
std::unique_ptr<char[]>* data,
|
|
size_t* size) {
|
|
assert(!tiers_.empty());
|
|
return tiers_.front()->Lookup(page_key, data, size);
|
|
}
|
|
|
|
void PersistentTieredCache::AddTier(const Tier& tier) {
|
|
if (!tiers_.empty()) {
|
|
tiers_.back()->set_next_tier(tier);
|
|
}
|
|
tiers_.push_back(tier);
|
|
}
|
|
|
|
} // namespace rocksdb
|
|
|
|
#endif
|