/*************************************************************************************************

 * The test cases of the file hash database

 *                                                               Copyright (C) 2009-2012 FAL Labs

 * This file is part of Kyoto Cabinet.

 * This program is free software: you can redistribute it and/or modify it under the terms of

 * the GNU General Public License as published by the Free Software Foundation, either version

 * 3 of the License, or any later version.

 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;

 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 * See the GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License along with this program.

 * If not, see <http://www.gnu.org/licenses/>.

 *************************************************************************************************/

#include <kchashdb.h>

#include "cmdcommon.h"

// global variables

const char* g_progname;                  // program name

uint32_t g_randseed;                     // random seed

int64_t g_memusage;                      // memory usage

// function prototypes

int main(int argc, char** argv);

static void usage();

static void dberrprint(kc::BasicDB* db, int32_t line, const char* func);

static void dbmetaprint(kc::BasicDB* db, bool verbose);

static int32_t runorder(int argc, char** argv);

static int32_t runqueue(int argc, char** argv);

static int32_t runwicked(int argc, char** argv);

static int32_t runtran(int argc, char** argv);

static int32_t procorder(const char* path, int64_t rnum, int32_t thnum, bool rnd, int32_t mode,

                         bool tran, int32_t oflags, int32_t apow, int32_t fpow,

                         int32_t opts, int64_t bnum, int64_t msiz, int64_t dfunit, bool lv);

static int32_t procqueue(const char* path, int64_t rnum, int32_t thnum, int32_t itnum,

                         bool rnd, int32_t oflags, int32_t apow, int32_t fpow, int32_t opts,

                         int64_t bnum, int64_t msiz, int64_t dfunit, bool lv);

static int32_t procwicked(const char* path, int64_t rnum, int32_t thnum, int32_t itnum,

                          int32_t oflags, int32_t apow, int32_t fpow, int32_t opts,

                          int64_t bnum, int64_t msiz, int64_t dfunit, bool lv);

static int32_t proctran(const char* path, int64_t rnum, int32_t thnum, int32_t itnum, bool hard,

                        int32_t oflags, int32_t apow, int32_t fpow, int32_t opts,

                        int64_t bnum, int64_t msiz, int64_t dfunit, bool lv);

// main routine

int main(int argc, char** argv) {

  g_progname = argv[0];

  const char* ebuf = kc::getenv("KCRNDSEED");

  g_randseed = ebuf ? (uint32_t)kc::atoi(ebuf) : (uint32_t)(kc::time() * 1000);

  mysrand(g_randseed);

  g_memusage = memusage();

  kc::setstdiobin();

  if (argc < 2) usage();

  int32_t rv = 0;

  if (!std::strcmp(argv[1], "order")) {

    rv = runorder(argc, argv);

  } else if (!std::strcmp(argv[1], "queue")) {

    rv = runqueue(argc, argv);

  } else if (!std::strcmp(argv[1], "wicked")) {

    rv = runwicked(argc, argv);

  } else if (!std::strcmp(argv[1], "tran")) {

    rv = runtran(argc, argv);

  } else {

    usage();

  }

  if (rv != 0) {

    oprintf("FAILED: KCRNDSEED=%u PID=%ld", g_randseed, (long)kc::getpid());

    for (int32_t i = 0; i < argc; i++) {

      oprintf(" %s", argv[i]);

    }

    oprintf("\n\n");

  }

  return rv;

}

// print the usage and exit

static void usage() {

  eprintf("%s: test cases of the file hash database of Kyoto Cabinet\n", g_progname);

  eprintf("\n");

  eprintf("usage:\n");

  eprintf("  %s order [-th num] [-rnd] [-set|-get|-getw|-rem|-etc] [-tran]"

          " [-oat|-oas|-onl|-otl|-onr] [-apow num] [-fpow num] [-ts] [-tl] [-tc] [-bnum num]"

          " [-msiz num] [-dfunit num] [-lv] path rnum\n", g_progname);

  eprintf("  %s queue [-th num] [-it num] [-rnd] [-oat|-oas|-onl|-otl|-onr]"

          " [-apow num] [-fpow num] [-ts] [-tl] [-tc] [-bnum num] [-msiz num] [-dfunit num]"

          " [-lv] path rnum\n", g_progname);

  eprintf("  %s wicked [-th num] [-it num] [-oat|-oas|-onl|-otl|-onr]"

          " [-apow num] [-fpow num] [-ts] [-tl] [-tc] [-bnum num] [-msiz num] [-dfunit num]"

          " [-lv] path rnum\n", g_progname);

  eprintf("  %s tran [-th num] [-it num] [-hard] [-oat|-oas|-onl|-otl|-onr]"

          " [-apow num] [-fpow num] [-ts] [-tl] [-tc] [-bnum num] [-msiz num] [-dfunit num]"

          " [-lv] path rnum\n", g_progname);

  eprintf("\n");

  std::exit(1);

}

