Divide file_reader_writer.h and .cc (#5803)
Summary: file_reader_writer.h and .cc contain several files and helper function, and it's hard to navigate. Separate it to multiple files and put them under file/ Pull Request resolved: https://github.com/facebook/rocksdb/pull/5803 Test Plan: Build whole project using make and cmake. Differential Revision: D17374550 fbshipit-source-id: 10efca907721e7a78ed25bbf74dc5410dea05987main
sdong
5 years ago
committed by
Facebook Github Bot
parent
915d72d849
commit
b931f84e56
@ -0,0 +1,133 @@ |
||||
// 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 "file/file_prefetch_buffer.h" |
||||
|
||||
#include <algorithm> |
||||
#include <mutex> |
||||
|
||||
#include "file/random_access_file_reader.h" |
||||
#include "monitoring/histogram.h" |
||||
#include "monitoring/iostats_context_imp.h" |
||||
#include "port/port.h" |
||||
#include "test_util/sync_point.h" |
||||
#include "util/random.h" |
||||
#include "util/rate_limiter.h" |
||||
|
||||
namespace rocksdb { |
||||
Status FilePrefetchBuffer::Prefetch(RandomAccessFileReader* reader, |
||||
uint64_t offset, size_t n, |
||||
bool for_compaction) { |
||||
size_t alignment = reader->file()->GetRequiredBufferAlignment(); |
||||
size_t offset_ = static_cast<size_t>(offset); |
||||
uint64_t rounddown_offset = Rounddown(offset_, alignment); |
||||
uint64_t roundup_end = Roundup(offset_ + n, alignment); |
||||
uint64_t roundup_len = roundup_end - rounddown_offset; |
||||
assert(roundup_len >= alignment); |
||||
assert(roundup_len % alignment == 0); |
||||
|
||||
// Check if requested bytes are in the existing buffer_.
|
||||
// If all bytes exist -- return.
|
||||
// If only a few bytes exist -- reuse them & read only what is really needed.
|
||||
// This is typically the case of incremental reading of data.
|
||||
// If no bytes exist in buffer -- full pread.
|
||||
|
||||
Status s; |
||||
uint64_t chunk_offset_in_buffer = 0; |
||||
uint64_t chunk_len = 0; |
||||
bool copy_data_to_new_buffer = false; |
||||
if (buffer_.CurrentSize() > 0 && offset >= buffer_offset_ && |
||||
offset <= buffer_offset_ + buffer_.CurrentSize()) { |
||||
if (offset + n <= buffer_offset_ + buffer_.CurrentSize()) { |
||||
// All requested bytes are already in the buffer. So no need to Read
|
||||
// again.
|
||||
return s; |
||||
} else { |
||||
// Only a few requested bytes are in the buffer. memmove those chunk of
|
||||
// bytes to the beginning, and memcpy them back into the new buffer if a
|
||||
// new buffer is created.
|
||||
chunk_offset_in_buffer = |
||||
Rounddown(static_cast<size_t>(offset - buffer_offset_), alignment); |
||||
chunk_len = buffer_.CurrentSize() - chunk_offset_in_buffer; |
||||
assert(chunk_offset_in_buffer % alignment == 0); |
||||
assert(chunk_len % alignment == 0); |
||||
assert(chunk_offset_in_buffer + chunk_len <= |
||||
buffer_offset_ + buffer_.CurrentSize()); |
||||
if (chunk_len > 0) { |
||||
copy_data_to_new_buffer = true; |
||||
} else { |
||||
// this reset is not necessary, but just to be safe.
|
||||
chunk_offset_in_buffer = 0; |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Create a new buffer only if current capacity is not sufficient, and memcopy
|
||||
// bytes from old buffer if needed (i.e., if chunk_len is greater than 0).
|
||||
if (buffer_.Capacity() < roundup_len) { |
||||
buffer_.Alignment(alignment); |
||||
buffer_.AllocateNewBuffer(static_cast<size_t>(roundup_len), |
||||
copy_data_to_new_buffer, chunk_offset_in_buffer, |
||||
static_cast<size_t>(chunk_len)); |
||||
} else if (chunk_len > 0) { |
||||
// New buffer not needed. But memmove bytes from tail to the beginning since
|
||||
// chunk_len is greater than 0.
|
||||
buffer_.RefitTail(static_cast<size_t>(chunk_offset_in_buffer), |
||||
static_cast<size_t>(chunk_len)); |
||||
} |
||||
|
||||
Slice result; |
||||
s = reader->Read(rounddown_offset + chunk_len, |
||||
static_cast<size_t>(roundup_len - chunk_len), &result, |
||||
buffer_.BufferStart() + chunk_len, for_compaction); |
||||
if (s.ok()) { |
||||
buffer_offset_ = rounddown_offset; |
||||
buffer_.Size(static_cast<size_t>(chunk_len) + result.size()); |
||||
} |
||||
return s; |
||||
} |
||||
|
||||
bool FilePrefetchBuffer::TryReadFromCache(uint64_t offset, size_t n, |
||||
Slice* result, bool for_compaction) { |
||||
if (track_min_offset_ && offset < min_offset_read_) { |
||||
min_offset_read_ = static_cast<size_t>(offset); |
||||
} |
||||
if (!enable_ || offset < buffer_offset_) { |
||||
return false; |
||||
} |
||||
|
||||
// If the buffer contains only a few of the requested bytes:
|
||||
// If readahead is enabled: prefetch the remaining bytes + readadhead bytes
|
||||
// and satisfy the request.
|
||||
// If readahead is not enabled: return false.
|
||||
if (offset + n > buffer_offset_ + buffer_.CurrentSize()) { |
||||
if (readahead_size_ > 0) { |
||||
assert(file_reader_ != nullptr); |
||||
assert(max_readahead_size_ >= readahead_size_); |
||||
Status s; |
||||
if (for_compaction) { |
||||
s = Prefetch(file_reader_, offset, std::max(n, readahead_size_), |
||||
for_compaction); |
||||
} else { |
||||
s = Prefetch(file_reader_, offset, n + readahead_size_, for_compaction); |
||||
} |
||||
if (!s.ok()) { |
||||
return false; |
||||
} |
||||
readahead_size_ = std::min(max_readahead_size_, readahead_size_ * 2); |
||||
} else { |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
uint64_t offset_in_buffer = offset - buffer_offset_; |
||||
*result = Slice(buffer_.BufferStart() + offset_in_buffer, n); |
||||
return true; |
||||
} |
||||
} // namespace rocksdb
|
||||
@ -0,0 +1,97 @@ |
||||
// 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.
|
||||
|
||||
#pragma once |
||||
#include <atomic> |
||||
#include <sstream> |
||||
#include <string> |
||||
#include "file/random_access_file_reader.h" |
||||
#include "port/port.h" |
||||
#include "rocksdb/env.h" |
||||
#include "util/aligned_buffer.h" |
||||
|
||||
namespace rocksdb { |
||||
|
||||
// FilePrefetchBuffer is a smart buffer to store and read data from a file.
|
||||
class FilePrefetchBuffer { |
||||
public: |
||||
// Constructor.
|
||||
//
|
||||
// All arguments are optional.
|
||||
// file_reader : the file reader to use. Can be a nullptr.
|
||||
// readahead_size : the initial readahead size.
|
||||
// max_readahead_size : the maximum readahead size.
|
||||
// If max_readahead_size > readahead_size, the readahead size will be
|
||||
// doubled on every IO until max_readahead_size is hit.
|
||||
// Typically this is set as a multiple of readahead_size.
|
||||
// max_readahead_size should be greater than equal to readahead_size.
|
||||
// enable : controls whether reading from the buffer is enabled.
|
||||
// If false, TryReadFromCache() always return false, and we only take stats
|
||||
// for the minimum offset if track_min_offset = true.
|
||||
// track_min_offset : Track the minimum offset ever read and collect stats on
|
||||
// it. Used for adaptable readahead of the file footer/metadata.
|
||||
//
|
||||
// Automatic readhead is enabled for a file if file_reader, readahead_size,
|
||||
// and max_readahead_size are passed in.
|
||||
// If file_reader is a nullptr, setting readadhead_size and max_readahead_size
|
||||
// does not make any sense. So it does nothing.
|
||||
// A user can construct a FilePrefetchBuffer without any arguments, but use
|
||||
// `Prefetch` to load data into the buffer.
|
||||
FilePrefetchBuffer(RandomAccessFileReader* file_reader = nullptr, |
||||
size_t readadhead_size = 0, size_t max_readahead_size = 0, |
||||
bool enable = true, bool track_min_offset = false) |
||||
: buffer_offset_(0), |
||||
file_reader_(file_reader), |
||||
readahead_size_(readadhead_size), |
||||
max_readahead_size_(max_readahead_size), |
||||
min_offset_read_(port::kMaxSizet), |
||||
enable_(enable), |
||||
track_min_offset_(track_min_offset) {} |
||||
|
||||
// Load data into the buffer from a file.
|
||||
// reader : the file reader.
|
||||
// offset : the file offset to start reading from.
|
||||
// n : the number of bytes to read.
|
||||
// for_compaction : if prefetch is done for compaction read.
|
||||
Status Prefetch(RandomAccessFileReader* reader, uint64_t offset, size_t n, |
||||
bool for_compaction = false); |
||||
|
||||
// Tries returning the data for a file raed from this buffer, if that data is
|
||||
// in the buffer.
|
||||
// It handles tracking the minimum read offset if track_min_offset = true.
|
||||
// It also does the exponential readahead when readadhead_size is set as part
|
||||
// of the constructor.
|
||||
//
|
||||
// offset : the file offset.
|
||||
// n : the number of bytes.
|
||||
// result : output buffer to put the data into.
|
||||
// for_compaction : if cache read is done for compaction read.
|
||||
bool TryReadFromCache(uint64_t offset, size_t n, Slice* result, |
||||
bool for_compaction = false); |
||||
|
||||
// The minimum `offset` ever passed to TryReadFromCache(). This will nly be
|
||||
// tracked if track_min_offset = true.
|
||||
size_t min_offset_read() const { return min_offset_read_; } |
||||
|
||||
private: |
||||
AlignedBuffer buffer_; |
||||
uint64_t buffer_offset_; |
||||
RandomAccessFileReader* file_reader_; |
||||
size_t readahead_size_; |
||||
size_t max_readahead_size_; |
||||
// The minimum `offset` ever passed to TryReadFromCache().
|
||||
size_t min_offset_read_; |
||||
// if false, TryReadFromCache() always return false, and we only take stats
|
||||
// for track_min_offset_ if track_min_offset_ = true
|
||||
bool enable_; |
||||
// If true, track minimum `offset` ever passed to TryReadFromCache(), which
|
||||
// can be fetched from min_offset_read().
|
||||
bool track_min_offset_; |
||||
}; |
||||
} // namespace rocksdb
|
||||
@ -0,0 +1,188 @@ |
||||
// 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 "file/random_access_file_reader.h" |
||||
|
||||
#include <algorithm> |
||||
#include <mutex> |
||||
|
||||
#include "monitoring/histogram.h" |
||||
#include "monitoring/iostats_context_imp.h" |
||||
#include "port/port.h" |
||||
#include "test_util/sync_point.h" |
||||
#include "util/random.h" |
||||
#include "util/rate_limiter.h" |
||||
|
||||
namespace rocksdb { |
||||
Status RandomAccessFileReader::Read(uint64_t offset, size_t n, Slice* result, |
||||
char* scratch, bool for_compaction) const { |
||||
Status s; |
||||
uint64_t elapsed = 0; |
||||
{ |
||||
StopWatch sw(env_, stats_, hist_type_, |
||||
(stats_ != nullptr) ? &elapsed : nullptr, true /*overwrite*/, |
||||
true /*delay_enabled*/); |
||||
auto prev_perf_level = GetPerfLevel(); |
||||
IOSTATS_TIMER_GUARD(read_nanos); |
||||
if (use_direct_io()) { |
||||
#ifndef ROCKSDB_LITE |
||||
size_t alignment = file_->GetRequiredBufferAlignment(); |
||||
size_t aligned_offset = |
||||
TruncateToPageBoundary(alignment, static_cast<size_t>(offset)); |
||||
size_t offset_advance = static_cast<size_t>(offset) - aligned_offset; |
||||
size_t read_size = |
||||
Roundup(static_cast<size_t>(offset + n), alignment) - aligned_offset; |
||||
AlignedBuffer buf; |
||||
buf.Alignment(alignment); |
||||
buf.AllocateNewBuffer(read_size); |
||||
while (buf.CurrentSize() < read_size) { |
||||
size_t allowed; |
||||
if (for_compaction && rate_limiter_ != nullptr) { |
||||
allowed = rate_limiter_->RequestToken( |
||||
buf.Capacity() - buf.CurrentSize(), buf.Alignment(), |
||||
Env::IOPriority::IO_LOW, stats_, RateLimiter::OpType::kRead); |
||||
} else { |
||||
assert(buf.CurrentSize() == 0); |
||||
allowed = read_size; |
||||
} |
||||
Slice tmp; |
||||
|
||||
FileOperationInfo::TimePoint start_ts; |
||||
uint64_t orig_offset = 0; |
||||
if (ShouldNotifyListeners()) { |
||||
start_ts = std::chrono::system_clock::now(); |
||||
orig_offset = aligned_offset + buf.CurrentSize(); |
||||
} |
||||
{ |
||||
IOSTATS_CPU_TIMER_GUARD(cpu_read_nanos, env_); |
||||
s = file_->Read(aligned_offset + buf.CurrentSize(), allowed, &tmp, |
||||
buf.Destination()); |
||||
} |
||||
if (ShouldNotifyListeners()) { |
||||
auto finish_ts = std::chrono::system_clock::now(); |
||||
NotifyOnFileReadFinish(orig_offset, tmp.size(), start_ts, finish_ts, |
||||
s); |
||||
} |
||||
|
||||
buf.Size(buf.CurrentSize() + tmp.size()); |
||||
if (!s.ok() || tmp.size() < allowed) { |
||||
break; |
||||
} |
||||
} |
||||
size_t res_len = 0; |
||||
if (s.ok() && offset_advance < buf.CurrentSize()) { |
||||
res_len = buf.Read(scratch, offset_advance, |
||||
std::min(buf.CurrentSize() - offset_advance, n)); |
||||
} |
||||
*result = Slice(scratch, res_len); |
||||
#endif // !ROCKSDB_LITE
|
||||
} else { |
||||
size_t pos = 0; |
||||
const char* res_scratch = nullptr; |
||||
while (pos < n) { |
||||
size_t allowed; |
||||
if (for_compaction && rate_limiter_ != nullptr) { |
||||
if (rate_limiter_->IsRateLimited(RateLimiter::OpType::kRead)) { |
||||
sw.DelayStart(); |
||||
} |
||||
allowed = rate_limiter_->RequestToken(n - pos, 0 /* alignment */, |
||||
Env::IOPriority::IO_LOW, stats_, |
||||
RateLimiter::OpType::kRead); |
||||
if (rate_limiter_->IsRateLimited(RateLimiter::OpType::kRead)) { |
||||
sw.DelayStop(); |
||||
} |
||||
} else { |
||||
allowed = n; |
||||
} |
||||
Slice tmp_result; |
||||
|
||||
#ifndef ROCKSDB_LITE |
||||
FileOperationInfo::TimePoint start_ts; |
||||
if (ShouldNotifyListeners()) { |
||||
start_ts = std::chrono::system_clock::now(); |
||||
} |
||||
#endif |
||||
{ |
||||
IOSTATS_CPU_TIMER_GUARD(cpu_read_nanos, env_); |
||||
s = file_->Read(offset + pos, allowed, &tmp_result, scratch + pos); |
||||
} |
||||
#ifndef ROCKSDB_LITE |
||||
if (ShouldNotifyListeners()) { |
||||
auto finish_ts = std::chrono::system_clock::now(); |
||||
NotifyOnFileReadFinish(offset + pos, tmp_result.size(), start_ts, |
||||
finish_ts, s); |
||||
} |
||||
#endif |
||||
|
||||
if (res_scratch == nullptr) { |
||||
// we can't simply use `scratch` because reads of mmap'd files return
|
||||
// data in a different buffer.
|
||||
res_scratch = tmp_result.data(); |
||||
} else { |
||||
// make sure chunks are inserted contiguously into `res_scratch`.
|
||||
assert(tmp_result.data() == res_scratch + pos); |
||||
} |
||||
pos += tmp_result.size(); |
||||
if (!s.ok() || tmp_result.size() < allowed) { |
||||
break; |
||||
} |
||||
} |
||||
*result = Slice(res_scratch, s.ok() ? pos : 0); |
||||
} |
||||
IOSTATS_ADD_IF_POSITIVE(bytes_read, result->size()); |
||||
SetPerfLevel(prev_perf_level); |
||||
} |
||||
if (stats_ != nullptr && file_read_hist_ != nullptr) { |
||||
file_read_hist_->Add(elapsed); |
||||
} |
||||
|
||||
return s; |
||||
} |
||||
|
||||
Status RandomAccessFileReader::MultiRead(ReadRequest* read_reqs, |
||||
size_t num_reqs) const { |
||||
Status s; |
||||
uint64_t elapsed = 0; |
||||
assert(!use_direct_io()); |
||||
{ |
||||
StopWatch sw(env_, stats_, hist_type_, |
||||
(stats_ != nullptr) ? &elapsed : nullptr, true /*overwrite*/, |
||||
true /*delay_enabled*/); |
||||
auto prev_perf_level = GetPerfLevel(); |
||||
IOSTATS_TIMER_GUARD(read_nanos); |
||||
|
||||
#ifndef ROCKSDB_LITE |
||||
FileOperationInfo::TimePoint start_ts; |
||||
if (ShouldNotifyListeners()) { |
||||
start_ts = std::chrono::system_clock::now(); |
||||
} |
||||
#endif // ROCKSDB_LITE
|
||||
{ |
||||
IOSTATS_CPU_TIMER_GUARD(cpu_read_nanos, env_); |
||||
s = file_->MultiRead(read_reqs, num_reqs); |
||||
} |
||||
for (size_t i = 0; i < num_reqs; ++i) { |
||||
#ifndef ROCKSDB_LITE |
||||
if (ShouldNotifyListeners()) { |
||||
auto finish_ts = std::chrono::system_clock::now(); |
||||
NotifyOnFileReadFinish(read_reqs[i].offset, read_reqs[i].result.size(), |
||||
start_ts, finish_ts, read_reqs[i].status); |
||||
} |
||||
#endif // ROCKSDB_LITE
|
||||
IOSTATS_ADD_IF_POSITIVE(bytes_read, read_reqs[i].result.size()); |
||||
} |
||||
SetPerfLevel(prev_perf_level); |
||||
} |
||||
if (stats_ != nullptr && file_read_hist_ != nullptr) { |
||||
file_read_hist_->Add(elapsed); |
||||
} |
||||
|
||||
return s; |
||||
} |
||||
} // namespace rocksdb
|
||||
@ -0,0 +1,120 @@ |
||||
// 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.
|
||||
|
||||
#pragma once |
||||
#include <atomic> |
||||
#include <sstream> |
||||
#include <string> |
||||
#include "port/port.h" |
||||
#include "rocksdb/env.h" |
||||
#include "rocksdb/listener.h" |
||||
#include "rocksdb/rate_limiter.h" |
||||
#include "util/aligned_buffer.h" |
||||
|
||||
namespace rocksdb { |
||||
|
||||
class Statistics; |
||||
class HistogramImpl; |
||||
|
||||
// RandomAccessFileReader is a wrapper on top of Env::RnadomAccessFile. It is
|
||||
// responsible for:
|
||||
// - Handling Buffered and Direct reads appropriately.
|
||||
// - Rate limiting compaction reads.
|
||||
// - Notifying any interested listeners on the completion of a read.
|
||||
// - Updating IO stats.
|
||||
class RandomAccessFileReader { |
||||
private: |
||||
#ifndef ROCKSDB_LITE |
||||
void NotifyOnFileReadFinish(uint64_t offset, size_t length, |
||||
const FileOperationInfo::TimePoint& start_ts, |
||||
const FileOperationInfo::TimePoint& finish_ts, |
||||
const Status& status) const { |
||||
FileOperationInfo info(file_name_, start_ts, finish_ts); |
||||
info.offset = offset; |
||||
info.length = length; |
||||
info.status = status; |
||||
|
||||
for (auto& listener : listeners_) { |
||||
listener->OnFileReadFinish(info); |
||||
} |
||||
} |
||||
#endif // ROCKSDB_LITE
|
||||
|
||||
bool ShouldNotifyListeners() const { return !listeners_.empty(); } |
||||
|
||||
std::unique_ptr<RandomAccessFile> file_; |
||||
std::string file_name_; |
||||
Env* env_; |
||||
Statistics* stats_; |
||||
uint32_t hist_type_; |
||||
HistogramImpl* file_read_hist_; |
||||
RateLimiter* rate_limiter_; |
||||
std::vector<std::shared_ptr<EventListener>> listeners_; |
||||
|
||||
public: |
||||
explicit RandomAccessFileReader( |
||||
std::unique_ptr<RandomAccessFile>&& raf, std::string _file_name, |
||||
Env* env = nullptr, Statistics* stats = nullptr, uint32_t hist_type = 0, |
||||
HistogramImpl* file_read_hist = nullptr, |
||||
RateLimiter* rate_limiter = nullptr, |
||||
const std::vector<std::shared_ptr<EventListener>>& listeners = {}) |
||||
: file_(std::move(raf)), |
||||
file_name_(std::move(_file_name)), |
||||
env_(env), |
||||
stats_(stats), |
||||
hist_type_(hist_type), |
||||
file_read_hist_(file_read_hist), |
||||
rate_limiter_(rate_limiter), |
||||
listeners_() { |
||||
#ifndef ROCKSDB_LITE |
||||
std::for_each(listeners.begin(), listeners.end(), |
||||
[this](const std::shared_ptr<EventListener>& e) { |
||||
if (e->ShouldBeNotifiedOnFileIO()) { |
||||
listeners_.emplace_back(e); |
||||
} |
||||
}); |
||||
#else // !ROCKSDB_LITE
|
||||
(void)listeners; |
||||
#endif |
||||
} |
||||
|
||||
RandomAccessFileReader(RandomAccessFileReader&& o) ROCKSDB_NOEXCEPT { |
||||
*this = std::move(o); |
||||
} |
||||
|
||||
RandomAccessFileReader& operator=(RandomAccessFileReader&& o) |
||||
ROCKSDB_NOEXCEPT { |
||||
file_ = std::move(o.file_); |
||||
env_ = std::move(o.env_); |
||||
stats_ = std::move(o.stats_); |
||||
hist_type_ = std::move(o.hist_type_); |
||||
file_read_hist_ = std::move(o.file_read_hist_); |
||||
rate_limiter_ = std::move(o.rate_limiter_); |
||||
return *this; |
||||
} |
||||
|
||||
RandomAccessFileReader(const RandomAccessFileReader&) = delete; |
||||
RandomAccessFileReader& operator=(const RandomAccessFileReader&) = delete; |
||||
|
||||
Status Read(uint64_t offset, size_t n, Slice* result, char* scratch, |
||||
bool for_compaction = false) const; |
||||
|
||||
Status MultiRead(ReadRequest* reqs, size_t num_reqs) const; |
||||
|
||||
Status Prefetch(uint64_t offset, size_t n) const { |
||||
return file_->Prefetch(offset, n); |
||||
} |
||||
|
||||
RandomAccessFile* file() { return file_.get(); } |
||||
|
||||
std::string file_name() const { return file_name_; } |
||||
|
||||
bool use_direct_io() const { return file_->use_direct_io(); } |
||||
}; |
||||
} // namespace rocksdb
|
||||
@ -0,0 +1,61 @@ |
||||
// 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 "file/read_write_util.h" |
||||
|
||||
#include <sstream> |
||||
#include "test_util/sync_point.h" |
||||
|
||||
namespace rocksdb { |
||||
Status NewWritableFile(Env* env, const std::string& fname, |
||||
std::unique_ptr<WritableFile>* result, |
||||
const EnvOptions& options) { |
||||
Status s = env->NewWritableFile(fname, result, options); |
||||
TEST_KILL_RANDOM("NewWritableFile:0", rocksdb_kill_odds * REDUCE_ODDS2); |
||||
return s; |
||||
} |
||||
|
||||
bool ReadOneLine(std::istringstream* iss, SequentialFile* seq_file, |
||||
std::string* output, bool* has_data, Status* result) { |
||||
const int kBufferSize = 8192; |
||||
char buffer[kBufferSize + 1]; |
||||
Slice input_slice; |
||||
|
||||
std::string line; |
||||
bool has_complete_line = false; |
||||
while (!has_complete_line) { |
||||
if (std::getline(*iss, line)) { |
||||
has_complete_line = !iss->eof(); |
||||
} else { |
||||
has_complete_line = false; |
||||
} |
||||
if (!has_complete_line) { |
||||
// if we're not sure whether we have a complete line,
|
||||
// further read from the file.
|
||||
if (*has_data) { |
||||
*result = seq_file->Read(kBufferSize, &input_slice, buffer); |
||||
} |
||||
if (input_slice.size() == 0) { |
||||
// meaning we have read all the data
|
||||
*has_data = false; |
||||
break; |
||||
} else { |
||||
iss->str(line + input_slice.ToString()); |
||||
// reset the internal state of iss so that we can keep reading it.
|
||||
iss->clear(); |
||||
*has_data = (input_slice.size() == kBufferSize); |
||||
continue; |
||||
} |
||||
} |
||||
} |
||||
*output = line; |
||||
return *has_data || has_complete_line; |
||||
} |
||||
|
||||
} // namespace rocksdb
|
||||
@ -0,0 +1,29 @@ |
||||
// 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.
|
||||
|
||||
#pragma once |
||||
#include <atomic> |
||||
#include "rocksdb/env.h" |
||||
|
||||
namespace rocksdb { |
||||
// Returns a WritableFile.
|
||||
//
|
||||
// env : the Env.
|
||||
// fname : the file name.
|
||||
// result : output arg. A WritableFile based on `fname` returned.
|
||||
// options : the Env Options.
|
||||
extern Status NewWritableFile(Env* env, const std::string& fname, |
||||
std::unique_ptr<WritableFile>* result, |
||||
const EnvOptions& options); |
||||
|
||||
// Read a single line from a file.
|
||||
bool ReadOneLine(std::istringstream* iss, SequentialFile* seq_file, |
||||
std::string* output, bool* has_data, Status* result); |
||||
|
||||
} // namespace rocksdb
|
||||
@ -0,0 +1,170 @@ |
||||
// 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 "file/readahead_raf.h" |
||||
|
||||
#include <algorithm> |
||||
#include <mutex> |
||||
#include "util/aligned_buffer.h" |
||||
#include "util/rate_limiter.h" |
||||
|
||||
namespace rocksdb { |
||||
|
||||
#ifndef NDEBUG |
||||
namespace { |
||||
bool IsFileSectorAligned(const size_t off, size_t sector_size) { |
||||
return off % sector_size == 0; |
||||
} |
||||
} // namespace
|
||||
#endif |
||||
|
||||
namespace { |
||||
class ReadaheadRandomAccessFile : public RandomAccessFile { |
||||
public: |
||||
ReadaheadRandomAccessFile(std::unique_ptr<RandomAccessFile>&& file, |
||||
size_t readahead_size) |
||||
: file_(std::move(file)), |
||||
alignment_(file_->GetRequiredBufferAlignment()), |
||||
readahead_size_(Roundup(readahead_size, alignment_)), |
||||
buffer_(), |
||||
buffer_offset_(0) { |
||||
buffer_.Alignment(alignment_); |
||||
buffer_.AllocateNewBuffer(readahead_size_); |
||||
} |
||||
|
||||
ReadaheadRandomAccessFile(const ReadaheadRandomAccessFile&) = delete; |
||||
|
||||
ReadaheadRandomAccessFile& operator=(const ReadaheadRandomAccessFile&) = |
||||
delete; |
||||
|
||||
Status Read(uint64_t offset, size_t n, Slice* result, |
||||
char* scratch) const override { |
||||
// Read-ahead only make sense if we have some slack left after reading
|
||||
if (n + alignment_ >= readahead_size_) { |
||||
return file_->Read(offset, n, result, scratch); |
||||
} |
||||
|
||||
std::unique_lock<std::mutex> lk(lock_); |
||||
|
||||
size_t cached_len = 0; |
||||
// Check if there is a cache hit, meaning that [offset, offset + n) is
|
||||
// either completely or partially in the buffer. If it's completely cached,
|
||||
// including end of file case when offset + n is greater than EOF, then
|
||||
// return.
|
||||
if (TryReadFromCache(offset, n, &cached_len, scratch) && |
||||
(cached_len == n || buffer_.CurrentSize() < readahead_size_)) { |
||||
// We read exactly what we needed, or we hit end of file - return.
|
||||
*result = Slice(scratch, cached_len); |
||||
return Status::OK(); |
||||
} |
||||
size_t advanced_offset = static_cast<size_t>(offset + cached_len); |
||||
// In the case of cache hit advanced_offset is already aligned, means that
|
||||
// chunk_offset equals to advanced_offset
|
||||
size_t chunk_offset = TruncateToPageBoundary(alignment_, advanced_offset); |
||||
|
||||
Status s = ReadIntoBuffer(chunk_offset, readahead_size_); |
||||
if (s.ok()) { |
||||
// The data we need is now in cache, so we can safely read it
|
||||
size_t remaining_len; |
||||
TryReadFromCache(advanced_offset, n - cached_len, &remaining_len, |
||||
scratch + cached_len); |
||||
*result = Slice(scratch, cached_len + remaining_len); |
||||
} |
||||
return s; |
||||
} |
||||
|
||||
Status Prefetch(uint64_t offset, size_t n) override { |
||||
if (n < readahead_size_) { |
||||
// Don't allow smaller prefetches than the configured `readahead_size_`.
|
||||
// `Read()` assumes a smaller prefetch buffer indicates EOF was reached.
|
||||
return Status::OK(); |
||||
} |
||||
|
||||
std::unique_lock<std::mutex> lk(lock_); |
||||
|
||||
size_t offset_ = static_cast<size_t>(offset); |
||||
size_t prefetch_offset = TruncateToPageBoundary(alignment_, offset_); |
||||
if (prefetch_offset == buffer_offset_) { |
||||
return Status::OK(); |
||||
} |
||||
return ReadIntoBuffer(prefetch_offset, |
||||
Roundup(offset_ + n, alignment_) - prefetch_offset); |
||||
} |
||||
|
||||
size_t GetUniqueId(char* id, size_t max_size) const override { |
||||
return file_->GetUniqueId(id, max_size); |
||||
} |
||||
|
||||
void Hint(AccessPattern pattern) override { file_->Hint(pattern); } |
||||
|
||||
Status InvalidateCache(size_t offset, size_t length) override { |
||||
std::unique_lock<std::mutex> lk(lock_); |
||||
buffer_.Clear(); |
||||
return file_->InvalidateCache(offset, length); |
||||
} |
||||
|
||||
bool use_direct_io() const override { return file_->use_direct_io(); } |
||||
|
||||
private: |
||||
// Tries to read from buffer_ n bytes starting at offset. If anything was read
|
||||
// from the cache, it sets cached_len to the number of bytes actually read,
|
||||
// copies these number of bytes to scratch and returns true.
|
||||
// If nothing was read sets cached_len to 0 and returns false.
|
||||
bool TryReadFromCache(uint64_t offset, size_t n, size_t* cached_len, |
||||
char* scratch) const { |
||||
if (offset < buffer_offset_ || |
||||
offset >= buffer_offset_ + buffer_.CurrentSize()) { |
||||
*cached_len = 0; |
||||
return false; |
||||
} |
||||
uint64_t offset_in_buffer = offset - buffer_offset_; |
||||
*cached_len = std::min( |
||||
buffer_.CurrentSize() - static_cast<size_t>(offset_in_buffer), n); |
||||
memcpy(scratch, buffer_.BufferStart() + offset_in_buffer, *cached_len); |
||||
return true; |
||||
} |
||||
|
||||
// Reads into buffer_ the next n bytes from file_ starting at offset.
|
||||
// Can actually read less if EOF was reached.
|
||||
// Returns the status of the read operastion on the file.
|
||||
Status ReadIntoBuffer(uint64_t offset, size_t n) const { |
||||
if (n > buffer_.Capacity()) { |
||||
n = buffer_.Capacity(); |
||||
} |
||||
assert(IsFileSectorAligned(offset, alignment_)); |
||||
assert(IsFileSectorAligned(n, alignment_)); |
||||
Slice result; |
||||
Status s = file_->Read(offset, n, &result, buffer_.BufferStart()); |
||||
if (s.ok()) { |
||||
buffer_offset_ = offset; |
||||
buffer_.Size(result.size()); |
||||
assert(result.size() == 0 || buffer_.BufferStart() == result.data()); |
||||
} |
||||
return s; |
||||
} |
||||
|
||||
const std::unique_ptr<RandomAccessFile> file_; |
||||
const size_t alignment_; |
||||
const size_t readahead_size_; |
||||
|
||||
mutable std::mutex lock_; |
||||
// The buffer storing the prefetched data
|
||||
mutable AlignedBuffer buffer_; |
||||
// The offset in file_, corresponding to data stored in buffer_
|
||||
mutable uint64_t buffer_offset_; |
||||
}; |
||||
} // namespace
|
||||
|
||||
std::unique_ptr<RandomAccessFile> NewReadaheadRandomAccessFile( |
||||
std::unique_ptr<RandomAccessFile>&& file, size_t readahead_size) { |
||||
std::unique_ptr<RandomAccessFile> result( |
||||
new ReadaheadRandomAccessFile(std::move(file), readahead_size)); |
||||
return result; |
||||
} |
||||
} // namespace rocksdb
|
||||
@ -0,0 +1,27 @@ |
||||
// 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.
|
||||
|
||||
#pragma once |
||||
#include <atomic> |
||||
#include "rocksdb/env.h" |
||||
|
||||
namespace rocksdb { |
||||
// This file provides the following main abstractions:
|
||||
// SequentialFileReader : wrapper over Env::SequentialFile
|
||||
// RandomAccessFileReader : wrapper over Env::RandomAccessFile
|
||||
// WritableFileWriter : wrapper over Env::WritableFile
|
||||
// In addition, it also exposed NewReadaheadRandomAccessFile, NewWritableFile,
|
||||
// and ReadOneLine primitives.
|
||||
|
||||
// NewReadaheadRandomAccessFile provides a wrapper over RandomAccessFile to
|
||||
// always prefetch additional data with every read. This is mainly used in
|
||||
// Compaction Table Readers.
|
||||
std::unique_ptr<RandomAccessFile> NewReadaheadRandomAccessFile( |
||||
std::unique_ptr<RandomAccessFile>&& file, size_t readahead_size); |
||||
} // namespace rocksdb
|
||||
@ -0,0 +1,241 @@ |
||||
// 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 "file/sequence_file_reader.h" |
||||
|
||||
#include <algorithm> |
||||
#include <mutex> |
||||
|
||||
#include "monitoring/histogram.h" |
||||
#include "monitoring/iostats_context_imp.h" |
||||
#include "port/port.h" |
||||
#include "test_util/sync_point.h" |
||||
#include "util/aligned_buffer.h" |
||||
#include "util/random.h" |
||||
#include "util/rate_limiter.h" |
||||
|
||||
namespace rocksdb { |
||||
|
||||
#ifndef NDEBUG |
||||
namespace { |
||||
bool IsFileSectorAligned(const size_t off, size_t sector_size) { |
||||
return off % sector_size == 0; |
||||
} |
||||
} // namespace
|
||||
#endif |
||||
|
||||
Status SequentialFileReader::Read(size_t n, Slice* result, char* scratch) { |
||||
Status s; |
||||
if (use_direct_io()) { |
||||
#ifndef ROCKSDB_LITE |
||||
size_t offset = offset_.fetch_add(n); |
||||
size_t alignment = file_->GetRequiredBufferAlignment(); |
||||
size_t aligned_offset = TruncateToPageBoundary(alignment, offset); |
||||
size_t offset_advance = offset - aligned_offset; |
||||
size_t size = Roundup(offset + n, alignment) - aligned_offset; |
||||
size_t r = 0; |
||||
AlignedBuffer buf; |
||||
buf.Alignment(alignment); |
||||
buf.AllocateNewBuffer(size); |
||||
Slice tmp; |
||||
s = file_->PositionedRead(aligned_offset, size, &tmp, buf.BufferStart()); |
||||
if (s.ok() && offset_advance < tmp.size()) { |
||||
buf.Size(tmp.size()); |
||||
r = buf.Read(scratch, offset_advance, |
||||
std::min(tmp.size() - offset_advance, n)); |
||||
} |
||||
*result = Slice(scratch, r); |
||||
#endif // !ROCKSDB_LITE
|
||||
} else { |
||||
s = file_->Read(n, result, scratch); |
||||
} |
||||
IOSTATS_ADD(bytes_read, result->size()); |
||||
return s; |
||||
} |
||||
|
||||
Status SequentialFileReader::Skip(uint64_t n) { |
||||
#ifndef ROCKSDB_LITE |
||||
if (use_direct_io()) { |
||||
offset_ += static_cast<size_t>(n); |
||||
return Status::OK(); |
||||
} |
||||
#endif // !ROCKSDB_LITE
|
||||
return file_->Skip(n); |
||||
} |
||||
|
||||
namespace { |
||||
// This class wraps a SequentialFile, exposing same API, with the differenece
|
||||
// of being able to prefetch up to readahead_size bytes and then serve them
|
||||
// from memory, avoiding the entire round-trip if, for example, the data for the
|
||||
// file is actually remote.
|
||||
class ReadaheadSequentialFile : public SequentialFile { |
||||
public: |
||||
ReadaheadSequentialFile(std::unique_ptr<SequentialFile>&& file, |
||||
size_t readahead_size) |
||||
: file_(std::move(file)), |
||||
alignment_(file_->GetRequiredBufferAlignment()), |
||||
readahead_size_(Roundup(readahead_size, alignment_)), |
||||
buffer_(), |
||||
buffer_offset_(0), |
||||
read_offset_(0) { |
||||
buffer_.Alignment(alignment_); |
||||
buffer_.AllocateNewBuffer(readahead_size_); |
||||
} |
||||
|
||||
ReadaheadSequentialFile(const ReadaheadSequentialFile&) = delete; |
||||
|
||||
ReadaheadSequentialFile& operator=(const ReadaheadSequentialFile&) = delete; |
||||
|
||||
Status Read(size_t n, Slice* result, char* scratch) override { |
||||
std::unique_lock<std::mutex> lk(lock_); |
||||
|
||||
size_t cached_len = 0; |
||||
// Check if there is a cache hit, meaning that [offset, offset + n) is
|
||||
// either completely or partially in the buffer. If it's completely cached,
|
||||
// including end of file case when offset + n is greater than EOF, then
|
||||
// return.
|
||||
if (TryReadFromCache(n, &cached_len, scratch) && |
||||
(cached_len == n || buffer_.CurrentSize() < readahead_size_)) { |
||||
// We read exactly what we needed, or we hit end of file - return.
|
||||
*result = Slice(scratch, cached_len); |
||||
return Status::OK(); |
||||
} |
||||
n -= cached_len; |
||||
|
||||
Status s; |
||||
// Read-ahead only make sense if we have some slack left after reading
|
||||
if (n + alignment_ >= readahead_size_) { |
||||
s = file_->Read(n, result, scratch + cached_len); |
||||
if (s.ok()) { |
||||
read_offset_ += result->size(); |
||||
*result = Slice(scratch, cached_len + result->size()); |
||||
} |
||||
buffer_.Clear(); |
||||
return s; |
||||
} |
||||
|
||||
s = ReadIntoBuffer(readahead_size_); |
||||
if (s.ok()) { |
||||
// The data we need is now in cache, so we can safely read it
|
||||
size_t remaining_len; |
||||
TryReadFromCache(n, &remaining_len, scratch + cached_len); |
||||
*result = Slice(scratch, cached_len + remaining_len); |
||||
} |
||||
return s; |
||||
} |
||||
|
||||
Status Skip(uint64_t n) override { |
||||
std::unique_lock<std::mutex> lk(lock_); |
||||
Status s = Status::OK(); |
||||
// First check if we need to skip already cached data
|
||||
if (buffer_.CurrentSize() > 0) { |
||||
// Do we need to skip beyond cached data?
|
||||
if (read_offset_ + n >= buffer_offset_ + buffer_.CurrentSize()) { |
||||
// Yes. Skip whaterver is in memory and adjust offset accordingly
|
||||
n -= buffer_offset_ + buffer_.CurrentSize() - read_offset_; |
||||
read_offset_ = buffer_offset_ + buffer_.CurrentSize(); |
||||
} else { |
||||
// No. The entire section to be skipped is entirely i cache.
|
||||
read_offset_ += n; |
||||
n = 0; |
||||
} |
||||
} |
||||
if (n > 0) { |
||||
// We still need to skip more, so call the file API for skipping
|
||||
s = file_->Skip(n); |
||||
if (s.ok()) { |
||||
read_offset_ += n; |
||||
} |
||||
buffer_.Clear(); |
||||
} |
||||
return s; |
||||
} |
||||
|
||||
Status PositionedRead(uint64_t offset, size_t n, Slice* result, |
||||
char* scratch) override { |
||||
return file_->PositionedRead(offset, n, result, scratch); |
||||
} |
||||
|
||||
Status InvalidateCache(size_t offset, size_t length) override { |
||||
std::unique_lock<std::mutex> lk(lock_); |
||||
buffer_.Clear(); |
||||
return file_->InvalidateCache(offset, length); |
||||
} |
||||
|
||||
bool use_direct_io() const override { return file_->use_direct_io(); } |
||||
|
||||
private: |
||||
// Tries to read from buffer_ n bytes. If anything was read from the cache, it
|
||||
// sets cached_len to the number of bytes actually read, copies these number
|
||||
// of bytes to scratch and returns true.
|
||||
// If nothing was read sets cached_len to 0 and returns false.
|
||||
bool TryReadFromCache(size_t n, size_t* cached_len, char* scratch) { |
||||
if (read_offset_ < buffer_offset_ || |
||||
read_offset_ >= buffer_offset_ + buffer_.CurrentSize()) { |
||||
*cached_len = 0; |
||||
return false; |
||||
} |
||||
uint64_t offset_in_buffer = read_offset_ - buffer_offset_; |
||||
*cached_len = std::min( |
||||
buffer_.CurrentSize() - static_cast<size_t>(offset_in_buffer), n); |
||||
memcpy(scratch, buffer_.BufferStart() + offset_in_buffer, *cached_len); |
||||
read_offset_ += *cached_len; |
||||
return true; |
||||
} |
||||
|
||||
// Reads into buffer_ the next n bytes from file_.
|
||||
// Can actually read less if EOF was reached.
|
||||
// Returns the status of the read operastion on the file.
|
||||
Status ReadIntoBuffer(size_t n) { |
||||
if (n > buffer_.Capacity()) { |
||||
n = buffer_.Capacity(); |
||||
} |
||||
assert(IsFileSectorAligned(n, alignment_)); |
||||
Slice result; |
||||
Status s = file_->Read(n, &result, buffer_.BufferStart()); |
||||
if (s.ok()) { |
||||
buffer_offset_ = read_offset_; |
||||
buffer_.Size(result.size()); |
||||
assert(result.size() == 0 || buffer_.BufferStart() == result.data()); |
||||
} |
||||
return s; |
||||
} |
||||
|
||||
const std::unique_ptr<SequentialFile> file_; |
||||
const size_t alignment_; |
||||
const size_t readahead_size_; |
||||
|
||||
std::mutex lock_; |
||||
// The buffer storing the prefetched data
|
||||
AlignedBuffer buffer_; |
||||
// The offset in file_, corresponding to data stored in buffer_
|
||||
uint64_t buffer_offset_; |
||||
// The offset up to which data was read from file_. In fact, it can be larger
|
||||
// than the actual file size, since the file_->Skip(n) call doesn't return the
|
||||
// actual number of bytes that were skipped, which can be less than n.
|
||||
// This is not a problemm since read_offset_ is monotonically increasing and
|
||||
// its only use is to figure out if next piece of data should be read from
|
||||
// buffer_ or file_ directly.
|
||||
uint64_t read_offset_; |
||||
}; |
||||
} // namespace
|
||||
|
||||
std::unique_ptr<SequentialFile> |
||||
SequentialFileReader::NewReadaheadSequentialFile( |
||||
std::unique_ptr<SequentialFile>&& file, size_t readahead_size) { |
||||
if (file->GetRequiredBufferAlignment() >= readahead_size) { |
||||
// Short-circuit and return the original file if readahead_size is
|
||||
// too small and hence doesn't make sense to be used for prefetching.
|
||||
return std::move(file); |
||||
} |
||||
std::unique_ptr<SequentialFile> result( |
||||
new ReadaheadSequentialFile(std::move(file), readahead_size)); |
||||
return result; |
||||
} |
||||
} // namespace rocksdb
|
||||
@ -0,0 +1,66 @@ |
||||
// 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.
|
||||
|
||||
#pragma once |
||||
#include <atomic> |
||||
#include <string> |
||||
#include "port/port.h" |
||||
#include "rocksdb/env.h" |
||||
|
||||
namespace rocksdb { |
||||
|
||||
// SequentialFileReader is a wrapper on top of Env::SequentialFile. It handles
|
||||
// Buffered (i.e when page cache is enabled) and Direct (with O_DIRECT / page
|
||||
// cache disabled) reads appropriately, and also updates the IO stats.
|
||||
class SequentialFileReader { |
||||
private: |
||||
std::unique_ptr<SequentialFile> file_; |
||||
std::string file_name_; |
||||
std::atomic<size_t> offset_{0}; // read offset
|
||||
|
||||
public: |
||||
explicit SequentialFileReader(std::unique_ptr<SequentialFile>&& _file, |
||||
const std::string& _file_name) |
||||
: file_(std::move(_file)), file_name_(_file_name) {} |
||||
|
||||
explicit SequentialFileReader(std::unique_ptr<SequentialFile>&& _file, |
||||
const std::string& _file_name, |
||||
size_t _readahead_size) |
||||
: file_(NewReadaheadSequentialFile(std::move(_file), _readahead_size)), |
||||
file_name_(_file_name) {} |
||||
|
||||
SequentialFileReader(SequentialFileReader&& o) ROCKSDB_NOEXCEPT { |
||||
*this = std::move(o); |
||||
} |
||||
|
||||
SequentialFileReader& operator=(SequentialFileReader&& o) ROCKSDB_NOEXCEPT { |
||||
file_ = std::move(o.file_); |
||||
return *this; |
||||
} |
||||
|
||||
SequentialFileReader(const SequentialFileReader&) = delete; |
||||
SequentialFileReader& operator=(const SequentialFileReader&) = delete; |
||||
|
||||
Status Read(size_t n, Slice* result, char* scratch); |
||||
|
||||
Status Skip(uint64_t n); |
||||
|
||||
SequentialFile* file() { return file_.get(); } |
||||
|
||||
std::string file_name() { return file_name_; } |
||||
|
||||
bool use_direct_io() const { return file_->use_direct_io(); } |
||||
|
||||
private: |
||||
// NewReadaheadSequentialFile provides a wrapper over SequentialFile to
|
||||
// always prefetch additional data with every read.
|
||||
static std::unique_ptr<SequentialFile> NewReadaheadSequentialFile( |
||||
std::unique_ptr<SequentialFile>&& file, size_t readahead_size); |
||||
}; |
||||
} // namespace rocksdb
|
||||
@ -0,0 +1,405 @@ |
||||
// 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 "file/writable_file_writer.h" |
||||
|
||||
#include <algorithm> |
||||
#include <mutex> |
||||
|
||||
#include "monitoring/histogram.h" |
||||
#include "monitoring/iostats_context_imp.h" |
||||
#include "port/port.h" |
||||
#include "test_util/sync_point.h" |
||||
#include "util/random.h" |
||||
#include "util/rate_limiter.h" |
||||
|
||||
namespace rocksdb { |
||||
Status WritableFileWriter::Append(const Slice& data) { |
||||
const char* src = data.data(); |
||||
size_t left = data.size(); |
||||
Status s; |
||||
pending_sync_ = true; |
||||
|
||||
TEST_KILL_RANDOM("WritableFileWriter::Append:0", |
||||
rocksdb_kill_odds * REDUCE_ODDS2); |
||||
|
||||
{ |
||||
IOSTATS_TIMER_GUARD(prepare_write_nanos); |
||||
TEST_SYNC_POINT("WritableFileWriter::Append:BeforePrepareWrite"); |
||||
writable_file_->PrepareWrite(static_cast<size_t>(GetFileSize()), left); |
||||
} |
||||
|
||||
// See whether we need to enlarge the buffer to avoid the flush
|
||||
if (buf_.Capacity() - buf_.CurrentSize() < left) { |
||||
for (size_t cap = buf_.Capacity(); |
||||
cap < max_buffer_size_; // There is still room to increase
|
||||
cap *= 2) { |
||||
// See whether the next available size is large enough.
|
||||
// Buffer will never be increased to more than max_buffer_size_.
|
||||
size_t desired_capacity = std::min(cap * 2, max_buffer_size_); |
||||
if (desired_capacity - buf_.CurrentSize() >= left || |
||||
(use_direct_io() && desired_capacity == max_buffer_size_)) { |
||||
buf_.AllocateNewBuffer(desired_capacity, true); |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Flush only when buffered I/O
|
||||
if (!use_direct_io() && (buf_.Capacity() - buf_.CurrentSize()) < left) { |
||||
if (buf_.CurrentSize() > 0) { |
||||
s = Flush(); |
||||
if (!s.ok()) { |
||||
return s; |
||||
} |
||||
} |
||||
assert(buf_.CurrentSize() == 0); |
||||
} |
||||
|
||||
// We never write directly to disk with direct I/O on.
|
||||
// or we simply use it for its original purpose to accumulate many small
|
||||
// chunks
|
||||
if (use_direct_io() || (buf_.Capacity() >= left)) { |
||||
while (left > 0) { |
||||
size_t appended = buf_.Append(src, left); |
||||
left -= appended; |
||||
src += appended; |
||||
|
||||
if (left > 0) { |
||||
s = Flush(); |
||||
if (!s.ok()) { |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
} else { |
||||
// Writing directly to file bypassing the buffer
|
||||
assert(buf_.CurrentSize() == 0); |
||||
s = WriteBuffered(src, left); |
||||
} |
||||
|
||||
TEST_KILL_RANDOM("WritableFileWriter::Append:1", rocksdb_kill_odds); |
||||
if (s.ok()) { |
||||
filesize_ += data.size(); |
||||
} |
||||
return s; |
||||
} |
||||
|
||||
Status WritableFileWriter::Pad(const size_t pad_bytes) { |
||||
assert(pad_bytes < kDefaultPageSize); |
||||
size_t left = pad_bytes; |
||||
size_t cap = buf_.Capacity() - buf_.CurrentSize(); |
||||
|
||||
// Assume pad_bytes is small compared to buf_ capacity. So we always
|
||||
// use buf_ rather than write directly to file in certain cases like
|
||||
// Append() does.
|
||||
while (left) { |
||||
size_t append_bytes = std::min(cap, left); |
||||
buf_.PadWith(append_bytes, 0); |
||||
left -= append_bytes; |
||||
if (left > 0) { |
||||
Status s = Flush(); |
||||
if (!s.ok()) { |
||||
return s; |
||||
} |
||||
} |
||||
cap = buf_.Capacity() - buf_.CurrentSize(); |
||||
} |
||||
pending_sync_ = true; |
||||
filesize_ += pad_bytes; |
||||
return Status::OK(); |
||||
} |
||||
|
||||
Status WritableFileWriter::Close() { |
||||
// Do not quit immediately on failure the file MUST be closed
|
||||
Status s; |
||||
|
||||
// Possible to close it twice now as we MUST close
|
||||
// in __dtor, simply flushing is not enough
|
||||
// Windows when pre-allocating does not fill with zeros
|
||||
// also with unbuffered access we also set the end of data.
|
||||
if (!writable_file_) { |
||||
return s; |
||||
} |
||||
|
||||
s = Flush(); // flush cache to OS
|
||||
|
||||
Status interim; |
||||
// In direct I/O mode we write whole pages so
|
||||
// we need to let the file know where data ends.
|
||||
if (use_direct_io()) { |
||||
interim = writable_file_->Truncate(filesize_); |
||||
if (interim.ok()) { |
||||
interim = writable_file_->Fsync(); |
||||
} |
||||
if (!interim.ok() && s.ok()) { |
||||
s = interim; |
||||
} |
||||
} |
||||
|
||||
TEST_KILL_RANDOM("WritableFileWriter::Close:0", rocksdb_kill_odds); |
||||
interim = writable_file_->Close(); |
||||
if (!interim.ok() && s.ok()) { |
||||
s = interim; |
||||
} |
||||
|
||||
writable_file_.reset(); |
||||
TEST_KILL_RANDOM("WritableFileWriter::Close:1", rocksdb_kill_odds); |
||||
|
||||
return s; |
||||
} |
||||
|
||||
// write out the cached data to the OS cache or storage if direct I/O
|
||||
// enabled
|
||||
Status WritableFileWriter::Flush() { |
||||
Status s; |
||||
TEST_KILL_RANDOM("WritableFileWriter::Flush:0", |
||||
rocksdb_kill_odds * REDUCE_ODDS2); |
||||
|
||||
if (buf_.CurrentSize() > 0) { |
||||
if (use_direct_io()) { |
||||
#ifndef ROCKSDB_LITE |
||||
if (pending_sync_) { |
||||
s = WriteDirect(); |
||||
} |
||||
#endif // !ROCKSDB_LITE
|
||||
} else { |
||||
s = WriteBuffered(buf_.BufferStart(), buf_.CurrentSize()); |
||||
} |
||||
if (!s.ok()) { |
||||
return s; |
||||
} |
||||
} |
||||
|
||||
s = writable_file_->Flush(); |
||||
|
||||
if (!s.ok()) { |
||||
return s; |
||||
} |
||||
|
||||
// sync OS cache to disk for every bytes_per_sync_
|
||||
// TODO: give log file and sst file different options (log
|
||||
// files could be potentially cached in OS for their whole
|
||||
// life time, thus we might not want to flush at all).
|
||||
|
||||
// We try to avoid sync to the last 1MB of data. For two reasons:
|
||||
// (1) avoid rewrite the same page that is modified later.
|
||||
// (2) for older version of OS, write can block while writing out
|
||||
// the page.
|
||||
// Xfs does neighbor page flushing outside of the specified ranges. We
|
||||
// need to make sure sync range is far from the write offset.
|
||||
if (!use_direct_io() && bytes_per_sync_) { |
||||
const uint64_t kBytesNotSyncRange = |
||||
1024 * 1024; // recent 1MB is not synced.
|
||||
const uint64_t kBytesAlignWhenSync = 4 * 1024; // Align 4KB.
|
||||
if (filesize_ > kBytesNotSyncRange) { |
||||
uint64_t offset_sync_to = filesize_ - kBytesNotSyncRange; |
||||
offset_sync_to -= offset_sync_to % kBytesAlignWhenSync; |
||||
assert(offset_sync_to >= last_sync_size_); |
||||
if (offset_sync_to > 0 && |
||||
offset_sync_to - last_sync_size_ >= bytes_per_sync_) { |
||||
s = RangeSync(last_sync_size_, offset_sync_to - last_sync_size_); |
||||
last_sync_size_ = offset_sync_to; |
||||
} |
||||
} |
||||
} |
||||
|
||||
return s; |
||||
} |
||||
|
||||
Status WritableFileWriter::Sync(bool use_fsync) { |
||||
Status s = Flush(); |
||||
if (!s.ok()) { |
||||
return s; |
||||
} |
||||
TEST_KILL_RANDOM("WritableFileWriter::Sync:0", rocksdb_kill_odds); |
||||
if (!use_direct_io() && pending_sync_) { |
||||
s = SyncInternal(use_fsync); |
||||
if (!s.ok()) { |
||||
return s; |
||||
} |
||||
} |
||||
TEST_KILL_RANDOM("WritableFileWriter::Sync:1", rocksdb_kill_odds); |
||||
pending_sync_ = false; |
||||
return Status::OK(); |
||||
} |
||||
|
||||
Status WritableFileWriter::SyncWithoutFlush(bool use_fsync) { |
||||
if (!writable_file_->IsSyncThreadSafe()) { |
||||
return Status::NotSupported( |
||||
"Can't WritableFileWriter::SyncWithoutFlush() because " |
||||
"WritableFile::IsSyncThreadSafe() is false"); |
||||
} |
||||
TEST_SYNC_POINT("WritableFileWriter::SyncWithoutFlush:1"); |
||||
Status s = SyncInternal(use_fsync); |
||||
TEST_SYNC_POINT("WritableFileWriter::SyncWithoutFlush:2"); |
||||
return s; |
||||
} |
||||
|
||||
Status WritableFileWriter::SyncInternal(bool use_fsync) { |
||||
Status s; |
||||
IOSTATS_TIMER_GUARD(fsync_nanos); |
||||
TEST_SYNC_POINT("WritableFileWriter::SyncInternal:0"); |
||||
auto prev_perf_level = GetPerfLevel(); |
||||
IOSTATS_CPU_TIMER_GUARD(cpu_write_nanos, env_); |
||||
if (use_fsync) { |
||||
s = writable_file_->Fsync(); |
||||
} else { |
||||
s = writable_file_->Sync(); |
||||
} |
||||
SetPerfLevel(prev_perf_level); |
||||
return s; |
||||
} |
||||
|
||||
Status WritableFileWriter::RangeSync(uint64_t offset, uint64_t nbytes) { |
||||
IOSTATS_TIMER_GUARD(range_sync_nanos); |
||||
TEST_SYNC_POINT("WritableFileWriter::RangeSync:0"); |
||||
return writable_file_->RangeSync(offset, nbytes); |
||||
} |
||||
|
||||
// This method writes to disk the specified data and makes use of the rate
|
||||
// limiter if available
|
||||
Status WritableFileWriter::WriteBuffered(const char* data, size_t size) { |
||||
Status s; |
||||
assert(!use_direct_io()); |
||||
const char* src = data; |
||||
size_t left = size; |
||||
|
||||
while (left > 0) { |
||||
size_t allowed; |
||||
if (rate_limiter_ != nullptr) { |
||||
allowed = rate_limiter_->RequestToken( |
||||
left, 0 /* alignment */, writable_file_->GetIOPriority(), stats_, |
||||
RateLimiter::OpType::kWrite); |
||||
} else { |
||||
allowed = left; |
||||
} |
||||
|
||||
{ |
||||
IOSTATS_TIMER_GUARD(write_nanos); |
||||
TEST_SYNC_POINT("WritableFileWriter::Flush:BeforeAppend"); |
||||
|
||||
#ifndef ROCKSDB_LITE |
||||
FileOperationInfo::TimePoint start_ts; |
||||
uint64_t old_size = writable_file_->GetFileSize(); |
||||
if (ShouldNotifyListeners()) { |
||||
start_ts = std::chrono::system_clock::now(); |
||||
old_size = next_write_offset_; |
||||
} |
||||
#endif |
||||
{ |
||||
auto prev_perf_level = GetPerfLevel(); |
||||
IOSTATS_CPU_TIMER_GUARD(cpu_write_nanos, env_); |
||||
s = writable_file_->Append(Slice(src, allowed)); |
||||
SetPerfLevel(prev_perf_level); |
||||
} |
||||
#ifndef ROCKSDB_LITE |
||||
if (ShouldNotifyListeners()) { |
||||
auto finish_ts = std::chrono::system_clock::now(); |
||||
NotifyOnFileWriteFinish(old_size, allowed, start_ts, finish_ts, s); |
||||
} |
||||
#endif |
||||
if (!s.ok()) { |
||||
return s; |
||||
} |
||||
} |
||||
|
||||
IOSTATS_ADD(bytes_written, allowed); |
||||
TEST_KILL_RANDOM("WritableFileWriter::WriteBuffered:0", rocksdb_kill_odds); |
||||
|
||||
left -= allowed; |
||||
src += allowed; |
||||
} |
||||
buf_.Size(0); |
||||
return s; |
||||
} |
||||
|
||||
// This flushes the accumulated data in the buffer. We pad data with zeros if
|
||||
// necessary to the whole page.
|
||||
// However, during automatic flushes padding would not be necessary.
|
||||
// We always use RateLimiter if available. We move (Refit) any buffer bytes
|
||||
// that are left over the
|
||||
// whole number of pages to be written again on the next flush because we can
|
||||
// only write on aligned
|
||||
// offsets.
|
||||
#ifndef ROCKSDB_LITE |
||||
Status WritableFileWriter::WriteDirect() { |
||||
assert(use_direct_io()); |
||||
Status s; |
||||
const size_t alignment = buf_.Alignment(); |
||||
assert((next_write_offset_ % alignment) == 0); |
||||
|
||||
// Calculate whole page final file advance if all writes succeed
|
||||
size_t file_advance = TruncateToPageBoundary(alignment, buf_.CurrentSize()); |
||||
|
||||
// Calculate the leftover tail, we write it here padded with zeros BUT we
|
||||
// will write
|
||||
// it again in the future either on Close() OR when the current whole page
|
||||
// fills out
|
||||
size_t leftover_tail = buf_.CurrentSize() - file_advance; |
||||
|
||||
// Round up and pad
|
||||
buf_.PadToAlignmentWith(0); |
||||
|
||||
const char* src = buf_.BufferStart(); |
||||
uint64_t write_offset = next_write_offset_; |
||||
size_t left = buf_.CurrentSize(); |
||||
|
||||
while (left > 0) { |
||||
// Check how much is allowed
|
||||
size_t size; |
||||
if (rate_limiter_ != nullptr) { |
||||
size = rate_limiter_->RequestToken(left, buf_.Alignment(), |
||||
writable_file_->GetIOPriority(), |
||||
stats_, RateLimiter::OpType::kWrite); |
||||
} else { |
||||
size = left; |
||||
} |
||||
|
||||
{ |
||||
IOSTATS_TIMER_GUARD(write_nanos); |
||||
TEST_SYNC_POINT("WritableFileWriter::Flush:BeforeAppend"); |
||||
FileOperationInfo::TimePoint start_ts; |
||||
if (ShouldNotifyListeners()) { |
||||
start_ts = std::chrono::system_clock::now(); |
||||
} |
||||
// direct writes must be positional
|
||||
s = writable_file_->PositionedAppend(Slice(src, size), write_offset); |
||||
if (ShouldNotifyListeners()) { |
||||
auto finish_ts = std::chrono::system_clock::now(); |
||||
NotifyOnFileWriteFinish(write_offset, size, start_ts, finish_ts, s); |
||||
} |
||||
if (!s.ok()) { |
||||
buf_.Size(file_advance + leftover_tail); |
||||
return s; |
||||
} |
||||
} |
||||
|
||||
IOSTATS_ADD(bytes_written, size); |
||||
left -= size; |
||||
src += size; |
||||
write_offset += size; |
||||
assert((next_write_offset_ % alignment) == 0); |
||||
} |
||||
|
||||
if (s.ok()) { |
||||
// Move the tail to the beginning of the buffer
|
||||
// This never happens during normal Append but rather during
|
||||
// explicit call to Flush()/Sync() or Close()
|
||||
buf_.RefitTail(file_advance, leftover_tail); |
||||
// This is where we start writing next time which may or not be
|
||||
// the actual file size on disk. They match if the buffer size
|
||||
// is a multiple of whole pages otherwise filesize_ is leftover_tail
|
||||
// behind
|
||||
next_write_offset_ += file_advance; |
||||
} |
||||
return s; |
||||
} |
||||
#endif // !ROCKSDB_LITE
|
||||
} // namespace rocksdb
|
||||
@ -0,0 +1,155 @@ |
||||
// 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.
|
||||
|
||||
#pragma once |
||||
#include <atomic> |
||||
#include <string> |
||||
#include "port/port.h" |
||||
#include "rocksdb/env.h" |
||||
#include "rocksdb/listener.h" |
||||
#include "rocksdb/rate_limiter.h" |
||||
#include "test_util/sync_point.h" |
||||
#include "util/aligned_buffer.h" |
||||
|
||||
namespace rocksdb { |
||||
|
||||
class Statistics; |
||||
|
||||
// WritableFileWriter is a wrapper on top of Env::WritableFile. It provides
|
||||
// facilities to:
|
||||
// - Handle Buffered and Direct writes.
|
||||
// - Rate limit writes.
|
||||
// - Flush and Sync the data to the underlying filesystem.
|
||||
// - Notify any interested listeners on the completion of a write.
|
||||
// - Update IO stats.
|
||||
class WritableFileWriter { |
||||
private: |
||||
#ifndef ROCKSDB_LITE |
||||
void NotifyOnFileWriteFinish(uint64_t offset, size_t length, |
||||
const FileOperationInfo::TimePoint& start_ts, |
||||
const FileOperationInfo::TimePoint& finish_ts, |
||||
const Status& status) { |
||||
FileOperationInfo info(file_name_, start_ts, finish_ts); |
||||
info.offset = offset; |
||||
info.length = length; |
||||
info.status = status; |
||||
|
||||
for (auto& listener : listeners_) { |
||||
listener->OnFileWriteFinish(info); |
||||
} |
||||
} |
||||
#endif // ROCKSDB_LITE
|
||||
|
||||
bool ShouldNotifyListeners() const { return !listeners_.empty(); } |
||||
|
||||
std::unique_ptr<WritableFile> writable_file_; |
||||
std::string file_name_; |
||||
Env* env_; |
||||
AlignedBuffer buf_; |
||||
size_t max_buffer_size_; |
||||
// Actually written data size can be used for truncate
|
||||
// not counting padding data
|
||||
uint64_t filesize_; |
||||
#ifndef ROCKSDB_LITE |
||||
// This is necessary when we use unbuffered access
|
||||
// and writes must happen on aligned offsets
|
||||
// so we need to go back and write that page again
|
||||
uint64_t next_write_offset_; |
||||
#endif // ROCKSDB_LITE
|
||||
bool pending_sync_; |
||||
uint64_t last_sync_size_; |
||||
uint64_t bytes_per_sync_; |
||||
RateLimiter* rate_limiter_; |
||||
Statistics* stats_; |
||||
std::vector<std::shared_ptr<EventListener>> listeners_; |
||||
|
||||
public: |
||||
WritableFileWriter( |
||||
std::unique_ptr<WritableFile>&& file, const std::string& _file_name, |
||||
const EnvOptions& options, Env* env = nullptr, |
||||
Statistics* stats = nullptr, |
||||
const std::vector<std::shared_ptr<EventListener>>& listeners = {}) |
||||
: writable_file_(std::move(file)), |
||||
file_name_(_file_name), |
||||
env_(env), |
||||
buf_(), |
||||
max_buffer_size_(options.writable_file_max_buffer_size), |
||||
filesize_(0), |
||||
#ifndef ROCKSDB_LITE |
||||
next_write_offset_(0), |
||||
#endif // ROCKSDB_LITE
|
||||
pending_sync_(false), |
||||
last_sync_size_(0), |
||||
bytes_per_sync_(options.bytes_per_sync), |
||||
rate_limiter_(options.rate_limiter), |
||||
stats_(stats), |
||||
listeners_() { |
||||
TEST_SYNC_POINT_CALLBACK("WritableFileWriter::WritableFileWriter:0", |
||||
reinterpret_cast<void*>(max_buffer_size_)); |
||||
buf_.Alignment(writable_file_->GetRequiredBufferAlignment()); |
||||
buf_.AllocateNewBuffer(std::min((size_t)65536, max_buffer_size_)); |
||||
#ifndef ROCKSDB_LITE |
||||
std::for_each(listeners.begin(), listeners.end(), |
||||
[this](const std::shared_ptr<EventListener>& e) { |
||||
if (e->ShouldBeNotifiedOnFileIO()) { |
||||
listeners_.emplace_back(e); |
||||
} |
||||
}); |
||||
#else // !ROCKSDB_LITE
|
||||
(void)listeners; |
||||
#endif |
||||
} |
||||
|
||||
WritableFileWriter(const WritableFileWriter&) = delete; |
||||
|
||||
WritableFileWriter& operator=(const WritableFileWriter&) = delete; |
||||
|
||||
~WritableFileWriter() { Close(); } |
||||
|
||||
std::string file_name() const { return file_name_; } |
||||
|
||||
Status Append(const Slice& data); |
||||
|
||||
Status Pad(const size_t pad_bytes); |
||||
|
||||
Status Flush(); |
||||
|
||||
Status Close(); |
||||
|
||||
Status Sync(bool use_fsync); |
||||
|
||||
// Sync only the data that was already Flush()ed. Safe to call concurrently
|
||||
// with Append() and Flush(). If !writable_file_->IsSyncThreadSafe(),
|
||||
// returns NotSupported status.
|
||||
Status SyncWithoutFlush(bool use_fsync); |
||||
|
||||
uint64_t GetFileSize() const { return filesize_; } |
||||
|
||||
Status InvalidateCache(size_t offset, size_t length) { |
||||
return writable_file_->InvalidateCache(offset, length); |
||||
} |
||||
|
||||
WritableFile* writable_file() const { return writable_file_.get(); } |
||||
|
||||
bool use_direct_io() { return writable_file_->use_direct_io(); } |
||||
|
||||
bool TEST_BufferIsEmpty() { return buf_.CurrentSize() == 0; } |
||||
|
||||
private: |
||||
// Used when os buffering is OFF and we are writing
|
||||
// DMA such as in Direct I/O mode
|
||||
#ifndef ROCKSDB_LITE |
||||
Status WriteDirect(); |
||||
#endif // !ROCKSDB_LITE
|
||||
// Normal write
|
||||
Status WriteBuffered(const char* data, size_t size); |
||||
Status RangeSync(uint64_t offset, uint64_t nbytes); |
||||
Status SyncInternal(bool use_fsync); |
||||
}; |
||||
} // namespace rocksdb
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,407 +0,0 @@ |
||||
// 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.
|
||||
|
||||
#pragma once |
||||
#include <atomic> |
||||
#include <sstream> |
||||
#include <string> |
||||
#include "port/port.h" |
||||
#include "rocksdb/env.h" |
||||
#include "rocksdb/listener.h" |
||||
#include "rocksdb/rate_limiter.h" |
||||
#include "test_util/sync_point.h" |
||||
#include "util/aligned_buffer.h" |
||||
|
||||
namespace rocksdb { |
||||
|
||||
class Statistics; |
||||
class HistogramImpl; |
||||
|
||||
// This file provides the following main abstractions:
|
||||
// SequentialFileReader : wrapper over Env::SequentialFile
|
||||
// RandomAccessFileReader : wrapper over Env::RandomAccessFile
|
||||
// WritableFileWriter : wrapper over Env::WritableFile
|
||||
// In addition, it also exposed NewReadaheadRandomAccessFile, NewWritableFile,
|
||||
// and ReadOneLine primitives.
|
||||
|
||||
// NewReadaheadRandomAccessFile provides a wrapper over RandomAccessFile to
|
||||
// always prefetch additional data with every read. This is mainly used in
|
||||
// Compaction Table Readers.
|
||||
std::unique_ptr<RandomAccessFile> NewReadaheadRandomAccessFile( |
||||
std::unique_ptr<RandomAccessFile>&& file, size_t readahead_size); |
||||
|
||||
// SequentialFileReader is a wrapper on top of Env::SequentialFile. It handles
|
||||
// Buffered (i.e when page cache is enabled) and Direct (with O_DIRECT / page
|
||||
// cache disabled) reads appropriately, and also updates the IO stats.
|
||||
class SequentialFileReader { |
||||
private: |
||||
std::unique_ptr<SequentialFile> file_; |
||||
std::string file_name_; |
||||
std::atomic<size_t> offset_{0}; // read offset
|
||||
|
||||
public: |
||||
explicit SequentialFileReader(std::unique_ptr<SequentialFile>&& _file, |
||||
const std::string& _file_name) |
||||
: file_(std::move(_file)), file_name_(_file_name) {} |
||||
|
||||
explicit SequentialFileReader(std::unique_ptr<SequentialFile>&& _file, |
||||
const std::string& _file_name, |
||||
size_t _readahead_size) |
||||
: file_(NewReadaheadSequentialFile(std::move(_file), _readahead_size)), |
||||
file_name_(_file_name) {} |
||||
|
||||
SequentialFileReader(SequentialFileReader&& o) ROCKSDB_NOEXCEPT { |
||||
*this = std::move(o); |
||||
} |
||||
|
||||
SequentialFileReader& operator=(SequentialFileReader&& o) ROCKSDB_NOEXCEPT { |
||||
file_ = std::move(o.file_); |
||||
return *this; |
||||
} |
||||
|
||||
SequentialFileReader(const SequentialFileReader&) = delete; |
||||
SequentialFileReader& operator=(const SequentialFileReader&) = delete; |
||||
|
||||
Status Read(size_t n, Slice* result, char* scratch); |
||||
|
||||
Status Skip(uint64_t n); |
||||
|
||||
SequentialFile* file() { return file_.get(); } |
||||
|
||||
std::string file_name() { return file_name_; } |
||||
|
||||
bool use_direct_io() const { return file_->use_direct_io(); } |
||||
|
||||
private: |
||||
// NewReadaheadSequentialFile provides a wrapper over SequentialFile to
|
||||
// always prefetch additional data with every read.
|
||||
static std::unique_ptr<SequentialFile> NewReadaheadSequentialFile( |
||||
std::unique_ptr<SequentialFile>&& file, size_t readahead_size); |
||||
}; |
||||
|
||||
// RandomAccessFileReader is a wrapper on top of Env::RnadomAccessFile. It is
|
||||
// responsible for:
|
||||
// - Handling Buffered and Direct reads appropriately.
|
||||
// - Rate limiting compaction reads.
|
||||
// - Notifying any interested listeners on the completion of a read.
|
||||
// - Updating IO stats.
|
||||
class RandomAccessFileReader { |
||||
private: |
||||
#ifndef ROCKSDB_LITE |
||||
void NotifyOnFileReadFinish(uint64_t offset, size_t length, |
||||
const FileOperationInfo::TimePoint& start_ts, |
||||
const FileOperationInfo::TimePoint& finish_ts, |
||||
const Status& status) const { |
||||
FileOperationInfo info(file_name_, start_ts, finish_ts); |
||||
info.offset = offset; |
||||
info.length = length; |
||||
info.status = status; |
||||
|
||||
for (auto& listener : listeners_) { |
||||
listener->OnFileReadFinish(info); |
||||
} |
||||
} |
||||
#endif // ROCKSDB_LITE
|
||||
|
||||
bool ShouldNotifyListeners() const { return !listeners_.empty(); } |
||||
|
||||
std::unique_ptr<RandomAccessFile> file_; |
||||
std::string file_name_; |
||||
Env* env_; |
||||
Statistics* stats_; |
||||
uint32_t hist_type_; |
||||
HistogramImpl* file_read_hist_; |
||||
RateLimiter* rate_limiter_; |
||||
std::vector<std::shared_ptr<EventListener>> listeners_; |
||||
|
||||
public: |
||||
explicit RandomAccessFileReader( |
||||
std::unique_ptr<RandomAccessFile>&& raf, std::string _file_name, |
||||
Env* env = nullptr, Statistics* stats = nullptr, uint32_t hist_type = 0, |
||||
HistogramImpl* file_read_hist = nullptr, |
||||
RateLimiter* rate_limiter = nullptr, |
||||
const std::vector<std::shared_ptr<EventListener>>& listeners = {}) |
||||
: file_(std::move(raf)), |
||||
file_name_(std::move(_file_name)), |
||||
env_(env), |
||||
stats_(stats), |
||||
hist_type_(hist_type), |
||||
file_read_hist_(file_read_hist), |
||||
rate_limiter_(rate_limiter), |
||||
listeners_() { |
||||
#ifndef ROCKSDB_LITE |
||||
std::for_each(listeners.begin(), listeners.end(), |
||||
[this](const std::shared_ptr<EventListener>& e) { |
||||
if (e->ShouldBeNotifiedOnFileIO()) { |
||||
listeners_.emplace_back(e); |
||||
} |
||||
}); |
||||
#else // !ROCKSDB_LITE
|
||||
(void)listeners; |
||||
#endif |
||||
} |
||||
|
||||
RandomAccessFileReader(RandomAccessFileReader&& o) ROCKSDB_NOEXCEPT { |
||||
*this = std::move(o); |
||||
} |
||||
|
||||
RandomAccessFileReader& operator=(RandomAccessFileReader&& o) |
||||
ROCKSDB_NOEXCEPT { |
||||
file_ = std::move(o.file_); |
||||
env_ = std::move(o.env_); |
||||
stats_ = std::move(o.stats_); |
||||
hist_type_ = std::move(o.hist_type_); |
||||
file_read_hist_ = std::move(o.file_read_hist_); |
||||
rate_limiter_ = std::move(o.rate_limiter_); |
||||
return *this; |
||||
} |
||||
|
||||
RandomAccessFileReader(const RandomAccessFileReader&) = delete; |
||||
RandomAccessFileReader& operator=(const RandomAccessFileReader&) = delete; |
||||
|
||||
Status Read(uint64_t offset, size_t n, Slice* result, char* scratch, |
||||
bool for_compaction = false) const; |
||||
|
||||
Status MultiRead(ReadRequest* reqs, size_t num_reqs) const; |
||||
|
||||
Status Prefetch(uint64_t offset, size_t n) const { |
||||
return file_->Prefetch(offset, n); |
||||
} |
||||
|
||||
RandomAccessFile* file() { return file_.get(); } |
||||
|
||||
std::string file_name() const { return file_name_; } |
||||
|
||||
bool use_direct_io() const { return file_->use_direct_io(); } |
||||
}; |
||||
|
||||
// WritableFileWriter is a wrapper on top of Env::WritableFile. It provides
|
||||
// facilities to:
|
||||
// - Handle Buffered and Direct writes.
|
||||
// - Rate limit writes.
|
||||
// - Flush and Sync the data to the underlying filesystem.
|
||||
// - Notify any interested listeners on the completion of a write.
|
||||
// - Update IO stats.
|
||||
class WritableFileWriter { |
||||
private: |
||||
#ifndef ROCKSDB_LITE |
||||
void NotifyOnFileWriteFinish(uint64_t offset, size_t length, |
||||
const FileOperationInfo::TimePoint& start_ts, |
||||
const FileOperationInfo::TimePoint& finish_ts, |
||||
const Status& status) { |
||||
FileOperationInfo info(file_name_, start_ts, finish_ts); |
||||
info.offset = offset; |
||||
info.length = length; |
||||
info.status = status; |
||||
|
||||
for (auto& listener : listeners_) { |
||||
listener->OnFileWriteFinish(info); |
||||
} |
||||
} |
||||
#endif // ROCKSDB_LITE
|
||||
|
||||
bool ShouldNotifyListeners() const { return !listeners_.empty(); } |
||||
|
||||
std::unique_ptr<WritableFile> writable_file_; |
||||
std::string file_name_; |
||||
Env* env_; |
||||
AlignedBuffer buf_; |
||||
size_t max_buffer_size_; |
||||
// Actually written data size can be used for truncate
|
||||
// not counting padding data
|
||||
uint64_t filesize_; |
||||
#ifndef ROCKSDB_LITE |
||||
// This is necessary when we use unbuffered access
|
||||
// and writes must happen on aligned offsets
|
||||
// so we need to go back and write that page again
|
||||
uint64_t next_write_offset_; |
||||
#endif // ROCKSDB_LITE
|
||||
bool pending_sync_; |
||||
uint64_t last_sync_size_; |
||||
uint64_t bytes_per_sync_; |
||||
RateLimiter* rate_limiter_; |
||||
Statistics* stats_; |
||||
std::vector<std::shared_ptr<EventListener>> listeners_; |
||||
|
||||
public: |
||||
WritableFileWriter( |
||||
std::unique_ptr<WritableFile>&& file, const std::string& _file_name, |
||||
const EnvOptions& options, Env* env = nullptr, |
||||
Statistics* stats = nullptr, |
||||
const std::vector<std::shared_ptr<EventListener>>& listeners = {}) |
||||
: writable_file_(std::move(file)), |
||||
file_name_(_file_name), |
||||
env_(env), |
||||
buf_(), |
||||
max_buffer_size_(options.writable_file_max_buffer_size), |
||||
filesize_(0), |
||||
#ifndef ROCKSDB_LITE |
||||
next_write_offset_(0), |
||||
#endif // ROCKSDB_LITE
|
||||
pending_sync_(false), |
||||
last_sync_size_(0), |
||||
bytes_per_sync_(options.bytes_per_sync), |
||||
rate_limiter_(options.rate_limiter), |
||||
stats_(stats), |
||||
listeners_() { |
||||
TEST_SYNC_POINT_CALLBACK("WritableFileWriter::WritableFileWriter:0", |
||||
reinterpret_cast<void*>(max_buffer_size_)); |
||||
buf_.Alignment(writable_file_->GetRequiredBufferAlignment()); |
||||
buf_.AllocateNewBuffer(std::min((size_t)65536, max_buffer_size_)); |
||||
#ifndef ROCKSDB_LITE |
||||
std::for_each(listeners.begin(), listeners.end(), |
||||
[this](const std::shared_ptr<EventListener>& e) { |
||||
if (e->ShouldBeNotifiedOnFileIO()) { |
||||
listeners_.emplace_back(e); |
||||
} |
||||
}); |
||||
#else // !ROCKSDB_LITE
|
||||
(void)listeners; |
||||
#endif |
||||
} |
||||
|
||||
WritableFileWriter(const WritableFileWriter&) = delete; |
||||
|
||||
WritableFileWriter& operator=(const WritableFileWriter&) = delete; |
||||
|
||||
~WritableFileWriter() { Close(); } |
||||
|
||||
std::string file_name() const { return file_name_; } |
||||
|
||||
Status Append(const Slice& data); |
||||
|
||||
Status Pad(const size_t pad_bytes); |
||||
|
||||
Status Flush(); |
||||
|
||||
Status Close(); |
||||
|
||||
Status Sync(bool use_fsync); |
||||
|
||||
// Sync only the data that was already Flush()ed. Safe to call concurrently
|
||||
// with Append() and Flush(). If !writable_file_->IsSyncThreadSafe(),
|
||||
// returns NotSupported status.
|
||||
Status SyncWithoutFlush(bool use_fsync); |
||||
|
||||
uint64_t GetFileSize() const { return filesize_; } |
||||
|
||||
Status InvalidateCache(size_t offset, size_t length) { |
||||
return writable_file_->InvalidateCache(offset, length); |
||||
} |
||||
|
||||
WritableFile* writable_file() const { return writable_file_.get(); } |
||||
|
||||
bool use_direct_io() { return writable_file_->use_direct_io(); } |
||||
|
||||
bool TEST_BufferIsEmpty() { return buf_.CurrentSize() == 0; } |
||||
|
||||
private: |
||||
// Used when os buffering is OFF and we are writing
|
||||
// DMA such as in Direct I/O mode
|
||||
#ifndef ROCKSDB_LITE |
||||
Status WriteDirect(); |
||||
#endif // !ROCKSDB_LITE
|
||||
// Normal write
|
||||
Status WriteBuffered(const char* data, size_t size); |
||||
Status RangeSync(uint64_t offset, uint64_t nbytes); |
||||
Status SyncInternal(bool use_fsync); |
||||
}; |
||||
|
||||
// FilePrefetchBuffer is a smart buffer to store and read data from a file.
|
||||
class FilePrefetchBuffer { |
||||
public: |
||||
// Constructor.
|
||||
//
|
||||
// All arguments are optional.
|
||||
// file_reader : the file reader to use. Can be a nullptr.
|
||||
// readahead_size : the initial readahead size.
|
||||
// max_readahead_size : the maximum readahead size.
|
||||
// If max_readahead_size > readahead_size, the readahead size will be
|
||||
// doubled on every IO until max_readahead_size is hit.
|
||||
// Typically this is set as a multiple of readahead_size.
|
||||
// max_readahead_size should be greater than equal to readahead_size.
|
||||
// enable : controls whether reading from the buffer is enabled.
|
||||
// If false, TryReadFromCache() always return false, and we only take stats
|
||||
// for the minimum offset if track_min_offset = true.
|
||||
// track_min_offset : Track the minimum offset ever read and collect stats on
|
||||
// it. Used for adaptable readahead of the file footer/metadata.
|
||||
//
|
||||
// Automatic readhead is enabled for a file if file_reader, readahead_size,
|
||||
// and max_readahead_size are passed in.
|
||||
// If file_reader is a nullptr, setting readadhead_size and max_readahead_size
|
||||
// does not make any sense. So it does nothing.
|
||||
// A user can construct a FilePrefetchBuffer without any arguments, but use
|
||||
// `Prefetch` to load data into the buffer.
|
||||
FilePrefetchBuffer(RandomAccessFileReader* file_reader = nullptr, |
||||
size_t readadhead_size = 0, size_t max_readahead_size = 0, |
||||
bool enable = true, bool track_min_offset = false) |
||||
: buffer_offset_(0), |
||||
file_reader_(file_reader), |
||||
readahead_size_(readadhead_size), |
||||
max_readahead_size_(max_readahead_size), |
||||
min_offset_read_(port::kMaxSizet), |
||||
enable_(enable), |
||||
track_min_offset_(track_min_offset) {} |
||||
|
||||
// Load data into the buffer from a file.
|
||||
// reader : the file reader.
|
||||
// offset : the file offset to start reading from.
|
||||
// n : the number of bytes to read.
|
||||
// for_compaction : if prefetch is done for compaction read.
|
||||
Status Prefetch(RandomAccessFileReader* reader, uint64_t offset, size_t n, |
||||
bool for_compaction = false); |
||||
|
||||
// Tries returning the data for a file raed from this buffer, if that data is
|
||||
// in the buffer.
|
||||
// It handles tracking the minimum read offset if track_min_offset = true.
|
||||
// It also does the exponential readahead when readadhead_size is set as part
|
||||
// of the constructor.
|
||||
//
|
||||
// offset : the file offset.
|
||||
// n : the number of bytes.
|
||||
// result : output buffer to put the data into.
|
||||
// for_compaction : if cache read is done for compaction read.
|
||||
bool TryReadFromCache(uint64_t offset, size_t n, Slice* result, |
||||
bool for_compaction = false); |
||||
|
||||
// The minimum `offset` ever passed to TryReadFromCache(). This will nly be
|
||||
// tracked if track_min_offset = true.
|
||||
size_t min_offset_read() const { return min_offset_read_; } |
||||
|
||||
private: |
||||
AlignedBuffer buffer_; |
||||
uint64_t buffer_offset_; |
||||
RandomAccessFileReader* file_reader_; |
||||
size_t readahead_size_; |
||||
size_t max_readahead_size_; |
||||
// The minimum `offset` ever passed to TryReadFromCache().
|
||||
size_t min_offset_read_; |
||||
// if false, TryReadFromCache() always return false, and we only take stats
|
||||
// for track_min_offset_ if track_min_offset_ = true
|
||||
bool enable_; |
||||
// If true, track minimum `offset` ever passed to TryReadFromCache(), which
|
||||
// can be fetched from min_offset_read().
|
||||
bool track_min_offset_; |
||||
}; |
||||
|
||||
// Returns a WritableFile.
|
||||
//
|
||||
// env : the Env.
|
||||
// fname : the file name.
|
||||
// result : output arg. A WritableFile based on `fname` returned.
|
||||
// options : the Env Options.
|
||||
extern Status NewWritableFile(Env* env, const std::string& fname, |
||||
std::unique_ptr<WritableFile>* result, |
||||
const EnvOptions& options); |
||||
|
||||
// Read a single line from a file.
|
||||
bool ReadOneLine(std::istringstream* iss, SequentialFile* seq_file, |
||||
std::string* output, bool* has_data, Status* result); |
||||
|
||||
} // namespace rocksdb
|
||||
Loading…
Reference in new issue