2016-02-09 23:12:00 +00:00
|
|
|
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
2017-07-15 23:03:42 +00: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).
|
2013-10-16 21:59:46 +00:00
|
|
|
//
|
2011-03-18 22:37:00 +00:00
|
|
|
// 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.
|
|
|
|
|
2013-08-23 15:38:13 +00:00
|
|
|
#include "rocksdb/env.h"
|
Buffer info logs when picking compactions and write them out after releasing the mutex
Summary: Now while the background thread is picking compactions, it writes out multiple info_logs, especially for universal compaction, which introduces a chance of waiting log writing in mutex, which is bad. To remove this risk, write all those info logs to a buffer and flush it after releasing the mutex.
Test Plan:
make all check
check the log lines while running some tests that trigger compactions.
Reviewers: haobo, igor, dhruba
Reviewed By: dhruba
CC: i.am.jin.lei, dhruba, yhchiang, leveldb, nkg-
Differential Revision: https://reviews.facebook.net/D16515
2014-03-04 22:32:55 +00:00
|
|
|
|
2015-06-11 21:18:02 +00:00
|
|
|
#include <thread>
|
2017-04-13 20:07:33 +00:00
|
|
|
#include "options/db_options.h"
|
2015-07-16 19:10:16 +00:00
|
|
|
#include "port/port.h"
|
2015-07-07 23:58:20 +00:00
|
|
|
#include "port/sys_time.h"
|
2013-08-23 15:38:13 +00:00
|
|
|
#include "rocksdb/options.h"
|
Buffer info logs when picking compactions and write them out after releasing the mutex
Summary: Now while the background thread is picking compactions, it writes out multiple info_logs, especially for universal compaction, which introduces a chance of waiting log writing in mutex, which is bad. To remove this risk, write all those info logs to a buffer and flush it after releasing the mutex.
Test Plan:
make all check
check the log lines while running some tests that trigger compactions.
Reviewers: haobo, igor, dhruba
Reviewed By: dhruba
CC: i.am.jin.lei, dhruba, yhchiang, leveldb, nkg-
Differential Revision: https://reviews.facebook.net/D16515
2014-03-04 22:32:55 +00:00
|
|
|
#include "util/arena.h"
|
|
|
|
#include "util/autovector.h"
|
2011-03-18 22:37:00 +00:00
|
|
|
|
2013-10-04 04:49:15 +00:00
|
|
|
namespace rocksdb {
|
2011-03-18 22:37:00 +00:00
|
|
|
|
|
|
|
Env::~Env() {
|
|
|
|
}
|
|
|
|
|
2018-04-19 00:25:37 +00:00
|
|
|
std::string Env::PriorityToString(Env::Priority priority) {
|
|
|
|
switch (priority) {
|
|
|
|
case Env::Priority::BOTTOM:
|
|
|
|
return "Bottom";
|
|
|
|
case Env::Priority::LOW:
|
|
|
|
return "Low";
|
|
|
|
case Env::Priority::HIGH:
|
|
|
|
return "High";
|
|
|
|
case Env::Priority::TOTAL:
|
|
|
|
assert(false);
|
|
|
|
}
|
|
|
|
return "Invalid";
|
|
|
|
}
|
|
|
|
|
2015-06-11 21:18:02 +00:00
|
|
|
uint64_t Env::GetThreadID() const {
|
|
|
|
std::hash<std::thread::id> hasher;
|
|
|
|
return hasher(std::this_thread::get_id());
|
|
|
|
}
|
|
|
|
|
2015-10-08 02:11:09 +00:00
|
|
|
Status Env::ReuseWritableFile(const std::string& fname,
|
|
|
|
const std::string& old_fname,
|
2018-11-09 19:17:34 +00:00
|
|
|
std::unique_ptr<WritableFile>* result,
|
2015-10-08 02:11:09 +00:00
|
|
|
const EnvOptions& options) {
|
|
|
|
Status s = RenameFile(old_fname, fname);
|
|
|
|
if (!s.ok()) {
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
return NewWritableFile(fname, result, options);
|
|
|
|
}
|
|
|
|
|
2016-02-09 22:54:32 +00:00
|
|
|
Status Env::GetChildrenFileAttributes(const std::string& dir,
|
|
|
|
std::vector<FileAttributes>* result) {
|
|
|
|
assert(result != nullptr);
|
|
|
|
std::vector<std::string> child_fnames;
|
|
|
|
Status s = GetChildren(dir, &child_fnames);
|
|
|
|
if (!s.ok()) {
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
result->resize(child_fnames.size());
|
|
|
|
size_t result_size = 0;
|
|
|
|
for (size_t i = 0; i < child_fnames.size(); ++i) {
|
|
|
|
const std::string path = dir + "/" + child_fnames[i];
|
|
|
|
if (!(s = GetFileSize(path, &(*result)[result_size].size_bytes)).ok()) {
|
|
|
|
if (FileExists(path).IsNotFound()) {
|
|
|
|
// The file may have been deleted since we listed the directory
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
(*result)[result_size].name = std::move(child_fnames[i]);
|
|
|
|
result_size++;
|
|
|
|
}
|
|
|
|
result->resize(result_size);
|
|
|
|
return Status::OK();
|
|
|
|
}
|
|
|
|
|
2011-03-18 22:37:00 +00:00
|
|
|
SequentialFile::~SequentialFile() {
|
|
|
|
}
|
|
|
|
|
|
|
|
RandomAccessFile::~RandomAccessFile() {
|
|
|
|
}
|
|
|
|
|
|
|
|
WritableFile::~WritableFile() {
|
|
|
|
}
|
|
|
|
|
2018-04-30 19:23:45 +00:00
|
|
|
MemoryMappedFileBuffer::~MemoryMappedFileBuffer() {}
|
|
|
|
|
2018-03-07 00:13:05 +00:00
|
|
|
Logger::~Logger() {}
|
2018-01-16 18:57:56 +00:00
|
|
|
|
|
|
|
Status Logger::Close() {
|
|
|
|
if (!closed_) {
|
|
|
|
closed_ = true;
|
|
|
|
return CloseImpl();
|
2018-02-23 21:50:02 +00:00
|
|
|
} else {
|
|
|
|
return Status::OK();
|
2018-01-16 18:57:56 +00:00
|
|
|
}
|
2011-07-21 02:40:18 +00:00
|
|
|
}
|
|
|
|
|
2018-02-23 21:50:02 +00:00
|
|
|
Status Logger::CloseImpl() { return Status::NotSupported(); }
|
2018-01-16 18:57:56 +00:00
|
|
|
|
2011-03-18 22:37:00 +00:00
|
|
|
FileLock::~FileLock() {
|
|
|
|
}
|
|
|
|
|
2013-11-07 19:31:56 +00:00
|
|
|
void LogFlush(Logger *info_log) {
|
|
|
|
if (info_log) {
|
|
|
|
info_log->Flush();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-13 17:58:25 +00:00
|
|
|
static void Logv(Logger *info_log, const char* format, va_list ap) {
|
2014-10-30 20:36:18 +00:00
|
|
|
if (info_log && info_log->GetInfoLogLevel() <= InfoLogLevel::INFO_LEVEL) {
|
2014-04-10 22:27:42 +00:00
|
|
|
info_log->Logv(InfoLogLevel::INFO_LEVEL, format, ap);
|
2013-01-20 10:07:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-13 17:58:25 +00:00
|
|
|
void Log(Logger* info_log, const char* format, ...) {
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
Logv(info_log, format, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
2015-07-16 19:10:16 +00:00
|
|
|
void Logger::Logv(const InfoLogLevel log_level, const char* format, va_list ap) {
|
|
|
|
static const char* kInfoLogLevelNames[5] = { "DEBUG", "INFO", "WARN",
|
|
|
|
"ERROR", "FATAL" };
|
|
|
|
if (log_level < log_level_) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (log_level == InfoLogLevel::INFO_LEVEL) {
|
|
|
|
// Doesn't print log level if it is INFO level.
|
|
|
|
// This is to avoid unexpected performance regression after we add
|
|
|
|
// the feature of log level. All the logs before we add the feature
|
|
|
|
// are INFO level. We don't want to add extra costs to those existing
|
|
|
|
// logging.
|
|
|
|
Logv(format, ap);
|
|
|
|
} else {
|
|
|
|
char new_format[500];
|
|
|
|
snprintf(new_format, sizeof(new_format) - 1, "[%s] %s",
|
|
|
|
kInfoLogLevelNames[log_level], format);
|
|
|
|
Logv(new_format, ap);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-13 17:58:25 +00:00
|
|
|
static void Logv(const InfoLogLevel log_level, Logger *info_log, const char *format, va_list ap) {
|
2014-10-30 20:36:18 +00:00
|
|
|
if (info_log && info_log->GetInfoLogLevel() <= log_level) {
|
2015-07-03 00:14:39 +00:00
|
|
|
if (log_level == InfoLogLevel::HEADER_LEVEL) {
|
|
|
|
info_log->LogHeader(format, ap);
|
|
|
|
} else {
|
|
|
|
info_log->Logv(log_level, format, ap);
|
|
|
|
}
|
2014-02-26 22:41:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-13 17:58:25 +00:00
|
|
|
void Log(const InfoLogLevel log_level, Logger* info_log, const char* format,
|
|
|
|
...) {
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
Logv(log_level, info_log, format, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void Headerv(Logger *info_log, const char *format, va_list ap) {
|
2015-02-02 17:47:24 +00:00
|
|
|
if (info_log) {
|
|
|
|
info_log->LogHeader(format, ap);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-13 17:58:25 +00:00
|
|
|
void Header(Logger* info_log, const char* format, ...) {
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
Headerv(info_log, format, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void Debugv(Logger* info_log, const char* format, va_list ap) {
|
2014-10-30 20:36:18 +00:00
|
|
|
if (info_log && info_log->GetInfoLogLevel() <= InfoLogLevel::DEBUG_LEVEL) {
|
2014-04-10 22:27:42 +00:00
|
|
|
info_log->Logv(InfoLogLevel::DEBUG_LEVEL, format, ap);
|
2014-02-26 22:41:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-13 17:58:25 +00:00
|
|
|
void Debug(Logger* info_log, const char* format, ...) {
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
Debugv(info_log, format, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void Infov(Logger* info_log, const char* format, va_list ap) {
|
2014-10-30 20:36:18 +00:00
|
|
|
if (info_log && info_log->GetInfoLogLevel() <= InfoLogLevel::INFO_LEVEL) {
|
2014-04-10 22:27:42 +00:00
|
|
|
info_log->Logv(InfoLogLevel::INFO_LEVEL, format, ap);
|
2014-02-26 22:41:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-13 17:58:25 +00:00
|
|
|
void Info(Logger* info_log, const char* format, ...) {
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
Infov(info_log, format, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void Warnv(Logger* info_log, const char* format, va_list ap) {
|
2014-10-30 20:36:18 +00:00
|
|
|
if (info_log && info_log->GetInfoLogLevel() <= InfoLogLevel::WARN_LEVEL) {
|
2014-04-10 22:27:42 +00:00
|
|
|
info_log->Logv(InfoLogLevel::WARN_LEVEL, format, ap);
|
2014-02-26 22:41:28 +00:00
|
|
|
}
|
|
|
|
}
|
2018-04-13 17:58:25 +00:00
|
|
|
|
|
|
|
void Warn(Logger* info_log, const char* format, ...) {
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
Warnv(info_log, format, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void Errorv(Logger* info_log, const char* format, va_list ap) {
|
2014-10-30 20:36:18 +00:00
|
|
|
if (info_log && info_log->GetInfoLogLevel() <= InfoLogLevel::ERROR_LEVEL) {
|
2014-04-10 22:27:42 +00:00
|
|
|
info_log->Logv(InfoLogLevel::ERROR_LEVEL, format, ap);
|
2014-02-26 22:41:28 +00:00
|
|
|
}
|
|
|
|
}
|
2018-04-13 17:58:25 +00:00
|
|
|
|
|
|
|
void Error(Logger* info_log, const char* format, ...) {
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
Errorv(info_log, format, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void Fatalv(Logger* info_log, const char* format, va_list ap) {
|
2014-10-30 20:36:18 +00:00
|
|
|
if (info_log && info_log->GetInfoLogLevel() <= InfoLogLevel::FATAL_LEVEL) {
|
2014-04-10 22:27:42 +00:00
|
|
|
info_log->Logv(InfoLogLevel::FATAL_LEVEL, format, ap);
|
2014-02-26 22:41:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-13 17:58:25 +00:00
|
|
|
void Fatal(Logger* info_log, const char* format, ...) {
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
Fatalv(info_log, format, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
2018-11-09 19:17:34 +00:00
|
|
|
void LogFlush(const std::shared_ptr<Logger>& info_log) {
|
2018-04-13 17:58:25 +00:00
|
|
|
LogFlush(info_log.get());
|
2013-11-07 19:31:56 +00:00
|
|
|
}
|
|
|
|
|
2018-11-09 19:17:34 +00:00
|
|
|
void Log(const InfoLogLevel log_level, const std::shared_ptr<Logger>& info_log,
|
2014-02-26 22:41:28 +00:00
|
|
|
const char* format, ...) {
|
2018-04-13 17:58:25 +00:00
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
Logv(log_level, info_log.get(), format, ap);
|
|
|
|
va_end(ap);
|
2014-02-26 22:41:28 +00:00
|
|
|
}
|
|
|
|
|
2018-11-09 19:17:34 +00:00
|
|
|
void Header(const std::shared_ptr<Logger>& info_log, const char* format, ...) {
|
2018-04-13 17:58:25 +00:00
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
Headerv(info_log.get(), format, ap);
|
|
|
|
va_end(ap);
|
2015-02-02 17:47:24 +00:00
|
|
|
}
|
|
|
|
|
2018-11-09 19:17:34 +00:00
|
|
|
void Debug(const std::shared_ptr<Logger>& info_log, const char* format, ...) {
|
2018-04-13 17:58:25 +00:00
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
Debugv(info_log.get(), format, ap);
|
|
|
|
va_end(ap);
|
2014-02-26 22:41:28 +00:00
|
|
|
}
|
|
|
|
|
2018-11-09 19:17:34 +00:00
|
|
|
void Info(const std::shared_ptr<Logger>& info_log, const char* format, ...) {
|
2018-04-13 17:58:25 +00:00
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
Infov(info_log.get(), format, ap);
|
|
|
|
va_end(ap);
|
2014-02-26 22:41:28 +00:00
|
|
|
}
|
|
|
|
|
2018-11-09 19:17:34 +00:00
|
|
|
void Warn(const std::shared_ptr<Logger>& info_log, const char* format, ...) {
|
2018-04-13 17:58:25 +00:00
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
Warnv(info_log.get(), format, ap);
|
|
|
|
va_end(ap);
|
2014-02-26 22:41:28 +00:00
|
|
|
}
|
|
|
|
|
2018-11-09 19:17:34 +00:00
|
|
|
void Error(const std::shared_ptr<Logger>& info_log, const char* format, ...) {
|
2018-04-13 17:58:25 +00:00
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
Errorv(info_log.get(), format, ap);
|
|
|
|
va_end(ap);
|
2014-02-26 22:41:28 +00:00
|
|
|
}
|
|
|
|
|
2018-11-09 19:17:34 +00:00
|
|
|
void Fatal(const std::shared_ptr<Logger>& info_log, const char* format, ...) {
|
2018-04-13 17:58:25 +00:00
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
Fatalv(info_log.get(), format, ap);
|
|
|
|
va_end(ap);
|
2014-02-26 22:41:28 +00:00
|
|
|
}
|
|
|
|
|
2018-11-09 19:17:34 +00:00
|
|
|
void Log(const std::shared_ptr<Logger>& info_log, const char* format, ...) {
|
2018-04-13 17:58:25 +00:00
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
Logv(info_log.get(), format, ap);
|
|
|
|
va_end(ap);
|
2011-03-18 22:37:00 +00:00
|
|
|
}
|
|
|
|
|
2014-04-10 04:17:14 +00:00
|
|
|
Status WriteStringToFile(Env* env, const Slice& data, const std::string& fname,
|
|
|
|
bool should_sync) {
|
2018-11-09 19:17:34 +00:00
|
|
|
std::unique_ptr<WritableFile> file;
|
2013-06-07 22:35:17 +00:00
|
|
|
EnvOptions soptions;
|
2013-03-15 00:00:04 +00:00
|
|
|
Status s = env->NewWritableFile(fname, &file, soptions);
|
2011-03-18 22:37:00 +00:00
|
|
|
if (!s.ok()) {
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
s = file->Append(data);
|
2012-01-25 22:56:52 +00:00
|
|
|
if (s.ok() && should_sync) {
|
|
|
|
s = file->Sync();
|
|
|
|
}
|
2011-03-18 22:37:00 +00:00
|
|
|
if (!s.ok()) {
|
|
|
|
env->DeleteFile(fname);
|
|
|
|
}
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
Status ReadFileToString(Env* env, const std::string& fname, std::string* data) {
|
2013-06-07 22:35:17 +00:00
|
|
|
EnvOptions soptions;
|
2011-03-18 22:37:00 +00:00
|
|
|
data->clear();
|
2018-11-09 19:17:34 +00:00
|
|
|
std::unique_ptr<SequentialFile> file;
|
2013-03-15 00:00:04 +00:00
|
|
|
Status s = env->NewSequentialFile(fname, &file, soptions);
|
2011-03-18 22:37:00 +00:00
|
|
|
if (!s.ok()) {
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
static const int kBufferSize = 8192;
|
|
|
|
char* space = new char[kBufferSize];
|
|
|
|
while (true) {
|
|
|
|
Slice fragment;
|
|
|
|
s = file->Read(kBufferSize, &fragment, space);
|
|
|
|
if (!s.ok()) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
data->append(fragment.data(), fragment.size());
|
|
|
|
if (fragment.empty()) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
delete[] space;
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
EnvWrapper::~EnvWrapper() {
|
|
|
|
}
|
|
|
|
|
2013-06-07 22:35:17 +00:00
|
|
|
namespace { // anonymous namespace
|
|
|
|
|
2014-02-05 21:12:23 +00:00
|
|
|
void AssignEnvOptions(EnvOptions* env_options, const DBOptions& options) {
|
2013-06-07 22:35:17 +00:00
|
|
|
env_options->use_mmap_reads = options.allow_mmap_reads;
|
|
|
|
env_options->use_mmap_writes = options.allow_mmap_writes;
|
2016-10-28 17:36:05 +00:00
|
|
|
env_options->use_direct_reads = options.use_direct_reads;
|
2013-06-07 22:35:17 +00:00
|
|
|
env_options->set_fd_cloexec = options.is_fd_close_on_exec;
|
2013-06-14 05:49:46 +00:00
|
|
|
env_options->bytes_per_sync = options.bytes_per_sync;
|
2015-10-27 21:44:16 +00:00
|
|
|
env_options->compaction_readahead_size = options.compaction_readahead_size;
|
2015-10-29 22:52:32 +00:00
|
|
|
env_options->random_access_max_buffer_size =
|
|
|
|
options.random_access_max_buffer_size;
|
2014-07-08 19:31:49 +00:00
|
|
|
env_options->rate_limiter = options.rate_limiter.get();
|
2015-11-16 20:56:21 +00:00
|
|
|
env_options->writable_file_max_buffer_size =
|
|
|
|
options.writable_file_max_buffer_size;
|
2015-10-07 17:04:05 +00:00
|
|
|
env_options->allow_fallocate = options.allow_fallocate;
|
2013-06-07 22:35:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2015-05-19 00:03:59 +00:00
|
|
|
EnvOptions Env::OptimizeForLogWrite(const EnvOptions& env_options,
|
|
|
|
const DBOptions& db_options) const {
|
|
|
|
EnvOptions optimized_env_options(env_options);
|
|
|
|
optimized_env_options.bytes_per_sync = db_options.wal_bytes_per_sync;
|
2017-10-31 20:49:25 +00:00
|
|
|
optimized_env_options.writable_file_max_buffer_size =
|
|
|
|
db_options.writable_file_max_buffer_size;
|
2015-05-19 00:03:59 +00:00
|
|
|
return optimized_env_options;
|
2014-03-18 04:52:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
EnvOptions Env::OptimizeForManifestWrite(const EnvOptions& env_options) const {
|
|
|
|
return env_options;
|
2014-02-28 21:19:47 +00:00
|
|
|
}
|
|
|
|
|
2017-05-23 01:40:41 +00:00
|
|
|
EnvOptions Env::OptimizeForLogRead(const EnvOptions& env_options) const {
|
|
|
|
EnvOptions optimized_env_options(env_options);
|
|
|
|
optimized_env_options.use_direct_reads = false;
|
|
|
|
return optimized_env_options;
|
|
|
|
}
|
|
|
|
|
|
|
|
EnvOptions Env::OptimizeForManifestRead(const EnvOptions& env_options) const {
|
|
|
|
EnvOptions optimized_env_options(env_options);
|
|
|
|
optimized_env_options.use_direct_reads = false;
|
|
|
|
return optimized_env_options;
|
|
|
|
}
|
|
|
|
|
2017-04-13 20:07:33 +00:00
|
|
|
EnvOptions Env::OptimizeForCompactionTableWrite(
|
|
|
|
const EnvOptions& env_options, const ImmutableDBOptions& db_options) const {
|
|
|
|
EnvOptions optimized_env_options(env_options);
|
|
|
|
optimized_env_options.use_direct_writes =
|
|
|
|
db_options.use_direct_io_for_flush_and_compaction;
|
|
|
|
return optimized_env_options;
|
|
|
|
}
|
|
|
|
|
|
|
|
EnvOptions Env::OptimizeForCompactionTableRead(
|
|
|
|
const EnvOptions& env_options, const ImmutableDBOptions& db_options) const {
|
|
|
|
EnvOptions optimized_env_options(env_options);
|
2018-05-10 02:26:43 +00:00
|
|
|
optimized_env_options.use_direct_reads = db_options.use_direct_reads;
|
2017-04-13 20:07:33 +00:00
|
|
|
return optimized_env_options;
|
|
|
|
}
|
|
|
|
|
2014-02-05 21:12:23 +00:00
|
|
|
EnvOptions::EnvOptions(const DBOptions& options) {
|
2013-06-07 22:35:17 +00:00
|
|
|
AssignEnvOptions(this, options);
|
|
|
|
}
|
|
|
|
|
|
|
|
EnvOptions::EnvOptions() {
|
2014-02-05 21:12:23 +00:00
|
|
|
DBOptions options;
|
2013-06-07 22:35:17 +00:00
|
|
|
AssignEnvOptions(this, options);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-10-04 04:49:15 +00:00
|
|
|
} // namespace rocksdb
|