// print the error message of a database

static void dberrprint(kc::BasicDB* db, int32_t line, const char* func) {

  const kc::BasicDB::Error& err = db->error();

  oprintf("%s: %d: %s: %s: %d: %s: %s\n",

          g_progname, line, func, db->path().c_str(), err.code(), err.name(), err.message());

}

// print members of a database

static void dbmetaprint(kc::BasicDB* db, bool verbose) {

  if (verbose) {

    std::map<std::string, std::string> status;

    status["opaque"] = "";

    status["fbpnum_used"] = "";

    status["bnum_used"] = "";

    if (db->status(&status)) {

      uint32_t type = kc::atoi(status["type"].c_str());

      oprintf("type: %s (%s) (type=0x%02X)\n",

              kc::BasicDB::typecname(type), kc::BasicDB::typestring(type), type);

      uint32_t rtype = kc::atoi(status["realtype"].c_str());

      if (rtype > 0 && rtype != type)

        oprintf("real type: %s (%s) (realtype=0x%02X)\n",

                kc::BasicDB::typecname(rtype), kc::BasicDB::typestring(rtype), rtype);

      uint32_t chksum = kc::atoi(status["chksum"].c_str());

      oprintf("format version: %s (libver=%s.%s) (chksum=0x%02X)\n", status["fmtver"].c_str(),

              status["libver"].c_str(), status["librev"].c_str(), chksum);

      oprintf("path: %s\n", status["path"].c_str());

      int32_t flags = kc::atoi(status["flags"].c_str());

      oprintf("status flags:");

      if (flags & kc::HashDB::FOPEN) oprintf(" open");

      if (flags & kc::HashDB::FFATAL) oprintf(" fatal");

      oprintf(" (flags=%d)", flags);

      if (kc::atoi(status["recovered"].c_str()) > 0) oprintf(" (recovered)");

      if (kc::atoi(status["reorganized"].c_str()) > 0) oprintf(" (reorganized)");

      if (kc::atoi(status["trimmed"].c_str()) > 0) oprintf(" (trimmed)");

      oprintf("\n", flags);

      int32_t apow = kc::atoi(status["apow"].c_str());

      oprintf("alignment: %d (apow=%d)\n", 1 << apow, apow);

      int32_t fpow = kc::atoi(status["fpow"].c_str());

      int32_t fbpnum = fpow > 0 ? 1 << fpow : 0;

      int32_t fbpused = kc::atoi(status["fbpnum_used"].c_str());

      int64_t frgcnt = kc::atoi(status["frgcnt"].c_str());

      oprintf("free block pool: %d (fpow=%d) (used=%d) (frg=%lld)\n",

              fbpnum, fpow, fbpused, (long long)frgcnt);

      int32_t opts = kc::atoi(status["opts"].c_str());

      oprintf("options:");

      if (opts & kc::HashDB::TSMALL) oprintf(" small");

      if (opts & kc::HashDB::TLINEAR) oprintf(" linear");

      if (opts & kc::HashDB::TCOMPRESS) oprintf(" compress");

      oprintf(" (opts=%d)\n", opts);

      if (status["opaque"].size() >= 16) {

        const char* opaque = status["opaque"].c_str();

        oprintf("opaque:");

        if (std::count(opaque, opaque + 16, 0) != 16) {

          for (int32_t i = 0; i < 16; i++) {

            oprintf(" %02X", ((unsigned char*)opaque)[i]);

          }

        } else {

          oprintf(" 0");

        }

        oprintf("\n");

      }

      int64_t bnum = kc::atoi(status["bnum"].c_str());

      int64_t bnumused = kc::atoi(status["bnum_used"].c_str());

      int64_t count = kc::atoi(status["count"].c_str());

      double load = 0;

      if (count > 0 && bnumused > 0) {

        load = (double)count / bnumused;

        if (!(opts & kc::HashDB::TLINEAR)) load = std::log(load + 1) / std::log(2.0);

      }

      oprintf("buckets: %lld (used=%lld) (load=%.2f)\n",

              (long long)bnum, (long long)bnumused, load);

      std::string cntstr = unitnumstr(count);

      oprintf("count: %lld (%s)\n", count, cntstr.c_str());

      int64_t size = kc::atoi(status["size"].c_str());

      int64_t msiz = kc::atoi(status["msiz"].c_str());

      int64_t realsize = kc::atoi(status["realsize"].c_str());

      std::string sizestr = unitnumstrbyte(size);

      oprintf("size: %lld (%s) (map=%lld)", size, sizestr.c_str(), (long long)msiz);

      if (size != realsize) oprintf(" (gap=%lld)", (long long)(realsize - size));

      oprintf("\n");

    }

  } else {

    oprintf("count: %lld\n", (long long)db->count());

    oprintf("size: %lld\n", (long long)db->size());

  }

  int64_t musage = memusage();

  if (musage > 0) oprintf("memory: %lld\n", (long long)(musage - g_memusage));

}

