bitcoinleveldb_bench/

db_bench.rs

crate::ix!();

//-------------------------------------------[.cpp/bitcoin/src/leveldb/benchmarks/db_bench.cc]

/**
  | Comma-separated list of operations to run in
  | the specified order
  |
  |   Actual benchmarks:
  |      fillseq       -- write N values in sequential key order in async mode
  |      fillrandom    -- write N values in random key order in async mode
  |      overwrite     -- overwrite N values in random key order in async mode
  |      fillsync      -- write N/100 values in random key order in sync mode
  |      fill100K      -- write N/1000 100K values in random order in async mode
  |      deleteseq     -- delete N keys in sequential order
  |      deleterandom  -- delete N keys in random order
  |      readseq       -- read N times sequentially
  |      readreverse   -- read N times in reverse order
  |      readrandom    -- read N times in random order
  |      readmissing   -- read N missing keys in random order
  |      readhot       -- read N times in random order from 1% section of DB
  |      seekrandom    -- N random seeks
  |      open          -- cost of opening a DB
  |      crc32c        -- repeated crc32c of 4K of data
  |   Meta operations:
  |      compact     -- Compact the entire DB
  |      stats       -- Print DB stats
  |      sstables    -- Print sstable info
  |      heapprofile -- Dump a heap profile (if supported by this port)
  */
pub const FLAGS_benchmarks: &'static str = concat!{
    "fillseq,",
    "fillsync,",
    "fillrandom,",
    "overwrite,",
    "readrandom,",
    "readrandom,",  // Extra run to allow previous compactions to quiesce
    "readseq,",
    "readreverse,",
    "compact,",
    "readrandom,",
    "readseq,",
    "readreverse,",
    "fill100K,",
    "crc32c,",
    "snappycomp,",
    "snappyuncomp,"
};

/**
  | Number of key/values to place in database
  |
  */
lazy_static!{
    /*
    static int FLAGS_num = 1000000;
    */
}

/**
  | Number of read operations to do. If negative,
  | do FLAGS_num reads.
  |
  */
lazy_static!{
    /*
    static int FLAGS_reads = -1;
    */
}

/**
   Number of concurrent threads to run.
  */
lazy_static!{
    /*
    static int FLAGS_threads = 1;
    */
}

/**
   Size of each value
  */
lazy_static!{
    /*
    static int FLAGS_value_size = 100;
    */
}

/**
  | Arrange to generate values that shrink to this
  | fraction of their original size after
  | compression
  */
lazy_static!{
    /*
    static double FLAGS_compression_ratio = 0.5;
    */
}

/**
   Print histogram of operation timings
  */
lazy_static!{
    /*
    static bool FLAGS_histogram = false;
    */
}

/**
  | Number of bytes to buffer in memtable before
  | compacting (initialized to default value by
  | "main")
  */
lazy_static!{
    /*
    static int FLAGS_write_buffer_size = 0;
    */
}

/**
   Number of bytes written to each file.
   (initialized to default value by "main")
  */
lazy_static!{
    /*
    static int FLAGS_max_file_size = 0;
    */
}

/**
  | Approximate size of user data packed per block
  | (before compression.  (initialized to default
  | value by "main")
  */
lazy_static!{
    /*
    static int FLAGS_block_size = 0;
    */
}

/**
  | Number of bytes to use as a cache of
  | uncompressed data.  Negative means use default
  | settings.
  */
lazy_static!{
    /*
    static int FLAGS_cache_size = -1;
    */
}

/**
   Maximum number of files to keep open at the
   same time (use default if == 0)
  */
lazy_static!{
    /*
    static int FLAGS_open_files = 0;
    */
}

/**
   Bloom filter bits per key.

   Negative means use default settings.
  */
lazy_static!{
    /*
    static int FLAGS_bloom_bits = -1;
    */
}

/**
  | If true, do not destroy the existing database.
  | If you set this flag and also specify
  | a benchmark that wants a fresh database, that
  | benchmark will fail.
  */
lazy_static!{
    /*
    static bool FLAGS_use_existing_db = false;
    */
}

/**
   If true, reuse existing log/MANIFEST files when
   re-opening a database.
  */
lazy_static!{
    /*
    static bool FLAGS_reuse_logs = false;
    */
}

/**
   Use the db with the following name.
  */
lazy_static!{
    /*
    static const char* FLAGS_db = nullptr;
    */
}

lazy_static!{
    /*
    leveldb::Env* g_env = nullptr;
    */
}

/**
   Helper for quickly generating random data.
  */
