leveldb::Benchmark Class Reference

Collaboration diagram for leveldb::Benchmark:

Classes
struct	ThreadArg

Public Member Functions
	Benchmark ()
	~Benchmark ()
void	Run ()

Private Member Functions
void	PrintHeader ()
void	PrintWarnings ()
void	PrintEnvironment ()
void	RunBenchmark (int n, Slice name, void(Benchmark::*method)(ThreadState *))
void	Crc32c (ThreadState *thread)
void	AcquireLoad (ThreadState *thread)
void	SnappyCompress (ThreadState *thread)
void	SnappyUncompress (ThreadState *thread)
void	Open ()
void	OpenBench (ThreadState *thread)
void	WriteSeq (ThreadState *thread)
void	WriteRandom (ThreadState *thread)
void	DoWrite (ThreadState *thread, bool seq)
void	ReadSequential (ThreadState *thread)
void	ReadReverse (ThreadState *thread)
void	ReadRandom (ThreadState *thread)
void	ReadMissing (ThreadState *thread)
void	ReadHot (ThreadState *thread)
void	SeekRandom (ThreadState *thread)
void	DoDelete (ThreadState *thread, bool seq)
void	DeleteSeq (ThreadState *thread)
void	DeleteRandom (ThreadState *thread)
void	ReadWhileWriting (ThreadState *thread)
void	Compact (ThreadState *thread)
void	PrintStats (const char *key)
void	HeapProfile ()

Static Private Member Functions
static void	ThreadBody (void *v)
static void	WriteToFile (void *arg, const char *buf, int n)

Private Attributes
Cache *	cache_
const FilterPolicy *	filter_policy_
DB *	db_
int	num_
int	value_size_
int	entries_per_batch_
WriteOptions	write_options_
int	reads_
int	heap_counter_

Detailed Description

Definition at line 317 of file db_bench.cc.

Constructor & Destructor Documentation

Benchmark()

leveldb::Benchmark::Benchmark ( )

inline

Definition at line 404 of file db_bench.cc.

  : cache_(FLAGS_cache_size >= 0 ? NewLRUCache(FLAGS_cache_size) : NULL),
    filter_policy_(FLAGS_bloom_bits >= 0
                   ? NewBloomFilterPolicy(FLAGS_bloom_bits)
                   : NULL),
    db_(NULL),
    num_(FLAGS_num),
    value_size_(FLAGS_value_size),
    entries_per_batch_(1),
    reads_(FLAGS_reads < 0 ? FLAGS_num : FLAGS_reads),
    heap_counter_(0) {
    std::vector<std::string> files;
    g_env->GetChildren(FLAGS_db, &files);
    for (size_t i = 0; i < files.size(); i++) {
      if (Slice(files[i]).starts_with("heap-")) {
        g_env->DeleteFile(std::string(FLAGS_db) + "/" + files[i]);
      }
    }
    if (!FLAGS_use_existing_db) {
      DestroyDB(FLAGS_db, Options());
    }
  }

Here is the call graph for this function:

~Benchmark()

leveldb::Benchmark::~Benchmark ( )

inline

Definition at line 427 of file db_bench.cc.

               {
    delete db_;
    delete cache_;
    delete filter_policy_;
  }

Member Function Documentation

AcquireLoad()

void leveldb::Benchmark::AcquireLoad ( ThreadState *  thread )

inlineprivate

Definition at line 646 of file db_bench.cc.

                                        {
    int dummy;
    port::AtomicPointer ap(&dummy);
    int count = 0;
    void *ptr = NULL;
    thread->stats.AddMessage("(each op is 1000 loads)");
    while (count < 100000) {
      for (int i = 0; i < 1000; i++) {
        ptr = ap.Acquire_Load();
      }
      count++;
      thread->stats.FinishedSingleOp();
    }
    if (ptr == NULL) exit(1); // Disable unused variable warning.
  }

Here is the caller graph for this function:

Compact()

void leveldb::Benchmark::Compact ( ThreadState *  thread )

inlineprivate