// parse arguments of order command

static int32_t runorder(int argc, char** argv) {

  bool argbrk = false;

  const char* path = NULL;

  const char* rstr = NULL;

  int32_t thnum = 1;

  bool rnd = false;

  int32_t mode = 0;

  bool tran = false;

  int32_t oflags = 0;

  int32_t apow = -1;

  int32_t fpow = -1;

  int32_t opts = 0;

  int64_t bnum = -1;

  int64_t msiz = -1;

  int64_t dfunit = -1;

  bool lv = false;

  for (int32_t i = 2; i < argc; i++) {

    if (!argbrk && argv[i][0] == '-') {

      if (!std::strcmp(argv[i], "--")) {

        argbrk = true;

      } else if (!std::strcmp(argv[i], "-th")) {

        if (++i >= argc) usage();

        thnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-rnd")) {

        rnd = true;

      } else if (!std::strcmp(argv[i], "-set")) {

        mode = 's';

      } else if (!std::strcmp(argv[i], "-get")) {

        mode = 'g';

      } else if (!std::strcmp(argv[i], "-getw")) {

        mode = 'w';

      } else if (!std::strcmp(argv[i], "-rem")) {

        mode = 'r';

      } else if (!std::strcmp(argv[i], "-etc")) {

        mode = 'e';

      } else if (!std::strcmp(argv[i], "-tran")) {

        tran = true;

      } else if (!std::strcmp(argv[i], "-oat")) {

        oflags |= kc::HashDB::OAUTOTRAN;

      } else if (!std::strcmp(argv[i], "-oas")) {

        oflags |= kc::HashDB::OAUTOSYNC;

      } else if (!std::strcmp(argv[i], "-onl")) {

        oflags |= kc::HashDB::ONOLOCK;

      } else if (!std::strcmp(argv[i], "-otl")) {

        oflags |= kc::HashDB::OTRYLOCK;

      } else if (!std::strcmp(argv[i], "-onr")) {

        oflags |= kc::HashDB::ONOREPAIR;

      } else if (!std::strcmp(argv[i], "-apow")) {

        if (++i >= argc) usage();

        apow = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-fpow")) {

        if (++i >= argc) usage();

        fpow = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-ts")) {

        opts |= kc::HashDB::TSMALL;

      } else if (!std::strcmp(argv[i], "-tl")) {

        opts |= kc::HashDB::TLINEAR;

      } else if (!std::strcmp(argv[i], "-tc")) {

        opts |= kc::HashDB::TCOMPRESS;

      } else if (!std::strcmp(argv[i], "-bnum")) {

        if (++i >= argc) usage();

        bnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-msiz")) {

        if (++i >= argc) usage();

        msiz = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-dfunit")) {

        if (++i >= argc) usage();

        dfunit = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-lv")) {

        lv = true;

      } else {

        usage();

      }

    } else if (!path) {

      argbrk = true;

      path = argv[i];

    } else if (!rstr) {

      rstr = argv[i];

    } else {

      usage();

    }

  }

  if (!path || !rstr) usage();

  int64_t rnum = kc::atoix(rstr);

  if (rnum < 1 || thnum < 1) usage();

  if (thnum > THREADMAX) thnum = THREADMAX;

  int32_t rv = procorder(path, rnum, thnum, rnd, mode, tran, oflags,

                         apow, fpow, opts, bnum, msiz, dfunit, lv);

  return rv;

}