pub struct RandomGenerator {
    data: String,
    pos:  i32,
}

impl Default for RandomGenerator {
    
    fn default() -> Self {
        todo!();
        /*


            // We use a limited amount of data over and over again and ensure
        // that it is larger than the compression window (32KB), and also
        // large enough to serve all typical value sizes we want to write.
        Random rnd(301);
        std::string piece;
        while (data_.size() < 1048576) {
          // Add a short fragment that is as compressible as specified
          // by FLAGS_compression_ratio.
          test::CompressibleString(&rnd, FLAGS_compression_ratio, 100, &piece);
          data_.append(piece);
        }
        pos_ = 0;
        */
    }
}

impl RandomGenerator {

    pub fn generate(&mut self, len: usize) -> Slice {
        
        todo!();
        /*
            if (pos_ + len > data_.size()) {
          pos_ = 0;
          assert(len < data_.size());
        }
        pos_ += len;
        return Slice(data_.data() + pos_ - len, len);
        */
    }
}

#[cfg(__linux)]
pub fn trim_space(s: Slice) -> Slice {
    
    todo!();
        /*
            size_t start = 0;
      while (start < s.size() && isspace(s[start])) {
        start++;
      }
      size_t limit = s.size();
      while (limit > start && isspace(s[limit - 1])) {
        limit--;
      }
      return Slice(s.data() + start, limit - start);
        */
}

pub fn append_with_space(
        str_: *mut String,
        msg:  Slice)  {
    
    todo!();
        /*
            if (msg.empty()) return;
      if (!str->empty()) {
        str->push_back(' ');
      }
      str->append(msg.data(), msg.size());
        */
}

///--------------------------
pub struct Stats {
    start:          f64,
    finish:         f64,
    seconds:        f64,
    done:           i32,
    next_report:    i32,
    bytes:          i64,
    last_op_finish: f64,
    hist:           Histogram,
    message:        String,
}

impl Default for Stats {
    
    fn default() -> Self {
        todo!();
        /*


            Start();
        */
    }
}

impl Stats {

    pub fn start(&mut self)  {
        
        todo!();
        /*
            next_report_ = 100;
        hist_.Clear();
        done_ = 0;
        bytes_ = 0;
        seconds_ = 0;
        message_.clear();
        start_ = finish_ = last_op_finish_ = g_env->NowMicros();
        */
    }
    
    pub fn merge(&mut self, other: &Stats)  {
        
        todo!();
        /*
            hist_.Merge(other.hist_);
        done_ += other.done_;
        bytes_ += other.bytes_;
        seconds_ += other.seconds_;
        if (other.start_ < start_) start_ = other.start_;
        if (other.finish_ > finish_) finish_ = other.finish_;

        // Just keep the messages from one thread
        if (message_.empty()) message_ = other.message_;
        */
    }
    
    pub fn stop(&mut self)  {
        
        todo!();
        /*
            finish_ = g_env->NowMicros();
        seconds_ = (finish_ - start_) * 1e-6;
        */
    }
    
    pub fn add_message(&mut self, msg: Slice)  {
        
        todo!();
        /*
            AppendWithSpace(&message_, msg);
        */
    }
    
    pub fn finished_single_op(&mut self)  {
        
        todo!();
        /*
            if (FLAGS_histogram) {
          double now = g_env->NowMicros();
          double micros = now - last_op_finish_;
          hist_.Add(micros);
          if (micros > 20000) {
            fprintf(stderr, "long op: %.1f micros%30s\r", micros, "");
            fflush(stderr);
          }
          last_op_finish_ = now;
        }

        done_++;
        if (done_ >= next_report_) {
          if (next_report_ < 1000)
            next_report_ += 100;
          else if (next_report_ < 5000)
            next_report_ += 500;
          else if (next_report_ < 10000)
            next_report_ += 1000;
          else if (next_report_ < 50000)
            next_report_ += 5000;
          else if (next_report_ < 100000)
            next_report_ += 10000;
          else if (next_report_ < 500000)
            next_report_ += 50000;
          else
            next_report_ += 100000;
          fprintf(stderr, "... finished %d ops%30s\r", done_, "");
          fflush(stderr);
        }
        */
    }
    
    pub fn add_bytes(&mut self, n: i64)  {
        
        todo!();
        /*
            bytes_ += n;
        */
    }
    
