mirror of
https://github.com/facebook/rocksdb
synced 2026-05-24 09:29:21 +00:00
d9cfaa2b16
Summary:
Persistent cache tier is the tier abstraction that can work for any block
device based device mounted on a file system. The design/implementation can
handle any generic block device.
Any generic block support is achieved by generalizing the access patten as
{io-size, q-depth, direct-io/buffered}.
We have specifically tested and adapted the IO path for NVM and SSD.
Persistent cache tier consists of there parts :
1) File layout
Provides the implementation for handling IO path for reading and writing data
(key/value pair).
2) Meta-data
Provides the implementation for handling the index for persistent read cache.
3) Implementation
It binds (1) and (2) and flushed out the PersistentCacheTier interface
This patch provides implementation for (1)(2). Follow up patch will provide (3)
and tests.
Test Plan: Compile and run check
Subscribers: andrewkr, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D57117
67 lines
1.4 KiB
C++
67 lines
1.4 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.
|
|
#pragma once
|
|
|
|
#include <limits>
|
|
#include <list>
|
|
|
|
#include "util/mutexlock.h"
|
|
|
|
namespace rocksdb {
|
|
|
|
//
|
|
// Simple synchronized queue implementation with the option of
|
|
// bounding the queue
|
|
//
|
|
// On overflow, the elements will be discarded
|
|
//
|
|
template <class T>
|
|
class BoundedQueue {
|
|
public:
|
|
explicit BoundedQueue(
|
|
const size_t max_size = std::numeric_limits<size_t>::max())
|
|
: cond_empty_(&lock_), max_size_(max_size) {}
|
|
|
|
virtual ~BoundedQueue() {}
|
|
|
|
void Push(T&& t) {
|
|
MutexLock _(&lock_);
|
|
if (max_size_ != std::numeric_limits<size_t>::max() &&
|
|
size_ + t.Size() >= max_size_) {
|
|
// overflow
|
|
return;
|
|
}
|
|
|
|
size_ += t.Size();
|
|
q_.push_back(std::move(t));
|
|
cond_empty_.SignalAll();
|
|
}
|
|
|
|
T Pop() {
|
|
MutexLock _(&lock_);
|
|
while (q_.empty()) {
|
|
cond_empty_.Wait();
|
|
}
|
|
|
|
T t = std::move(q_.front());
|
|
size_ -= t.Size();
|
|
q_.pop_front();
|
|
return std::move(t);
|
|
}
|
|
|
|
size_t Size() const {
|
|
MutexLock _(&lock_);
|
|
return size_;
|
|
}
|
|
|
|
private:
|
|
mutable port::Mutex lock_;
|
|
port::CondVar cond_empty_;
|
|
std::list<T> q_;
|
|
size_t size_ = 0;
|
|
const size_t max_size_;
|
|
};
|
|
|
|
} // namespace rocksdb
|