Berkeley DB 4.8 with rust build script for linux.

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;
+}