    pub fn report(&mut self, name: &Slice)  {
        
        todo!();
        /*
            // Pretend at least one op was done in case we are running a benchmark
        // that does not call FinishedSingleOp().
        if (done_ < 1) done_ = 1;

        std::string extra;
        if (bytes_ > 0) {
          // Rate is computed on actual elapsed time, not the sum of per-thread
          // elapsed times.
          double elapsed = (finish_ - start_) * 1e-6;
          char rate[100];
          snprintf(rate, sizeof(rate), "%6.1f MB/s",
                   (bytes_ / 1048576.0) / elapsed);
          extra = rate;
        }
        AppendWithSpace(&extra, message_);

        fprintf(stdout, "%-12s : %11.3f micros/op;%s%s\n", name.ToString().c_str(),
                seconds_ * 1e6 / done_, (extra.empty() ? "" : " "), extra.c_str());
        if (FLAGS_histogram) {
          fprintf(stdout, "Microseconds per op:\n%s\n", hist_.ToString().c_str());
        }
        fflush(stdout);
        */
    }
}

/**
   State shared by all concurrent executions of
   the same benchmark.
  */
pub struct SharedState {

    mu:    Mutex<shared_state::Inner>,
}

pub mod shared_state {

    use super::*;

    pub struct Inner {

        cv:    Condvar,
        total: i32,

        /*
          | Each thread goes through the following states:
          |
          |    (1) initializing
          |
          |    (2) waiting for others to be initialized
          |
          |    (3) running
          |
          |    (4) done
          */

        num_initialized: i32,
        num_done:        i32,
        start:           bool,
    }
}

impl SharedState {

    pub fn new(total: i32) -> Self {
    
        todo!();
        /*
        : cv(&mu),
        : total(total),
        : num_initialized(0),
        : num_done(0),
        : start(false),
        
        */
    }
}

/**
  | Per-thread state for concurrent executions
  | of the same benchmark.
  |
  */
pub struct ThreadState {

    /**
       0..n-1 when running in n threads
      */
    tid:    i32,

    /**
       Has different seeds for different threads
      */
    rand:   Random,
    stats:  Stats,
    shared: *mut SharedState,
}

impl ThreadState {
    
    pub fn new(index: i32) -> Self {
    
        todo!();
        /*


            : tid(index), rand(1000 + index), shared(nullptr)
        */
    }
}

///-------------------------
pub struct Benchmark {
    cache:             *mut Cache,
    filter_policy:     Box<dyn FilterPolicy>,
    db:                *mut dyn DB,
    num:               i32,
    value_size:        i32,
    entries_per_batch: i32,
    write_options:     WriteOptions,
    reads:             i32,
    heap_counter:      i32,
}

pub mod benchmark {
    use super::*;

    pub struct ThreadArg {
        bm:     *mut Benchmark,
        shared: *mut SharedState,
        thread: *mut ThreadState,
        method: fn(_0: *mut ThreadState) -> c_void,
    }
}

impl Default for Benchmark {
    
    fn default() -> Self {
        todo!();
        /*


            : cache_(FLAGS_cache_size >= 0 ? NewLRUCache(FLAGS_cache_size) : nullptr),
            filter_policy_(FLAGS_bloom_bits >= 0
                               ? NewBloomFilterPolicy(FLAGS_bloom_bits)
                               : nullptr),
            db_(nullptr),
            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());
        }
        */
    }
}

impl Drop for Benchmark {
    fn drop(&mut self) {
        todo!();
        /*
            delete db_;
        delete cache_;
        delete filter_policy_;
        */
    }
}

impl Benchmark {

    pub fn print_header(&mut self)  {
        
        todo!();
        /*
            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");
        */
    }
    
    pub fn print_warnings(&mut self)  {
        
        todo!();
        /*
            #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 (!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");
        }
        */
    }
    
    pub fn print_environment(&mut self)  {
        
        todo!();
        /*
            fprintf(stderr, "LevelDB:    version %d.%d\n", kMajorVersion,
                kMinorVersion);

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

        FILE* cpuinfo = fopen("/proc/cpuinfo", "r");
        if (cpuinfo != nullptr) {
          char line[1000];
          int num_cpus = 0;
          std::string cpu_type;
          std::string cache_size;
          while (fgets(line, sizeof(line), cpuinfo) != nullptr) {
            const char* sep = strchr(line, ':');
            if (sep == nullptr) {
              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
        */
    }
    
