Inside Bitcoin

751    thread->stats.AddBytes(bytes);
752  }
753
754  void ReadReverse(ThreadState* thread) {
755    Iterator* iter = db_->NewIterator(ReadOptions());
756    int i = 0;
757    int64_t bytes = 0;
758    for (iter->SeekToLast(); i < reads_ && iter->Valid(); iter->Prev()) {
759      bytes += iter->key().size() + iter->value().size();
760      thread->stats.FinishedSingleOp();
761      ++i;
762    }
763    delete iter;
764    thread->stats.AddBytes(bytes);
765  }
766
767  void ReadRandom(ThreadState* thread) {
768    ReadOptions options;
769    std::string value;
770    int found = 0;
771    for (int i = 0; i < reads_; i++) {
772      char key[100];
773      const int k = thread->rand.Next() % FLAGS_num;
774      snprintf(key, sizeof(key), "%016d", k);
775      if (db_->Get(options, key, &value).ok()) {
776        found++;
777      }
778      thread->stats.FinishedSingleOp();
779    }
780    char msg[100];
781    snprintf(msg, sizeof(msg), "(%d of %d found)", found, num_);
782    thread->stats.AddMessage(msg);
783  }
784
785  void ReadMissing(ThreadState* thread) {
786    ReadOptions options;
787    std::string value;
788    for (int i = 0; i < reads_; i++) {
789      char key[100];
790      const int k = thread->rand.Next() % FLAGS_num;
791      snprintf(key, sizeof(key), "%016d.", k);
792      db_->Get(options, key, &value);
793      thread->stats.FinishedSingleOp();
794    }
795  }
796
797  void ReadHot(ThreadState* thread) {
798    ReadOptions options;
799    std::string value;
800    const int range = (FLAGS_num + 99) / 100;
801    for (int i = 0; i < reads_; i++) {
802      char key[100];
803      const int k = thread->rand.Next() % range;
804      snprintf(key, sizeof(key), "%016d", k);
805      db_->Get(options, key, &value);
806      thread->stats.FinishedSingleOp();
807    }
808  }
809
810  void SeekRandom(ThreadState* thread) {
811    ReadOptions options;
812    int found = 0;
813    for (int i = 0; i < reads_; i++) {
814      Iterator* iter = db_->NewIterator(options);
815      char key[100];
816      const int k = thread->rand.Next() % FLAGS_num;
817      snprintf(key, sizeof(key), "%016d", k);
818      iter->Seek(key);
819      if (iter->Valid() && iter->key() == key) found++;
820      delete iter;
821      thread->stats.FinishedSingleOp();
822    }
823    char msg[100];
824    snprintf(msg, sizeof(msg), "(%d of %d found)", found, num_);
825    thread->stats.AddMessage(msg);
826  }
827
828  void DoDelete(ThreadState* thread, bool seq) {
829    RandomGenerator gen;
830    WriteBatch batch;
831    Status s;
832    for (int i = 0; i < num_; i += entries_per_batch_) {
833      batch.Clear();
834      for (int j = 0; j < entries_per_batch_; j++) {
835        const int k = seq ? i + j : (thread->rand.Next() % FLAGS_num);
836        char key[100];
837        snprintf(key, sizeof(key), "%016d", k);
838        batch.Delete(key);
839        thread->stats.FinishedSingleOp();
840      }
841      s = db_->Write(write_options_, &batch);
842      if (!s.ok()) {
843        fprintf(stderr, "del error: %s\n", s.ToString().c_str());
844        exit(1);
845      }
846    }
847  }
848
849  void DeleteSeq(ThreadState* thread) { DoDelete(thread, true); }
850
851  void DeleteRandom(ThreadState* thread) { DoDelete(thread, false); }
852
853  void ReadWhileWriting(ThreadState* thread) {
854    if (thread->tid > 0) {
855      ReadRandom(thread);
856    } else {
857      // Special thread that keeps writing until other threads are done.
858      RandomGenerator gen;
859      while (true) {
860        {
861          MutexLock l(&thread->shared->mu);
862          if (thread->shared->num_done + 1 >= thread->shared->num_initialized) {
863            // Other threads have finished
864            break;
865          }
866        }
867
868        const int k = thread->rand.Next() % FLAGS_num;
869        char key[100];
870        snprintf(key, sizeof(key), "%016d", k);
871        Status s = db_->Put(write_options_, key, gen.Generate(value_size_));
872        if (!s.ok()) {
873          fprintf(stderr, "put error: %s\n", s.ToString().c_str());
874          exit(1);
875        }
876      }
877
878      // Do not count any of the preceding work/delay in stats.
879      thread->stats.Start();
880    }
881  }
882
883  void Compact(ThreadState* thread) { db_->CompactRange(nullptr, nullptr); }
884
885  void PrintStats(const char* key) {
886    std::string stats;
887    if (!db_->GetProperty(key, &stats)) {
888      stats = "(failed)";
889    }
890    fprintf(stdout, "\n%s\n", stats.c_str());
891  }
892
893  static void WriteToFile(void* arg, const char* buf, int n) {
894    reinterpret_cast<WritableFile*>(arg)->Append(Slice(buf, n));
895  }
896
897  void HeapProfile() {
898    char fname[100];
899    snprintf(fname, sizeof(fname), "%s/heap-%04d", FLAGS_db, ++heap_counter_);
900    WritableFile* file;
901    Status s = g_env->NewWritableFile(fname, &file);
902    if (!s.ok()) {
903      fprintf(stderr, "%s\n", s.ToString().c_str());
904      return;
905    }
906    bool ok = port::GetHeapProfile(WriteToFile, file);
907    delete file;
908    if (!ok) {
909      fprintf(stderr, "heap profiling not supported\n");
910      g_env->DeleteFile(fname);
911    }
912  }
913};
914
915}  // namespace leveldb
916
917int main(int argc, char** argv) {
918  FLAGS_write_buffer_size = leveldb::Options().write_buffer_size;
919  FLAGS_max_file_size = leveldb::Options().max_file_size;
920  FLAGS_block_size = leveldb::Options().block_size;
921  FLAGS_open_files = leveldb::Options().max_open_files;
922  std::string default_db_path;
923
924  for (int i = 1; i < argc; i++) {
925    double d;
926    int n;
927    char junk;
928    if (leveldb::Slice(argv[i]).starts_with("--benchmarks=")) {
929      FLAGS_benchmarks = argv[i] + strlen("--benchmarks=");
930    } else if (sscanf(argv[i], "--compression_ratio=%lf%c", &d, &junk) == 1) {
931      FLAGS_compression_ratio = d;
932    } else if (sscanf(argv[i], "--histogram=%d%c", &n, &junk) == 1 &&
933               (n == 0 || n == 1)) {
934      FLAGS_histogram = n;
935    } else if (sscanf(argv[i], "--use_existing_db=%d%c", &n, &junk) == 1 &&
936               (n == 0 || n == 1)) {
937      FLAGS_use_existing_db = n;
938    } else if (sscanf(argv[i], "--reuse_logs=%d%c", &n, &junk) == 1 &&
939               (n == 0 || n == 1)) {
940      FLAGS_reuse_logs = n;
941    } else if (sscanf(argv[i], "--num=%d%c", &n, &junk) == 1) {
942      FLAGS_num = n;
943    } else if (sscanf(argv[i], "--reads=%d%c", &n, &junk) == 1) {
944      FLAGS_reads = n;
945    } else if (sscanf(argv[i], "--threads=%d%c", &n, &junk) == 1) {
946      FLAGS_threads = n;
947    } else if (sscanf(argv[i], "--value_size=%d%c", &n, &junk) == 1) {
948      FLAGS_value_size = n;
949    } else if (sscanf(argv[i], "--write_buffer_size=%d%c", &n, &junk) == 1) {
950      FLAGS_write_buffer_size = n;
951    } else if (sscanf(argv[i], "--max_file_size=%d%c", &n, &junk) == 1) {
952      FLAGS_max_file_size = n;
953    } else if (sscanf(argv[i], "--block_size=%d%c", &n, &junk) == 1) {
954      FLAGS_block_size = n;
955    } else if (sscanf(argv[i], "--cache_size=%d%c", &n, &junk) == 1) {
956      FLAGS_cache_size = n;
957    } else if (sscanf(argv[i], "--bloom_bits=%d%c", &n, &junk) == 1) {
958      FLAGS_bloom_bits = n;
959    } else if (sscanf(argv[i], "--open_files=%d%c", &n, &junk) == 1) {
960      FLAGS_open_files = n;
961    } else if (strncmp(argv[i], "--db=", 5) == 0) {
962      FLAGS_db = argv[i] + 5;
963    } else {
964      fprintf(stderr, "Invalid flag '%s'\n", argv[i]);
965      exit(1);
966    }
967  }
968
969  leveldb::g_env = leveldb::Env::Default();
970
971  // Choose a location for the test database if none given with --db=<path>
972  if (FLAGS_db == nullptr) {
973    leveldb::g_env->GetTestDirectory(&default_db_path);
974    default_db_path += "/dbbench";
975    FLAGS_db = default_db_path.c_str();
976  }
977
978  leveldb::Benchmark benchmark;
979  benchmark.Run();
980  return 0;
981}
982