|
Packit |
807167 |
/*************************************************************************************************
|
|
Packit |
807167 |
* The test cases of the cache tree database
|
|
Packit |
807167 |
* Copyright (C) 2009-2012 FAL Labs
|
|
Packit |
807167 |
* This file is part of Kyoto Cabinet.
|
|
Packit |
807167 |
* This program is free software: you can redistribute it and/or modify it under the terms of
|
|
Packit |
807167 |
* the GNU General Public License as published by the Free Software Foundation, either version
|
|
Packit |
807167 |
* 3 of the License, or any later version.
|
|
Packit |
807167 |
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
|
Packit |
807167 |
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
Packit |
807167 |
* See the GNU General Public License for more details.
|
|
Packit |
807167 |
* You should have received a copy of the GNU General Public License along with this program.
|
|
Packit |
807167 |
* If not, see <http://www.gnu.org/licenses/>.
|
|
Packit |
807167 |
*************************************************************************************************/
|
|
Packit |
807167 |
|
|
Packit |
807167 |
|
|
Packit |
807167 |
#include <kccachedb.h>
|
|
Packit |
807167 |
#include "cmdcommon.h"
|
|
Packit |
807167 |
|
|
Packit |
807167 |
|
|
Packit |
807167 |
// global variables
|
|
Packit |
807167 |
const char* g_progname; // program name
|
|
Packit |
807167 |
uint32_t g_randseed; // random seed
|
|
Packit |
807167 |
int64_t g_memusage; // memory usage
|
|
Packit |
807167 |
|
|
Packit |
807167 |
|
|
Packit |
807167 |
// function prototypes
|
|
Packit |
807167 |
int main(int argc, char** argv);
|
|
Packit |
807167 |
static void usage();
|
|
Packit |
807167 |
static void dberrprint(kc::BasicDB* db, int32_t line, const char* func);
|
|
Packit |
807167 |
static void dbmetaprint(kc::BasicDB* db, bool verbose);
|
|
Packit |
807167 |
static int32_t runorder(int argc, char** argv);
|
|
Packit |
807167 |
static int32_t runqueue(int argc, char** argv);
|
|
Packit |
807167 |
static int32_t runwicked(int argc, char** argv);
|
|
Packit |
807167 |
static int32_t runtran(int argc, char** argv);
|
|
Packit |
807167 |
static int32_t procorder(int64_t rnum, int32_t thnum, bool rnd, bool etc, bool tran,
|
|
Packit |
807167 |
int32_t opts, int64_t bnum, int32_t psiz, int64_t pccap,
|
|
Packit |
807167 |
kc::Comparator* rcomp, bool lv);
|
|
Packit |
807167 |
static int32_t procqueue(int64_t rnum, int32_t thnum, int32_t itnum, bool rnd,
|
|
Packit |
807167 |
int32_t opts, int64_t bnum, int32_t psiz, int64_t pccap,
|
|
Packit |
807167 |
kc::Comparator* rcomp, bool lv);
|
|
Packit |
807167 |
static int32_t procwicked(int64_t rnum, int32_t thnum, int32_t itnum,
|
|
Packit |
807167 |
int32_t opts, int64_t bnum, int32_t psiz, int64_t pccap,
|
|
Packit |
807167 |
kc::Comparator* rcomp, bool lv);
|
|
Packit |
807167 |
static int32_t proctran(int64_t rnum, int32_t thnum, int32_t itnum,
|
|
Packit |
807167 |
int32_t opts, int64_t bnum, int32_t psiz, int64_t pccap,
|
|
Packit |
807167 |
kc::Comparator* rcomp, bool lv);
|
|
Packit |
807167 |
|
|
Packit |
807167 |
|
|
Packit |
807167 |
// main routine
|
|
Packit |
807167 |
int main(int argc, char** argv) {
|
|
Packit |
807167 |
g_progname = argv[0];
|
|
Packit |
807167 |
const char* ebuf = kc::getenv("KCRNDSEED");
|
|
Packit |
807167 |
g_randseed = ebuf ? (uint32_t)kc::atoi(ebuf) : (uint32_t)(kc::time() * 1000);
|
|
Packit |
807167 |
mysrand(g_randseed);
|
|
Packit |
807167 |
g_memusage = memusage();
|
|
Packit |
807167 |
kc::setstdiobin();
|
|
Packit |
807167 |
if (argc < 2) usage();
|
|
Packit |
807167 |
int32_t rv = 0;
|
|
Packit |
807167 |
if (!std::strcmp(argv[1], "order")) {
|
|
Packit |
807167 |
rv = runorder(argc, argv);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[1], "queue")) {
|
|
Packit |
807167 |
rv = runqueue(argc, argv);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[1], "wicked")) {
|
|
Packit |
807167 |
rv = runwicked(argc, argv);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[1], "tran")) {
|
|
Packit |
807167 |
rv = runtran(argc, argv);
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
usage();
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (rv != 0) {
|
|
Packit |
807167 |
oprintf("FAILED: KCRNDSEED=%u PID=%ld", g_randseed, (long)kc::getpid());
|
|
Packit |
807167 |
for (int32_t i = 0; i < argc; i++) {
|
|
Packit |
807167 |
oprintf(" %s", argv[i]);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
oprintf("\n\n");
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
return rv;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
|
|
Packit |
807167 |
|
|
Packit |
807167 |
// print the usage and exit
|
|
Packit |
807167 |
static void usage() {
|
|
Packit |
807167 |
eprintf("%s: test cases of the cache tree database of Kyoto Cabinet\n", g_progname);
|
|
Packit |
807167 |
eprintf("\n");
|
|
Packit |
807167 |
eprintf("usage:\n");
|
|
Packit |
807167 |
eprintf(" %s order [-th num] [-rnd] [-etc] [-tran] [-tc] [-bnum num] [-psiz num] [-pccap num]"
|
|
Packit |
807167 |
" [-rcd|-rcld|-rcdd] [-lv] rnum\n", g_progname);
|
|
Packit |
807167 |
eprintf(" %s queue [-th num] [-it num] [-rnd] [-tc] [-bnum num] [-psiz num] [-pccap num]"
|
|
Packit |
807167 |
" [-rcd|-rcld|-rcdd] [-lv] rnum\n", g_progname);
|
|
Packit |
807167 |
eprintf(" %s wicked [-th num] [-it num] [-tc] [-bnum num] [-psiz num] [-pccap num]"
|
|
Packit |
807167 |
" [-rcd|-rcld|-rcdd] [-lv] rnum\n", g_progname);
|
|
Packit |
807167 |
eprintf(" %s tran [-th num] [-it num] [-tc] [-bnum num] [-psiz num] [-pccap num]"
|
|
Packit |
807167 |
" [-rcd|-rcld|-rcdd] [-lv] rnum\n", g_progname);
|
|
Packit |
807167 |
eprintf("\n");
|
|
Packit |
807167 |
std::exit(1);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
|
|
Packit |
807167 |
|
|
Packit |
807167 |
// print the error message of a database
|
|
Packit |
807167 |
static void dberrprint(kc::BasicDB* db, int32_t line, const char* func) {
|
|
Packit |
807167 |
const kc::BasicDB::Error& err = db->error();
|
|
Packit |
807167 |
oprintf("%s: %d: %s: %s: %d: %s: %s\n",
|
|
Packit |
807167 |
g_progname, line, func, db->path().c_str(), err.code(), err.name(), err.message());
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
|
|
Packit |
807167 |
|
|
Packit |
807167 |
// print members of a database
|
|
Packit |
807167 |
static void dbmetaprint(kc::BasicDB* db, bool verbose) {
|
|
Packit |
807167 |
if (verbose) {
|
|
Packit |
807167 |
std::map<std::string, std::string> status;
|
|
Packit |
807167 |
status["opaque"] = "";
|
|
Packit |
807167 |
status["bnum_used"] = "";
|
|
Packit |
807167 |
status["cusage_lcnt"] = "";
|
|
Packit |
807167 |
status["cusage_lsiz"] = "";
|
|
Packit |
807167 |
status["cusage_icnt"] = "";
|
|
Packit |
807167 |
status["cusage_isiz"] = "";
|
|
Packit |
807167 |
status["tree_level"] = "";
|
|
Packit |
807167 |
if (db->status(&status)) {
|
|
Packit |
807167 |
uint32_t type = kc::atoi(status["type"].c_str());
|
|
Packit |
807167 |
oprintf("type: %s (%s) (type=0x%02X)\n",
|
|
Packit |
807167 |
kc::BasicDB::typecname(type), kc::BasicDB::typestring(type), type);
|
|
Packit |
807167 |
uint32_t chksum = kc::atoi(status["chksum"].c_str());
|
|
Packit |
807167 |
oprintf("format version: %s (libver=%s.%s) (chksum=0x%02X)\n", status["fmtver"].c_str(),
|
|
Packit |
807167 |
status["libver"].c_str(), status["librev"].c_str(), chksum);
|
|
Packit |
807167 |
oprintf("path: %s\n", status["path"].c_str());
|
|
Packit |
807167 |
int32_t flags = kc::atoi(status["flags"].c_str());
|
|
Packit |
807167 |
oprintf("status flags:");
|
|
Packit |
807167 |
if (flags & kc::GrassDB::FOPEN) oprintf(" open");
|
|
Packit |
807167 |
if (flags & kc::GrassDB::FFATAL) oprintf(" fatal");
|
|
Packit |
807167 |
oprintf(" (flags=%d)", flags);
|
|
Packit |
807167 |
if (kc::atoi(status["recovered"].c_str()) > 0) oprintf(" (recovered)");
|
|
Packit |
807167 |
if (kc::atoi(status["reorganized"].c_str()) > 0) oprintf(" (reorganized)");
|
|
Packit |
807167 |
if (kc::atoi(status["trimmed"].c_str()) > 0) oprintf(" (trimmed)");
|
|
Packit |
807167 |
oprintf("\n", flags);
|
|
Packit |
807167 |
int32_t opts = kc::atoi(status["opts"].c_str());
|
|
Packit |
807167 |
oprintf("options:");
|
|
Packit |
807167 |
if (opts & kc::GrassDB::TSMALL) oprintf(" small");
|
|
Packit |
807167 |
if (opts & kc::GrassDB::TLINEAR) oprintf(" linear");
|
|
Packit |
807167 |
if (opts & kc::GrassDB::TCOMPRESS) oprintf(" compress");
|
|
Packit |
807167 |
oprintf(" (opts=%d)\n", opts);
|
|
Packit |
807167 |
oprintf("comparator: %s\n", status["rcomp"].c_str());
|
|
Packit |
807167 |
if (status.find("opaque") != status.end()) {
|
|
Packit |
807167 |
const char* opaque = status["opaque"].c_str();
|
|
Packit |
807167 |
oprintf("opaque:");
|
|
Packit |
807167 |
if (std::count(opaque, opaque + 16, 0) != 16) {
|
|
Packit |
807167 |
for (int32_t i = 0; i < 16; i++) {
|
|
Packit |
807167 |
oprintf(" %02X", ((unsigned char*)opaque)[i]);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
oprintf(" 0");
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
oprintf("\n");
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
int64_t bnum = kc::atoi(status["bnum"].c_str());
|
|
Packit |
807167 |
int64_t bnumused = kc::atoi(status["bnum_used"].c_str());
|
|
Packit |
807167 |
int64_t count = kc::atoi(status["count"].c_str());
|
|
Packit |
807167 |
int64_t pnum = kc::atoi(status["pnum"].c_str());
|
|
Packit |
807167 |
int64_t lcnt = kc::atoi(status["lcnt"].c_str());
|
|
Packit |
807167 |
int64_t icnt = kc::atoi(status["icnt"].c_str());
|
|
Packit |
807167 |
int32_t tlevel = kc::atoi(status["tree_level"].c_str());
|
|
Packit |
807167 |
int32_t psiz = kc::atoi(status["psiz"].c_str());
|
|
Packit |
807167 |
double load = 0;
|
|
Packit |
807167 |
if (pnum > 0 && bnumused > 0) {
|
|
Packit |
807167 |
load = (double)pnum / bnumused;
|
|
Packit |
807167 |
if (!(opts & kc::GrassDB::TLINEAR)) load = std::log(load + 1) / std::log(2.0);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
oprintf("buckets: %lld (used=%lld) (load=%.2f)\n",
|
|
Packit |
807167 |
(long long)bnum, (long long)bnumused, load);
|
|
Packit |
807167 |
oprintf("pages: %lld (leaf=%lld) (inner=%lld) (level=%d) (psiz=%d)\n",
|
|
Packit |
807167 |
(long long)pnum, (long long)lcnt, (long long)icnt, tlevel, psiz);
|
|
Packit |
807167 |
int64_t pccap = kc::atoi(status["pccap"].c_str());
|
|
Packit |
807167 |
int64_t cusage = kc::atoi(status["cusage"].c_str());
|
|
Packit |
807167 |
int64_t culcnt = kc::atoi(status["cusage_lcnt"].c_str());
|
|
Packit |
807167 |
int64_t culsiz = kc::atoi(status["cusage_lsiz"].c_str());
|
|
Packit |
807167 |
int64_t cuicnt = kc::atoi(status["cusage_icnt"].c_str());
|
|
Packit |
807167 |
int64_t cuisiz = kc::atoi(status["cusage_isiz"].c_str());
|
|
Packit |
807167 |
oprintf("cache: %lld (cap=%lld) (ratio=%.2f) (leaf=%lld:%lld) (inner=%lld:%lld)\n",
|
|
Packit |
807167 |
(long long)cusage, (long long)pccap, (double)cusage / pccap,
|
|
Packit |
807167 |
(long long)culsiz, (long long)culcnt, (long long)cuisiz, (long long)cuicnt);
|
|
Packit |
807167 |
std::string cntstr = unitnumstr(count);
|
|
Packit |
807167 |
oprintf("count: %lld (%s)\n", count, cntstr.c_str());
|
|
Packit |
807167 |
int64_t size = kc::atoi(status["size"].c_str());
|
|
Packit |
807167 |
std::string sizestr = unitnumstrbyte(size);
|
|
Packit |
807167 |
oprintf("size: %lld (%s)\n", size, sizestr.c_str());
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
oprintf("count: %lld\n", (long long)db->count());
|
|
Packit |
807167 |
oprintf("size: %lld\n", (long long)db->size());
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
int64_t musage = memusage();
|
|
Packit |
807167 |
if (musage > 0) oprintf("memory: %lld\n", (long long)(musage - g_memusage));
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
|
|
Packit |
807167 |
|
|
Packit |
807167 |
// parse arguments of order command
|
|
Packit |
807167 |
static int32_t runorder(int argc, char** argv) {
|
|
Packit |
807167 |
bool argbrk = false;
|
|
Packit |
807167 |
const char* rstr = NULL;
|
|
Packit |
807167 |
int32_t thnum = 1;
|
|
Packit |
807167 |
bool rnd = false;
|
|
Packit |
807167 |
bool etc = false;
|
|
Packit |
807167 |
bool tran = false;
|
|
Packit |
807167 |
int32_t opts = 0;
|
|
Packit |
807167 |
int64_t bnum = -1;
|
|
Packit |
807167 |
int64_t psiz = -1;
|
|
Packit |
807167 |
int64_t pccap = 0;
|
|
Packit |
807167 |
kc::Comparator* rcomp = NULL;
|
|
Packit |
807167 |
bool lv = false;
|
|
Packit |
807167 |
for (int32_t i = 2; i < argc; i++) {
|
|
Packit |
807167 |
if (!argbrk && argv[i][0] == '-') {
|
|
Packit |
807167 |
if (!std::strcmp(argv[i], "--")) {
|
|
Packit |
807167 |
argbrk = true;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-th")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
thnum = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-rnd")) {
|
|
Packit |
807167 |
rnd = true;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-etc")) {
|
|
Packit |
807167 |
etc = true;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-tran")) {
|
|
Packit |
807167 |
tran = true;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-tc")) {
|
|
Packit |
807167 |
opts |= kc::CacheDB::TCOMPRESS;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-bnum")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
bnum = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-psiz")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
psiz = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-pccap")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
pccap = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-rcd")) {
|
|
Packit |
807167 |
rcomp = kc::DECIMALCOMP;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-rcld")) {
|
|
Packit |
807167 |
rcomp = kc::LEXICALDESCCOMP;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-rcdd")) {
|
|
Packit |
807167 |
rcomp = kc::DECIMALDESCCOMP;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-lv")) {
|
|
Packit |
807167 |
lv = true;
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
usage();
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else if (!rstr) {
|
|
Packit |
807167 |
argbrk = true;
|
|
Packit |
807167 |
rstr = argv[i];
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
usage();
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (!rstr) usage();
|
|
Packit |
807167 |
int64_t rnum = kc::atoix(rstr);
|
|
Packit |
807167 |
if (rnum < 1 || thnum < 1) usage();
|
|
Packit |
807167 |
if (thnum > THREADMAX) thnum = THREADMAX;
|
|
Packit |
807167 |
int32_t rv = procorder(rnum, thnum, rnd, etc, tran, opts, bnum, psiz, pccap, rcomp, lv);
|
|
Packit |
807167 |
return rv;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
|
|
Packit |
807167 |
|
|
Packit |
807167 |
// parse arguments of queue command
|
|
Packit |
807167 |
static int32_t runqueue(int argc, char** argv) {
|
|
Packit |
807167 |
bool argbrk = false;
|
|
Packit |
807167 |
const char* rstr = NULL;
|
|
Packit |
807167 |
int32_t thnum = 1;
|
|
Packit |
807167 |
int32_t itnum = 1;
|
|
Packit |
807167 |
bool rnd = false;
|
|
Packit |
807167 |
int32_t opts = 0;
|
|
Packit |
807167 |
int64_t bnum = -1;
|
|
Packit |
807167 |
int64_t psiz = -1;
|
|
Packit |
807167 |
int64_t pccap = 0;
|
|
Packit |
807167 |
kc::Comparator* rcomp = NULL;
|
|
Packit |
807167 |
bool lv = false;
|
|
Packit |
807167 |
for (int32_t i = 2; i < argc; i++) {
|
|
Packit |
807167 |
if (!argbrk && argv[i][0] == '-') {
|
|
Packit |
807167 |
if (!std::strcmp(argv[i], "--")) {
|
|
Packit |
807167 |
argbrk = true;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-th")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
thnum = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-it")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
itnum = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-rnd")) {
|
|
Packit |
807167 |
rnd = true;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-tc")) {
|
|
Packit |
807167 |
opts |= kc::CacheDB::TCOMPRESS;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-bnum")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
bnum = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-psiz")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
psiz = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-pccap")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
pccap = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-rcd")) {
|
|
Packit |
807167 |
rcomp = kc::DECIMALCOMP;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-rcld")) {
|
|
Packit |
807167 |
rcomp = kc::LEXICALDESCCOMP;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-rcdd")) {
|
|
Packit |
807167 |
rcomp = kc::DECIMALDESCCOMP;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-lv")) {
|
|
Packit |
807167 |
lv = true;
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
usage();
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else if (!rstr) {
|
|
Packit |
807167 |
argbrk = true;
|
|
Packit |
807167 |
rstr = argv[i];
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
usage();
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (!rstr) usage();
|
|
Packit |
807167 |
int64_t rnum = kc::atoix(rstr);
|
|
Packit |
807167 |
if (rnum < 1 || thnum < 1 || itnum < 1) usage();
|
|
Packit |
807167 |
if (thnum > THREADMAX) thnum = THREADMAX;
|
|
Packit |
807167 |
int32_t rv = procqueue(rnum, thnum, itnum, rnd, opts, bnum, psiz, pccap, rcomp, lv);
|
|
Packit |
807167 |
return rv;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
|
|
Packit |
807167 |
|
|
Packit |
807167 |
// parse arguments of wicked command
|
|
Packit |
807167 |
static int32_t runwicked(int argc, char** argv) {
|
|
Packit |
807167 |
bool argbrk = false;
|
|
Packit |
807167 |
const char* rstr = NULL;
|
|
Packit |
807167 |
int32_t thnum = 1;
|
|
Packit |
807167 |
int32_t itnum = 1;
|
|
Packit |
807167 |
int32_t opts = 0;
|
|
Packit |
807167 |
int64_t bnum = -1;
|
|
Packit |
807167 |
int64_t psiz = -1;
|
|
Packit |
807167 |
int64_t pccap = 0;
|
|
Packit |
807167 |
kc::Comparator* rcomp = NULL;
|
|
Packit |
807167 |
bool lv = false;
|
|
Packit |
807167 |
for (int32_t i = 2; i < argc; i++) {
|
|
Packit |
807167 |
if (!argbrk && argv[i][0] == '-') {
|
|
Packit |
807167 |
if (!std::strcmp(argv[i], "--")) {
|
|
Packit |
807167 |
argbrk = true;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-th")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
thnum = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-it")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
itnum = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-tc")) {
|
|
Packit |
807167 |
opts |= kc::CacheDB::TCOMPRESS;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-bnum")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
bnum = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-psiz")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
psiz = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-pccap")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
pccap = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-rcd")) {
|
|
Packit |
807167 |
rcomp = kc::DECIMALCOMP;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-rcld")) {
|
|
Packit |
807167 |
rcomp = kc::LEXICALDESCCOMP;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-rcdd")) {
|
|
Packit |
807167 |
rcomp = kc::DECIMALDESCCOMP;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-lv")) {
|
|
Packit |
807167 |
lv = true;
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
usage();
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else if (!rstr) {
|
|
Packit |
807167 |
argbrk = true;
|
|
Packit |
807167 |
rstr = argv[i];
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
usage();
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (!rstr) usage();
|
|
Packit |
807167 |
int64_t rnum = kc::atoix(rstr);
|
|
Packit |
807167 |
if (rnum < 1 || thnum < 1 || itnum < 1) usage();
|
|
Packit |
807167 |
if (thnum > THREADMAX) thnum = THREADMAX;
|
|
Packit |
807167 |
int32_t rv = procwicked(rnum, thnum, itnum, opts, bnum, psiz, pccap, rcomp, lv);
|
|
Packit |
807167 |
return rv;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
|
|
Packit |
807167 |
|
|
Packit |
807167 |
// parse arguments of tran command
|
|
Packit |
807167 |
static int32_t runtran(int argc, char** argv) {
|
|
Packit |
807167 |
bool argbrk = false;
|
|
Packit |
807167 |
const char* rstr = NULL;
|
|
Packit |
807167 |
int32_t thnum = 1;
|
|
Packit |
807167 |
int32_t itnum = 1;
|
|
Packit |
807167 |
int32_t opts = 0;
|
|
Packit |
807167 |
int64_t bnum = -1;
|
|
Packit |
807167 |
int64_t psiz = -1;
|
|
Packit |
807167 |
int64_t pccap = 0;
|
|
Packit |
807167 |
kc::Comparator* rcomp = NULL;
|
|
Packit |
807167 |
bool lv = false;
|
|
Packit |
807167 |
for (int32_t i = 2; i < argc; i++) {
|
|
Packit |
807167 |
if (!argbrk && argv[i][0] == '-') {
|
|
Packit |
807167 |
if (!std::strcmp(argv[i], "--")) {
|
|
Packit |
807167 |
argbrk = true;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-th")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
thnum = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-it")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
itnum = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-tc")) {
|
|
Packit |
807167 |
opts |= kc::CacheDB::TCOMPRESS;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-bnum")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
bnum = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-psiz")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
psiz = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-pccap")) {
|
|
Packit |
807167 |
if (++i >= argc) usage();
|
|
Packit |
807167 |
pccap = kc::atoix(argv[i]);
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-rcd")) {
|
|
Packit |
807167 |
rcomp = kc::DECIMALCOMP;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-rcld")) {
|
|
Packit |
807167 |
rcomp = kc::LEXICALDESCCOMP;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-rcdd")) {
|
|
Packit |
807167 |
rcomp = kc::DECIMALDESCCOMP;
|
|
Packit |
807167 |
} else if (!std::strcmp(argv[i], "-lv")) {
|
|
Packit |
807167 |
lv = true;
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
usage();
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else if (!rstr) {
|
|
Packit |
807167 |
argbrk = true;
|
|
Packit |
807167 |
rstr = argv[i];
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
usage();
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (!rstr) usage();
|
|
Packit |
807167 |
int64_t rnum = kc::atoix(rstr);
|
|
Packit |
807167 |
if (rnum < 1 || thnum < 1 || itnum < 1) usage();
|
|
Packit |
807167 |
if (thnum > THREADMAX) thnum = THREADMAX;
|
|
Packit |
807167 |
int32_t rv = proctran(rnum, thnum, itnum, opts, bnum, psiz, pccap, rcomp, lv);
|
|
Packit |
807167 |
return rv;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
|
|
Packit |
807167 |
|
|
Packit |
807167 |
// perform order command
|
|
Packit |
807167 |
static int32_t procorder(int64_t rnum, int32_t thnum, bool rnd, bool etc, bool tran,
|
|
Packit |
807167 |
int32_t opts, int64_t bnum, int32_t psiz, int64_t pccap,
|
|
Packit |
807167 |
kc::Comparator* rcomp, bool lv) {
|
|
Packit |
807167 |
oprintf("<In-order Test>\n seed=%u rnum=%lld thnum=%d rnd=%d etc=%d tran=%d"
|
|
Packit |
807167 |
" opts=%d bnum=%lld psiz=%d pccap=%lld rcomp=%p lv=%d\n\n",
|
|
Packit |
807167 |
g_randseed, (long long)rnum, thnum, rnd, etc, tran,
|
|
Packit |
807167 |
opts, (long long)bnum, psiz, (long long)pccap, rcomp, lv);
|
|
Packit |
807167 |
bool err = false;
|
|
Packit |
807167 |
kc::GrassDB db;
|
|
Packit |
807167 |
oprintf("opening the database:\n");
|
|
Packit |
807167 |
double stime = kc::time();
|
|
Packit |
807167 |
db.tune_logger(stdlogger(g_progname, &std::cout),
|
|
Packit |
807167 |
lv ? kc::UINT32MAX : kc::BasicDB::Logger::WARN | kc::BasicDB::Logger::ERROR);
|
|
Packit |
807167 |
if (opts > 0) db.tune_options(opts);
|
|
Packit |
807167 |
if (bnum > 0) db.tune_buckets(bnum);
|
|
Packit |
807167 |
if (psiz > 0) db.tune_page(psiz);
|
|
Packit |
807167 |
if (pccap > 0) db.tune_page_cache(pccap);
|
|
Packit |
807167 |
if (rcomp) db.tune_comparator(rcomp);
|
|
Packit |
807167 |
if (!db.open("%", kc::GrassDB::OWRITER | kc::GrassDB::OCREATE | kc::GrassDB::OTRUNCATE)) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::open");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
double etime = kc::time();
|
|
Packit |
807167 |
dbmetaprint(&db, false);
|
|
Packit |
807167 |
oprintf("time: %.3f\n", etime - stime);
|
|
Packit |
807167 |
oprintf("setting records:\n");
|
|
Packit |
807167 |
stime = kc::time();
|
|
Packit |
807167 |
class ThreadSet : public kc::Thread {
|
|
Packit |
807167 |
public:
|
|
Packit |
807167 |
void setparams(int32_t id, kc::BasicDB* db, int64_t rnum, int32_t thnum,
|
|
Packit |
807167 |
bool rnd, bool tran) {
|
|
Packit |
807167 |
id_ = id;
|
|
Packit |
807167 |
db_ = db;
|
|
Packit |
807167 |
rnum_ = rnum;
|
|
Packit |
807167 |
thnum_ = thnum;
|
|
Packit |
807167 |
err_ = false;
|
|
Packit |
807167 |
rnd_ = rnd;
|
|
Packit |
807167 |
tran_ = tran;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
bool error() {
|
|
Packit |
807167 |
return err_;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
void run() {
|
|
Packit |
807167 |
int64_t base = id_ * rnum_;
|
|
Packit |
807167 |
int64_t range = rnum_ * thnum_;
|
|
Packit |
807167 |
for (int64_t i = 1; !err_ && i <= rnum_; i++) {
|
|
Packit |
807167 |
if (tran_ && !db_->begin_transaction(false)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::begin_transaction");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
char kbuf[RECBUFSIZ];
|
|
Packit |
807167 |
size_t ksiz = std::sprintf(kbuf, "%08lld",
|
|
Packit |
807167 |
(long long)(rnd_ ? myrand(range) + 1 : base + i));
|
|
Packit |
807167 |
if (!db_->set(kbuf, ksiz, kbuf, ksiz)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::set");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (rnd_ && i % 8 == 0) {
|
|
Packit |
807167 |
switch (myrand(8)) {
|
|
Packit |
807167 |
case 0: {
|
|
Packit |
807167 |
if (!db_->set(kbuf, ksiz, kbuf, ksiz)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::set");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 1: {
|
|
Packit |
807167 |
if (!db_->append(kbuf, ksiz, kbuf, ksiz)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::append");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 2: {
|
|
Packit |
807167 |
if (!db_->remove(kbuf, ksiz) && db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::remove");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 3: {
|
|
Packit |
807167 |
kc::DB::Cursor* cur = db_->cursor();
|
|
Packit |
807167 |
if (cur->jump(kbuf, ksiz)) {
|
|
Packit |
807167 |
switch (myrand(8)) {
|
|
Packit |
807167 |
default: {
|
|
Packit |
807167 |
size_t rsiz;
|
|
Packit |
807167 |
char* rbuf = cur->get_key(&rsiz, myrand(10) == 0);
|
|
Packit |
807167 |
if (rbuf) {
|
|
Packit |
807167 |
delete[] rbuf;
|
|
Packit |
807167 |
} else if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::get_key");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 1: {
|
|
Packit |
807167 |
size_t rsiz;
|
|
Packit |
807167 |
char* rbuf = cur->get_value(&rsiz, myrand(10) == 0);
|
|
Packit |
807167 |
if (rbuf) {
|
|
Packit |
807167 |
delete[] rbuf;
|
|
Packit |
807167 |
} else if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::get_value");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 2: {
|
|
Packit |
807167 |
size_t rksiz;
|
|
Packit |
807167 |
const char* rvbuf;
|
|
Packit |
807167 |
size_t rvsiz;
|
|
Packit |
807167 |
char* rkbuf = cur->get(&rksiz, &rvbuf, &rvsiz, myrand(10) == 0);
|
|
Packit |
807167 |
if (rkbuf) {
|
|
Packit |
807167 |
delete[] rkbuf;
|
|
Packit |
807167 |
} else if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::get");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 3: {
|
|
Packit |
807167 |
std::string key, value;
|
|
Packit |
807167 |
if (!cur->get(&key, &value, myrand(10) == 0) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::get");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 4: {
|
|
Packit |
807167 |
if (myrand(8) == 0 && !cur->remove() &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::remove");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::jump");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
delete cur;
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
default: {
|
|
Packit |
807167 |
size_t vsiz;
|
|
Packit |
807167 |
char* vbuf = db_->get(kbuf, ksiz, &vsiz);
|
|
Packit |
807167 |
if (vbuf) {
|
|
Packit |
807167 |
delete[] vbuf;
|
|
Packit |
807167 |
} else if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::get");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (tran_ && !db_->end_transaction(true)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::end_transaction");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (id_ < 1 && rnum_ > 250 && i % (rnum_ / 250) == 0) {
|
|
Packit |
807167 |
oputchar('.');
|
|
Packit |
807167 |
if (i == rnum_ || i % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)i);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
private:
|
|
Packit |
807167 |
int32_t id_;
|
|
Packit |
807167 |
kc::BasicDB* db_;
|
|
Packit |
807167 |
int64_t rnum_;
|
|
Packit |
807167 |
int32_t thnum_;
|
|
Packit |
807167 |
bool err_;
|
|
Packit |
807167 |
bool rnd_;
|
|
Packit |
807167 |
bool tran_;
|
|
Packit |
807167 |
};
|
|
Packit |
807167 |
ThreadSet threadsets[THREADMAX];
|
|
Packit |
807167 |
if (thnum < 2) {
|
|
Packit |
807167 |
threadsets[0].setparams(0, &db, rnum, thnum, rnd, tran);
|
|
Packit |
807167 |
threadsets[0].run();
|
|
Packit |
807167 |
if (threadsets[0].error()) err = true;
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
for (int32_t i = 0; i < thnum; i++) {
|
|
Packit |
807167 |
threadsets[i].setparams(i, &db, rnum, thnum, rnd, tran);
|
|
Packit |
807167 |
threadsets[i].start();
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
for (int32_t i = 0; i < thnum; i++) {
|
|
Packit |
807167 |
threadsets[i].join();
|
|
Packit |
807167 |
if (threadsets[i].error()) err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
etime = kc::time();
|
|
Packit |
807167 |
dbmetaprint(&db, false);
|
|
Packit |
807167 |
oprintf("time: %.3f\n", etime - stime);
|
|
Packit |
807167 |
if (etc) {
|
|
Packit |
807167 |
oprintf("adding records:\n");
|
|
Packit |
807167 |
stime = kc::time();
|
|
Packit |
807167 |
class ThreadAdd : public kc::Thread {
|
|
Packit |
807167 |
public:
|
|
Packit |
807167 |
void setparams(int32_t id, kc::BasicDB* db, int64_t rnum, int32_t thnum,
|
|
Packit |
807167 |
bool rnd, bool tran) {
|
|
Packit |
807167 |
id_ = id;
|
|
Packit |
807167 |
db_ = db;
|
|
Packit |
807167 |
rnum_ = rnum;
|
|
Packit |
807167 |
thnum_ = thnum;
|
|
Packit |
807167 |
err_ = false;
|
|
Packit |
807167 |
rnd_ = rnd;
|
|
Packit |
807167 |
tran_ = tran;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
bool error() {
|
|
Packit |
807167 |
return err_;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
void run() {
|
|
Packit |
807167 |
int64_t base = id_ * rnum_;
|
|
Packit |
807167 |
int64_t range = rnum_ * thnum_;
|
|
Packit |
807167 |
for (int64_t i = 1; !err_ && i <= rnum_; i++) {
|
|
Packit |
807167 |
if (tran_ && !db_->begin_transaction(false)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::begin_transaction");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
char kbuf[RECBUFSIZ];
|
|
Packit |
807167 |
size_t ksiz = std::sprintf(kbuf, "%08lld",
|
|
Packit |
807167 |
(long long)(rnd_ ? myrand(range) + 1 : base + i));
|
|
Packit |
807167 |
if (!db_->add(kbuf, ksiz, kbuf, ksiz) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::DUPREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::add");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (tran_ && !db_->end_transaction(true)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::end_transaction");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (id_ < 1 && rnum_ > 250 && i % (rnum_ / 250) == 0) {
|
|
Packit |
807167 |
oputchar('.');
|
|
Packit |
807167 |
if (i == rnum_ || i % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)i);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
private:
|
|
Packit |
807167 |
int32_t id_;
|
|
Packit |
807167 |
kc::BasicDB* db_;
|
|
Packit |
807167 |
int64_t rnum_;
|
|
Packit |
807167 |
int32_t thnum_;
|
|
Packit |
807167 |
bool err_;
|
|
Packit |
807167 |
bool rnd_;
|
|
Packit |
807167 |
bool tran_;
|
|
Packit |
807167 |
};
|
|
Packit |
807167 |
ThreadAdd threadadds[THREADMAX];
|
|
Packit |
807167 |
if (thnum < 2) {
|
|
Packit |
807167 |
threadadds[0].setparams(0, &db, rnum, thnum, rnd, tran);
|
|
Packit |
807167 |
threadadds[0].run();
|
|
Packit |
807167 |
if (threadadds[0].error()) err = true;
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
for (int32_t i = 0; i < thnum; i++) {
|
|
Packit |
807167 |
threadadds[i].setparams(i, &db, rnum, thnum, rnd, tran);
|
|
Packit |
807167 |
threadadds[i].start();
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
for (int32_t i = 0; i < thnum; i++) {
|
|
Packit |
807167 |
threadadds[i].join();
|
|
Packit |
807167 |
if (threadadds[i].error()) err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
etime = kc::time();
|
|
Packit |
807167 |
dbmetaprint(&db, false);
|
|
Packit |
807167 |
oprintf("time: %.3f\n", etime - stime);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (etc) {
|
|
Packit |
807167 |
oprintf("appending records:\n");
|
|
Packit |
807167 |
stime = kc::time();
|
|
Packit |
807167 |
class ThreadAppend : public kc::Thread {
|
|
Packit |
807167 |
public:
|
|
Packit |
807167 |
void setparams(int32_t id, kc::BasicDB* db, int64_t rnum, int32_t thnum,
|
|
Packit |
807167 |
bool rnd, bool tran) {
|
|
Packit |
807167 |
id_ = id;
|
|
Packit |
807167 |
db_ = db;
|
|
Packit |
807167 |
rnum_ = rnum;
|
|
Packit |
807167 |
thnum_ = thnum;
|
|
Packit |
807167 |
err_ = false;
|
|
Packit |
807167 |
rnd_ = rnd;
|
|
Packit |
807167 |
tran_ = tran;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
bool error() {
|
|
Packit |
807167 |
return err_;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
void run() {
|
|
Packit |
807167 |
int64_t base = id_ * rnum_;
|
|
Packit |
807167 |
int64_t range = rnum_ * thnum_;
|
|
Packit |
807167 |
for (int64_t i = 1; !err_ && i <= rnum_; i++) {
|
|
Packit |
807167 |
if (tran_ && !db_->begin_transaction(false)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::begin_transaction");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
char kbuf[RECBUFSIZ];
|
|
Packit |
807167 |
size_t ksiz = std::sprintf(kbuf, "%08lld",
|
|
Packit |
807167 |
(long long)(rnd_ ? myrand(range) + 1 : base + i));
|
|
Packit |
807167 |
if (!db_->append(kbuf, ksiz, kbuf, ksiz)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::append");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (tran_ && !db_->end_transaction(true)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::end_transaction");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (id_ < 1 && rnum_ > 250 && i % (rnum_ / 250) == 0) {
|
|
Packit |
807167 |
oputchar('.');
|
|
Packit |
807167 |
if (i == rnum_ || i % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)i);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
private:
|
|
Packit |
807167 |
int32_t id_;
|
|
Packit |
807167 |
kc::BasicDB* db_;
|
|
Packit |
807167 |
int64_t rnum_;
|
|
Packit |
807167 |
int32_t thnum_;
|
|
Packit |
807167 |
bool err_;
|
|
Packit |
807167 |
bool rnd_;
|
|
Packit |
807167 |
bool tran_;
|
|
Packit |
807167 |
};
|
|
Packit |
807167 |
ThreadAppend threadappends[THREADMAX];
|
|
Packit |
807167 |
if (thnum < 2) {
|
|
Packit |
807167 |
threadappends[0].setparams(0, &db, rnum, thnum, rnd, tran);
|
|
Packit |
807167 |
threadappends[0].run();
|
|
Packit |
807167 |
if (threadappends[0].error()) err = true;
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
for (int32_t i = 0; i < thnum; i++) {
|
|
Packit |
807167 |
threadappends[i].setparams(i, &db, rnum, thnum, rnd, tran);
|
|
Packit |
807167 |
threadappends[i].start();
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
for (int32_t i = 0; i < thnum; i++) {
|
|
Packit |
807167 |
threadappends[i].join();
|
|
Packit |
807167 |
if (threadappends[i].error()) err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
etime = kc::time();
|
|
Packit |
807167 |
dbmetaprint(&db, false);
|
|
Packit |
807167 |
oprintf("time: %.3f\n", etime - stime);
|
|
Packit |
807167 |
char* opaque = db.opaque();
|
|
Packit |
807167 |
if (opaque) {
|
|
Packit |
807167 |
std::memcpy(opaque, "1234567890123456", 16);
|
|
Packit |
807167 |
if (!db.synchronize_opaque()) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::synchronize_opaque");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::opaque");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
oprintf("getting records:\n");
|
|
Packit |
807167 |
stime = kc::time();
|
|
Packit |
807167 |
class ThreadGet : public kc::Thread {
|
|
Packit |
807167 |
public:
|
|
Packit |
807167 |
void setparams(int32_t id, kc::BasicDB* db, int64_t rnum, int32_t thnum,
|
|
Packit |
807167 |
bool rnd, bool tran) {
|
|
Packit |
807167 |
id_ = id;
|
|
Packit |
807167 |
db_ = db;
|
|
Packit |
807167 |
rnum_ = rnum;
|
|
Packit |
807167 |
thnum_ = thnum;
|
|
Packit |
807167 |
err_ = false;
|
|
Packit |
807167 |
rnd_ = rnd;
|
|
Packit |
807167 |
tran_ = tran;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
bool error() {
|
|
Packit |
807167 |
return err_;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
void run() {
|
|
Packit |
807167 |
int64_t base = id_ * rnum_;
|
|
Packit |
807167 |
int64_t range = rnum_ * thnum_;
|
|
Packit |
807167 |
for (int64_t i = 1; !err_ && i <= rnum_; i++) {
|
|
Packit |
807167 |
if (tran_ && !db_->begin_transaction(false)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::begin_transaction");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
char kbuf[RECBUFSIZ];
|
|
Packit |
807167 |
size_t ksiz = std::sprintf(kbuf, "%08lld",
|
|
Packit |
807167 |
(long long)(rnd_ ? myrand(range) + 1 : base + i));
|
|
Packit |
807167 |
size_t vsiz;
|
|
Packit |
807167 |
char* vbuf = db_->get(kbuf, ksiz, &vsiz);
|
|
Packit |
807167 |
if (vbuf) {
|
|
Packit |
807167 |
if (vsiz < ksiz || std::memcmp(vbuf, kbuf, ksiz)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::get");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
delete[] vbuf;
|
|
Packit |
807167 |
} else if (!rnd_ || db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::get");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (rnd_ && i % 8 == 0) {
|
|
Packit |
807167 |
switch (myrand(8)) {
|
|
Packit |
807167 |
case 0: {
|
|
Packit |
807167 |
if (!db_->set(kbuf, ksiz, kbuf, ksiz)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::set");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 1: {
|
|
Packit |
807167 |
if (!db_->append(kbuf, ksiz, kbuf, ksiz)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::append");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 2: {
|
|
Packit |
807167 |
if (!db_->remove(kbuf, ksiz) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::remove");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 3: {
|
|
Packit |
807167 |
kc::DB::Cursor* cur = db_->cursor();
|
|
Packit |
807167 |
if (cur->jump(kbuf, ksiz)) {
|
|
Packit |
807167 |
switch (myrand(8)) {
|
|
Packit |
807167 |
default: {
|
|
Packit |
807167 |
size_t rsiz;
|
|
Packit |
807167 |
char* rbuf = cur->get_key(&rsiz, myrand(10) == 0);
|
|
Packit |
807167 |
if (rbuf) {
|
|
Packit |
807167 |
delete[] rbuf;
|
|
Packit |
807167 |
} else if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::get_key");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 1: {
|
|
Packit |
807167 |
size_t rsiz;
|
|
Packit |
807167 |
char* rbuf = cur->get_value(&rsiz, myrand(10) == 0);
|
|
Packit |
807167 |
if (rbuf) {
|
|
Packit |
807167 |
delete[] rbuf;
|
|
Packit |
807167 |
} else if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::get_value");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 2: {
|
|
Packit |
807167 |
size_t rksiz;
|
|
Packit |
807167 |
const char* rvbuf;
|
|
Packit |
807167 |
size_t rvsiz;
|
|
Packit |
807167 |
char* rkbuf = cur->get(&rksiz, &rvbuf, &rvsiz, myrand(10) == 0);
|
|
Packit |
807167 |
if (rkbuf) {
|
|
Packit |
807167 |
delete[] rkbuf;
|
|
Packit |
807167 |
} else if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::get");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 3: {
|
|
Packit |
807167 |
std::string key, value;
|
|
Packit |
807167 |
if (!cur->get(&key, &value, myrand(10) == 0) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::get");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 4: {
|
|
Packit |
807167 |
if (myrand(8) == 0 && !cur->remove() &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::remove");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::jump");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
delete cur;
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
default: {
|
|
Packit |
807167 |
size_t vsiz;
|
|
Packit |
807167 |
char* vbuf = db_->get(kbuf, ksiz, &vsiz);
|
|
Packit |
807167 |
if (vbuf) {
|
|
Packit |
807167 |
delete[] vbuf;
|
|
Packit |
807167 |
} else if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::get");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (tran_ && !db_->end_transaction(true)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::end_transaction");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (id_ < 1 && rnum_ > 250 && i % (rnum_ / 250) == 0) {
|
|
Packit |
807167 |
oputchar('.');
|
|
Packit |
807167 |
if (i == rnum_ || i % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)i);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
private:
|
|
Packit |
807167 |
int32_t id_;
|
|
Packit |
807167 |
kc::BasicDB* db_;
|
|
Packit |
807167 |
int64_t rnum_;
|
|
Packit |
807167 |
int32_t thnum_;
|
|
Packit |
807167 |
bool err_;
|
|
Packit |
807167 |
bool rnd_;
|
|
Packit |
807167 |
bool tran_;
|
|
Packit |
807167 |
};
|
|
Packit |
807167 |
ThreadGet threadgets[THREADMAX];
|
|
Packit |
807167 |
if (thnum < 2) {
|
|
Packit |
807167 |
threadgets[0].setparams(0, &db, rnum, thnum, rnd, tran);
|
|
Packit |
807167 |
threadgets[0].run();
|
|
Packit |
807167 |
if (threadgets[0].error()) err = true;
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
for (int32_t i = 0; i < thnum; i++) {
|
|
Packit |
807167 |
threadgets[i].setparams(i, &db, rnum, thnum, rnd, tran);
|
|
Packit |
807167 |
threadgets[i].start();
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
for (int32_t i = 0; i < thnum; i++) {
|
|
Packit |
807167 |
threadgets[i].join();
|
|
Packit |
807167 |
if (threadgets[i].error()) err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
etime = kc::time();
|
|
Packit |
807167 |
dbmetaprint(&db, false);
|
|
Packit |
807167 |
oprintf("time: %.3f\n", etime - stime);
|
|
Packit |
807167 |
if (etc) {
|
|
Packit |
807167 |
oprintf("getting records with a buffer:\n");
|
|
Packit |
807167 |
stime = kc::time();
|
|
Packit |
807167 |
class ThreadGetBuffer : public kc::Thread {
|
|
Packit |
807167 |
public:
|
|
Packit |
807167 |
void setparams(int32_t id, kc::BasicDB* db, int64_t rnum, int32_t thnum,
|
|
Packit |
807167 |
bool rnd, bool tran) {
|
|
Packit |
807167 |
id_ = id;
|
|
Packit |
807167 |
db_ = db;
|
|
Packit |
807167 |
rnum_ = rnum;
|
|
Packit |
807167 |
thnum_ = thnum;
|
|
Packit |
807167 |
err_ = false;
|
|
Packit |
807167 |
rnd_ = rnd;
|
|
Packit |
807167 |
tran_ = tran;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
bool error() {
|
|
Packit |
807167 |
return err_;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
void run() {
|
|
Packit |
807167 |
int64_t base = id_ * rnum_;
|
|
Packit |
807167 |
int64_t range = rnum_ * thnum_;
|
|
Packit |
807167 |
for (int64_t i = 1; !err_ && i <= rnum_; i++) {
|
|
Packit |
807167 |
if (tran_ && !db_->begin_transaction(false)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::begin_transaction");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
char kbuf[RECBUFSIZ];
|
|
Packit |
807167 |
size_t ksiz = std::sprintf(kbuf, "%08lld",
|
|
Packit |
807167 |
(long long)(rnd_ ? myrand(range) + 1 : base + i));
|
|
Packit |
807167 |
char vbuf[RECBUFSIZ];
|
|
Packit |
807167 |
int32_t vsiz = db_->get(kbuf, ksiz, vbuf, sizeof(vbuf));
|
|
Packit |
807167 |
if (vsiz >= 0) {
|
|
Packit |
807167 |
if (vsiz < (int32_t)ksiz || std::memcmp(vbuf, kbuf, ksiz)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::get");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else if (!rnd_ || db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::get");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (tran_ && !db_->end_transaction(true)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::end_transaction");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (id_ < 1 && rnum_ > 250 && i % (rnum_ / 250) == 0) {
|
|
Packit |
807167 |
oputchar('.');
|
|
Packit |
807167 |
if (i == rnum_ || i % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)i);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
private:
|
|
Packit |
807167 |
int32_t id_;
|
|
Packit |
807167 |
kc::BasicDB* db_;
|
|
Packit |
807167 |
int64_t rnum_;
|
|
Packit |
807167 |
int32_t thnum_;
|
|
Packit |
807167 |
bool err_;
|
|
Packit |
807167 |
bool rnd_;
|
|
Packit |
807167 |
bool tran_;
|
|
Packit |
807167 |
};
|
|
Packit |
807167 |
ThreadGetBuffer threadgetbuffers[THREADMAX];
|
|
Packit |
807167 |
if (thnum < 2) {
|
|
Packit |
807167 |
threadgetbuffers[0].setparams(0, &db, rnum, thnum, rnd, tran);
|
|
Packit |
807167 |
threadgetbuffers[0].run();
|
|
Packit |
807167 |
if (threadgetbuffers[0].error()) err = true;
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
for (int32_t i = 0; i < thnum; i++) {
|
|
Packit |
807167 |
threadgetbuffers[i].setparams(i, &db, rnum, thnum, rnd, tran);
|
|
Packit |
807167 |
threadgetbuffers[i].start();
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
for (int32_t i = 0; i < thnum; i++) {
|
|
Packit |
807167 |
threadgetbuffers[i].join();
|
|
Packit |
807167 |
if (threadgetbuffers[i].error()) err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
etime = kc::time();
|
|
Packit |
807167 |
dbmetaprint(&db, false);
|
|
Packit |
807167 |
oprintf("time: %.3f\n", etime - stime);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (etc) {
|
|
Packit |
807167 |
oprintf("traversing the database by the inner iterator:\n");
|
|
Packit |
807167 |
stime = kc::time();
|
|
Packit |
807167 |
int64_t cnt = db.count();
|
|
Packit |
807167 |
class VisitorIterator : public kc::DB::Visitor {
|
|
Packit |
807167 |
public:
|
|
Packit |
807167 |
explicit VisitorIterator(int64_t rnum, bool rnd) :
|
|
Packit |
807167 |
rnum_(rnum), rnd_(rnd), cnt_(0), rbuf_() {
|
|
Packit |
807167 |
std::memset(rbuf_, '+', sizeof(rbuf_));
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
int64_t cnt() {
|
|
Packit |
807167 |
return cnt_;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
private:
|
|
Packit |
807167 |
const char* visit_full(const char* kbuf, size_t ksiz,
|
|
Packit |
807167 |
const char* vbuf, size_t vsiz, size_t* sp) {
|
|
Packit |
807167 |
cnt_++;
|
|
Packit |
807167 |
const char* rv = NOP;
|
|
Packit |
807167 |
switch (rnd_ ? myrand(7) : cnt_ % 7) {
|
|
Packit |
807167 |
case 0: {
|
|
Packit |
807167 |
rv = rbuf_;
|
|
Packit |
807167 |
*sp = rnd_ ? myrand(sizeof(rbuf_)) : sizeof(rbuf_) / (cnt_ % 5 + 1);
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 1: {
|
|
Packit |
807167 |
rv = REMOVE;
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (rnum_ > 250 && cnt_ % (rnum_ / 250) == 0) {
|
|
Packit |
807167 |
oputchar('.');
|
|
Packit |
807167 |
if (cnt_ == rnum_ || cnt_ % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)cnt_);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
return rv;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
int64_t rnum_;
|
|
Packit |
807167 |
bool rnd_;
|
|
Packit |
807167 |
int64_t cnt_;
|
|
Packit |
807167 |
char rbuf_[RECBUFSIZ];
|
|
Packit |
807167 |
} visitoriterator(rnum, rnd);
|
|
Packit |
807167 |
if (tran && !db.begin_transaction(false)) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::begin_transaction");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (!db.iterate(&visitoriterator, true)) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::iterate");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (rnd) oprintf(" (end)\n");
|
|
Packit |
807167 |
if (tran && !db.end_transaction(true)) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::end_transaction");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (visitoriterator.cnt() != cnt) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::iterate");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
etime = kc::time();
|
|
Packit |
807167 |
dbmetaprint(&db, false);
|
|
Packit |
807167 |
oprintf("time: %.3f\n", etime - stime);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (etc) {
|
|
Packit |
807167 |
oprintf("traversing the database by the outer cursor:\n");
|
|
Packit |
807167 |
stime = kc::time();
|
|
Packit |
807167 |
int64_t cnt = db.count();
|
|
Packit |
807167 |
class VisitorCursor : public kc::DB::Visitor {
|
|
Packit |
807167 |
public:
|
|
Packit |
807167 |
explicit VisitorCursor(int64_t rnum, bool rnd) :
|
|
Packit |
807167 |
rnum_(rnum), rnd_(rnd), cnt_(0), rbuf_() {
|
|
Packit |
807167 |
std::memset(rbuf_, '-', sizeof(rbuf_));
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
int64_t cnt() {
|
|
Packit |
807167 |
return cnt_;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
private:
|
|
Packit |
807167 |
const char* visit_full(const char* kbuf, size_t ksiz,
|
|
Packit |
807167 |
const char* vbuf, size_t vsiz, size_t* sp) {
|
|
Packit |
807167 |
cnt_++;
|
|
Packit |
807167 |
const char* rv = NOP;
|
|
Packit |
807167 |
switch (rnd_ ? myrand(7) : cnt_ % 7) {
|
|
Packit |
807167 |
case 0: {
|
|
Packit |
807167 |
rv = rbuf_;
|
|
Packit |
807167 |
*sp = rnd_ ? myrand(sizeof(rbuf_)) : sizeof(rbuf_) / (cnt_ % 5 + 1);
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 1: {
|
|
Packit |
807167 |
rv = REMOVE;
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (rnum_ > 250 && cnt_ % (rnum_ / 250) == 0) {
|
|
Packit |
807167 |
oputchar('.');
|
|
Packit |
807167 |
if (cnt_ == rnum_ || cnt_ % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)cnt_);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
return rv;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
int64_t rnum_;
|
|
Packit |
807167 |
bool rnd_;
|
|
Packit |
807167 |
int64_t cnt_;
|
|
Packit |
807167 |
char rbuf_[RECBUFSIZ];
|
|
Packit |
807167 |
} visitorcursor(rnum, rnd);
|
|
Packit |
807167 |
if (tran && !db.begin_transaction(false)) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::begin_transaction");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
kc::GrassDB::Cursor cur(&db);
|
|
Packit |
807167 |
if (!cur.jump() && db.error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "Cursor::jump");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
kc::DB::Cursor* paracur = db.cursor();
|
|
Packit |
807167 |
int64_t range = rnum * thnum;
|
|
Packit |
807167 |
while (!err && cur.accept(&visitorcursor, true, !rnd)) {
|
|
Packit |
807167 |
if (rnd) {
|
|
Packit |
807167 |
char kbuf[RECBUFSIZ];
|
|
Packit |
807167 |
size_t ksiz = std::sprintf(kbuf, "%08lld", (long long)myrand(range));
|
|
Packit |
807167 |
switch (myrand(3)) {
|
|
Packit |
807167 |
case 0: {
|
|
Packit |
807167 |
if (!db.remove(kbuf, ksiz) && db.error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::remove");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 1: {
|
|
Packit |
807167 |
if (!paracur->jump(kbuf, ksiz) && db.error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "Cursor::jump");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
default: {
|
|
Packit |
807167 |
if (!cur.step() && db.error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "Cursor::step");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (db.error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "Cursor::accept");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
oprintf(" (end)\n");
|
|
Packit |
807167 |
delete paracur;
|
|
Packit |
807167 |
if (tran && !db.end_transaction(true)) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::end_transaction");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (!rnd && visitorcursor.cnt() != cnt) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "Cursor::accept");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
etime = kc::time();
|
|
Packit |
807167 |
dbmetaprint(&db, false);
|
|
Packit |
807167 |
oprintf("time: %.3f\n", etime - stime);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (etc) {
|
|
Packit |
807167 |
oprintf("synchronizing the database:\n");
|
|
Packit |
807167 |
stime = kc::time();
|
|
Packit |
807167 |
if (!db.synchronize(false, NULL)) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::synchronize");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
class SyncProcessor : public kc::BasicDB::FileProcessor {
|
|
Packit |
807167 |
public:
|
|
Packit |
807167 |
explicit SyncProcessor(int64_t rnum, bool rnd, int64_t size) :
|
|
Packit |
807167 |
rnum_(rnum), rnd_(rnd), size_(size) {}
|
|
Packit |
807167 |
private:
|
|
Packit |
807167 |
bool process(const std::string& path, int64_t count, int64_t size) {
|
|
Packit |
807167 |
if (size != size_) return false;
|
|
Packit |
807167 |
return true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
int64_t rnum_;
|
|
Packit |
807167 |
bool rnd_;
|
|
Packit |
807167 |
int64_t size_;
|
|
Packit |
807167 |
} syncprocessor(rnum, rnd, db.size());
|
|
Packit |
807167 |
if (!db.synchronize(false, &syncprocessor)) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::synchronize");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (!db.occupy(rnd ? myrand(2) == 0 : true, &syncprocessor)) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::occupy");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
etime = kc::time();
|
|
Packit |
807167 |
dbmetaprint(&db, false);
|
|
Packit |
807167 |
oprintf("time: %.3f\n", etime - stime);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (etc && db.size() < (256LL << 20)) {
|
|
Packit |
807167 |
oprintf("dumping records into snapshot:\n");
|
|
Packit |
807167 |
stime = kc::time();
|
|
Packit |
807167 |
std::ostringstream ostrm;
|
|
Packit |
807167 |
if (!db.dump_snapshot(&ostrm)) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::dump_snapshot");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
etime = kc::time();
|
|
Packit |
807167 |
dbmetaprint(&db, false);
|
|
Packit |
807167 |
oprintf("time: %.3f\n", etime - stime);
|
|
Packit |
807167 |
oprintf("loading records from snapshot:\n");
|
|
Packit |
807167 |
stime = kc::time();
|
|
Packit |
807167 |
int64_t cnt = db.count();
|
|
Packit |
807167 |
if (rnd && myrand(2) == 0 && !db.clear()) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::clear");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
const std::string& str = ostrm.str();
|
|
Packit |
807167 |
std::istringstream istrm(str);
|
|
Packit |
807167 |
if (!db.load_snapshot(&istrm) || db.count() != cnt) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::load_snapshot");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
etime = kc::time();
|
|
Packit |
807167 |
dbmetaprint(&db, false);
|
|
Packit |
807167 |
oprintf("time: %.3f\n", etime - stime);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
oprintf("removing records:\n");
|
|
Packit |
807167 |
stime = kc::time();
|
|
Packit |
807167 |
class ThreadRemove : public kc::Thread {
|
|
Packit |
807167 |
public:
|
|
Packit |
807167 |
void setparams(int32_t id, kc::BasicDB* db, int64_t rnum, int32_t thnum,
|
|
Packit |
807167 |
bool rnd, bool etc, bool tran) {
|
|
Packit |
807167 |
id_ = id;
|
|
Packit |
807167 |
db_ = db;
|
|
Packit |
807167 |
rnum_ = rnum;
|
|
Packit |
807167 |
thnum_ = thnum;
|
|
Packit |
807167 |
err_ = false;
|
|
Packit |
807167 |
rnd_ = rnd;
|
|
Packit |
807167 |
etc_ = etc;
|
|
Packit |
807167 |
tran_ = tran;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
bool error() {
|
|
Packit |
807167 |
return err_;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
void run() {
|
|
Packit |
807167 |
int64_t base = id_ * rnum_;
|
|
Packit |
807167 |
int64_t range = rnum_ * thnum_;
|
|
Packit |
807167 |
for (int64_t i = 1; !err_ && i <= rnum_; i++) {
|
|
Packit |
807167 |
if (tran_ && !db_->begin_transaction(false)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::begin_transaction");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
char kbuf[RECBUFSIZ];
|
|
Packit |
807167 |
size_t ksiz = std::sprintf(kbuf, "%08lld",
|
|
Packit |
807167 |
(long long)(rnd_ ? myrand(range) + 1 : base + i));
|
|
Packit |
807167 |
if (!db_->remove(kbuf, ksiz) &&
|
|
Packit |
807167 |
((!rnd_ && !etc_) || db_->error() != kc::BasicDB::Error::NOREC)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::remove");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (rnd_ && i % 8 == 0) {
|
|
Packit |
807167 |
switch (myrand(8)) {
|
|
Packit |
807167 |
case 0: {
|
|
Packit |
807167 |
if (!db_->set(kbuf, ksiz, kbuf, ksiz)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::set");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 1: {
|
|
Packit |
807167 |
if (!db_->append(kbuf, ksiz, kbuf, ksiz)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::append");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 2: {
|
|
Packit |
807167 |
if (!db_->remove(kbuf, ksiz) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::remove");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 3: {
|
|
Packit |
807167 |
kc::DB::Cursor* cur = db_->cursor();
|
|
Packit |
807167 |
if (cur->jump(kbuf, ksiz)) {
|
|
Packit |
807167 |
switch (myrand(8)) {
|
|
Packit |
807167 |
default: {
|
|
Packit |
807167 |
size_t rsiz;
|
|
Packit |
807167 |
char* rbuf = cur->get_key(&rsiz, myrand(10) == 0);
|
|
Packit |
807167 |
if (rbuf) {
|
|
Packit |
807167 |
delete[] rbuf;
|
|
Packit |
807167 |
} else if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::get_key");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 1: {
|
|
Packit |
807167 |
size_t rsiz;
|
|
Packit |
807167 |
char* rbuf = cur->get_value(&rsiz, myrand(10) == 0);
|
|
Packit |
807167 |
if (rbuf) {
|
|
Packit |
807167 |
delete[] rbuf;
|
|
Packit |
807167 |
} else if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::get_value");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 2: {
|
|
Packit |
807167 |
size_t rksiz;
|
|
Packit |
807167 |
const char* rvbuf;
|
|
Packit |
807167 |
size_t rvsiz;
|
|
Packit |
807167 |
char* rkbuf = cur->get(&rksiz, &rvbuf, &rvsiz, myrand(10) == 0);
|
|
Packit |
807167 |
if (rkbuf) {
|
|
Packit |
807167 |
delete[] rkbuf;
|
|
Packit |
807167 |
} else if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::get");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 3: {
|
|
Packit |
807167 |
std::string key, value;
|
|
Packit |
807167 |
if (!cur->get(&key, &value, myrand(10) == 0) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::get");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 4: {
|
|
Packit |
807167 |
if (myrand(8) == 0 && !cur->remove() &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::remove");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::jump");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
delete cur;
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
default: {
|
|
Packit |
807167 |
size_t vsiz;
|
|
Packit |
807167 |
char* vbuf = db_->get(kbuf, ksiz, &vsiz);
|
|
Packit |
807167 |
if (vbuf) {
|
|
Packit |
807167 |
delete[] vbuf;
|
|
Packit |
807167 |
} else if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::get");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (tran_ && !db_->end_transaction(true)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::end_transaction");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (id_ < 1 && rnum_ > 250 && i % (rnum_ / 250) == 0) {
|
|
Packit |
807167 |
oputchar('.');
|
|
Packit |
807167 |
if (i == rnum_ || i % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)i);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
private:
|
|
Packit |
807167 |
int32_t id_;
|
|
Packit |
807167 |
kc::BasicDB* db_;
|
|
Packit |
807167 |
int64_t rnum_;
|
|
Packit |
807167 |
int32_t thnum_;
|
|
Packit |
807167 |
bool err_;
|
|
Packit |
807167 |
bool rnd_;
|
|
Packit |
807167 |
bool etc_;
|
|
Packit |
807167 |
bool tran_;
|
|
Packit |
807167 |
};
|
|
Packit |
807167 |
ThreadRemove threadremoves[THREADMAX];
|
|
Packit |
807167 |
if (thnum < 2) {
|
|
Packit |
807167 |
threadremoves[0].setparams(0, &db, rnum, thnum, rnd, etc, tran);
|
|
Packit |
807167 |
threadremoves[0].run();
|
|
Packit |
807167 |
if (threadremoves[0].error()) err = true;
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
for (int32_t i = 0; i < thnum; i++) {
|
|
Packit |
807167 |
threadremoves[i].setparams(i, &db, rnum, thnum, rnd, etc, tran);
|
|
Packit |
807167 |
threadremoves[i].start();
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
for (int32_t i = 0; i < thnum; i++) {
|
|
Packit |
807167 |
threadremoves[i].join();
|
|
Packit |
807167 |
if (threadremoves[i].error()) err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
etime = kc::time();
|
|
Packit |
807167 |
dbmetaprint(&db, etc);
|
|
Packit |
807167 |
oprintf("time: %.3f\n", etime - stime);
|
|
Packit |
807167 |
oprintf("closing the database:\n");
|
|
Packit |
807167 |
stime = kc::time();
|
|
Packit |
807167 |
if (!db.close()) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::close");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
etime = kc::time();
|
|
Packit |
807167 |
oprintf("time: %.3f\n", etime - stime);
|
|
Packit |
807167 |
oprintf("%s\n\n", err ? "error" : "ok");
|
|
Packit |
807167 |
return err ? 1 : 0;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
|
|
Packit |
807167 |
|
|
Packit |
807167 |
// perform queue command
|
|
Packit |
807167 |
static int32_t procqueue(int64_t rnum, int32_t thnum, int32_t itnum, bool rnd,
|
|
Packit |
807167 |
int32_t opts, int64_t bnum, int32_t psiz, int64_t pccap,
|
|
Packit |
807167 |
kc::Comparator* rcomp, bool lv) {
|
|
Packit |
807167 |
oprintf("<Queue Test>\n seed=%u rnum=%lld thnum=%d itnum=%d rnd=%d"
|
|
Packit |
807167 |
" opts=%d bnum=%lld psiz=%d pccap=%lld rcomp=%p lv=%d\n\n",
|
|
Packit |
807167 |
g_randseed, (long long)rnum, thnum, itnum, rnd,
|
|
Packit |
807167 |
opts, (long long)bnum, psiz, (long long)pccap, rcomp, lv);
|
|
Packit |
807167 |
bool err = false;
|
|
Packit |
807167 |
kc::GrassDB db;
|
|
Packit |
807167 |
db.tune_logger(stdlogger(g_progname, &std::cout),
|
|
Packit |
807167 |
lv ? kc::UINT32MAX : kc::BasicDB::Logger::WARN | kc::BasicDB::Logger::ERROR);
|
|
Packit |
807167 |
if (opts > 0) db.tune_options(opts);
|
|
Packit |
807167 |
if (bnum > 0) db.tune_buckets(bnum);
|
|
Packit |
807167 |
if (psiz > 0) db.tune_page(psiz);
|
|
Packit |
807167 |
if (pccap > 0) db.tune_page_cache(pccap);
|
|
Packit |
807167 |
if (rcomp) db.tune_comparator(rcomp);
|
|
Packit |
807167 |
for (int32_t itcnt = 1; itcnt <= itnum; itcnt++) {
|
|
Packit |
807167 |
if (itnum > 1) oprintf("iteration %d:\n", itcnt);
|
|
Packit |
807167 |
double stime = kc::time();
|
|
Packit |
807167 |
uint32_t omode = kc::GrassDB::OWRITER | kc::GrassDB::OCREATE;
|
|
Packit |
807167 |
if (itcnt == 1) omode |= kc::GrassDB::OTRUNCATE;
|
|
Packit |
807167 |
if (!db.open("%", omode)) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::open");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
class ThreadQueue : public kc::Thread {
|
|
Packit |
807167 |
public:
|
|
Packit |
807167 |
void setparams(int32_t id, kc::GrassDB* db, int64_t rnum, int32_t thnum, bool rnd,
|
|
Packit |
807167 |
int64_t width) {
|
|
Packit |
807167 |
id_ = id;
|
|
Packit |
807167 |
db_ = db;
|
|
Packit |
807167 |
rnum_ = rnum;
|
|
Packit |
807167 |
thnum_ = thnum;
|
|
Packit |
807167 |
rnd_ = rnd;
|
|
Packit |
807167 |
width_ = width;
|
|
Packit |
807167 |
err_ = false;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
bool error() {
|
|
Packit |
807167 |
return err_;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
void run() {
|
|
Packit |
807167 |
kc::DB::Cursor* cur = db_->cursor();
|
|
Packit |
807167 |
int64_t base = id_ * rnum_;
|
|
Packit |
807167 |
int64_t range = rnum_ * thnum_;
|
|
Packit |
807167 |
for (int64_t i = 1; !err_ && i <= rnum_; i++) {
|
|
Packit |
807167 |
char kbuf[RECBUFSIZ];
|
|
Packit |
807167 |
size_t ksiz = std::sprintf(kbuf, "%010lld", (long long)(base + i));
|
|
Packit |
807167 |
if (!db_->set(kbuf, ksiz, kbuf, ksiz)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::set");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (rnd_) {
|
|
Packit |
807167 |
if (myrand(width_ / 2) == 0) {
|
|
Packit |
807167 |
if (!cur->jump() && db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::jump");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
ksiz = std::sprintf(kbuf, "%010lld", (long long)myrand(range) + 1);
|
|
Packit |
807167 |
switch (myrand(10)) {
|
|
Packit |
807167 |
case 0: {
|
|
Packit |
807167 |
if (!db_->set(kbuf, ksiz, kbuf, ksiz)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::set");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 1: {
|
|
Packit |
807167 |
if (!db_->append(kbuf, ksiz, kbuf, ksiz)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::append");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 2: {
|
|
Packit |
807167 |
if (!db_->remove(kbuf, ksiz) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::remove");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
int64_t dnum = myrand(width_) + 2;
|
|
Packit |
807167 |
for (int64_t j = 0; j < dnum; j++) {
|
|
Packit |
807167 |
if (myrand(2) == 0) {
|
|
Packit |
807167 |
size_t rsiz;
|
|
Packit |
807167 |
char* rbuf = cur->get_key(&rsiz);
|
|
Packit |
807167 |
if (rbuf) {
|
|
Packit |
807167 |
if (myrand(10) == 0 && !db_->remove(rbuf, rsiz) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::remove");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (myrand(2) == 0 && !cur->jump(rbuf, rsiz) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::jump");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (myrand(10) == 0 && !db_->remove(rbuf, rsiz) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::remove");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
delete[] rbuf;
|
|
Packit |
807167 |
} else if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::get_key");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (!cur->remove() && db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::remove");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
if (i > width_) {
|
|
Packit |
807167 |
if (!cur->jump() && db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::jump");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (!cur->remove() && db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::remove");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (id_ < 1 && rnum_ > 250 && i % (rnum_ / 250) == 0) {
|
|
Packit |
807167 |
oputchar('.');
|
|
Packit |
807167 |
if (i == rnum_ || i % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)i);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
delete cur;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
private:
|
|
Packit |
807167 |
int32_t id_;
|
|
Packit |
807167 |
kc::GrassDB* db_;
|
|
Packit |
807167 |
int64_t rnum_;
|
|
Packit |
807167 |
int32_t thnum_;
|
|
Packit |
807167 |
bool rnd_;
|
|
Packit |
807167 |
int64_t width_;
|
|
Packit |
807167 |
bool err_;
|
|
Packit |
807167 |
};
|
|
Packit |
807167 |
int64_t width = rnum / 10;
|
|
Packit |
807167 |
ThreadQueue threads[THREADMAX];
|
|
Packit |
807167 |
if (thnum < 2) {
|
|
Packit |
807167 |
threads[0].setparams(0, &db, rnum, thnum, rnd, width);
|
|
Packit |
807167 |
threads[0].run();
|
|
Packit |
807167 |
if (threads[0].error()) err = true;
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
for (int32_t i = 0; i < thnum; i++) {
|
|
Packit |
807167 |
threads[i].setparams(i, &db, rnum, thnum, rnd, width);
|
|
Packit |
807167 |
threads[i].start();
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
for (int32_t i = 0; i < thnum; i++) {
|
|
Packit |
807167 |
threads[i].join();
|
|
Packit |
807167 |
if (threads[i].error()) err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
int64_t count = db.count();
|
|
Packit |
807167 |
if (!rnd && itcnt == 1 && count != width * thnum) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::count");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if ((rnd ? (myrand(2) == 0) : itcnt == itnum) && count > 0) {
|
|
Packit |
807167 |
kc::DB::Cursor* cur = db.cursor();
|
|
Packit |
807167 |
if (!cur->jump()) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "Cursor::jump");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
for (int64_t i = 1; i <= count; i++) {
|
|
Packit |
807167 |
if (!cur->remove()) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "Cursor::remove");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (rnum > 250 && i % (rnum / 250) == 0) {
|
|
Packit |
807167 |
oputchar('.');
|
|
Packit |
807167 |
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08lld)\n", (long long)i);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (rnd) oprintf(" (end)\n");
|
|
Packit |
807167 |
delete cur;
|
|
Packit |
807167 |
if (db.count() != 0) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::count");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
dbmetaprint(&db, itcnt == itnum);
|
|
Packit |
807167 |
if (!db.close()) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::close");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
oprintf("time: %.3f\n", kc::time() - stime);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
oprintf("%s\n\n", err ? "error" : "ok");
|
|
Packit |
807167 |
return err ? 1 : 0;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
|
|
Packit |
807167 |
|
|
Packit |
807167 |
// perform wicked command
|
|
Packit |
807167 |
static int32_t procwicked(int64_t rnum, int32_t thnum, int32_t itnum,
|
|
Packit |
807167 |
int32_t opts, int64_t bnum, int32_t psiz, int64_t pccap,
|
|
Packit |
807167 |
kc::Comparator* rcomp, bool lv) {
|
|
Packit |
807167 |
oprintf("<Wicked Test>\n seed=%u rnum=%lld thnum=%d itnum=%d"
|
|
Packit |
807167 |
" opts=%d bnum=%lld psiz=%d pccap=%lld rcomp=%p lv=%d\n\n",
|
|
Packit |
807167 |
g_randseed, (long long)rnum, thnum, itnum,
|
|
Packit |
807167 |
opts, (long long)bnum, psiz, (long long)pccap, rcomp, lv);
|
|
Packit |
807167 |
bool err = false;
|
|
Packit |
807167 |
kc::GrassDB db;
|
|
Packit |
807167 |
db.tune_logger(stdlogger(g_progname, &std::cout),
|
|
Packit |
807167 |
lv ? kc::UINT32MAX : kc::BasicDB::Logger::WARN | kc::BasicDB::Logger::ERROR);
|
|
Packit |
807167 |
if (opts > 0) db.tune_options(opts);
|
|
Packit |
807167 |
if (bnum > 0) db.tune_buckets(bnum);
|
|
Packit |
807167 |
if (psiz > 0) db.tune_page(psiz);
|
|
Packit |
807167 |
if (pccap > 0) db.tune_page_cache(pccap);
|
|
Packit |
807167 |
if (rcomp) db.tune_comparator(rcomp);
|
|
Packit |
807167 |
for (int32_t itcnt = 1; itcnt <= itnum; itcnt++) {
|
|
Packit |
807167 |
if (itnum > 1) oprintf("iteration %d:\n", itcnt);
|
|
Packit |
807167 |
double stime = kc::time();
|
|
Packit |
807167 |
uint32_t omode = kc::GrassDB::OWRITER | kc::GrassDB::OCREATE;
|
|
Packit |
807167 |
if (itcnt == 1) omode |= kc::GrassDB::OTRUNCATE;
|
|
Packit |
807167 |
if (!db.open("%", omode)) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::open");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
class ThreadWicked : public kc::Thread {
|
|
Packit |
807167 |
public:
|
|
Packit |
807167 |
void setparams(int32_t id, kc::GrassDB* db, int64_t rnum, int32_t thnum,
|
|
Packit |
807167 |
const char* lbuf) {
|
|
Packit |
807167 |
id_ = id;
|
|
Packit |
807167 |
db_ = db;
|
|
Packit |
807167 |
rnum_ = rnum;
|
|
Packit |
807167 |
thnum_ = thnum;
|
|
Packit |
807167 |
lbuf_ = lbuf;
|
|
Packit |
807167 |
err_ = false;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
bool error() {
|
|
Packit |
807167 |
return err_;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
void run() {
|
|
Packit |
807167 |
kc::DB::Cursor* cur = db_->cursor();
|
|
Packit |
807167 |
int64_t range = rnum_ * thnum_ / 2;
|
|
Packit |
807167 |
for (int64_t i = 1; !err_ && i <= rnum_; i++) {
|
|
Packit |
807167 |
bool tran = myrand(100) == 0;
|
|
Packit |
807167 |
if (tran) {
|
|
Packit |
807167 |
if (myrand(2) == 0) {
|
|
Packit |
807167 |
if (!db_->begin_transaction(myrand(rnum_) == 0)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::begin_transaction");
|
|
Packit |
807167 |
tran = false;
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
if (!db_->begin_transaction_try(myrand(rnum_) == 0)) {
|
|
Packit |
807167 |
if (db_->error() != kc::BasicDB::Error::LOGIC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::begin_transaction_try");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
tran = false;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
char kbuf[RECBUFSIZ];
|
|
Packit |
807167 |
size_t ksiz = std::sprintf(kbuf, "%lld", (long long)(myrand(range) + 1));
|
|
Packit |
807167 |
if (myrand(1000) == 0) {
|
|
Packit |
807167 |
ksiz = myrand(RECBUFSIZ) + 1;
|
|
Packit |
807167 |
if (myrand(2) == 0) {
|
|
Packit |
807167 |
for (size_t j = 0; j < ksiz; j++) {
|
|
Packit |
807167 |
kbuf[j] = j;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
for (size_t j = 0; j < ksiz; j++) {
|
|
Packit |
807167 |
kbuf[j] = myrand(256);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
const char* vbuf = kbuf;
|
|
Packit |
807167 |
size_t vsiz = ksiz;
|
|
Packit |
807167 |
if (myrand(10) == 0) {
|
|
Packit |
807167 |
vbuf = lbuf_;
|
|
Packit |
807167 |
vsiz = myrand(RECBUFSIZL) / (myrand(5) + 1);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
do {
|
|
Packit |
807167 |
switch (myrand(9)) {
|
|
Packit |
807167 |
case 0: {
|
|
Packit |
807167 |
if (!db_->set(kbuf, ksiz, vbuf, vsiz)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::set");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 1: {
|
|
Packit |
807167 |
if (!db_->add(kbuf, ksiz, vbuf, vsiz) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::DUPREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::add");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 2: {
|
|
Packit |
807167 |
if (!db_->replace(kbuf, ksiz, vbuf, vsiz) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::replace");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 3: {
|
|
Packit |
807167 |
if (!db_->append(kbuf, ksiz, vbuf, vsiz)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::append");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 4: {
|
|
Packit |
807167 |
if (myrand(2) == 0) {
|
|
Packit |
807167 |
int64_t num = myrand(rnum_);
|
|
Packit |
807167 |
int64_t orig = myrand(10) == 0 ? kc::INT64MIN : myrand(rnum_);
|
|
Packit |
807167 |
if (myrand(10) == 0) orig = orig == kc::INT64MIN ? kc::INT64MAX : -orig;
|
|
Packit |
807167 |
if (db_->increment(kbuf, ksiz, num, orig) == kc::INT64MIN &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::LOGIC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::increment");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
double num = myrand(rnum_ * 10) / (myrand(rnum_) + 1.0);
|
|
Packit |
807167 |
double orig = myrand(10) == 0 ? -kc::inf() : myrand(rnum_);
|
|
Packit |
807167 |
if (myrand(10) == 0) orig = -orig;
|
|
Packit |
807167 |
if (kc::chknan(db_->increment_double(kbuf, ksiz, num, orig)) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::LOGIC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::increment_double");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 5: {
|
|
Packit |
807167 |
if (!db_->cas(kbuf, ksiz, kbuf, ksiz, vbuf, vsiz) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::LOGIC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::cas");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 6: {
|
|
Packit |
807167 |
if (!db_->remove(kbuf, ksiz) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::remove");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 7: {
|
|
Packit |
807167 |
if (myrand(2) == 0) {
|
|
Packit |
807167 |
if (db_->check(kbuf, ksiz) < 0 && db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::check");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
size_t rsiz;
|
|
Packit |
807167 |
char* rbuf = db_->seize(kbuf, ksiz, &rsiz);
|
|
Packit |
807167 |
if (rbuf) {
|
|
Packit |
807167 |
delete[] rbuf;
|
|
Packit |
807167 |
} else if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::seize");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 8: {
|
|
Packit |
807167 |
if (myrand(10) == 0) {
|
|
Packit |
807167 |
if (!cur->jump(kbuf, ksiz) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::jump");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
class VisitorImpl : public kc::DB::Visitor {
|
|
Packit |
807167 |
public:
|
|
Packit |
807167 |
explicit VisitorImpl(const char* lbuf) : lbuf_(lbuf) {}
|
|
Packit |
807167 |
private:
|
|
Packit |
807167 |
const char* visit_full(const char* kbuf, size_t ksiz,
|
|
Packit |
807167 |
const char* vbuf, size_t vsiz, size_t* sp) {
|
|
Packit |
807167 |
const char* rv = NOP;
|
|
Packit |
807167 |
switch (myrand(3)) {
|
|
Packit |
807167 |
case 0: {
|
|
Packit |
807167 |
rv = lbuf_;
|
|
Packit |
807167 |
*sp = myrand(RECBUFSIZL) / (myrand(5) + 1);
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 1: {
|
|
Packit |
807167 |
rv = REMOVE;
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
return rv;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
const char* lbuf_;
|
|
Packit |
807167 |
} visitor(lbuf_);
|
|
Packit |
807167 |
if (!cur->accept(&visitor, true, myrand(2) == 0) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::accept");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (myrand(3) == 0 && !cur->step() &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::step");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (myrand(3) == 0 && !cur->step_back() &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::step");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
default: {
|
|
Packit |
807167 |
size_t rsiz;
|
|
Packit |
807167 |
char* rbuf = db_->get(kbuf, ksiz, &rsiz);
|
|
Packit |
807167 |
if (rbuf) {
|
|
Packit |
807167 |
delete[] rbuf;
|
|
Packit |
807167 |
} else if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::get");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} while (myrand(100) == 0);
|
|
Packit |
807167 |
if (i == rnum_ / 2) {
|
|
Packit |
807167 |
if (myrand(thnum_ * 4) == 0) {
|
|
Packit |
807167 |
if (!db_->clear()) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::clear");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
class SyncProcessor : public kc::BasicDB::FileProcessor {
|
|
Packit |
807167 |
private:
|
|
Packit |
807167 |
bool process(const std::string& path, int64_t count, int64_t size) {
|
|
Packit |
807167 |
yield();
|
|
Packit |
807167 |
return true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} syncprocessor;
|
|
Packit |
807167 |
if (!db_->synchronize(false, &syncprocessor)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::synchronize");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (tran) {
|
|
Packit |
807167 |
yield();
|
|
Packit |
807167 |
if (!db_->end_transaction(myrand(10) > 0)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::end_transactin");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (id_ < 1 && rnum_ > 250 && i % (rnum_ / 250) == 0) {
|
|
Packit |
807167 |
oputchar('.');
|
|
Packit |
807167 |
if (i == rnum_ || i % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)i);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
delete cur;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
private:
|
|
Packit |
807167 |
int32_t id_;
|
|
Packit |
807167 |
kc::GrassDB* db_;
|
|
Packit |
807167 |
int64_t rnum_;
|
|
Packit |
807167 |
int32_t thnum_;
|
|
Packit |
807167 |
const char* lbuf_;
|
|
Packit |
807167 |
bool err_;
|
|
Packit |
807167 |
};
|
|
Packit |
807167 |
char lbuf[RECBUFSIZL];
|
|
Packit |
807167 |
std::memset(lbuf, '*', sizeof(lbuf));
|
|
Packit |
807167 |
ThreadWicked threads[THREADMAX];
|
|
Packit |
807167 |
if (thnum < 2) {
|
|
Packit |
807167 |
threads[0].setparams(0, &db, rnum, thnum, lbuf);
|
|
Packit |
807167 |
threads[0].run();
|
|
Packit |
807167 |
if (threads[0].error()) err = true;
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
for (int32_t i = 0; i < thnum; i++) {
|
|
Packit |
807167 |
threads[i].setparams(i, &db, rnum, thnum, lbuf);
|
|
Packit |
807167 |
threads[i].start();
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
for (int32_t i = 0; i < thnum; i++) {
|
|
Packit |
807167 |
threads[i].join();
|
|
Packit |
807167 |
if (threads[i].error()) err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
dbmetaprint(&db, itcnt == itnum);
|
|
Packit |
807167 |
if (!db.close()) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::close");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
oprintf("time: %.3f\n", kc::time() - stime);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
oprintf("%s\n\n", err ? "error" : "ok");
|
|
Packit |
807167 |
return err ? 1 : 0;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
|
|
Packit |
807167 |
|
|
Packit |
807167 |
// perform tran command
|
|
Packit |
807167 |
static int32_t proctran(int64_t rnum, int32_t thnum, int32_t itnum,
|
|
Packit |
807167 |
int32_t opts, int64_t bnum, int32_t psiz, int64_t pccap,
|
|
Packit |
807167 |
kc::Comparator* rcomp, bool lv) {
|
|
Packit |
807167 |
oprintf("<Transaction Test>\n seed=%u rnum=%lld thnum=%d itnum=%d"
|
|
Packit |
807167 |
" opts=%d bnum=%lld psiz=%d pccap=%lld rcomp=%p lv=%d\n\n",
|
|
Packit |
807167 |
g_randseed, (long long)rnum, thnum, itnum,
|
|
Packit |
807167 |
opts, (long long)bnum, psiz, (long long)pccap, rcomp, lv);
|
|
Packit |
807167 |
bool err = false;
|
|
Packit |
807167 |
kc::GrassDB db;
|
|
Packit |
807167 |
kc::GrassDB paradb;
|
|
Packit |
807167 |
db.tune_logger(stdlogger(g_progname, &std::cout),
|
|
Packit |
807167 |
lv ? kc::UINT32MAX : kc::BasicDB::Logger::WARN | kc::BasicDB::Logger::ERROR);
|
|
Packit |
807167 |
paradb.tune_logger(stdlogger(g_progname, &std::cout), lv ? kc::UINT32MAX :
|
|
Packit |
807167 |
kc::BasicDB::Logger::WARN | kc::BasicDB::Logger::ERROR);
|
|
Packit |
807167 |
if (opts > 0) db.tune_options(opts);
|
|
Packit |
807167 |
if (bnum > 0) db.tune_buckets(bnum);
|
|
Packit |
807167 |
if (psiz > 0) db.tune_page(psiz);
|
|
Packit |
807167 |
if (pccap > 0) db.tune_page_cache(pccap);
|
|
Packit |
807167 |
if (rcomp) db.tune_comparator(rcomp);
|
|
Packit |
807167 |
for (int32_t itcnt = 1; itcnt <= itnum; itcnt++) {
|
|
Packit |
807167 |
oprintf("iteration %d updating:\n", itcnt);
|
|
Packit |
807167 |
double stime = kc::time();
|
|
Packit |
807167 |
uint32_t omode = kc::GrassDB::OWRITER | kc::GrassDB::OCREATE;
|
|
Packit |
807167 |
if (itcnt == 1) omode |= kc::GrassDB::OTRUNCATE;
|
|
Packit |
807167 |
if (!db.open("%", omode)) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::open");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (!paradb.open("para", omode)) {
|
|
Packit |
807167 |
dberrprint(¶db, __LINE__, "DB::open");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
class ThreadTran : public kc::Thread {
|
|
Packit |
807167 |
public:
|
|
Packit |
807167 |
void setparams(int32_t id, kc::GrassDB* db, kc::GrassDB* paradb, int64_t rnum,
|
|
Packit |
807167 |
int32_t thnum, const char* lbuf) {
|
|
Packit |
807167 |
id_ = id;
|
|
Packit |
807167 |
db_ = db;
|
|
Packit |
807167 |
paradb_ = paradb;
|
|
Packit |
807167 |
rnum_ = rnum;
|
|
Packit |
807167 |
thnum_ = thnum;
|
|
Packit |
807167 |
lbuf_ = lbuf;
|
|
Packit |
807167 |
err_ = false;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
bool error() {
|
|
Packit |
807167 |
return err_;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
void run() {
|
|
Packit |
807167 |
kc::DB::Cursor* cur = db_->cursor();
|
|
Packit |
807167 |
int64_t range = rnum_ * thnum_;
|
|
Packit |
807167 |
char kbuf[RECBUFSIZ];
|
|
Packit |
807167 |
size_t ksiz = std::sprintf(kbuf, "%lld", (long long)(myrand(range) + 1));
|
|
Packit |
807167 |
if (!cur->jump(kbuf, ksiz) && db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::jump");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
bool tran = true;
|
|
Packit |
807167 |
if (!db_->begin_transaction(false)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::begin_transaction");
|
|
Packit |
807167 |
tran = false;
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
bool commit = myrand(10) > 0;
|
|
Packit |
807167 |
for (int64_t i = 1; !err_ && i <= rnum_; i++) {
|
|
Packit |
807167 |
ksiz = std::sprintf(kbuf, "%lld", (long long)(myrand(range) + 1));
|
|
Packit |
807167 |
const char* vbuf = kbuf;
|
|
Packit |
807167 |
size_t vsiz = ksiz;
|
|
Packit |
807167 |
if (myrand(10) == 0) {
|
|
Packit |
807167 |
vbuf = lbuf_;
|
|
Packit |
807167 |
vsiz = myrand(RECBUFSIZL) / (myrand(5) + 1);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
class VisitorImpl : public kc::DB::Visitor {
|
|
Packit |
807167 |
public:
|
|
Packit |
807167 |
explicit VisitorImpl(const char* vbuf, size_t vsiz, kc::BasicDB* paradb) :
|
|
Packit |
807167 |
vbuf_(vbuf), vsiz_(vsiz), paradb_(paradb) {}
|
|
Packit |
807167 |
private:
|
|
Packit |
807167 |
const char* visit_full(const char* kbuf, size_t ksiz,
|
|
Packit |
807167 |
const char* vbuf, size_t vsiz, size_t* sp) {
|
|
Packit |
807167 |
return visit_empty(kbuf, ksiz, sp);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
const char* visit_empty(const char* kbuf, size_t ksiz, size_t* sp) {
|
|
Packit |
807167 |
const char* rv = NOP;
|
|
Packit |
807167 |
switch (myrand(3)) {
|
|
Packit |
807167 |
case 0: {
|
|
Packit |
807167 |
rv = vbuf_;
|
|
Packit |
807167 |
*sp = vsiz_;
|
|
Packit |
807167 |
if (paradb_) paradb_->set(kbuf, ksiz, vbuf_, vsiz_);
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
case 1: {
|
|
Packit |
807167 |
rv = REMOVE;
|
|
Packit |
807167 |
if (paradb_) paradb_->remove(kbuf, ksiz);
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
return rv;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
const char* vbuf_;
|
|
Packit |
807167 |
size_t vsiz_;
|
|
Packit |
807167 |
kc::BasicDB* paradb_;
|
|
Packit |
807167 |
} visitor(vbuf, vsiz, !tran || commit ? paradb_ : NULL);
|
|
Packit |
807167 |
if (myrand(4) == 0) {
|
|
Packit |
807167 |
if (!cur->accept(&visitor, true, myrand(2) == 0) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::accept");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
if (!db_->accept(kbuf, ksiz, &visitor, true)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::accept");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (myrand(1000) == 0) {
|
|
Packit |
807167 |
ksiz = std::sprintf(kbuf, "%lld", (long long)(myrand(range) + 1));
|
|
Packit |
807167 |
if (!cur->jump(kbuf, ksiz)) {
|
|
Packit |
807167 |
if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::jump");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
} else if (!cur->jump() && db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::jump");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
std::vector<std::string> keys;
|
|
Packit |
807167 |
keys.reserve(100);
|
|
Packit |
807167 |
while (myrand(50) != 0) {
|
|
Packit |
807167 |
std::string key;
|
|
Packit |
807167 |
if (cur->get_key(&key)) {
|
|
Packit |
807167 |
keys.push_back(key);
|
|
Packit |
807167 |
if (!cur->get_value(&key) && kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::get_value");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::get_key");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (!cur->step()) {
|
|
Packit |
807167 |
if (db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::jump");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
break;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
class Remover : public kc::DB::Visitor {
|
|
Packit |
807167 |
public:
|
|
Packit |
807167 |
explicit Remover(kc::BasicDB* paradb) : paradb_(paradb) {}
|
|
Packit |
807167 |
private:
|
|
Packit |
807167 |
const char* visit_full(const char* kbuf, size_t ksiz,
|
|
Packit |
807167 |
const char* vbuf, size_t vsiz, size_t* sp) {
|
|
Packit |
807167 |
if (myrand(200) == 0) return NOP;
|
|
Packit |
807167 |
if (paradb_) paradb_->remove(kbuf, ksiz);
|
|
Packit |
807167 |
return REMOVE;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
kc::BasicDB* paradb_;
|
|
Packit |
807167 |
} remover(!tran || commit ? paradb_ : NULL);
|
|
Packit |
807167 |
std::vector<std::string>::iterator it = keys.begin();
|
|
Packit |
807167 |
std::vector<std::string>::iterator end = keys.end();
|
|
Packit |
807167 |
while (it != end) {
|
|
Packit |
807167 |
if (myrand(50) == 0) {
|
|
Packit |
807167 |
if (!cur->accept(&remover, true, false) &&
|
|
Packit |
807167 |
db_->error() != kc::BasicDB::Error::NOREC) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "Cursor::accept");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
if (!db_->accept(it->c_str(), it->size(), &remover, true)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::accept");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
++it;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (tran && myrand(100) == 0) {
|
|
Packit |
807167 |
if (db_->end_transaction(commit)) {
|
|
Packit |
807167 |
yield();
|
|
Packit |
807167 |
if (!db_->begin_transaction(false)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::begin_transaction");
|
|
Packit |
807167 |
tran = false;
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::end_transaction");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (id_ < 1 && rnum_ > 250 && i % (rnum_ / 250) == 0) {
|
|
Packit |
807167 |
oputchar('.');
|
|
Packit |
807167 |
if (i == rnum_ || i % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)i);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (tran && !db_->end_transaction(commit)) {
|
|
Packit |
807167 |
dberrprint(db_, __LINE__, "DB::end_transaction");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
delete cur;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
private:
|
|
Packit |
807167 |
int32_t id_;
|
|
Packit |
807167 |
kc::GrassDB* db_;
|
|
Packit |
807167 |
kc::GrassDB* paradb_;
|
|
Packit |
807167 |
int64_t rnum_;
|
|
Packit |
807167 |
int32_t thnum_;
|
|
Packit |
807167 |
const char* lbuf_;
|
|
Packit |
807167 |
bool err_;
|
|
Packit |
807167 |
};
|
|
Packit |
807167 |
char lbuf[RECBUFSIZL];
|
|
Packit |
807167 |
std::memset(lbuf, '*', sizeof(lbuf));
|
|
Packit |
807167 |
ThreadTran threads[THREADMAX];
|
|
Packit |
807167 |
if (thnum < 2) {
|
|
Packit |
807167 |
threads[0].setparams(0, &db, ¶db, rnum, thnum, lbuf);
|
|
Packit |
807167 |
threads[0].run();
|
|
Packit |
807167 |
if (threads[0].error()) err = true;
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
for (int32_t i = 0; i < thnum; i++) {
|
|
Packit |
807167 |
threads[i].setparams(i, &db, ¶db, rnum, thnum, lbuf);
|
|
Packit |
807167 |
threads[i].start();
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
for (int32_t i = 0; i < thnum; i++) {
|
|
Packit |
807167 |
threads[i].join();
|
|
Packit |
807167 |
if (threads[i].error()) err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
oprintf("iteration %d checking:\n", itcnt);
|
|
Packit |
807167 |
if (db.count() != paradb.count()) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::count");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
class VisitorImpl : public kc::DB::Visitor {
|
|
Packit |
807167 |
public:
|
|
Packit |
807167 |
explicit VisitorImpl(int64_t rnum, kc::BasicDB* paradb) :
|
|
Packit |
807167 |
rnum_(rnum), paradb_(paradb), err_(false), cnt_(0) {}
|
|
Packit |
807167 |
bool error() {
|
|
Packit |
807167 |
return err_;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
private:
|
|
Packit |
807167 |
const char* visit_full(const char* kbuf, size_t ksiz,
|
|
Packit |
807167 |
const char* vbuf, size_t vsiz, size_t* sp) {
|
|
Packit |
807167 |
cnt_++;
|
|
Packit |
807167 |
size_t rsiz;
|
|
Packit |
807167 |
char* rbuf = paradb_->get(kbuf, ksiz, &rsiz);
|
|
Packit |
807167 |
if (rbuf) {
|
|
Packit |
807167 |
delete[] rbuf;
|
|
Packit |
807167 |
} else {
|
|
Packit |
807167 |
dberrprint(paradb_, __LINE__, "DB::get");
|
|
Packit |
807167 |
err_ = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
if (rnum_ > 250 && cnt_ % (rnum_ / 250) == 0) {
|
|
Packit |
807167 |
oputchar('.');
|
|
Packit |
807167 |
if (cnt_ == rnum_ || cnt_ % (rnum_ / 10) == 0) oprintf(" (%08lld)\n", (long long)cnt_);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
return NOP;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
int64_t rnum_;
|
|
Packit |
807167 |
kc::BasicDB* paradb_;
|
|
Packit |
807167 |
bool err_;
|
|
Packit |
807167 |
int64_t cnt_;
|
|
Packit |
807167 |
} visitor(rnum, ¶db), paravisitor(rnum, &db);
|
|
Packit |
807167 |
if (!db.iterate(&visitor, false)) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::iterate");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
oprintf(" (end)\n");
|
|
Packit |
807167 |
if (visitor.error()) err = true;
|
|
Packit |
807167 |
if (!paradb.iterate(¶visitor, false)) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::iterate");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
oprintf(" (end)\n");
|
|
Packit |
807167 |
if (paravisitor.error()) err = true;
|
|
Packit |
807167 |
if (!paradb.close()) {
|
|
Packit |
807167 |
dberrprint(¶db, __LINE__, "DB::close");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
dbmetaprint(&db, itcnt == itnum);
|
|
Packit |
807167 |
if (!db.close()) {
|
|
Packit |
807167 |
dberrprint(&db, __LINE__, "DB::close");
|
|
Packit |
807167 |
err = true;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
oprintf("time: %.3f\n", kc::time() - stime);
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
oprintf("%s\n\n", err ? "error" : "ok");
|
|
Packit |
807167 |
return err ? 1 : 0;
|
|
Packit |
807167 |
}
|
|
Packit |
807167 |
|
|
Packit |
807167 |
|
|
Packit |
807167 |
|
|
Packit |
807167 |
// END OF FILE
|