    pub fn run(&mut self)  {
        
        todo!();
        /*
            PrintHeader();
        Open();

        const char* benchmarks = FLAGS_benchmarks;
        while (benchmarks != nullptr) {
          const char* sep = strchr(benchmarks, ',');
          Slice name;
          if (sep == nullptr) {
            name = benchmarks;
            benchmarks = nullptr;
          } 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();

          c_void (Benchmark::*method)(ThreadState*) = nullptr;
          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("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.empty()) {  // 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 = nullptr;
            } else {
              delete db_;
              db_ = nullptr;
              DestroyDB(FLAGS_db, Options());
              Open();
            }
          }

          if (method != nullptr) {
            RunBenchmark(num_threads, name, method);
          }
        }
        */
    }
    
    pub fn thread_body(v: *mut c_void)  {
        
        todo!();
        /*
            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();
          }
        }
        */
    }
    
    pub fn run_benchmark(&mut self, 
        n:      i32,
        name:   Slice,
        method: fn(_0: *mut ThreadState) -> c_void)  {
        
        todo!();
        /*
            SharedState shared(n);

        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;
        */
    }
    
    pub fn crc_32c(&mut self, thread: *mut ThreadState)  {
        
        todo!();
        /*
            // 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);
        */
    }
    
    pub fn snappy_compress(&mut self, thread: *mut ThreadState)  {
        
        todo!();
        /*
            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 = 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);
        }
        */
    }
    
    pub fn snappy_uncompress(&mut self, thread: *mut ThreadState)  {
        
        todo!();
        /*
            RandomGenerator gen;
        Slice input = gen.Generate(Options().block_size);
        std::string compressed;
        bool ok = 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 = 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);
        }
        */
    }
    
    pub fn open(&mut self)  {
        
        todo!();
        /*
            assert(db_ == nullptr);
        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;
        crate::Status s = DB::Open(options, FLAGS_db, &db_);
        if (!s.ok()) {
          fprintf(stderr, "open error: %s\n", s.ToString().c_str());
          exit(1);
        }
        */
    }
    
    pub fn open_bench(&mut self, thread: *mut ThreadState)  {
        
        todo!();
        /*
            for (int i = 0; i < num_; i++) {
          delete db_;
          Open();
          thread->stats.FinishedSingleOp();
        }
        */
    }
    
    pub fn write_seq(&mut self, thread: *mut ThreadState)  {
        
        todo!();
        /*
            DoWrite(thread, true);
        */
    }
    
    pub fn write_random(&mut self, thread: *mut ThreadState)  {
        
        todo!();
        /*
            DoWrite(thread, false);
        */
    }
    
    pub fn do_write(&mut self, 
        thread: *mut ThreadState,
        seq:    bool)  {
        
        todo!();
        /*
            if (num_ != FLAGS_num) {
          char msg[100];
          snprintf(msg, sizeof(msg), "(%d ops)", num_);
          thread->stats.AddMessage(msg);
        }

        RandomGenerator gen;
        WriteBatch batch;
        crate::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);
        */
    }
    
    pub fn read_sequential(&mut self, thread: *mut ThreadState)  {
        
        todo!();
        /*
            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);
        */
    }
    
    pub fn read_reverse(&mut self, thread: *mut ThreadState)  {
        
        todo!();
        /*
            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);
        */
    }
    
    pub fn read_random(&mut self, thread: *mut ThreadState)  {
        
        todo!();
        /*
            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);
        */
    }
    
    pub fn read_missing(&mut self, thread: *mut ThreadState)  {
        
        todo!();
        /*
            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();
        }
        */
    }
    
    pub fn read_hot(&mut self, thread: *mut ThreadState)  {
        
        todo!();
        /*
            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();
        }
        */
    }
    
    pub fn seek_random(&mut self, thread: *mut ThreadState)  {
        
        todo!();
        /*
            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);
        */
    }
    
    pub fn do_delete(&mut self, 
        thread: *mut ThreadState,
        seq:    bool)  {
        
        todo!();
        /*
            RandomGenerator gen;
        WriteBatch batch;
        crate::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);
          }
        }
        */
    }
    
    pub fn delete_seq(&mut self, thread: *mut ThreadState)  {
        
        todo!();
        /*
            DoDelete(thread, true);
        */
    }
    
    pub fn delete_random(&mut self, thread: *mut ThreadState)  {
        
        todo!();
        /*
            DoDelete(thread, false);
        */
    }
    
    pub fn read_while_writing(&mut self, thread: *mut ThreadState)  {
        
        todo!();
        /*
            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);
            crate::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();
        }
        */
    }
    
    pub fn compact(&mut self, thread: *mut ThreadState)  {
        
        todo!();
        /*
            db_->CompactRange(nullptr, nullptr);
        */
    }
    
