2019-05-31 20:52:59 +02:00
|
|
|
|
2017-05-10 23:54:35 +02:00
|
|
|
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
2017-07-16 01:03:42 +02:00
|
|
|
// 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).
|
2017-05-10 23:54:35 +02:00
|
|
|
#ifndef ROCKSDB_LITE
|
2017-10-13 23:36:36 +02:00
|
|
|
#include "utilities/blob_db/blob_file.h"
|
2017-05-10 23:54:35 +02:00
|
|
|
|
2017-05-16 20:50:43 +02:00
|
|
|
#include <stdio.h>
|
2019-09-20 21:00:55 +02:00
|
|
|
#include <cinttypes>
|
2017-10-17 21:11:52 +02:00
|
|
|
|
|
|
|
#include <algorithm>
|
2017-12-11 21:01:22 +01:00
|
|
|
#include <limits>
|
2017-05-10 23:54:35 +02:00
|
|
|
#include <memory>
|
|
|
|
|
2017-10-27 22:14:34 +02:00
|
|
|
#include "db/column_family.h"
|
2019-05-31 20:52:59 +02:00
|
|
|
#include "db/db_impl/db_impl.h"
|
Blob DB: Inline small values in base DB
Summary:
Adding the `min_blob_size` option to allow storing small values in base db (in LSM tree) together with the key. The goal is to improve performance for small values, while taking advantage of blob db's low write amplification for large values.
Also adding expiration timestamp to blob index. It will be useful to evict stale blob indexes in base db by adding a compaction filter. I'll work on the compaction filter in future patches.
See blob_index.h for the new blob index format. There are 4 cases when writing a new key:
* small value w/o TTL: put in base db as normal value (i.e. ValueType::kTypeValue)
* small value w/ TTL: put (type, expiration, value) to base db.
* large value w/o TTL: write value to blob log and put (type, file, offset, size, compression) to base db.
* large value w/TTL: write value to blob log and put (type, expiration, file, offset, size, compression) to base db.
Closes https://github.com/facebook/rocksdb/pull/3066
Differential Revision: D6142115
Pulled By: yiwu-arbug
fbshipit-source-id: 9526e76e19f0839310a3f5f2a43772a4ad182cd0
2017-10-26 21:19:43 +02:00
|
|
|
#include "db/dbformat.h"
|
2019-05-30 05:44:08 +02:00
|
|
|
#include "file/filename.h"
|
2019-09-16 19:31:27 +02:00
|
|
|
#include "file/readahead_raf.h"
|
2019-06-01 02:19:43 +02:00
|
|
|
#include "logging/logging.h"
|
2017-10-13 23:36:36 +02:00
|
|
|
#include "utilities/blob_db/blob_db_impl.h"
|
2017-05-10 23:54:35 +02:00
|
|
|
|
|
|
|
namespace rocksdb {
|
|
|
|
|
|
|
|
namespace blob_db {
|
|
|
|
|
|
|
|
BlobFile::BlobFile()
|
|
|
|
: parent_(nullptr),
|
|
|
|
file_number_(0),
|
2017-12-11 21:01:22 +01:00
|
|
|
info_log_(nullptr),
|
|
|
|
column_family_id_(std::numeric_limits<uint32_t>::max()),
|
2017-11-08 02:40:44 +01:00
|
|
|
compression_(kNoCompression),
|
2017-12-11 21:01:22 +01:00
|
|
|
has_ttl_(false),
|
2017-05-10 23:54:35 +02:00
|
|
|
blob_count_(0),
|
|
|
|
file_size_(0),
|
|
|
|
closed_(false),
|
2019-11-19 01:28:04 +01:00
|
|
|
immutable_sequence_(0),
|
2017-11-02 23:50:30 +01:00
|
|
|
obsolete_(false),
|
2019-11-19 01:28:04 +01:00
|
|
|
obsolete_sequence_(0),
|
2017-10-27 22:14:34 +02:00
|
|
|
expiration_range_({0, 0}),
|
2017-05-10 23:54:35 +02:00
|
|
|
last_access_(-1),
|
|
|
|
last_fsync_(0),
|
2017-12-11 21:01:22 +01:00
|
|
|
header_valid_(false),
|
|
|
|
footer_valid_(false) {}
|
2017-05-10 23:54:35 +02:00
|
|
|
|
2017-12-11 21:01:22 +01:00
|
|
|
BlobFile::BlobFile(const BlobDBImpl* p, const std::string& bdir, uint64_t fn,
|
|
|
|
Logger* info_log)
|
2017-05-10 23:54:35 +02:00
|
|
|
: parent_(p),
|
|
|
|
path_to_dir_(bdir),
|
|
|
|
file_number_(fn),
|
2017-12-11 21:01:22 +01:00
|
|
|
info_log_(info_log),
|
|
|
|
column_family_id_(std::numeric_limits<uint32_t>::max()),
|
2017-11-08 02:40:44 +01:00
|
|
|
compression_(kNoCompression),
|
2017-12-11 21:01:22 +01:00
|
|
|
has_ttl_(false),
|
2017-05-10 23:54:35 +02:00
|
|
|
blob_count_(0),
|
|
|
|
file_size_(0),
|
|
|
|
closed_(false),
|
2019-11-19 01:28:04 +01:00
|
|
|
immutable_sequence_(0),
|
2017-11-02 23:50:30 +01:00
|
|
|
obsolete_(false),
|
2019-11-19 01:28:04 +01:00
|
|
|
obsolete_sequence_(0),
|
2017-10-27 22:14:34 +02:00
|
|
|
expiration_range_({0, 0}),
|
2017-05-10 23:54:35 +02:00
|
|
|
last_access_(-1),
|
|
|
|
last_fsync_(0),
|
2017-12-11 21:01:22 +01:00
|
|
|
header_valid_(false),
|
|
|
|
footer_valid_(false) {}
|
2017-05-10 23:54:35 +02:00
|
|
|
|
|
|
|
BlobFile::~BlobFile() {
|
2017-11-02 23:50:30 +01:00
|
|
|
if (obsolete_) {
|
2017-05-10 23:54:35 +02:00
|
|
|
std::string pn(PathName());
|
|
|
|
Status s = Env::Default()->DeleteFile(PathName());
|
|
|
|
if (!s.ok()) {
|
2017-07-13 19:03:39 +02:00
|
|
|
// ROCKS_LOG_INFO(db_options_.info_log,
|
2017-05-10 23:54:35 +02:00
|
|
|
// "File could not be deleted %s", pn.c_str());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-11 21:01:22 +01:00
|
|
|
uint32_t BlobFile::column_family_id() const { return column_family_id_; }
|
2017-10-27 22:14:34 +02:00
|
|
|
|
2017-05-10 23:54:35 +02:00
|
|
|
std::string BlobFile::PathName() const {
|
|
|
|
return BlobFileName(path_to_dir_, file_number_);
|
|
|
|
}
|
|
|
|
|
2018-06-24 08:08:33 +02:00
|
|
|
std::shared_ptr<Reader> BlobFile::OpenRandomAccessReader(
|
2017-05-10 23:54:35 +02:00
|
|
|
Env* env, const DBOptions& db_options,
|
|
|
|
const EnvOptions& env_options) const {
|
2018-06-24 08:08:33 +02:00
|
|
|
constexpr size_t kReadaheadSize = 2 * 1024 * 1024;
|
|
|
|
std::unique_ptr<RandomAccessFile> sfile;
|
2018-06-21 17:34:24 +02:00
|
|
|
std::string path_name(PathName());
|
2018-06-24 08:08:33 +02:00
|
|
|
Status s = env->NewRandomAccessFile(path_name, &sfile, env_options);
|
2017-05-10 23:54:35 +02:00
|
|
|
if (!s.ok()) {
|
|
|
|
// report something here.
|
|
|
|
return nullptr;
|
|
|
|
}
|
2018-06-24 08:08:33 +02:00
|
|
|
sfile = NewReadaheadRandomAccessFile(std::move(sfile), kReadaheadSize);
|
2017-05-10 23:54:35 +02:00
|
|
|
|
2018-06-24 08:08:33 +02:00
|
|
|
std::unique_ptr<RandomAccessFileReader> sfile_reader;
|
|
|
|
sfile_reader.reset(new RandomAccessFileReader(std::move(sfile), path_name));
|
2017-05-10 23:54:35 +02:00
|
|
|
|
2017-11-28 20:42:28 +01:00
|
|
|
std::shared_ptr<Reader> log_reader = std::make_shared<Reader>(
|
|
|
|
std::move(sfile_reader), db_options.env, db_options.statistics.get());
|
2017-05-10 23:54:35 +02:00
|
|
|
|
|
|
|
return log_reader;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string BlobFile::DumpState() const {
|
|
|
|
char str[1000];
|
2018-03-02 21:54:24 +01:00
|
|
|
snprintf(
|
|
|
|
str, sizeof(str),
|
|
|
|
"path: %s fn: %" PRIu64 " blob_count: %" PRIu64 " file_size: %" PRIu64
|
|
|
|
" closed: %d obsolete: %d expiration_range: (%" PRIu64 ", %" PRIu64
|
|
|
|
"), writer: %d reader: %d",
|
|
|
|
path_to_dir_.c_str(), file_number_, blob_count_.load(), file_size_.load(),
|
|
|
|
closed_.load(), obsolete_.load(), expiration_range_.first,
|
|
|
|
expiration_range_.second, (!!log_writer_), (!!ra_file_reader_));
|
2017-05-10 23:54:35 +02:00
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
2017-11-02 23:50:30 +01:00
|
|
|
void BlobFile::MarkObsolete(SequenceNumber sequence) {
|
2017-12-11 21:01:22 +01:00
|
|
|
assert(Immutable());
|
2017-11-02 23:50:30 +01:00
|
|
|
obsolete_sequence_ = sequence;
|
|
|
|
obsolete_.store(true);
|
|
|
|
}
|
|
|
|
|
2017-05-10 23:54:35 +02:00
|
|
|
bool BlobFile::NeedsFsync(bool hard, uint64_t bytes_per_sync) const {
|
|
|
|
assert(last_fsync_ <= file_size_);
|
|
|
|
return (hard) ? file_size_ > last_fsync_
|
|
|
|
: (file_size_ - last_fsync_) >= bytes_per_sync;
|
|
|
|
}
|
|
|
|
|
2019-11-19 01:28:04 +01:00
|
|
|
Status BlobFile::WriteFooterAndCloseLocked(SequenceNumber sequence) {
|
2017-05-10 23:54:35 +02:00
|
|
|
BlobLogFooter footer;
|
2017-10-27 22:14:34 +02:00
|
|
|
footer.blob_count = blob_count_;
|
|
|
|
if (HasTTL()) {
|
|
|
|
footer.expiration_range = expiration_range_;
|
|
|
|
}
|
2017-05-10 23:54:35 +02:00
|
|
|
|
|
|
|
// this will close the file and reset the Writable File Pointer.
|
|
|
|
Status s = log_writer_->AppendFooter(footer);
|
|
|
|
if (s.ok()) {
|
|
|
|
closed_ = true;
|
2019-11-19 01:28:04 +01:00
|
|
|
immutable_sequence_ = sequence;
|
2017-10-27 22:14:34 +02:00
|
|
|
file_size_ += BlobLogFooter::kSize;
|
2017-05-10 23:54:35 +02:00
|
|
|
}
|
|
|
|
// delete the sequential writer
|
|
|
|
log_writer_.reset();
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
Status BlobFile::ReadFooter(BlobLogFooter* bf) {
|
2017-10-27 22:14:34 +02:00
|
|
|
if (file_size_ < (BlobLogHeader::kSize + BlobLogFooter::kSize)) {
|
2017-05-10 23:54:35 +02:00
|
|
|
return Status::IOError("File does not have footer", PathName());
|
|
|
|
}
|
|
|
|
|
2017-10-27 22:14:34 +02:00
|
|
|
uint64_t footer_offset = file_size_ - BlobLogFooter::kSize;
|
2017-05-10 23:54:35 +02:00
|
|
|
// assume that ra_file_reader_ is valid before we enter this
|
|
|
|
assert(ra_file_reader_);
|
|
|
|
|
|
|
|
Slice result;
|
2017-10-27 22:14:34 +02:00
|
|
|
char scratch[BlobLogFooter::kSize + 10];
|
|
|
|
Status s = ra_file_reader_->Read(footer_offset, BlobLogFooter::kSize, &result,
|
|
|
|
scratch);
|
2017-05-10 23:54:35 +02:00
|
|
|
if (!s.ok()) return s;
|
2017-10-27 22:14:34 +02:00
|
|
|
if (result.size() != BlobLogFooter::kSize) {
|
2017-05-10 23:54:35 +02:00
|
|
|
// should not happen
|
|
|
|
return Status::IOError("EOF reached before footer");
|
|
|
|
}
|
|
|
|
|
2017-05-23 19:30:04 +02:00
|
|
|
s = bf->DecodeFrom(result);
|
2017-05-10 23:54:35 +02:00
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
Status BlobFile::SetFromFooterLocked(const BlobLogFooter& footer) {
|
|
|
|
// assume that file has been fully fsync'd
|
|
|
|
last_fsync_.store(file_size_);
|
2017-10-27 22:14:34 +02:00
|
|
|
blob_count_ = footer.blob_count;
|
|
|
|
expiration_range_ = footer.expiration_range;
|
2017-05-10 23:54:35 +02:00
|
|
|
closed_ = true;
|
|
|
|
return Status::OK();
|
|
|
|
}
|
|
|
|
|
2017-12-11 21:01:22 +01:00
|
|
|
Status BlobFile::Fsync() {
|
|
|
|
Status s;
|
2017-05-10 23:54:35 +02:00
|
|
|
if (log_writer_.get()) {
|
2017-12-11 21:01:22 +01:00
|
|
|
s = log_writer_->Sync();
|
2017-05-10 23:54:35 +02:00
|
|
|
last_fsync_.store(file_size_.load());
|
|
|
|
}
|
2017-12-11 21:01:22 +01:00
|
|
|
return s;
|
2017-05-10 23:54:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void BlobFile::CloseRandomAccessLocked() {
|
|
|
|
ra_file_reader_.reset();
|
|
|
|
last_access_ = -1;
|
|
|
|
}
|
|
|
|
|
2018-09-21 01:50:07 +02:00
|
|
|
Status BlobFile::GetReader(Env* env, const EnvOptions& env_options,
|
|
|
|
std::shared_ptr<RandomAccessFileReader>* reader,
|
|
|
|
bool* fresh_open) {
|
|
|
|
assert(reader != nullptr);
|
|
|
|
assert(fresh_open != nullptr);
|
2017-05-10 23:54:35 +02:00
|
|
|
*fresh_open = false;
|
2017-10-13 23:36:36 +02:00
|
|
|
int64_t current_time = 0;
|
|
|
|
env->GetCurrentTime(¤t_time);
|
|
|
|
last_access_.store(current_time);
|
2018-09-21 01:50:07 +02:00
|
|
|
Status s;
|
2017-10-13 23:36:36 +02:00
|
|
|
|
2017-05-10 23:54:35 +02:00
|
|
|
{
|
|
|
|
ReadLock lockbfile_r(&mutex_);
|
2018-09-21 01:50:07 +02:00
|
|
|
if (ra_file_reader_) {
|
|
|
|
*reader = ra_file_reader_;
|
|
|
|
return s;
|
|
|
|
}
|
2017-05-10 23:54:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
WriteLock lockbfile_w(&mutex_);
|
2018-09-21 01:50:07 +02:00
|
|
|
// Double check.
|
|
|
|
if (ra_file_reader_) {
|
|
|
|
*reader = ra_file_reader_;
|
|
|
|
return s;
|
|
|
|
}
|
2017-05-10 23:54:35 +02:00
|
|
|
|
|
|
|
std::unique_ptr<RandomAccessFile> rfile;
|
2018-09-21 01:50:07 +02:00
|
|
|
s = env->NewRandomAccessFile(PathName(), &rfile, env_options);
|
2017-05-10 23:54:35 +02:00
|
|
|
if (!s.ok()) {
|
2017-12-11 21:01:22 +01:00
|
|
|
ROCKS_LOG_ERROR(info_log_,
|
2017-07-13 19:03:39 +02:00
|
|
|
"Failed to open blob file for random-read: %s status: '%s'"
|
|
|
|
" exists: '%s'",
|
|
|
|
PathName().c_str(), s.ToString().c_str(),
|
|
|
|
env->FileExists(PathName()).ToString().c_str());
|
2018-09-21 01:50:07 +02:00
|
|
|
return s;
|
2017-05-10 23:54:35 +02:00
|
|
|
}
|
|
|
|
|
2017-06-29 06:26:03 +02:00
|
|
|
ra_file_reader_ = std::make_shared<RandomAccessFileReader>(std::move(rfile),
|
|
|
|
PathName());
|
2018-09-21 01:50:07 +02:00
|
|
|
*reader = ra_file_reader_;
|
2017-05-10 23:54:35 +02:00
|
|
|
*fresh_open = true;
|
2018-09-21 01:50:07 +02:00
|
|
|
return s;
|
2017-05-10 23:54:35 +02:00
|
|
|
}
|
|
|
|
|
2017-12-11 21:01:22 +01:00
|
|
|
Status BlobFile::ReadMetadata(Env* env, const EnvOptions& env_options) {
|
|
|
|
assert(Immutable());
|
|
|
|
// Get file size.
|
|
|
|
uint64_t file_size = 0;
|
|
|
|
Status s = env->GetFileSize(PathName(), &file_size);
|
|
|
|
if (s.ok()) {
|
|
|
|
file_size_ = file_size;
|
|
|
|
} else {
|
|
|
|
ROCKS_LOG_ERROR(info_log_,
|
2019-04-04 21:05:42 +02:00
|
|
|
"Failed to get size of blob file %" PRIu64
|
2017-12-11 21:01:22 +01:00
|
|
|
", status: %s",
|
|
|
|
file_number_, s.ToString().c_str());
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
if (file_size < BlobLogHeader::kSize) {
|
|
|
|
ROCKS_LOG_ERROR(info_log_,
|
2019-04-04 21:05:42 +02:00
|
|
|
"Incomplete blob file blob file %" PRIu64
|
2017-12-11 21:01:22 +01:00
|
|
|
", size: %" PRIu64,
|
|
|
|
file_number_, file_size);
|
|
|
|
return Status::Corruption("Incomplete blob file header.");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create file reader.
|
|
|
|
std::unique_ptr<RandomAccessFile> file;
|
|
|
|
s = env->NewRandomAccessFile(PathName(), &file, env_options);
|
|
|
|
if (!s.ok()) {
|
|
|
|
ROCKS_LOG_ERROR(info_log_,
|
2019-04-04 21:05:42 +02:00
|
|
|
"Failed to open blob file %" PRIu64 ", status: %s",
|
2017-12-11 21:01:22 +01:00
|
|
|
file_number_, s.ToString().c_str());
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
std::unique_ptr<RandomAccessFileReader> file_reader(
|
|
|
|
new RandomAccessFileReader(std::move(file), PathName()));
|
|
|
|
|
|
|
|
// Read file header.
|
|
|
|
char header_buf[BlobLogHeader::kSize];
|
|
|
|
Slice header_slice;
|
|
|
|
s = file_reader->Read(0, BlobLogHeader::kSize, &header_slice, header_buf);
|
|
|
|
if (!s.ok()) {
|
|
|
|
ROCKS_LOG_ERROR(info_log_,
|
2019-04-04 21:05:42 +02:00
|
|
|
"Failed to read header of blob file %" PRIu64
|
2017-12-11 21:01:22 +01:00
|
|
|
", status: %s",
|
|
|
|
file_number_, s.ToString().c_str());
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
BlobLogHeader header;
|
|
|
|
s = header.DecodeFrom(header_slice);
|
|
|
|
if (!s.ok()) {
|
|
|
|
ROCKS_LOG_ERROR(info_log_,
|
2019-04-04 21:05:42 +02:00
|
|
|
"Failed to decode header of blob file %" PRIu64
|
2017-12-11 21:01:22 +01:00
|
|
|
", status: %s",
|
|
|
|
file_number_, s.ToString().c_str());
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
column_family_id_ = header.column_family_id;
|
|
|
|
compression_ = header.compression;
|
|
|
|
has_ttl_ = header.has_ttl;
|
|
|
|
if (has_ttl_) {
|
|
|
|
expiration_range_ = header.expiration_range;
|
|
|
|
}
|
|
|
|
header_valid_ = true;
|
|
|
|
|
|
|
|
// Read file footer.
|
|
|
|
if (file_size_ < BlobLogHeader::kSize + BlobLogFooter::kSize) {
|
|
|
|
// OK not to have footer.
|
|
|
|
assert(!footer_valid_);
|
|
|
|
return Status::OK();
|
|
|
|
}
|
|
|
|
char footer_buf[BlobLogFooter::kSize];
|
|
|
|
Slice footer_slice;
|
|
|
|
s = file_reader->Read(file_size - BlobLogFooter::kSize, BlobLogFooter::kSize,
|
|
|
|
&footer_slice, footer_buf);
|
|
|
|
if (!s.ok()) {
|
|
|
|
ROCKS_LOG_ERROR(info_log_,
|
2019-04-04 21:05:42 +02:00
|
|
|
"Failed to read footer of blob file %" PRIu64
|
2017-12-11 21:01:22 +01:00
|
|
|
", status: %s",
|
|
|
|
file_number_, s.ToString().c_str());
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
BlobLogFooter footer;
|
|
|
|
s = footer.DecodeFrom(footer_slice);
|
|
|
|
if (!s.ok()) {
|
|
|
|
// OK not to have footer.
|
|
|
|
assert(!footer_valid_);
|
|
|
|
return Status::OK();
|
|
|
|
}
|
|
|
|
blob_count_ = footer.blob_count;
|
|
|
|
if (has_ttl_) {
|
|
|
|
assert(header.expiration_range.first <= footer.expiration_range.first);
|
|
|
|
assert(header.expiration_range.second >= footer.expiration_range.second);
|
|
|
|
expiration_range_ = footer.expiration_range;
|
|
|
|
}
|
|
|
|
footer_valid_ = true;
|
|
|
|
return Status::OK();
|
|
|
|
}
|
|
|
|
|
2017-05-10 23:54:35 +02:00
|
|
|
} // namespace blob_db
|
|
|
|
} // namespace rocksdb
|
|
|
|
#endif // ROCKSDB_LITE
|