// 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.
-#ifndef __STDC_FORMAT_MACROS
-#define __STDC_FORMAT_MACROS
-#endif
-
#ifndef GFLAGS
#include <cstdio>
int main() {
#include "db/dbformat.h"
#include "db/memtable.h"
+#include "memory/arena.h"
#include "port/port.h"
#include "port/stack_trace.h"
#include "rocksdb/comparator.h"
#include "rocksdb/options.h"
#include "rocksdb/slice_transform.h"
#include "rocksdb/write_buffer_manager.h"
-#include "util/arena.h"
+#include "test_util/testutil.h"
#include "util/gflags_compat.h"
#include "util/mutexlock.h"
#include "util/stop_watch.h"
-#include "util/testutil.h"
using GFLAGS_NAMESPACE::ParseCommandLineFlags;
using GFLAGS_NAMESPACE::RegisterFlagValidator;
"Seed base for random number generators. "
"When 0 it is deterministic.");
-namespace rocksdb {
+namespace ROCKSDB_NAMESPACE {
namespace {
struct CallbackVerifyArgs {
}
};
-} // namespace rocksdb
+} // namespace ROCKSDB_NAMESPACE
void PrintWarnings() {
#if defined(__GNUC__) && !defined(__OPTIMIZE__)
}
int main(int argc, char** argv) {
- rocksdb::port::InstallStackTraceHandler();
+ ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
SetUsageMessage(std::string("\nUSAGE:\n") + std::string(argv[0]) +
" [OPTIONS]...");
ParseCommandLineFlags(&argc, &argv, true);
PrintWarnings();
- rocksdb::Options options;
+ ROCKSDB_NAMESPACE::Options options;
- std::unique_ptr<rocksdb::MemTableRepFactory> factory;
+ std::unique_ptr<ROCKSDB_NAMESPACE::MemTableRepFactory> factory;
if (FLAGS_memtablerep == "skiplist") {
- factory.reset(new rocksdb::SkipListFactory);
+ factory.reset(new ROCKSDB_NAMESPACE::SkipListFactory);
#ifndef ROCKSDB_LITE
} else if (FLAGS_memtablerep == "vector") {
- factory.reset(new rocksdb::VectorRepFactory);
+ factory.reset(new ROCKSDB_NAMESPACE::VectorRepFactory);
} else if (FLAGS_memtablerep == "hashskiplist") {
- factory.reset(rocksdb::NewHashSkipListRepFactory(
+ factory.reset(ROCKSDB_NAMESPACE::NewHashSkipListRepFactory(
FLAGS_bucket_count, FLAGS_hashskiplist_height,
FLAGS_hashskiplist_branching_factor));
options.prefix_extractor.reset(
- rocksdb::NewFixedPrefixTransform(FLAGS_prefix_length));
+ ROCKSDB_NAMESPACE::NewFixedPrefixTransform(FLAGS_prefix_length));
} else if (FLAGS_memtablerep == "hashlinklist") {
- factory.reset(rocksdb::NewHashLinkListRepFactory(
+ factory.reset(ROCKSDB_NAMESPACE::NewHashLinkListRepFactory(
FLAGS_bucket_count, FLAGS_huge_page_tlb_size,
FLAGS_bucket_entries_logging_threshold,
FLAGS_if_log_bucket_dist_when_flash, FLAGS_threshold_use_skiplist));
options.prefix_extractor.reset(
- rocksdb::NewFixedPrefixTransform(FLAGS_prefix_length));
+ ROCKSDB_NAMESPACE::NewFixedPrefixTransform(FLAGS_prefix_length));
#endif // ROCKSDB_LITE
} else {
fprintf(stdout, "Unknown memtablerep: %s\n", FLAGS_memtablerep.c_str());
exit(1);
}
- rocksdb::InternalKeyComparator internal_key_comp(
- rocksdb::BytewiseComparator());
- rocksdb::MemTable::KeyComparator key_comp(internal_key_comp);
- rocksdb::Arena arena;
- rocksdb::WriteBufferManager wb(FLAGS_write_buffer_size);
+ ROCKSDB_NAMESPACE::InternalKeyComparator internal_key_comp(
+ ROCKSDB_NAMESPACE::BytewiseComparator());
+ ROCKSDB_NAMESPACE::MemTable::KeyComparator key_comp(internal_key_comp);
+ ROCKSDB_NAMESPACE::Arena arena;
+ ROCKSDB_NAMESPACE::WriteBufferManager wb(FLAGS_write_buffer_size);
uint64_t sequence;
auto createMemtableRep = [&] {
sequence = 0;
options.prefix_extractor.get(),
options.info_log.get());
};
- std::unique_ptr<rocksdb::MemTableRep> memtablerep;
- rocksdb::Random64 rng(FLAGS_seed);
+ std::unique_ptr<ROCKSDB_NAMESPACE::MemTableRep> memtablerep;
+ ROCKSDB_NAMESPACE::Random64 rng(FLAGS_seed);
const char* benchmarks = FLAGS_benchmarks.c_str();
while (benchmarks != nullptr) {
- std::unique_ptr<rocksdb::KeyGenerator> key_gen;
+ std::unique_ptr<ROCKSDB_NAMESPACE::KeyGenerator> key_gen;
const char* sep = strchr(benchmarks, ',');
- rocksdb::Slice name;
+ ROCKSDB_NAMESPACE::Slice name;
if (sep == nullptr) {
name = benchmarks;
benchmarks = nullptr;
} else {
- name = rocksdb::Slice(benchmarks, sep - benchmarks);
+ name = ROCKSDB_NAMESPACE::Slice(benchmarks, sep - benchmarks);
benchmarks = sep + 1;
}
- std::unique_ptr<rocksdb::Benchmark> benchmark;
- if (name == rocksdb::Slice("fillseq")) {
+ std::unique_ptr<ROCKSDB_NAMESPACE::Benchmark> benchmark;
+ if (name == ROCKSDB_NAMESPACE::Slice("fillseq")) {
memtablerep.reset(createMemtableRep());
- key_gen.reset(new rocksdb::KeyGenerator(&rng, rocksdb::SEQUENTIAL,
- FLAGS_num_operations));
- benchmark.reset(new rocksdb::FillBenchmark(memtablerep.get(),
- key_gen.get(), &sequence));
- } else if (name == rocksdb::Slice("fillrandom")) {
+ key_gen.reset(new ROCKSDB_NAMESPACE::KeyGenerator(
+ &rng, ROCKSDB_NAMESPACE::SEQUENTIAL, FLAGS_num_operations));
+ benchmark.reset(new ROCKSDB_NAMESPACE::FillBenchmark(
+ memtablerep.get(), key_gen.get(), &sequence));
+ } else if (name == ROCKSDB_NAMESPACE::Slice("fillrandom")) {
memtablerep.reset(createMemtableRep());
- key_gen.reset(new rocksdb::KeyGenerator(&rng, rocksdb::UNIQUE_RANDOM,
- FLAGS_num_operations));
- benchmark.reset(new rocksdb::FillBenchmark(memtablerep.get(),
- key_gen.get(), &sequence));
- } else if (name == rocksdb::Slice("readrandom")) {
- key_gen.reset(new rocksdb::KeyGenerator(&rng, rocksdb::RANDOM,
- FLAGS_num_operations));
- benchmark.reset(new rocksdb::ReadBenchmark(memtablerep.get(),
- key_gen.get(), &sequence));
- } else if (name == rocksdb::Slice("readseq")) {
- key_gen.reset(new rocksdb::KeyGenerator(&rng, rocksdb::SEQUENTIAL,
- FLAGS_num_operations));
- benchmark.reset(
- new rocksdb::SeqReadBenchmark(memtablerep.get(), &sequence));
- } else if (name == rocksdb::Slice("readwrite")) {
+ key_gen.reset(new ROCKSDB_NAMESPACE::KeyGenerator(
+ &rng, ROCKSDB_NAMESPACE::UNIQUE_RANDOM, FLAGS_num_operations));
+ benchmark.reset(new ROCKSDB_NAMESPACE::FillBenchmark(
+ memtablerep.get(), key_gen.get(), &sequence));
+ } else if (name == ROCKSDB_NAMESPACE::Slice("readrandom")) {
+ key_gen.reset(new ROCKSDB_NAMESPACE::KeyGenerator(
+ &rng, ROCKSDB_NAMESPACE::RANDOM, FLAGS_num_operations));
+ benchmark.reset(new ROCKSDB_NAMESPACE::ReadBenchmark(
+ memtablerep.get(), key_gen.get(), &sequence));
+ } else if (name == ROCKSDB_NAMESPACE::Slice("readseq")) {
+ key_gen.reset(new ROCKSDB_NAMESPACE::KeyGenerator(
+ &rng, ROCKSDB_NAMESPACE::SEQUENTIAL, FLAGS_num_operations));
+ benchmark.reset(new ROCKSDB_NAMESPACE::SeqReadBenchmark(memtablerep.get(),
+ &sequence));
+ } else if (name == ROCKSDB_NAMESPACE::Slice("readwrite")) {
memtablerep.reset(createMemtableRep());
- key_gen.reset(new rocksdb::KeyGenerator(&rng, rocksdb::RANDOM,
- FLAGS_num_operations));
- benchmark.reset(new rocksdb::ReadWriteBenchmark<
- rocksdb::ConcurrentReadBenchmarkThread>(memtablerep.get(),
- key_gen.get(), &sequence));
- } else if (name == rocksdb::Slice("seqreadwrite")) {
+ key_gen.reset(new ROCKSDB_NAMESPACE::KeyGenerator(
+ &rng, ROCKSDB_NAMESPACE::RANDOM, FLAGS_num_operations));
+ benchmark.reset(new ROCKSDB_NAMESPACE::ReadWriteBenchmark<
+ ROCKSDB_NAMESPACE::ConcurrentReadBenchmarkThread>(
+ memtablerep.get(), key_gen.get(), &sequence));
+ } else if (name == ROCKSDB_NAMESPACE::Slice("seqreadwrite")) {
memtablerep.reset(createMemtableRep());
- key_gen.reset(new rocksdb::KeyGenerator(&rng, rocksdb::RANDOM,
- FLAGS_num_operations));
- benchmark.reset(new rocksdb::ReadWriteBenchmark<
- rocksdb::SeqConcurrentReadBenchmarkThread>(memtablerep.get(),
- key_gen.get(), &sequence));
+ key_gen.reset(new ROCKSDB_NAMESPACE::KeyGenerator(
+ &rng, ROCKSDB_NAMESPACE::RANDOM, FLAGS_num_operations));
+ benchmark.reset(new ROCKSDB_NAMESPACE::ReadWriteBenchmark<
+ ROCKSDB_NAMESPACE::SeqConcurrentReadBenchmarkThread>(
+ memtablerep.get(), key_gen.get(), &sequence));
} else {
std::cout << "WARNING: skipping unknown benchmark '" << name.ToString()
<< std::endl;
projects / ceph.git / blobdiff