    pub fn print_stats(&mut self, key_: *const u8)  {
        
        todo!();
        /*
            std::string stats;
        if (!db_->GetProperty(key, &stats)) {
          stats = "(failed)";
        }
        fprintf(stdout, "\n%s\n", stats.c_str());
        */
    }
    
    pub fn write_to_file(
        arg: *mut c_void,
        buf: *const u8,
        n:   i32)  {
        
        todo!();
        /*
            reinterpret_cast<WritableFile*>(arg)->Append(Slice(buf, n));
        */
    }
    
    pub fn heap_profile(&mut self)  {
        
        todo!();
        /*
            char fname[100];
        snprintf(fname, sizeof(fname), "%s/heap-%04d", FLAGS_db, ++heap_counter_);
        WritableFile* file;
        crate::Status s = g_env->NewWritableFile(fname, &file);
        if (!s.ok()) {
          fprintf(stderr, "%s\n", s.ToString().c_str());
          return;
        }
        bool ok = GetHeapProfile(WriteToFile, file);
        delete file;
        if (!ok) {
          fprintf(stderr, "heap profiling not supported\n");
          g_env->DeleteFile(fname);
        }
        */
    }
}

pub fn benchdb_bench_main (
    argc: i32,
    argv: *mut *mut u8) -> i32 {

    todo!();
        /*
            FLAGS_write_buffer_size = leveldb::Options().write_buffer_size;
      FLAGS_max_file_size = leveldb::Options().max_file_size;
      FLAGS_block_size = leveldb::Options().block_size;
      FLAGS_open_files = leveldb::Options().max_open_files;
      std::string default_db_path;

      for (int i = 1; i < argc; i++) {
        double d;
        int n;
        char junk;
        if (leveldb::Slice(argv[i]).starts_with("--benchmarks=")) {
          FLAGS_benchmarks = argv[i] + strlen("--benchmarks=");
        } else if (sscanf(argv[i], "--compression_ratio=%lf%c", &d, &junk) == 1) {
          FLAGS_compression_ratio = d;
        } else if (sscanf(argv[i], "--histogram=%d%c", &n, &junk) == 1 &&
                   (n == 0 || n == 1)) {
          FLAGS_histogram = n;
        } else if (sscanf(argv[i], "--use_existing_db=%d%c", &n, &junk) == 1 &&
                   (n == 0 || n == 1)) {
          FLAGS_use_existing_db = n;
        } else if (sscanf(argv[i], "--reuse_logs=%d%c", &n, &junk) == 1 &&
                   (n == 0 || n == 1)) {
          FLAGS_reuse_logs = n;
        } else if (sscanf(argv[i], "--num=%d%c", &n, &junk) == 1) {
          FLAGS_num = n;
        } else if (sscanf(argv[i], "--reads=%d%c", &n, &junk) == 1) {
          FLAGS_reads = n;
        } else if (sscanf(argv[i], "--threads=%d%c", &n, &junk) == 1) {
          FLAGS_threads = n;
        } else if (sscanf(argv[i], "--value_size=%d%c", &n, &junk) == 1) {
          FLAGS_value_size = n;
        } else if (sscanf(argv[i], "--write_buffer_size=%d%c", &n, &junk) == 1) {
          FLAGS_write_buffer_size = n;
        } else if (sscanf(argv[i], "--max_file_size=%d%c", &n, &junk) == 1) {
          FLAGS_max_file_size = n;
        } else if (sscanf(argv[i], "--block_size=%d%c", &n, &junk) == 1) {
          FLAGS_block_size = n;
        } else if (sscanf(argv[i], "--cache_size=%d%c", &n, &junk) == 1) {
          FLAGS_cache_size = n;
        } else if (sscanf(argv[i], "--bloom_bits=%d%c", &n, &junk) == 1) {
          FLAGS_bloom_bits = n;
        } else if (sscanf(argv[i], "--open_files=%d%c", &n, &junk) == 1) {
          FLAGS_open_files = n;
        } else if (strncmp(argv[i], "--db=", 5) == 0) {
          FLAGS_db = argv[i] + 5;
        } else {
          fprintf(stderr, "Invalid flag '%s'\n", argv[i]);
          exit(1);
        }
      }

      leveldb::g_env = leveldb::Env::Default();

      // Choose a location for the test database if none given with --db=<path>
      if (FLAGS_db == nullptr) {
        leveldb::g_env->GetTestDirectory(&default_db_path);
        default_db_path += "/dbbench";
        FLAGS_db = default_db_path.c_str();
      }

      leveldb::Benchmark benchmark;
      benchmark.Run();
      return 0;
        */
}