summaryrefslogtreecommitdiff
path: root/db-4.8.30/test_stl/base/test_dbstl.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'db-4.8.30/test_stl/base/test_dbstl.cpp')
-rw-r--r--db-4.8.30/test_stl/base/test_dbstl.cpp313
1 files changed, 313 insertions, 0 deletions
diff --git a/db-4.8.30/test_stl/base/test_dbstl.cpp b/db-4.8.30/test_stl/base/test_dbstl.cpp
new file mode 100644
index 0000000..0a75c72
--- /dev/null
+++ b/db-4.8.30/test_stl/base/test_dbstl.cpp
@@ -0,0 +1,313 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2009 Oracle. All rights reserved.
+ *
+ * $Id$
+ */
+
+// test_dbstl.cpp : A test program which tests all container's all methods,
+// by verify the result is identical to expected value, or by doing paralell
+// operations with corresponding container of STL and verify the result of
+// both containers are identical after the same operations. Also, it tests
+// multithreaded test
+//
+#include "db_config.h"
+#include "db_int.h"
+
+#include "test.h"
+#include "test_util.h"
+#include "test_vector.h"
+#include "test_assoc.h"
+#include "test_mt.h"
+
+int main(int argc, char *argv[])
+{
+ int c, i, j, ret;
+ int nreader = 5, nwriter = 3;
+ char *mode = NULL;
+ int flags = DB_THREAD, setflags = 0, EXPLICIT_TXN = 0;
+ int TEST_AUTOCOMMIT = 1, totalinsert = 100, verbose = 0;
+ DBTYPE dbtype = DB_BTREE;
+ int gi, shortest = 50, longest = 200, loop_count = 1;
+ bool multionly = false;
+ u_int32_t sflags = 0, oflags = 0;
+ u_int32_t cachesize = 8 * 1024 * 1024;
+ db_threadid_t tid;
+ string contname;
+ DbEnv *penv = NULL;
+ Db *dbstrv = NULL;
+ __os_id(0, 0, &tid);
+
+ TestParam *ptp = new TestParam;
+ ContainerType contypes[] = {
+ ct_vector,
+ ct_map,
+ ct_multimap,
+ ct_set,
+ ct_multiset,
+ ct_none
+ };
+
+ while ((c = getopt(argc, argv, "MT:c:hk:l:m:n:r:s:t:vw:")) != EOF) {
+ switch (c) {
+ case 'M':
+ multionly = true;
+ break;
+ case 'T':
+ totalinsert = atoi(optarg);
+ break;
+ case 'c':
+ cachesize = atoi(optarg);
+ break;
+ case 'h':
+ usage();
+ return 0;
+ break;
+ case 'k':
+ shortest = atoi(optarg);
+ break;
+ case 'l':
+ longest = atoi(optarg);
+ break;
+ case 'm':
+ mode = optarg;
+ break;
+ case 'n':
+ loop_count = atoi(optarg);
+ break;
+ case 'r':
+ nreader = atoi(optarg);
+ break;
+ case 's': // db type for associative containers
+ if (*optarg == 'h') // hash db type
+ dbtype = DB_HASH;
+ else if (*optarg == 'b')
+ dbtype = DB_BTREE;
+ else
+ usage();
+ break;
+ case 't':
+ EXPLICIT_TXN = 1;
+ if (*optarg == 'a')
+ setflags = DB_AUTO_COMMIT;
+ else if (*optarg == 'e') // explicit txn
+ TEST_AUTOCOMMIT = 0;
+ else
+ usage();
+ break;
+ case 'v':
+ verbose = 1;
+ break;
+ case 'w':
+ nwriter = atoi(optarg);
+ break;
+ default:
+ usage();
+ break;
+ }
+ }
+
+ if (nwriter < 3)
+ nwriter = 3;
+
+ if (mode == NULL)
+ flags |= 0;
+ else if (*mode == 'c') //cds
+ flags |= DB_INIT_CDB;
+ else if (*mode == 't')
+ flags |= DB_INIT_TXN | DB_RECOVER
+ | DB_INIT_LOG | DB_INIT_LOCK;
+ else
+ flags |= 0;
+ g_test_start_txn = TEST_AUTOCOMMIT * EXPLICIT_TXN;
+ ptp->EXPLICIT_TXN = EXPLICIT_TXN;
+ ptp->flags = flags;
+ ptp->dbtype = dbtype;
+ ptp->setflags = setflags;
+ ptp->TEST_AUTOCOMMIT = TEST_AUTOCOMMIT;
+ ptp->dboflags = DB_THREAD;
+
+ // This may fail because there is already dbenv.
+ __os_mkdir(NULL, "dbenv", 0777);
+ if (!multionly){
+ if (loop_count <= 0)
+ loop_count = 1;
+ dbstl_startup();
+ for (; loop_count > 0; loop_count--){
+ rmdir_rcsv("dbenv", true);
+ BDBOP(__os_mkdir(NULL, "dbenv/data", 0777), ret);// This should not fail.
+ penv = new DbEnv(DB_CXX_NO_EXCEPTIONS);
+ BDBOP(penv->set_flags(setflags, 1), ret);
+ BDBOP(penv->set_cachesize(0, cachesize, 1), ret);
+ BDBOP(penv->set_data_dir("data"), ret);
+
+ // Methods of containers returning a reference costs
+ // locker/object/lock slots.
+ penv->set_lk_max_lockers(10000);
+ penv->set_lk_max_objects(10000);
+ penv->set_lk_max_locks(10000);
+
+ penv->set_flags(DB_TXN_NOSYNC, 1);
+ penv->log_set_config(DB_LOG_IN_MEMORY, 1);
+ penv->set_lg_bsize(128 * 1024 * 1024);
+
+ BDBOP(penv->open("dbenv", flags | DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE, 0777), ret);
+ register_db_env(penv);
+ // CDS dose not need deadlock detection
+ if (penv->get_open_flags(&oflags) == 0 && ((oflags & DB_INIT_TXN) != 0)) {
+ penv->set_lk_detect(DB_LOCK_RANDOM);
+ penv->set_timeout(1000000, DB_SET_LOCK_TIMEOUT);
+
+ }
+
+ ptp->dbenv = penv;
+ g_env = penv;
+ TestVector testvector(ptp);
+ testvector.start_test();
+ TestAssoc testassoc(ptp);
+ testassoc.start_test();
+
+ close_all_dbs();
+ //close_db_env(penv);
+ close_all_db_envs();
+ cerr<<"\n\nOne round of dbstl test is run to completion successfully!\n\n";
+ }
+ }
+ else {
+ dbstl_startup();
+ rmdir_rcsv("dbenv", true);
+ BDBOP(__os_mkdir(NULL, "dbenv/data", 0777), ret);// This should not fail.
+ penv = new DbEnv(DB_CXX_NO_EXCEPTIONS);
+ BDBOP(penv->set_flags(setflags, 1), ret);
+ BDBOP(penv->set_cachesize(0, cachesize, 1), ret);
+ BDBOP(penv->set_data_dir("data"), ret);
+
+ // Multi-CPU machines requires larger lockers/locks/objects because of
+ // the higher concurrency, more iterators can be opened at the same time.
+ // This setting was required by the stahp05 8-cpu machine, not others.
+ BDBOP(penv->set_lk_max_lockers(100000), ret);
+ BDBOP(penv->set_lk_max_locks(100000), ret);
+ BDBOP(penv->set_lk_max_objects(100000), ret);
+
+ penv->set_flags(DB_TXN_NOSYNC, 1);
+ penv->log_set_config(DB_LOG_IN_MEMORY, 1);
+ penv->set_lg_bsize(128 * 1024 * 1024);
+
+ BDBOP(penv->open("dbenv", flags | DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE, 0777), ret);
+ register_db_env(penv);
+ // CDS dose not need deadlock detection
+ if (penv->get_open_flags(&oflags) == 0 && ((oflags & DB_INIT_TXN) != 0)) {
+ penv->set_lk_detect(DB_LOCK_RANDOM);
+ penv->set_timeout(1000000, DB_SET_LOCK_TIMEOUT);
+ }
+
+ ptp->dbenv = penv;
+ g_env = penv;
+
+ ThreadMgr thrds, insthrds;
+ vector<wt_job> jobs;
+ jobs.push_back(wt_insert);
+ jobs.push_back(wt_update);
+ jobs.push_back(wt_delete);
+ srand ((unsigned int)tid);
+
+ for (i = 3; i < nwriter; i++) {
+ j = rand() % 3;
+ switch (j) {
+ case 0: jobs.push_back(wt_insert); break;
+ case 1: jobs.push_back(wt_update); break;
+ case 2: jobs.push_back(wt_delete); break;
+ }
+ }
+
+ vector<WorkerThread *> vctthrds;
+ WorkerThread *pwthrd;
+ for (gi = 0; contypes[gi] != ct_none; gi++) {
+
+ switch (contypes[gi]) {
+ case ct_vector: contname = "db_vector"; break;
+ case ct_map: contname = "db_map"; break;
+ case ct_multimap: contname = "db_multimap"; break;
+ case ct_set: contname = "db_set"; break;
+ case ct_multiset: contname = "db_multiset"; break;
+ default: throw "unexpected container type!"; break;
+ }
+ cout<<endl<<contname<<" multi-threaded tests:\n";
+
+ g_StopInsert = 0;
+ WorkerThread par;
+ memset(&par, 0, sizeof(par));
+ par.total_insert = totalinsert;
+ par.verbose = verbose != 0;
+ par.strlenmax = longest;
+ par.strlenmin = shortest;
+ par.cntnr_type = contypes[gi];
+ par.penv = penv;
+ if (par.cntnr_type != ct_vector) {
+ if (par.cntnr_type == ct_map ||
+ par.cntnr_type == ct_set)
+ sflags = 0;
+ else if (par.cntnr_type == ct_multimap ||
+ par.cntnr_type == ct_multiset)
+ sflags = DB_DUP;
+ par.pdb = dbstl::
+ open_db(penv, "db_mt_map.db",
+ ptp->dbtype, DB_CREATE | ptp->dboflags, sflags);
+ } else if (par.cntnr_type == ct_vector) {
+ if (NULL == dbstrv)
+ dbstrv = dbstl::open_db(penv, "dbstr.db",
+ DB_RECNO, DB_CREATE | ptp->dboflags, DB_RENUMBER);
+ par.pdb = dbstrv;
+ }
+
+ par.txnal = ptp->EXPLICIT_TXN != 0;
+ for (j = 0; j < nwriter; j++) {
+ par.job = jobs[j];
+ pwthrd = new WorkerThread(par);
+ if (par.job == wt_insert) {
+ insthrds.create_thread(pwthrd);
+ } else {
+ thrds.create_thread(pwthrd);
+ }
+
+ vctthrds.push_back(pwthrd);
+ if (j == 0)
+ __os_yield(NULL, 3, 0);// sleep 3 secs
+ }
+
+ par.job = wt_read;
+ for (i = 0; i < nreader; i++) {
+ pwthrd = new WorkerThread(par);
+ thrds.create_thread(pwthrd);
+ vctthrds.push_back(pwthrd);
+ }
+
+ thrds.join_all();
+
+ g_StopInsert = 1;
+ insthrds.join_all();
+ for (vector<WorkerThread *>::size_type ui = 0; ui < vctthrds.size(); ui++)
+ delete vctthrds[ui];
+ vctthrds.clear();
+ if (ptp->EXPLICIT_TXN && !TEST_AUTOCOMMIT)
+ dbstl::begin_txn(0, penv);
+ dbstl::close_db(par.pdb);
+ penv->dbremove(dbstl::current_txn(penv), "db_mt_map.db", NULL, 0);
+ if (ptp->EXPLICIT_TXN && !TEST_AUTOCOMMIT)
+ dbstl::commit_txn(penv);
+ thrds.clear();
+ insthrds.clear();
+ cout.flush();
+
+ } // for (int gi
+
+
+ } // else
+
+ delete ptp;
+ dbstl_exit();
+
+ if (penv)
+ delete penv;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-07-19 17:09:53 +0000