#include "db/db_impl/db_impl.h"
#include "db/dbformat.h"
-#include "env/composite_env_wrapper.h"
#include "file/random_access_file_reader.h"
#include "monitoring/histogram.h"
#include "rocksdb/db.h"
+#include "rocksdb/file_system.h"
#include "rocksdb/slice_transform.h"
+#include "rocksdb/system_clock.h"
#include "rocksdb/table.h"
#include "table/block_based/block_based_table_factory.h"
#include "table/get_context.h"
return key.Encode().ToString();
}
-uint64_t Now(Env* env, bool measured_by_nanosecond) {
- return measured_by_nanosecond ? env->NowNanos() : env->NowMicros();
+uint64_t Now(SystemClock* clock, bool measured_by_nanosecond) {
+ return measured_by_nanosecond ? clock->NowNanos() : clock->NowMicros();
}
} // namespace
std::string dbname = test::PerThreadDBPath("rocksdb_table_reader_bench_db");
WriteOptions wo;
Env* env = Env::Default();
+ auto* clock = env->GetSystemClock().get();
TableBuilder* tb = nullptr;
DB* db = nullptr;
Status s;
- const ImmutableCFOptions ioptions(opts);
+ const ImmutableOptions ioptions(opts);
const ColumnFamilyOptions cfo(opts);
const MutableCFOptions moptions(cfo);
std::unique_ptr<WritableFileWriter> file_writer;
if (!through_db) {
- std::unique_ptr<WritableFile> file;
- env->NewWritableFile(file_name, &file, env_options);
+ ASSERT_OK(WritableFileWriter::Create(env->GetFileSystem(), file_name,
+ FileOptions(env_options), &file_writer,
+ nullptr));
- std::vector<std::unique_ptr<IntTblPropCollectorFactory> >
- int_tbl_prop_collector_factories;
+ IntTblPropCollectorFactories int_tbl_prop_collector_factories;
- file_writer.reset(new WritableFileWriter(
- NewLegacyWritableFileWrapper(std::move(file)), file_name, env_options));
int unknown_level = -1;
tb = opts.table_factory->NewTableBuilder(
TableBuilderOptions(
ioptions, moptions, ikc, &int_tbl_prop_collector_factories,
- CompressionType::kNoCompression, 0 /* sample_for_compression */,
- CompressionOptions(), false /* skip_filters */,
- kDefaultColumnFamilyName, unknown_level),
- 0 /* column_family_id */, file_writer.get());
+ CompressionType::kNoCompression, CompressionOptions(),
+ 0 /* column_family_id */, kDefaultColumnFamilyName, unknown_level),
+ file_writer.get());
} else {
s = DB::Open(opts, dbname, &db);
ASSERT_OK(s);
std::unique_ptr<TableReader> table_reader;
if (!through_db) {
- std::unique_ptr<RandomAccessFile> raf;
- s = env->NewRandomAccessFile(file_name, &raf, env_options);
+ const auto& fs = env->GetFileSystem();
+ FileOptions fopts(env_options);
+
+ std::unique_ptr<FSRandomAccessFile> raf;
+ s = fs->NewRandomAccessFile(file_name, fopts, &raf, nullptr);
if (!s.ok()) {
fprintf(stderr, "Create File Error: %s\n", s.ToString().c_str());
exit(1);
}
uint64_t file_size;
- env->GetFileSize(file_name, &file_size);
+ fs->GetFileSize(file_name, fopts.io_options, &file_size, nullptr);
std::unique_ptr<RandomAccessFileReader> file_reader(
- new RandomAccessFileReader(NewLegacyRandomAccessFileWrapper(raf),
- file_name));
+ new RandomAccessFileReader(std::move(raf), file_name));
s = opts.table_factory->NewTableReader(
- TableReaderOptions(ioptions, moptions.prefix_extractor.get(),
- env_options, ikc),
+ TableReaderOptions(ioptions, moptions.prefix_extractor, env_options,
+ ikc),
std::move(file_reader), file_size, &table_reader);
if (!s.ok()) {
fprintf(stderr, "Open Table Error: %s\n", s.ToString().c_str());
if (!for_iterator) {
// Query one existing key;
std::string key = MakeKey(r1, r2, through_db);
- uint64_t start_time = Now(env, measured_by_nanosecond);
+ uint64_t start_time = Now(clock, measured_by_nanosecond);
if (!through_db) {
PinnableSlice value;
MergeContext merge_context;
SequenceNumber max_covering_tombstone_seq = 0;
- GetContext get_context(ioptions.user_comparator,
- ioptions.merge_operator, ioptions.info_log,
- ioptions.statistics, GetContext::kNotFound,
- Slice(key), &value, nullptr, &merge_context,
- true, &max_covering_tombstone_seq, env);
+ GetContext get_context(
+ ioptions.user_comparator, ioptions.merge_operator.get(),
+ ioptions.logger, ioptions.stats, GetContext::kNotFound,
+ Slice(key), &value, /*columns=*/nullptr, /*timestamp=*/nullptr,
+ &merge_context, true, &max_covering_tombstone_seq, clock);
s = table_reader->Get(read_options, key, &get_context, nullptr);
} else {
s = db->Get(read_options, key, &result);
}
- hist.Add(Now(env, measured_by_nanosecond) - start_time);
+ hist.Add(Now(clock, measured_by_nanosecond) - start_time);
} else {
int r2_len;
if (if_query_empty_keys) {
std::string start_key = MakeKey(r1, r2, through_db);
std::string end_key = MakeKey(r1, r2 + r2_len, through_db);
uint64_t total_time = 0;
- uint64_t start_time = Now(env, measured_by_nanosecond);
+ uint64_t start_time = Now(clock, measured_by_nanosecond);
Iterator* iter = nullptr;
InternalIterator* iiter = nullptr;
if (!through_db) {
break;
}
// verify key;
- total_time += Now(env, measured_by_nanosecond) - start_time;
+ total_time += Now(clock, measured_by_nanosecond) - start_time;
assert(Slice(MakeKey(r1, r2 + count, through_db)) ==
(through_db ? iter->key() : iiter->key()));
- start_time = Now(env, measured_by_nanosecond);
+ start_time = Now(clock, measured_by_nanosecond);
if (++count >= r2_len) {
break;
}
}
if (count != r2_len) {
- fprintf(
- stderr, "Iterator cannot iterate expected number of entries. "
- "Expected %d but got %d\n", r2_len, count);
+ fprintf(stderr,
+ "Iterator cannot iterate expected number of entries. "
+ "Expected %d but got %d\n",
+ r2_len, count);
assert(false);
}
delete iter;
- total_time += Now(env, measured_by_nanosecond) - start_time;
+ total_time += Now(clock, measured_by_nanosecond) - start_time;
hist.Add(total_time);
}
}
} // namespace
} // namespace ROCKSDB_NAMESPACE
-DEFINE_bool(query_empty, false, "query non-existing keys instead of existing "
- "ones.");
+DEFINE_bool(query_empty, false,
+ "query non-existing keys instead of existing ones.");
DEFINE_int32(num_keys1, 4096, "number of distinguish prefix of keys");
DEFINE_int32(num_keys2, 512, "number of distinguish keys for each prefix");
DEFINE_int32(iter, 3, "query non-existing keys instead of existing ones");
DEFINE_int32(prefix_len, 16, "Prefix length used for iterators and indexes");
DEFINE_bool(iterator, false, "For test iterator");
-DEFINE_bool(through_db, false, "If enable, a DB instance will be created and "
- "the query will be against DB. Otherwise, will be directly against "
- "a table reader.");
+DEFINE_bool(through_db, false,
+ "If enable, a DB instance will be created and the query will be "
+ "against DB. Otherwise, will be directly against a table reader.");
DEFINE_bool(mmap_read, true, "Whether use mmap read");
DEFINE_string(table_factory, "block_based",
"Table factory to use: `block_based` (default), `plain_table` or "
projects / ceph.git / blobdiff