Definition at line 920 of file db_bench.cc.

                                    {
    db_->CompactRange(NULL, NULL);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Crc32c()

void leveldb::Benchmark::Crc32c ( ThreadState *  thread )

inlineprivate

Definition at line 627 of file db_bench.cc.

                                   {
    // Checksum about 500MB of data total
    const int size = 4096;
    const char* label = "(4K per op)";
    std::string data(size, 'x');
    int64_t bytes = 0;
    uint32_t crc = 0;
    while (bytes < 500 * 1048576) {
      crc = crc32c::Value(data.data(), size);
      thread->stats.FinishedSingleOp();
      bytes += size;
    }
    // Print so result is not dead
    fprintf(stderr, "... crc=0x%x\r", static_cast<unsigned int>(crc));

    thread->stats.AddBytes(bytes);
    thread->stats.AddMessage(label);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

DeleteRandom()

void leveldb::Benchmark::DeleteRandom ( ThreadState *  thread )

inlineprivate

Definition at line 886 of file db_bench.cc.

                                         {
    DoDelete(thread, false);
  }

Here is the caller graph for this function:

DeleteSeq()

void leveldb::Benchmark::DeleteSeq ( ThreadState *  thread )

inlineprivate

Definition at line 882 of file db_bench.cc.

                                      {
    DoDelete(thread, true);
  }

Here is the caller graph for this function:

DoDelete()

void leveldb::Benchmark::DoDelete ( ThreadState *  thread, bool  seq  )

inlineprivate

Definition at line 861 of file db_bench.cc.

                                               {
    RandomGenerator gen;
    WriteBatch batch;
    Status s;
    for (int i = 0; i < num_; i += entries_per_batch_) {
      batch.Clear();
      for (int j = 0; j < entries_per_batch_; j++) {
        const int k = seq ? i+j : (thread->rand.Next() % FLAGS_num);
        char key[100];
        snprintf(key, sizeof(key), "%016d", k);
        batch.Delete(key);
        thread->stats.FinishedSingleOp();
      }
      s = db_->Write(write_options_, &batch);
      if (!s.ok()) {
        fprintf(stderr, "del error: %s\n", s.ToString().c_str());
        exit(1);
      }
    }
  }

Here is the call graph for this function:

DoWrite()

void leveldb::Benchmark::DoWrite ( ThreadState *  thread, bool  seq  )

inlineprivate

Definition at line 744 of file db_bench.cc.

                                              {
    if (num_ != FLAGS_num) {
      char msg[100];
      snprintf(msg, sizeof(msg), "(%d ops)", num_);
      thread->stats.AddMessage(msg);
    }

    RandomGenerator gen;
    WriteBatch batch;
    Status s;
    int64_t bytes = 0;
    for (int i = 0; i < num_; i += entries_per_batch_) {
      batch.Clear();
      for (int j = 0; j < entries_per_batch_; j++) {
        const int k = seq ? i+j : (thread->rand.Next() % FLAGS_num);
        char key[100];
        snprintf(key, sizeof(key), "%016d", k);
        batch.Put(key, gen.Generate(value_size_));
        bytes += value_size_ + strlen(key);
        thread->stats.FinishedSingleOp();
      }
      s = db_->Write(write_options_, &batch);
      if (!s.ok()) {
        fprintf(stderr, "put error: %s\n", s.ToString().c_str());
        exit(1);
      }
    }
    thread->stats.AddBytes(bytes);
  }

Here is the call graph for this function:

HeapProfile()

void leveldb::Benchmark::HeapProfile ( )

inlineprivate

Definition at line 936 of file db_bench.cc.

                     {
    char fname[100];
    snprintf(fname, sizeof(fname), "%s/heap-%04d", FLAGS_db, ++heap_counter_);
    WritableFile* file;
    Status s = g_env->NewWritableFile(fname, &file);
    if (!s.ok()) {
      fprintf(stderr, "%s\n", s.ToString().c_str());
      return;
    }
    bool ok = port::GetHeapProfile(WriteToFile, file);
    delete file;
    if (!ok) {
      fprintf(stderr, "heap profiling not supported\n");
      g_env->DeleteFile(fname);
    }
  }

Here is the call graph for this function:

Open()

void leveldb::Benchmark::Open ( )

inlineprivate

Definition at line 709 of file db_bench.cc.

              {
    assert(db_ == NULL);
    Options options;
    options.env = g_env;
    options.create_if_missing = !FLAGS_use_existing_db;
    options.block_cache = cache_;
    options.write_buffer_size = FLAGS_write_buffer_size;
    options.max_file_size = FLAGS_max_file_size;
    options.block_size = FLAGS_block_size;
    options.max_open_files = FLAGS_open_files;
    options.filter_policy = filter_policy_;
    options.reuse_logs = FLAGS_reuse_logs;
    Status s = DB::Open(options, FLAGS_db, &db_);
    if (!s.ok()) {
      fprintf(stderr, "open error: %s\n", s.ToString().c_str());
      exit(1);
    }
  }

Here is the call graph for this function:

OpenBench()

void leveldb::Benchmark::OpenBench ( ThreadState *  thread )

inlineprivate

Definition at line 728 of file db_bench.cc.

                                      {
    for (int i = 0; i < num_; i++) {
      delete db_;
      Open();
      thread->stats.FinishedSingleOp();
    }
  }

Here is the caller graph for this function:

PrintEnvironment()

void leveldb::Benchmark::PrintEnvironment ( )

inlineprivate

Definition at line 368 of file db_bench.cc.

                          {
    fprintf(stderr, "LevelDB:    version %d.%d\n",
            kMajorVersion, kMinorVersion);

#if defined(__linux)
    time_t now = time(NULL);
    fprintf(stderr, "Date:       %s", ctime(&now));  // ctime() adds newline

    FILE* cpuinfo = fopen("/proc/cpuinfo", "r");
    if (cpuinfo != NULL) {
      char line[1000];
      int num_cpus = 0;
      std::string cpu_type;
      std::string cache_size;
      while (fgets(line, sizeof(line), cpuinfo) != NULL) {
        const char* sep = strchr(line, ':');
        if (sep == NULL) {
          continue;
        }
        Slice key = TrimSpace(Slice(line, sep - 1 - line));
        Slice val = TrimSpace(Slice(sep + 1));
        if (key == "model name") {
          ++num_cpus;
          cpu_type = val.ToString();
        } else if (key == "cache size") {
          cache_size = val.ToString();
        }
      }
      fclose(cpuinfo);
      fprintf(stderr, "CPU:        %d * %s\n", num_cpus, cpu_type.c_str());
      fprintf(stderr, "CPUCache:   %s\n", cache_size.c_str());
    }
#endif
  }

Here is the call graph for this function:

PrintHeader()

void leveldb::Benchmark::PrintHeader ( )

inlineprivate

Definition at line 329 of file db_bench.cc.

                     {
    const int kKeySize = 16;
    PrintEnvironment();
    fprintf(stdout, "Keys:       %d bytes each\n", kKeySize);
    fprintf(stdout, "Values:     %d bytes each (%d bytes after compression)\n",
            FLAGS_value_size,
            static_cast<int>(FLAGS_value_size * FLAGS_compression_ratio + 0.5));
    fprintf(stdout, "Entries:    %d\n", num_);
    fprintf(stdout, "RawSize:    %.1f MB (estimated)\n",
            ((static_cast<int64_t>(kKeySize + FLAGS_value_size) * num_)
             / 1048576.0));
    fprintf(stdout, "FileSize:   %.1f MB (estimated)\n",
            (((kKeySize + FLAGS_value_size * FLAGS_compression_ratio) * num_)
             / 1048576.0));
    PrintWarnings();
    fprintf(stdout, "------------------------------------------------\n");
  }

PrintStats()

void leveldb::Benchmark::PrintStats ( const char *  key )

inlineprivate

Definition at line 924 of file db_bench.cc.

                                   {
    std::string stats;
    if (!db_->GetProperty(key, &stats)) {
      stats = "(failed)";
    }
    fprintf(stdout, "\n%s\n", stats.c_str());
  }

Here is the call graph for this function:

PrintWarnings()

void leveldb::Benchmark::PrintWarnings ( )

inlineprivate

Definition at line 347 of file db_bench.cc.

                       {
#if defined(__GNUC__) && !defined(__OPTIMIZE__)
    fprintf(stdout,
            "WARNING: Optimization is disabled: benchmarks unnecessarily slow\n"
            );
#endif
#ifndef NDEBUG
    fprintf(stdout,
            "WARNING: Assertions are enabled; benchmarks unnecessarily slow\n");
#endif

    // See if snappy is working by attempting to compress a compressible string
    const char text[] = "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy";
    std::string compressed;
    if (!port::Snappy_Compress(text, sizeof(text), &compressed)) {
      fprintf(stdout, "WARNING: Snappy compression is not enabled\n");
    } else if (compressed.size() >= sizeof(text)) {
      fprintf(stdout, "WARNING: Snappy compression is not effective\n");
    }
  }

ReadHot()

void leveldb::Benchmark::ReadHot ( ThreadState *  thread )

inlineprivate

Definition at line 830 of file db_bench.cc.

                                    {
    ReadOptions options;
    std::string value;
    const int range = (FLAGS_num + 99) / 100;
    for (int i = 0; i < reads_; i++) {
      char key[100];
      const int k = thread->rand.Next() % range;
      snprintf(key, sizeof(key), "%016d", k);
      db_->Get(options, key, &value);
      thread->stats.FinishedSingleOp();
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ReadMissing()

void leveldb::Benchmark::ReadMissing ( ThreadState *  thread )

inlineprivate

Definition at line 818 of file db_bench.cc.

                                        {
    ReadOptions options;
    std::string value;
    for (int i = 0; i < reads_; i++) {
      char key[100];
      const int k = thread->rand.Next() % FLAGS_num;
      snprintf(key, sizeof(key), "%016d.", k);
      db_->Get(options, key, &value);
      thread->stats.FinishedSingleOp();
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ReadRandom()

void leveldb::Benchmark::ReadRandom ( ThreadState *  thread )

inlineprivate

Definition at line 800 of file db_bench.cc.

                                       {
    ReadOptions options;
    std::string value;
    int found = 0;
    for (int i = 0; i < reads_; i++) {
      char key[100];
      const int k = thread->rand.Next() % FLAGS_num;
      snprintf(key, sizeof(key), "%016d", k);
      if (db_->Get(options, key, &value).ok()) {
        found++;
      }
      thread->stats.FinishedSingleOp();
    }
    char msg[100];
    snprintf(msg, sizeof(msg), "(%d of %d found)", found, num_);
    thread->stats.AddMessage(msg);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ReadReverse()

void leveldb::Benchmark::ReadReverse ( ThreadState *  thread )

inlineprivate

Definition at line 787 of file db_bench.cc.

                                        {
    Iterator* iter = db_->NewIterator(ReadOptions());
    int i = 0;
    int64_t bytes = 0;
    for (iter->SeekToLast(); i < reads_ && iter->Valid(); iter->Prev()) {
      bytes += iter->key().size() + iter->value().size();
      thread->stats.FinishedSingleOp();
      ++i;
    }
    delete iter;
    thread->stats.AddBytes(bytes);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ReadSequential()

void leveldb::Benchmark::ReadSequential ( ThreadState *  thread )

inlineprivate

Definition at line 774 of file db_bench.cc.

                                           {
    Iterator* iter = db_->NewIterator(ReadOptions());
    int i = 0;
    int64_t bytes = 0;
    for (iter->SeekToFirst(); i < reads_ && iter->Valid(); iter->Next()) {
      bytes += iter->key().size() + iter->value().size();
      thread->stats.FinishedSingleOp();
      ++i;
    }
    delete iter;
    thread->stats.AddBytes(bytes);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ReadWhileWriting()

void leveldb::Benchmark::ReadWhileWriting ( ThreadState *  thread )

inlineprivate

Definition at line 890 of file db_bench.cc.

                                             {
    if (thread->tid > 0) {
      ReadRandom(thread);
    } else {
      // Special thread that keeps writing until other threads are done.
      RandomGenerator gen;
      while (true) {
        {
          MutexLock l(&thread->shared->mu);
          if (thread->shared->num_done + 1 >= thread->shared->num_initialized) {
            // Other threads have finished
            break;
          }
        }

        const int k = thread->rand.Next() % FLAGS_num;
        char key[100];
        snprintf(key, sizeof(key), "%016d", k);
        Status s = db_->Put(write_options_, key, gen.Generate(value_size_));
        if (!s.ok()) {
          fprintf(stderr, "put error: %s\n", s.ToString().c_str());
          exit(1);
        }
      }

      // Do not count any of the preceding work/delay in stats.
      thread->stats.Start();
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Run()

void leveldb::Benchmark::Run ( )

inline

Definition at line 433 of file db_bench.cc.

             {
    PrintHeader();
    Open();

    const char* benchmarks = FLAGS_benchmarks;
    while (benchmarks != NULL) {
      const char* sep = strchr(benchmarks, ',');
      Slice name;
      if (sep == NULL) {
        name = benchmarks;
        benchmarks = NULL;
      } else {
        name = Slice(benchmarks, sep - benchmarks);
        benchmarks = sep + 1;
      }

      // Reset parameters that may be overridden below
      num_ = FLAGS_num;
      reads_ = (FLAGS_reads < 0 ? FLAGS_num : FLAGS_reads);
      value_size_ = FLAGS_value_size;
      entries_per_batch_ = 1;
      write_options_ = WriteOptions();

      void (Benchmark::*method)(ThreadState*) = NULL;
      bool fresh_db = false;
      int num_threads = FLAGS_threads;

      if (name == Slice("open")) {
        method = &Benchmark::OpenBench;
        num_ /= 10000;
        if (num_ < 1) num_ = 1;
      } else if (name == Slice("fillseq")) {
        fresh_db = true;
        method = &Benchmark::WriteSeq;
      } else if (name == Slice("fillbatch")) {
        fresh_db = true;
        entries_per_batch_ = 1000;
        method = &Benchmark::WriteSeq;
      } else if (name == Slice("fillrandom")) {
        fresh_db = true;
        method = &Benchmark::WriteRandom;
      } else if (name == Slice("overwrite")) {
        fresh_db = false;
        method = &Benchmark::WriteRandom;
      } else if (name == Slice("fillsync")) {
        fresh_db = true;
        num_ /= 1000;
        write_options_.sync = true;
        method = &Benchmark::WriteRandom;
      } else if (name == Slice("fill100K")) {
        fresh_db = true;
        num_ /= 1000;
        value_size_ = 100 * 1000;
        method = &Benchmark::WriteRandom;
      } else if (name == Slice("readseq")) {
        method = &Benchmark::ReadSequential;
      } else if (name == Slice("readreverse")) {
        method = &Benchmark::ReadReverse;
      } else if (name == Slice("readrandom")) {
        method = &Benchmark::ReadRandom;
      } else if (name == Slice("readmissing")) {
        method = &Benchmark::ReadMissing;
      } else if (name == Slice("seekrandom")) {
        method = &Benchmark::SeekRandom;
      } else if (name == Slice("readhot")) {
        method = &Benchmark::ReadHot;
      } else if (name == Slice("readrandomsmall")) {
        reads_ /= 1000;
        method = &Benchmark::ReadRandom;
      } else if (name == Slice("deleteseq")) {
        method = &Benchmark::DeleteSeq;
      } else if (name == Slice("deleterandom")) {
        method = &Benchmark::DeleteRandom;
      } else if (name == Slice("readwhilewriting")) {
        num_threads++;  // Add extra thread for writing
        method = &Benchmark::ReadWhileWriting;
      } else if (name == Slice("compact")) {
        method = &Benchmark::Compact;
      } else if (name == Slice("crc32c")) {
        method = &Benchmark::Crc32c;
      } else if (name == Slice("acquireload")) {
        method = &Benchmark::AcquireLoad;
      } else if (name == Slice("snappycomp")) {
        method = &Benchmark::SnappyCompress;
      } else if (name == Slice("snappyuncomp")) {
        method = &Benchmark::SnappyUncompress;
      } else if (name == Slice("heapprofile")) {
        HeapProfile();
      } else if (name == Slice("stats")) {
        PrintStats("leveldb.stats");
      } else if (name == Slice("sstables")) {
        PrintStats("leveldb.sstables");
      } else {
        if (name != Slice()) {  // No error message for empty name
          fprintf(stderr, "unknown benchmark '%s'\n", name.ToString().c_str());
        }
      }

      if (fresh_db) {
        if (FLAGS_use_existing_db) {
          fprintf(stdout, "%-12s : skipped (--use_existing_db is true)\n",
                  name.ToString().c_str());
          method = NULL;
        } else {
          delete db_;
          db_ = NULL;
          DestroyDB(FLAGS_db, Options());
          Open();
        }
      }

      if (method != NULL) {
        RunBenchmark(num_threads, name, method);
      }
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

RunBenchmark()

void leveldb::Benchmark::RunBenchmark ( int  n, Slice  name, void(Benchmark::*)(ThreadState *)  method  )

inlineprivate

Definition at line 586 of file db_bench.cc.

                                                           {
    SharedState shared;
    shared.total = n;
    shared.num_initialized = 0;
    shared.num_done = 0;
    shared.start = false;

    ThreadArg* arg = new ThreadArg[n];
    for (int i = 0; i < n; i++) {
      arg[i].bm = this;
      arg[i].method = method;
      arg[i].shared = &shared;
      arg[i].thread = new ThreadState(i);
      arg[i].thread->shared = &shared;
      g_env->StartThread(ThreadBody, &arg[i]);
    }

    shared.mu.Lock();
    while (shared.num_initialized < n) {
      shared.cv.Wait();
    }

    shared.start = true;
    shared.cv.SignalAll();
    while (shared.num_done < n) {
      shared.cv.Wait();
    }
    shared.mu.Unlock();

    for (int i = 1; i < n; i++) {
      arg[0].thread->stats.Merge(arg[i].thread->stats);
    }
    arg[0].thread->stats.Report(name);

    for (int i = 0; i < n; i++) {
      delete arg[i].thread;
    }
    delete[] arg;
  }

Here is the call graph for this function:

SeekRandom()

void leveldb::Benchmark::SeekRandom ( ThreadState *  thread )

inlineprivate

Definition at line 843 of file db_bench.cc.

                                       {
    ReadOptions options;
    int found = 0;
    for (int i = 0; i < reads_; i++) {
      Iterator* iter = db_->NewIterator(options);
      char key[100];
      const int k = thread->rand.Next() % FLAGS_num;
      snprintf(key, sizeof(key), "%016d", k);
      iter->Seek(key);
      if (iter->Valid() && iter->key() == key) found++;
      delete iter;
      thread->stats.FinishedSingleOp();
    }
    char msg[100];
    snprintf(msg, sizeof(msg), "(%d of %d found)", found, num_);
    thread->stats.AddMessage(msg);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

SnappyCompress()

void leveldb::Benchmark::SnappyCompress ( ThreadState *  thread )

inlineprivate

Definition at line 662 of file db_bench.cc.

                                           {
    RandomGenerator gen;
    Slice input = gen.Generate(Options().block_size);
    int64_t bytes = 0;
    int64_t produced = 0;
    bool ok = true;
    std::string compressed;
    while (ok && bytes < 1024 * 1048576) {  // Compress 1G
      ok = port::Snappy_Compress(input.data(), input.size(), &compressed);
      produced += compressed.size();
      bytes += input.size();
      thread->stats.FinishedSingleOp();
    }

    if (!ok) {
      thread->stats.AddMessage("(snappy failure)");
    } else {
      char buf[100];
      snprintf(buf, sizeof(buf), "(output: %.1f%%)",
               (produced * 100.0) / bytes);
      thread->stats.AddMessage(buf);
      thread->stats.AddBytes(bytes);
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

SnappyUncompress()

void leveldb::Benchmark::SnappyUncompress ( ThreadState *  thread )

inlineprivate

Definition at line 687 of file db_bench.cc.

                                             {
    RandomGenerator gen;
    Slice input = gen.Generate(Options().block_size);
    std::string compressed;
    bool ok = port::Snappy_Compress(input.data(), input.size(), &compressed);
    int64_t bytes = 0;
    char* uncompressed = new char[input.size()];
    while (ok && bytes < 1024 * 1048576) {  // Compress 1G
      ok =  port::Snappy_Uncompress(compressed.data(), compressed.size(),
                                    uncompressed);
      bytes += input.size();
      thread->stats.FinishedSingleOp();
    }
    delete[] uncompressed;

    if (!ok) {
      thread->stats.AddMessage("(snappy failure)");
    } else {
      thread->stats.AddBytes(bytes);
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ThreadBody()

static void leveldb::Benchmark::ThreadBody ( void *  v )

inlinestaticprivate

Definition at line 558 of file db_bench.cc.

                                  {
    ThreadArg* arg = reinterpret_cast<ThreadArg*>(v);
    SharedState* shared = arg->shared;
    ThreadState* thread = arg->thread;
    {
      MutexLock l(&shared->mu);
      shared->num_initialized++;
      if (shared->num_initialized >= shared->total) {
        shared->cv.SignalAll();
      }
      while (!shared->start) {
        shared->cv.Wait();
      }
    }

    thread->stats.Start();
    (arg->bm->*(arg->method))(thread);
    thread->stats.Stop();

    {
      MutexLock l(&shared->mu);
      shared->num_done++;
      if (shared->num_done >= shared->total) {
        shared->cv.SignalAll();
      }
    }
  }

WriteRandom()

void leveldb::Benchmark::WriteRandom ( ThreadState *  thread )

inlineprivate

Definition at line 740 of file db_bench.cc.

                                        {
    DoWrite(thread, false);
  }

Here is the caller graph for this function:

WriteSeq()

void leveldb::Benchmark::WriteSeq ( ThreadState *  thread )

inlineprivate

Definition at line 736 of file db_bench.cc.

                                     {
    DoWrite(thread, true);
  }

Here is the caller graph for this function:

WriteToFile()

static void leveldb::Benchmark::WriteToFile ( void *  arg, const char *  buf, int  n  )

inlinestaticprivate

Definition at line 932 of file db_bench.cc.

                                                             {
    reinterpret_cast<WritableFile*>(arg)->Append(Slice(buf, n));
  }

Member Data Documentation

cache_

Cache* leveldb::Benchmark::cache_

private

Definition at line 319 of file db_bench.cc.

db_

DB* leveldb::Benchmark::db_

private

Definition at line 321 of file db_bench.cc.

entries_per_batch_

int leveldb::Benchmark::entries_per_batch_

private

Definition at line 324 of file db_bench.cc.

filter_policy_

const FilterPolicy* leveldb::Benchmark::filter_policy_

private

Definition at line 320 of file db_bench.cc.

heap_counter_

int leveldb::Benchmark::heap_counter_

private

Definition at line 327 of file db_bench.cc.

num_

int leveldb::Benchmark::num_

private

Definition at line 322 of file db_bench.cc.

reads_

int leveldb::Benchmark::reads_

private

Definition at line 326 of file db_bench.cc.

value_size_

int leveldb::Benchmark::value_size_

private

Definition at line 323 of file db_bench.cc.

write_options_

WriteOptions leveldb::Benchmark::write_options_

private

Definition at line 325 of file db_bench.cc.

---

The documentation for this class was generated from the following file:

• db/db_bench.cc