// parse arguments of queue command

static int32_t runqueue(int argc, char** argv) {

  bool argbrk = false;

  const char* path = NULL;

  const char* rstr = NULL;

  int32_t thnum = 1;

  int32_t itnum = 1;

  bool rnd = false;

  int32_t oflags = 0;

  int32_t apow = -1;

  int32_t fpow = -1;

  int32_t opts = 0;

  int64_t bnum = -1;

  int64_t msiz = -1;

  int64_t dfunit = -1;

  bool lv = false;

  for (int32_t i = 2; i < argc; i++) {

    if (!argbrk && argv[i][0] == '-') {

      if (!std::strcmp(argv[i], "--")) {

        argbrk = true;

      } else if (!std::strcmp(argv[i], "-th")) {

        if (++i >= argc) usage();

        thnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-it")) {

        if (++i >= argc) usage();

        itnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-rnd")) {

        rnd = true;

      } else if (!std::strcmp(argv[i], "-oat")) {

        oflags |= kc::HashDB::OAUTOTRAN;

      } else if (!std::strcmp(argv[i], "-oas")) {

        oflags |= kc::HashDB::OAUTOSYNC;

      } else if (!std::strcmp(argv[i], "-onl")) {

        oflags |= kc::HashDB::ONOLOCK;

      } else if (!std::strcmp(argv[i], "-otl")) {

        oflags |= kc::HashDB::OTRYLOCK;

      } else if (!std::strcmp(argv[i], "-onr")) {

        oflags |= kc::HashDB::ONOREPAIR;

      } else if (!std::strcmp(argv[i], "-apow")) {

        if (++i >= argc) usage();

        apow = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-fpow")) {

        if (++i >= argc) usage();

        fpow = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-ts")) {

        opts |= kc::HashDB::TSMALL;

      } else if (!std::strcmp(argv[i], "-tl")) {

        opts |= kc::HashDB::TLINEAR;

      } else if (!std::strcmp(argv[i], "-tc")) {

        opts |= kc::HashDB::TCOMPRESS;

      } else if (!std::strcmp(argv[i], "-bnum")) {

        if (++i >= argc) usage();

        bnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-msiz")) {

        if (++i >= argc) usage();

        msiz = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-dfunit")) {

        if (++i >= argc) usage();

        dfunit = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-lv")) {

        lv = true;

      } else {

        usage();

      }

    } else if (!path) {

      argbrk = true;

      path = argv[i];

    } else if (!rstr) {

      rstr = argv[i];

    } else {

      usage();

    }

  }

  if (!path || !rstr) usage();

  int64_t rnum = kc::atoix(rstr);

  if (rnum < 1 || thnum < 1 || itnum < 1) usage();

  if (thnum > THREADMAX) thnum = THREADMAX;

  int32_t rv = procqueue(path, rnum, thnum, itnum, rnd, oflags,

                         apow, fpow, opts, bnum, msiz, dfunit, lv);

  return rv;

}

// parse arguments of wicked command

