Inside Bitcoin

251        next_report_ += 100000;
252      fprintf(stderr, "... finished %d ops%30s\r", done_, "");
253      fflush(stderr);
254    }
255  }
256
257  void Stop(const Slice& name) {
258    double finish = Env::Default()->NowMicros() * 1e-6;
259
260    // Pretend at least one op was done in case we are running a benchmark
261    // that does not call FinishedSingleOp().
262    if (done_ < 1) done_ = 1;
263
264    if (bytes_ > 0) {
265      char rate[100];
266      snprintf(rate, sizeof(rate), "%6.1f MB/s",
267               (bytes_ / 1048576.0) / (finish - start_));
268      if (!message_.empty()) {
269        message_ = std::string(rate) + " " + message_;
270      } else {
271        message_ = rate;
272      }
273    }
274
275    fprintf(stdout, "%-12s : %11.3f micros/op;%s%s\n", name.ToString().c_str(),
276            (finish - start_) * 1e6 / done_, (message_.empty() ? "" : " "),
277            message_.c_str());
278    if (FLAGS_histogram) {
279      fprintf(stdout, "Microseconds per op:\n%s\n", hist_.ToString().c_str());
280    }
281    fflush(stdout);
282  }
283
284 public:
285  enum Order { SEQUENTIAL, RANDOM };
286  enum DBState { FRESH, EXISTING };
287
288  Benchmark()
289      : db_(nullptr),
290        num_(FLAGS_num),
291        reads_(FLAGS_reads < 0 ? FLAGS_num : FLAGS_reads),
292        bytes_(0),
293        rand_(301) {
294    std::vector<std::string> files;
295    std::string test_dir;
296    Env::Default()->GetTestDirectory(&test_dir);
297    Env::Default()->GetChildren(test_dir.c_str(), &files);
298    if (!FLAGS_use_existing_db) {
299      for (int i = 0; i < files.size(); i++) {
300        if (Slice(files[i]).starts_with("dbbench_polyDB")) {
301          std::string file_name(test_dir);
302          file_name += "/";
303          file_name += files[i];
304          Env::Default()->DeleteFile(file_name.c_str());
305        }
306      }
307    }
308  }
309
310  ~Benchmark() {
311    if (!db_->close()) {
312      fprintf(stderr, "close error: %s\n", db_->error().name());
313    }
314  }
315
316  void Run() {
317    PrintHeader();
318    Open(false);
319
320    const char* benchmarks = FLAGS_benchmarks;
321    while (benchmarks != nullptr) {
322      const char* sep = strchr(benchmarks, ',');
323      Slice name;
324      if (sep == nullptr) {
325        name = benchmarks;
326        benchmarks = nullptr;
327      } else {
328        name = Slice(benchmarks, sep - benchmarks);
329        benchmarks = sep + 1;
330      }
331
332      Start();
333
334      bool known = true;
335      bool write_sync = false;
336      if (name == Slice("fillseq")) {
337        Write(write_sync, SEQUENTIAL, FRESH, num_, FLAGS_value_size, 1);
338        DBSynchronize(db_);
339      } else if (name == Slice("fillrandom")) {
340        Write(write_sync, RANDOM, FRESH, num_, FLAGS_value_size, 1);
341        DBSynchronize(db_);
342      } else if (name == Slice("overwrite")) {
343        Write(write_sync, RANDOM, EXISTING, num_, FLAGS_value_size, 1);
344        DBSynchronize(db_);
345      } else if (name == Slice("fillrandsync")) {
346        write_sync = true;
347        Write(write_sync, RANDOM, FRESH, num_ / 100, FLAGS_value_size, 1);
348        DBSynchronize(db_);
349      } else if (name == Slice("fillseqsync")) {
350        write_sync = true;
351        Write(write_sync, SEQUENTIAL, FRESH, num_ / 100, FLAGS_value_size, 1);
352        DBSynchronize(db_);
353      } else if (name == Slice("fillrand100K")) {
354        Write(write_sync, RANDOM, FRESH, num_ / 1000, 100 * 1000, 1);
355        DBSynchronize(db_);
356      } else if (name == Slice("fillseq100K")) {
357        Write(write_sync, SEQUENTIAL, FRESH, num_ / 1000, 100 * 1000, 1);
358        DBSynchronize(db_);
359      } else if (name == Slice("readseq")) {
360        ReadSequential();
361      } else if (name == Slice("readrandom")) {
362        ReadRandom();
363      } else if (name == Slice("readrand100K")) {
364        int n = reads_;
365        reads_ /= 1000;
366        ReadRandom();
367        reads_ = n;
368      } else if (name == Slice("readseq100K")) {
369        int n = reads_;
370        reads_ /= 1000;
371        ReadSequential();
372        reads_ = n;
373      } else {
374        known = false;
375        if (name != Slice()) {  // No error message for empty name
376          fprintf(stderr, "unknown benchmark '%s'\n", name.ToString().c_str());
377        }
378      }
379      if (known) {
380        Stop(name);
381      }
382    }
383  }
384
385 private:
386  void Open(bool sync) {
387    assert(db_ == nullptr);
388
389    // Initialize db_
390    db_ = new kyotocabinet::TreeDB();
391    char file_name[100];
392    db_num_++;
393    std::string test_dir;
394    Env::Default()->GetTestDirectory(&test_dir);
395    snprintf(file_name, sizeof(file_name), "%s/dbbench_polyDB-%d.kct",
396             test_dir.c_str(), db_num_);
397
398    // Create tuning options and open the database
399    int open_options =
400        kyotocabinet::PolyDB::OWRITER | kyotocabinet::PolyDB::OCREATE;
401    int tune_options =
402        kyotocabinet::TreeDB::TSMALL | kyotocabinet::TreeDB::TLINEAR;
403    if (FLAGS_compression) {
404      tune_options |= kyotocabinet::TreeDB::TCOMPRESS;
405      db_->tune_compressor(&comp_);
406    }
407    db_->tune_options(tune_options);
408    db_->tune_page_cache(FLAGS_cache_size);
409    db_->tune_page(FLAGS_page_size);
410    db_->tune_map(256LL << 20);
411    if (sync) {
412      open_options |= kyotocabinet::PolyDB::OAUTOSYNC;
413    }
414    if (!db_->open(file_name, open_options)) {
415      fprintf(stderr, "open error: %s\n", db_->error().name());
416    }
417  }
418
419  void Write(bool sync, Order order, DBState state, int num_entries,
420             int value_size, int entries_per_batch) {
421    // Create new database if state == FRESH
422    if (state == FRESH) {
423      if (FLAGS_use_existing_db) {
424        message_ = "skipping (--use_existing_db is true)";
425        return;
426      }
427      delete db_;
428      db_ = nullptr;
429      Open(sync);
430      Start();  // Do not count time taken to destroy/open
431    }
432
433    if (num_entries != num_) {
434      char msg[100];
435      snprintf(msg, sizeof(msg), "(%d ops)", num_entries);
436      message_ = msg;
437    }
438
439    // Write to database
440    for (int i = 0; i < num_entries; i++) {
441      const int k = (order == SEQUENTIAL) ? i : (rand_.Next() % num_entries);
442      char key[100];
443      snprintf(key, sizeof(key), "%016d", k);
444      bytes_ += value_size + strlen(key);
445      std::string cpp_key = key;
446      if (!db_->set(cpp_key, gen_.Generate(value_size).ToString())) {
447        fprintf(stderr, "set error: %s\n", db_->error().name());
448      }
449      FinishedSingleOp();
450    }
451  }
452
453  void ReadSequential() {
454    kyotocabinet::DB::Cursor* cur = db_->cursor();
455    cur->jump();
456    std::string ckey, cvalue;
457    while (cur->get(&ckey, &cvalue, true)) {
458      bytes_ += ckey.size() + cvalue.size();
459      FinishedSingleOp();
460    }
461    delete cur;
462  }
463
464  void ReadRandom() {
465    std::string value;
466    for (int i = 0; i < reads_; i++) {
467      char key[100];
468      const int k = rand_.Next() % reads_;
469      snprintf(key, sizeof(key), "%016d", k);
470      db_->get(key, &value);
471      FinishedSingleOp();
472    }
473  }
474};
475
476}  // namespace leveldb
477
478int main(int argc, char** argv) {
479  std::string default_db_path;
480  for (int i = 1; i < argc; i++) {
481    double d;
482    int n;
483    char junk;
484    if (leveldb::Slice(argv[i]).starts_with("--benchmarks=")) {
485      FLAGS_benchmarks = argv[i] + strlen("--benchmarks=");
486    } else if (sscanf(argv[i], "--compression_ratio=%lf%c", &d, &junk) == 1) {
487      FLAGS_compression_ratio = d;
488    } else if (sscanf(argv[i], "--histogram=%d%c", &n, &junk) == 1 &&
489               (n == 0 || n == 1)) {
490      FLAGS_histogram = n;
491    } else if (sscanf(argv[i], "--num=%d%c", &n, &junk) == 1) {
492      FLAGS_num = n;
493    } else if (sscanf(argv[i], "--reads=%d%c", &n, &junk) == 1) {
494      FLAGS_reads = n;
495    } else if (sscanf(argv[i], "--value_size=%d%c", &n, &junk) == 1) {
496      FLAGS_value_size = n;
497    } else if (sscanf(argv[i], "--cache_size=%d%c", &n, &junk) == 1) {
498      FLAGS_cache_size = n;
499    } else if (sscanf(argv[i], "--page_size=%d%c", &n, &junk) == 1) {
500      FLAGS_page_size = n;