static int32_t runwicked(int argc, char** argv) {

  bool argbrk = false;

  const char* path = NULL;

  const char* rstr = NULL;

  int32_t thnum = 1;

  int32_t itnum = 1;

  int32_t oflags = 0;

  int32_t apow = -1;

  int32_t fpow = -1;

  int32_t opts = 0;

  int64_t bnum = -1;

  int64_t msiz = -1;

  int64_t dfunit = -1;

  bool lv = false;

  for (int32_t i = 2; i < argc; i++) {

    if (!argbrk && argv[i][0] == '-') {

      if (!std::strcmp(argv[i], "--")) {

        argbrk = true;

      } else if (!std::strcmp(argv[i], "-th")) {

        if (++i >= argc) usage();

        thnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-it")) {

        if (++i >= argc) usage();

        itnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-oat")) {

        oflags |= kc::HashDB::OAUTOTRAN;

      } else if (!std::strcmp(argv[i], "-oas")) {

        oflags |= kc::HashDB::OAUTOSYNC;

      } else if (!std::strcmp(argv[i], "-onl")) {

        oflags |= kc::HashDB::ONOLOCK;

      } else if (!std::strcmp(argv[i], "-otl")) {

        oflags |= kc::HashDB::OTRYLOCK;

      } else if (!std::strcmp(argv[i], "-onr")) {

        oflags |= kc::HashDB::ONOREPAIR;

      } else if (!std::strcmp(argv[i], "-apow")) {

        if (++i >= argc) usage();

        apow = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-fpow")) {

        if (++i >= argc) usage();

        fpow = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-ts")) {

        opts |= kc::HashDB::TSMALL;

      } else if (!std::strcmp(argv[i], "-tl")) {

        opts |= kc::HashDB::TLINEAR;

      } else if (!std::strcmp(argv[i], "-tc")) {

        opts |= kc::HashDB::TCOMPRESS;

      } else if (!std::strcmp(argv[i], "-bnum")) {

        if (++i >= argc) usage();

        bnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-msiz")) {

        if (++i >= argc) usage();

        msiz = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-dfunit")) {

        if (++i >= argc) usage();

        dfunit = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-lv")) {

        lv = true;

      } else {

        usage();

      }

    } else if (!path) {

      argbrk = true;

      path = argv[i];

    } else if (!rstr) {

      rstr = argv[i];

    } else {

      usage();

    }

  }

  if (!path || !rstr) usage();

  int64_t rnum = kc::atoix(rstr);

  if (rnum < 1 || thnum < 1 || itnum < 1) usage();

  if (thnum > THREADMAX) thnum = THREADMAX;

  int32_t rv = procwicked(path, rnum, thnum, itnum, oflags,

                          apow, fpow, opts, bnum, msiz, dfunit, lv);

  return rv;

}

// parse arguments of tran command

static int32_t runtran(int argc, char** argv) {

  bool argbrk = false;

  const char* path = NULL;

  const char* rstr = NULL;

  int32_t thnum = 1;

  int32_t itnum = 1;

  bool hard = false;

  int32_t oflags = 0;

  int32_t apow = -1;

  int32_t fpow = -1;

  int32_t opts = 0;

  int64_t bnum = -1;

  int64_t msiz = -1;

  int64_t dfunit = -1;

  bool lv = false;

  for (int32_t i = 2; i < argc; i++) {

    if (!argbrk && argv[i][0] == '-') {

      if (!std::strcmp(argv[i], "--")) {

        argbrk = true;

      } else if (!std::strcmp(argv[i], "-th")) {

        if (++i >= argc) usage();

        thnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-it")) {

        if (++i >= argc) usage();

        itnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-hard")) {

        hard = true;

      } else if (!std::strcmp(argv[i], "-oat")) {

        oflags |= kc::HashDB::OAUTOTRAN;

      } else if (!std::strcmp(argv[i], "-oas")) {

        oflags |= kc::HashDB::OAUTOSYNC;

      } else if (!std::strcmp(argv[i], "-onl")) {

        oflags |= kc::HashDB::ONOLOCK;

      } else if (!std::strcmp(argv[i], "-otl")) {

        oflags |= kc::HashDB::OTRYLOCK;

      } else if (!std::strcmp(argv[i], "-onr")) {

        oflags |= kc::HashDB::ONOREPAIR;

      } else if (!std::strcmp(argv[i], "-apow")) {

        if (++i >= argc) usage();

        apow = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-fpow")) {

        if (++i >= argc) usage();

        fpow = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-ts")) {

        opts |= kc::HashDB::TSMALL;

      } else if (!std::strcmp(argv[i], "-tl")) {

        opts |= kc::HashDB::TLINEAR;

      } else if (!std::strcmp(argv[i], "-tc")) {

        opts |= kc::HashDB::TCOMPRESS;

      } else if (!std::strcmp(argv[i], "-bnum")) {

        if (++i >= argc) usage();

        bnum = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-msiz")) {

        if (++i >= argc) usage();

        msiz = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-dfunit")) {

        if (++i >= argc) usage();

        dfunit = kc::atoix(argv[i]);

      } else if (!std::strcmp(argv[i], "-lv")) {

        lv = true;

      } else {

        usage();

      }

    } else if (!path) {

      argbrk = true;

      path = argv[i];

    } else if (!rstr) {

      rstr = argv[i];

    } else {

      usage();

    }

  }

  if (!path || !rstr) usage();

  int64_t rnum = kc::atoix(rstr);

  if (rnum < 1 || thnum < 1 || itnum < 1) usage();

  if (thnum > THREADMAX) thnum = THREADMAX;

  int32_t rv = proctran(path, rnum, thnum, itnum, hard, oflags,

                        apow, fpow, opts, bnum, msiz, dfunit, lv);

  return rv;

}

// perform order command

static int32_t procorder(const char* path, int64_t rnum, int32_t thnum, bool rnd, int32_t mode,

                         bool tran, int32_t oflags, int32_t apow, int32_t fpow,

                         int32_t opts, int64_t bnum, int64_t msiz, int64_t dfunit, bool lv) {

  oprintf("<In-order Test>\n  seed=%u  path=%s  rnum=%lld  thnum=%d  rnd=%d  mode=%d  tran=%d"

          "  oflags=%d  apow=%d  fpow=%d  opts=%d  bnum=%lld  msiz=%lld  dfunit=%lld"

          "  lv=%d\n\n", g_randseed, path, (long long)rnum, thnum, rnd, mode, tran,

          oflags, apow, fpow, opts, (long long)bnum, (long long)msiz, (long long)dfunit, lv);

  bool err = false;

  kc::HashDB db;

  oprintf("opening the database:\n");

  double stime = kc::time();

  db.tune_logger(stdlogger(g_progname, &std::cout),

                 lv ? kc::UINT32MAX : kc::BasicDB::Logger::WARN | kc::BasicDB::Logger::ERROR);

  if (apow >= 0) db.tune_alignment(apow);

  if (fpow >= 0) db.tune_fbp(fpow);

  if (opts > 0) db.tune_options(opts);

  if (bnum > 0) db.tune_buckets(bnum);

  if (msiz >= 0) db.tune_map(msiz);

  if (dfunit > 0) db.tune_defrag(dfunit);

  uint32_t omode = kc::HashDB::OWRITER | kc::HashDB::OCREATE | kc::HashDB::OTRUNCATE;

  if (mode == 'r') {

    omode = kc::HashDB::OWRITER | kc::HashDB::OCREATE;

  } else if (mode == 'g' || mode == 'w') {

    omode = kc::HashDB::OREADER;

  }

  if (!db.open(path, omode | oflags)) {

    dberrprint(&db, __LINE__, "DB::open");

    err = true;

  }

  double etime = kc::time();

  dbmetaprint(&db, false);

  oprintf("time: %.3f\n", etime - stime);

  if (mode == 0 || mode == 's' || mode == 'e') {

    oprintf("setting records:\n");

    stime = kc::time();

    class ThreadSet : public kc::Thread {

     public:

      void setparams(int32_t id, kc::BasicDB* db, int64_t rnum, int32_t thnum,

                     bool rnd, bool tran) {

        id_ = id;

        db_ = db;

        rnum_ = rnum;

        thnum_ = thnum;

        err_ = false;

        rnd_ = rnd;

        tran_ = tran;

      }

      bool error() {

        return err_;

      }

      void run() {

        int64_t base = id_ * rnum_;

        int64_t range = rnum_ * thnum_;

        for (int64_t i = 1; !err_ && i <= rnum_; i++) {

          if (tran_ && !db_->begin_transaction(false)) {

            dberrprint(db_, __LINE__, "DB::begin_transaction");

            err_ = true;

          }

          char kbuf[RECBUFSIZ];

          size_t ksiz = std::sprintf(kbuf, "%08lld",

                                     (long long)(rnd_ ? myrand(range) + 1 : base + i));

          if (!db_->set(kbuf, ksiz, kbuf, ksiz)) {

            dberrprint(db_, __LINE__, "DB::set");

            err_ = true;

          }

          if (rnd_ && i % 8 == 0) {

            switch (myrand(8)) {

              case 0: {

                if (!db_->set(kbuf, ksiz, kbuf, ksiz)) {

                  dberrprint(db_, __LINE__, "DB::set");

                  err_ = true;

                }

                break;

              }

              case 1: {

                if (!db_->append(kbuf, ksiz, kbuf, ksiz)) {

                  dberrprint(db_, __LINE__, "DB::append");

                  err_ = true;

                }

                break;

              }

              case 2: {

                if (!db_->remove(kbuf, ksiz) && db_->error() != kc::BasicDB::Error::NOREC) {

                  dberrprint(db_, __LINE__, "DB::remove");

                  err_ = true;

                }

                break;

              }

              case 3: {

                kc::DB::Cursor* cur = db_->cursor();

                if (cur->jump(kbuf, ksiz)) {

                  switch (myrand(8)) {

                    default: {

                      size_t rsiz;

                      char* rbuf = cur->get_key(&rsiz, myrand(10) == 0);

                      if (rbuf) {

                        delete[] rbuf;

                      } else if (db_->error() != kc::BasicDB::Error::NOREC) {

                        dberrprint(db_, __LINE__, "Cursor::get_key");

                        err_ = true;

                      }

                      break;

                    }

                    case 1: {

                      size_t rsiz;

                      char* rbuf = cur->get_value(&rsiz, myrand(10) == 0);

                      if (rbuf) {

                        delete[] rbuf;

                      } else if (db_->error() != kc::BasicDB::Error::NOREC) {

                        dberrprint(db_, __LINE__, "Cursor::get_value");

                        err_ = true;

                      }

                      break;

                    }

                    case 2: {

                      size_t rksiz;

                      const char* rvbuf;

                      size_t rvsiz;

                      char* rkbuf = cur->get(&rksiz, &rvbuf, &rvsiz, myrand(10) == 0);

                      if (rkbuf) {

                        delete[] rkbuf;

                      } else if (db_->error() != kc::BasicDB::Error::NOREC) {

                        dberrprint(db_, __LINE__, "Cursor::get");

                        err_ = true;

                      }

                      break;

                    }

                    case 3: {

                      std::string key, value;

                      if (!cur->get(&key, &value, myrand(10) == 0) &&

                          db_->error() != kc::BasicDB::Error::NOREC) {

                        dberrprint(db_, __LINE__, "Cursor::get");

                        err_ = true;

                      }

                      break;

                    }

                    case 4: {

                      if (myrand(8) == 0 && !cur->remove() &&

                          db_->error() != kc::BasicDB::Error::NOREC) {

                        dberrprint(db_, __LINE__, "Cursor::remove");

                        err_ = true;

                      }

                      break;

                    }

                  }

                } else if (db_->error() != kc::BasicDB::Error::NOREC) {

                  dberrprint(db_, __LINE__, "Cursor::jump");

                  err_ = true;

                }

                delete cur;

                break;

              }

              default: {

                size_t vsiz;

                char* vbuf = db_->get(kbuf, ksiz, &vsiz);

                if (vbuf) {

                  delete[] vbuf;

                } else if (db_->error() != kc::BasicDB::Error::NOREC) {

                  dberrprint(db_, __LINE__, "DB::get");

                  err_ = true;

                }

                break;

              }

            }

          }

          if (tran_ && !db_->end_transaction(true)) {

            dberrprint(db_, __LINE__, "DB::end_transaction");

            err_ = true;

          }

          if (id_ < 1 && rnum_ > 250 && i % (rnum_ / 250) == 0) {

            oputchar('.');

            if (i == rnum_ || i % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)i);

          }

        }

      }

     private:

      int32_t id_;

      kc::BasicDB* db_;

      int64_t rnum_;

      int32_t thnum_;

      bool err_;

      bool rnd_;

      bool tran_;

    };

    ThreadSet threadsets[THREADMAX];

    if (thnum < 2) {

      threadsets[0].setparams(0, &db, rnum, thnum, rnd, tran);

      threadsets[0].run();

      if (threadsets[0].error()) err = true;

    } else {

      for (int32_t i = 0; i < thnum; i++) {

        threadsets[i].setparams(i, &db, rnum, thnum, rnd, tran);

        threadsets[i].start();

      }

      for (int32_t i = 0; i < thnum; i++) {

        threadsets[i].join();

        if (threadsets[i].error()) err = true;

      }

    }

    etime = kc::time();

    dbmetaprint(&db, mode == 's');

    oprintf("time: %.3f\n", etime - stime);

  }

  if (mode == 'e') {

    oprintf("adding records:\n");

    stime = kc::time();

    class ThreadAdd : public kc::Thread {

     public:

      void setparams(int32_t id, kc::BasicDB* db, int64_t rnum, int32_t thnum,

                     bool rnd, bool tran) {

        id_ = id;

        db_ = db;

        rnum_ = rnum;

        thnum_ = thnum;

        err_ = false;

        rnd_ = rnd;

        tran_ = tran;

      }

      bool error() {

        return err_;

      }

      void run() {

        int64_t base = id_ * rnum_;

        int64_t range = rnum_ * thnum_;

        for (int64_t i = 1; !err_ && i <= rnum_; i++) {

          if (tran_ && !db_->begin_transaction(false)) {

            dberrprint(db_, __LINE__, "DB::begin_transaction");

            err_ = true;

          }

          char kbuf[RECBUFSIZ];

          size_t ksiz = std::sprintf(kbuf, "%08lld",

                                     (long long)(rnd_ ? myrand(range) + 1 : base + i));

          if (!db_->add(kbuf, ksiz, kbuf, ksiz) &&

              db_->error() != kc::BasicDB::Error::DUPREC) {

            dberrprint(db_, __LINE__, "DB::add");

            err_ = true;

          }

          if (tran_ && !db_->end_transaction(true)) {

            dberrprint(db_, __LINE__, "DB::end_transaction");

            err_ = true;

          }

          if (id_ < 1 && rnum_ > 250 && i % (rnum_ / 250) == 0) {

            oputchar('.');

            if (i == rnum_ || i % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)i);

          }

        }

      }

     private:

      int32_t id_;

      kc::BasicDB* db_;

      int64_t rnum_;

      int32_t thnum_;

      bool err_;

      bool rnd_;

      bool tran_;

    };

    ThreadAdd threadadds[THREADMAX];

    if (thnum < 2) {

      threadadds[0].setparams(0, &db, rnum, thnum, rnd, tran);

      threadadds[0].run();

      if (threadadds[0].error()) err = true;

    } else {

      for (int32_t i = 0; i < thnum; i++) {

        threadadds[i].setparams(i, &db, rnum, thnum, rnd, tran);

        threadadds[i].start();

      }

      for (int32_t i = 0; i < thnum; i++) {

        threadadds[i].join();

        if (threadadds[i].error()) err = true;

      }

    }

    etime = kc::time();

    dbmetaprint(&db, false);

    oprintf("time: %.3f\n", etime - stime);

  }

  if (mode == 'e') {

    oprintf("appending records:\n");

    stime = kc::time();

    class ThreadAppend : public kc::Thread {

     public:

      void setparams(int32_t id, kc::BasicDB* db, int64_t rnum, int32_t thnum,

                     bool rnd, bool tran) {

        id_ = id;

        db_ = db;

        rnum_ = rnum;

        thnum_ = thnum;

        err_ = false;

        rnd_ = rnd;

        tran_ = tran;

      }

      bool error() {

        return err_;

      }

      void run() {

        int64_t base = id_ * rnum_;

        int64_t range = rnum_ * thnum_;

        for (int64_t i = 1; !err_ && i <= rnum_; i++) {

          if (tran_ && !db_->begin_transaction(false)) {

            dberrprint(db_, __LINE__, "DB::begin_transaction");

            err_ = true;

          }

          char kbuf[RECBUFSIZ];

          size_t ksiz = std::sprintf(kbuf, "%08lld",

                                     (long long)(rnd_ ? myrand(range) + 1 : base + i));

          if (!db_->append(kbuf, ksiz, kbuf, ksiz)) {

            dberrprint(db_, __LINE__, "DB::append");

            err_ = true;

          }

          if (tran_ && !db_->end_transaction(true)) {

            dberrprint(db_, __LINE__, "DB::end_transaction");

            err_ = true;

          }

          if (id_ < 1 && rnum_ > 250 && i % (rnum_ / 250) == 0) {

            oputchar('.');

            if (i == rnum_ || i % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)i);

          }

        }

      }

     private:

      int32_t id_;

      kc::BasicDB* db_;

      int64_t rnum_;

      int32_t thnum_;

      bool err_;

      bool rnd_;

      bool tran_;

    };

    ThreadAppend threadappends[THREADMAX];

    if (thnum < 2) {

      threadappends[0].setparams(0, &db, rnum, thnum, rnd, tran);

      threadappends[0].run();

      if (threadappends[0].error()) err = true;

    } else {

      for (int32_t i = 0; i < thnum; i++) {

        threadappends[i].setparams(i, &db, rnum, thnum, rnd, tran);

        threadappends[i].start();

      }

      for (int32_t i = 0; i < thnum; i++) {

        threadappends[i].join();

        if (threadappends[i].error()) err = true;

      }

    }

    etime = kc::time();

    dbmetaprint(&db, false);

    oprintf("time: %.3f\n", etime - stime);

    char* opaque = db.opaque();

    if (opaque) {