开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
ex_tpcb.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：19k
源码类别：

MySQL数据库

开发平台：

Visual C++

ex_tpcb.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1997, 1998, 1999, 2000
  5.  * Sleepycat Software.  All rights reserved.
  6.  *
  7.  * $Id: ex_tpcb.c,v 11.21 2000/10/27 20:32:00 dda Exp $
  8.  */
  10. #include "db_config.h"
  12. #ifndef NO_SYSTEM_INCLUDES
  13. #include <sys/types.h>
  15. #if TIME_WITH_SYS_TIME
  16. #include <sys/time.h>
  17. #include <time.h>
  18. #else
  19. #if HAVE_SYS_TIME_H
  20. #include <sys/time.h>
  21. #else
  22. #include <time.h>
  23. #endif
  24. #endif
  26. #include <errno.h>
  27. #include <stdlib.h>
  28. #include <string.h>
  29. #include <unistd.h>
  30. #endif
  32. #ifdef DB_WIN32
  33. #include <sys/types.h>
  34. #include <sys/timeb.h>
  35. #endif
  37. #include <db.h>
  39. typedef enum { ACCOUNT, BRANCH, TELLER } FTYPE;
  41. DB_ENV  *db_init __P((char *, char *, int, int, int));
  42. int   hpopulate __P((DB *, int, int, int, int));
  43. int   populate __P((DB *, u_int32_t, u_int32_t, int, char *));
  44. u_int32_t random_id __P((FTYPE, int, int, int));
  45. u_int32_t random_int __P((u_int32_t, u_int32_t));
  46. int   tp_populate __P((DB_ENV *, int, int, int, int, int));
  47. int   tp_run __P((DB_ENV *, int, int, int, int, int));
  48. int   tp_txn __P((DB_ENV *, DB *, DB *, DB *, DB *, int, int, int, int));
  50. #ifdef HAVE_VXWORKS
  51. #define ERROR_RETURN ERROR
  52. #define HOME "/vxtmp/vxtmp/TESTDIR"
  53. #define VXSHM_KEY 13
  54. int   ex_tpcb_init __P(());
  55. int   ex_tpcb __P(());
  56. #else
  57. #define ERROR_RETURN 1
  58. void   invarg __P((char *, int, char *));
  59. int   main __P((int, char *[]));
  60. void   usage __P((char *));
  61. #endif
  63. /*
  64.  * This program implements a basic TPC/B driver program.  To create the
  65.  * TPC/B database, run with the -i (init) flag.  The number of records
  66.  * with which to populate the account, history, branch, and teller tables
  67.  * is specified by the a, s, b, and t flags respectively.  To run a TPC/B
  68.  * test, use the n flag to indicate a number of transactions to run (note
  69.  * that you can run many of these processes in parallel to simulate a
  70.  * multiuser test run).
  71.  */
  72. #define TELLERS_PER_BRANCH 10
  73. #define ACCOUNTS_PER_TELLER 10000
  74. #define HISTORY_PER_BRANCH 2592000
  76. /*
  77.  * The default configuration that adheres to TPCB scaling rules requires
  78.  * nearly 3 GB of space.  To avoid requiring that much space for testing,
  79.  * we set the parameters much lower.  If you want to run a valid 10 TPS
  80.  * configuration, define VALID_SCALING.
  81.  */
  82. #ifdef VALID_SCALING
  83. #define ACCOUNTS  1000000
  84. #define BRANCHES       10
  85. #define TELLERS      100
  86. #define HISTORY 25920000
  87. #endif
  89. #ifdef TINY
  90. #define ACCOUNTS     1000
  91. #define BRANCHES       10
  92. #define TELLERS      100
  93. #define HISTORY    10000
  94. #endif
  96. #ifdef VERY_TINY
  97. #define ACCOUNTS      500
  98. #define BRANCHES       10
  99. #define TELLERS       50
  100. #define HISTORY     5000
  101. #endif
  103. #if !defined(VALID_SCALING) && !defined(TINY) && !defined(VERY_TINY)
  104. #define ACCOUNTS   100000
  105. #define BRANCHES       10
  106. #define TELLERS      100
  107. #define HISTORY   259200
  108. #endif
  110. #define HISTORY_LEN     100
  111. #define RECLEN     100
  112. #define BEGID 1000000
  114. typedef struct _defrec {
  115. u_int32_t id;
  116. u_int32_t balance;
  117. u_int8_t pad[RECLEN - sizeof(u_int32_t) - sizeof(u_int32_t)];
  118. } defrec;
  120. typedef struct _histrec {
  121. u_int32_t aid;
  122. u_int32_t bid;
  123. u_int32_t tid;
  124. u_int32_t amount;
  125. u_int8_t pad[RECLEN - 4 * sizeof(u_int32_t)];
  126. } histrec;
  128. #ifdef HAVE_VXWORKS
  129. int
  130. ex_tpcb_init()
  131. {
  132. DB_ENV *dbenv;
  133. int accounts, branches, ret, seed, t_ret, tellers, history, verbose;
  134. char *home;
  135. char *progname = "ex_tpcb_init"; /* Program name. */
  137. verbose = 1;
  138. if ((dbenv = db_init(HOME, progname, 0, 1, 0)) == NULL)
  139. return (ERROR_RETURN);
  141. accounts = ACCOUNTS;
  142. branches = BRANCHES;
  143. tellers = TELLERS;
  144. history = HISTORY;
  146. if ((ret = tp_populate(dbenv, accounts, branches, history, tellers,
  147.     verbose)) != OK)
  148. fprintf(stderr, "%s: %sn", progname, db_strerror(ret));
  149. if ((t_ret = dbenv->close(dbenv, 0)) != 0) {
  150. fprintf(stderr, "%s: %sn", progname, db_strerror(ret));
  151. return (ERROR_RETURN);
  152. }
  154. return (ret == 0 ? t_ret : ret);
  155. }
  157. int
  158. ex_tpcb()
  159. {
  160. DB_ENV *dbenv;
  161. int accounts, branches, seed, tellers, history;
  162. int ch, mpool, ntxns, ret, t_ret, txn_no_sync, verbose;
  163. char *progname = "ex_tpcb"; /* Program name. */
  165. accounts = ACCOUNTS;
  166. branches = BRANCHES;
  167. tellers = TELLERS;
  168. history = HISTORY;
  170. txn_no_sync = 0;
  171. mpool = 0;
  172. ntxns = 20;
  173. verbose = 1;
  174. seed = (int)((u_int)getpid() | time(NULL));
  176. srand((u_int)seed);
  178. /* Initialize the database environment. */
  179. if ((dbenv = db_init(HOME, progname, mpool, 0,
  180.     txn_no_sync ? DB_TXN_NOSYNC : 0)) == NULL)
  181. return (ERROR_RETURN);
  183. if (verbose)
  184. printf("%ld Accounts, %ld Branches, %ld Tellers, %ld Historyn",
  185.     (long)accounts, (long)branches,
  186.     (long)tellers, (long)history);
  188. if ((ret = tp_run(dbenv, ntxns, accounts, branches, tellers, verbose))
  189.     != OK)
  190. fprintf(stderr, "tp_run failedn");
  192. if ((t_ret = dbenv->close(dbenv, 0)) != 0) {
  193. fprintf(stderr, "%s: %sn", progname, db_strerror(ret));
  194. return (ERROR_RETURN);
  195. }
  196. return (ret == 0 ? t_ret : ret);
  197. }
  198. #else
  199. int
  200. main(argc, argv)
  201. int argc;
  202. char *argv[];
  203. {
  204. extern char *optarg;
  205. extern int optind;
  206. DB_ENV *dbenv;
  207. int accounts, branches, seed, tellers, history;
  208. int ch, iflag, mpool, ntxns, ret, txn_no_sync, verbose;
  209. char *home, *progname;
  211. home = "TESTDIR";
  212. progname = "ex_tpcb";
  213. accounts = branches = history = tellers = 0;
  214. txn_no_sync = 0;
  215. mpool = ntxns = 0;
  216. verbose = 0;
  217. iflag = 0;
  218. seed = (int)((u_int)getpid() | time(NULL));
  219. while ((ch = getopt(argc, argv, "a:b:c:fh:in:S:s:t:v")) != EOF)
  220. switch (ch) {
  221. case 'a': /* Number of account records */
  222. if ((accounts = atoi(optarg)) <= 0)
  223. invarg(progname, ch, optarg);
  224. break;
  225. case 'b': /* Number of branch records */
  226. if ((branches = atoi(optarg)) <= 0)
  227. invarg(progname, ch, optarg);
  228. break;
  229. case 'c': /* Cachesize in bytes */
  230. if ((mpool = atoi(optarg)) <= 0)
  231. invarg(progname, ch, optarg);
  232. break;
  233. case 'f': /* Fast mode: no txn sync. */
  234. txn_no_sync = 1;
  235. break;
  236. case 'h': /* DB  home. */
  237. home = optarg;
  238. break;
  239. case 'i': /* Initialize the test. */
  240. iflag = 1;
  241. break;
  242. case 'n': /* Number of transactions */
  243. if ((ntxns = atoi(optarg)) <= 0)
  244. invarg(progname, ch, optarg);
  245. break;
  246. case 'S': /* Random number seed. */
  247. if ((seed = atoi(optarg)) <= 0)
  248. invarg(progname, ch, optarg);
  249. break;
  250. case 's': /* Number of history records */
  251. if ((history = atoi(optarg)) <= 0)
  252. invarg(progname, ch, optarg);
  253. break;
  254. case 't': /* Number of teller records */
  255. if ((tellers = atoi(optarg)) <= 0)
  256. invarg(progname, ch, optarg);
  257. break;
  258. case 'v': /* Verbose option. */
  259. verbose = 1;
  260. break;
  261. case '?':
  262. default:
  263. usage(progname);
  264. }
  265. argc -= optind;
  266. argv += optind;
  268. srand((u_int)seed);
  270. /* Initialize the database environment. */
  271. if ((dbenv = db_init(home,
  272.     progname, mpool, iflag, txn_no_sync ? DB_TXN_NOSYNC : 0)) == NULL)
  273. return (1);
  275. accounts = accounts == 0 ? ACCOUNTS : accounts;
  276. branches = branches == 0 ? BRANCHES : branches;
  277. tellers = tellers == 0 ? TELLERS : tellers;
  278. history = history == 0 ? HISTORY : history;
  280. if (verbose)
  281. printf("%ld Accounts, %ld Branches, %ld Tellers, %ld Historyn",
  282.     (long)accounts, (long)branches,
  283.     (long)tellers, (long)history);
  285. if (iflag) {
  286. if (ntxns != 0)
  287. usage(progname);
  288. tp_populate(dbenv,
  289.     accounts, branches, history, tellers, verbose);
  290. } else {
  291. if (ntxns == 0)
  292. usage(progname);
  293. tp_run(dbenv, ntxns, accounts, branches, tellers, verbose);
  294. }
  296. if ((ret = dbenv->close(dbenv, 0)) != 0) {
  297. fprintf(stderr, "%s: dbenv->close failed: %sn",
  298.     progname, db_strerror(ret));
  299. return (1);
  300. }
  302. return (0);
  303. }
  305. void
  306. invarg(progname, arg, str)
  307. char *progname;
  308. int arg;
  309. char *str;
  310. {
  311. (void)fprintf(stderr,
  312.     "%s: invalid argument for -%c: %sn", progname, arg, str);
  313. exit (1);
  314. }
  316. void
  317. usage(progname)
  318. char *progname;
  319. {
  320. char *a1, *a2;
  322. a1 = "[-fv] [-a accounts] [-b branches]n";
  323. a2 = "t[-c cache_size] [-h home] [-S seed] [-s history] [-t tellers]";
  324. (void)fprintf(stderr, "usage: %s -i %s %sn", progname, a1, a2);
  325. (void)fprintf(stderr,
  326.     "       %s -n transactions %s %sn", progname, a1, a2);
  327. exit(1);
  328. }
  329. #endif
  331. /*
  332.  * db_init --
  333.  * Initialize the environment.
  334.  */
  335. DB_ENV *
  336. db_init(home, prefix, cachesize, initializing, flags)
  337. char *home, *prefix;
  338. int cachesize, initializing, flags;
  339. {
  340. DB_ENV *dbenv;
  341. u_int32_t local_flags;
  342. int ret;
  344. if ((ret = db_env_create(&dbenv, 0)) != 0) {
  345. dbenv->err(dbenv, ret, "db_env_create");
  346. return (NULL);
  347. }
  348. dbenv->set_errfile(dbenv, stderr);
  349. dbenv->set_errpfx(dbenv, prefix);
  350. #ifdef HAVE_VXWORKS
  351. if ((ret = dbenv->set_shm_key(dbenv, VXSHM_KEY)) != 0) {
  352. dbenv->err(dbenv, ret, "set_shm_key");
  353. return (NULL);
  354. }
  355. #endif
  356. (void)dbenv->set_cachesize(dbenv, 0,
  357.     cachesize == 0 ? 4 * 1024 * 1024 : (u_int32_t)cachesize, 0);
  359. local_flags = flags | DB_CREATE | (initializing ? DB_INIT_MPOOL :
  360.     DB_INIT_TXN | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL);
  361. if ((ret = dbenv->open(dbenv, home, local_flags, 0)) != 0) {
  362. dbenv->err(dbenv, ret, "DBENV->open: %s", home);
  363. (void)dbenv->close(dbenv, 0);
  364. return (NULL);
  365. }
  366. return (dbenv);
  367. }
  369. /*
  370.  * Initialize the database to the specified number of accounts, branches,
  371.  * history records, and tellers.
  372.  */
  373. int
  374. tp_populate(env, accounts, branches, history, tellers, verbose)
  375. DB_ENV *env;
  376. int accounts, branches, history, tellers, verbose;
  377. {
  378. DB *dbp;
  379. char dbname[100];
  380. u_int32_t balance, idnum, oflags;
  381. u_int32_t end_anum, end_bnum, end_tnum;
  382. u_int32_t start_anum, start_bnum, start_tnum;
  383. int ret;
  385. idnum = BEGID;
  386. balance = 500000;
  387. #ifdef HAVE_VXWORKS
  388. oflags = DB_CREATE;
  389. #else
  390. oflags = DB_CREATE | DB_TRUNCATE;
  391. #endif
  393. if ((ret = db_create(&dbp, env, 0)) != 0) {
  394. env->err(env, ret, "db_create");
  395. return (ERROR_RETURN);
  396. }
  397. (void)dbp->set_h_nelem(dbp, (u_int32_t)accounts);
  399. snprintf(dbname, sizeof(dbname), "account");
  400. if ((ret = dbp->open(dbp, dbname, NULL,
  401.     DB_HASH, oflags, 0644)) != 0) {
  402. env->err(env, ret, "DB->open: account");
  403. return (ERROR_RETURN);
  404. }
  406. start_anum = idnum;
  407. populate(dbp, idnum, balance, accounts, "account");
  408. idnum += accounts;
  409. end_anum = idnum - 1;
  410. if ((ret = dbp->close(dbp, 0)) != 0) {
  411. env->err(env, ret, "DB->close: account");
  412. return (ERROR_RETURN);
  413. }
  414. if (verbose)
  415. printf("Populated accounts: %ld - %ldn",
  416.     (long)start_anum, (long)end_anum);
  418. /*
  419.  * Since the number of branches is very small, we want to use very
  420.  * small pages and only 1 key per page, i.e., key-locking instead
  421.  * of page locking.
  422.  */
  423. if ((ret = db_create(&dbp, env, 0)) != 0) {
  424. env->err(env, ret, "db_create");
  425. return (ERROR_RETURN);
  426. }
  427. (void)dbp->set_h_ffactor(dbp, 1);
  428. (void)dbp->set_h_nelem(dbp, (u_int32_t)branches);
  429. (void)dbp->set_pagesize(dbp, 512);
  430. snprintf(dbname, sizeof(dbname), "branch");
  431. if ((ret = dbp->open(dbp, dbname, NULL,
  432.     DB_HASH, oflags, 0644)) != 0) {
  433. env->err(env, ret, "DB->open: branch");
  434. return (ERROR_RETURN);
  435. }
  436. start_bnum = idnum;
  437. populate(dbp, idnum, balance, branches, "branch");
  438. idnum += branches;
  439. end_bnum = idnum - 1;
  440. if ((ret = dbp->close(dbp, 0)) != 0) {
  441. env->err(env, ret, "DB->close: branch");
  442. return (ERROR_RETURN);
  443. }
  444. if (verbose)
  445. printf("Populated branches: %ld - %ldn",
  446.     (long)start_bnum, (long)end_bnum);
  448. /*
  449.  * In the case of tellers, we also want small pages, but we'll let
  450.  * the fill factor dynamically adjust itself.
  451.  */
  452. if ((ret = db_create(&dbp, env, 0)) != 0) {
  453. env->err(env, ret, "db_create");
  454. return (ERROR_RETURN);
  455. }
  456. (void)dbp->set_h_ffactor(dbp, 0);
  457. (void)dbp->set_h_nelem(dbp, (u_int32_t)tellers);
  458. (void)dbp->set_pagesize(dbp, 512);
  459. snprintf(dbname, sizeof(dbname), "teller");
  460. if ((ret = dbp->open(dbp, dbname, NULL,
  461.     DB_HASH, oflags, 0644)) != 0) {
  462. env->err(env, ret, "DB->open: teller");
  463. return (ERROR_RETURN);
  464. }
  466. start_tnum = idnum;
  467. populate(dbp, idnum, balance, tellers, "teller");
  468. idnum += tellers;
  469. end_tnum = idnum - 1;
  470. if ((ret = dbp->close(dbp, 0)) != 0) {
  471. env->err(env, ret, "DB->close: teller");
  472. return (ERROR_RETURN);
  473. }
  474. if (verbose)
  475. printf("Populated tellers: %ld - %ldn",
  476.     (long)start_tnum, (long)end_tnum);
  478. if ((ret = db_create(&dbp, env, 0)) != 0) {
  479. env->err(env, ret, "db_create");
  480. return (ERROR_RETURN);
  481. }
  482. (void)dbp->set_re_len(dbp, HISTORY_LEN);
  483. snprintf(dbname, sizeof(dbname), "history");
  484. if ((ret = dbp->open(dbp, dbname, NULL,
  485.     DB_RECNO, oflags, 0644)) != 0) {
  486. env->err(env, ret, "DB->open: history");
  487. return (ERROR_RETURN);
  488. }
  490. hpopulate(dbp, history, accounts, branches, tellers);
  491. if ((ret = dbp->close(dbp, 0)) != 0) {
  492. env->err(env, ret, "DB->close: history");
  493. return (ERROR_RETURN);
  494. }
  495. return (0);
  496. }
  498. int
  499. populate(dbp, start_id, balance, nrecs, msg)
  500. DB *dbp;
  501. u_int32_t start_id, balance;
  502. int nrecs;
  503. char *msg;
  504. {
  505. DBT kdbt, ddbt;
  506. defrec drec;
  507. int i, ret;
  509. kdbt.flags = 0;
  510. kdbt.data = &drec.id;
  511. kdbt.size = sizeof(u_int32_t);
  512. ddbt.flags = 0;
  513. ddbt.data = &drec;
  514. ddbt.size = sizeof(drec);
  515. memset(&drec.pad[0], 1, sizeof(drec.pad));
  517. for (i = 0; i < nrecs; i++) {
  518. drec.id = start_id + (u_int32_t)i;
  519. drec.balance = balance;
  520. if ((ret =
  521.     (dbp->put)(dbp, NULL, &kdbt, &ddbt, DB_NOOVERWRITE)) != 0) {
  522. dbp->err(dbp,
  523.     ret, "Failure initializing %s filen", msg);
  524. return (ERROR_RETURN);
  525. }
  526. }
  527. return (0);
  528. }
  530. int
  531. hpopulate(dbp, history, accounts, branches, tellers)
  532. DB *dbp;
  533. int history, accounts, branches, tellers;
  534. {
  535. DBT kdbt, ddbt;
  536. histrec hrec;
  537. db_recno_t key;
  538. int i, ret;
  540. memset(&kdbt, 0, sizeof(kdbt));
  541. memset(&ddbt, 0, sizeof(ddbt));
  542. ddbt.data = &hrec;
  543. ddbt.size = sizeof(hrec);
  544. kdbt.data = &key;
  545. kdbt.size = sizeof(key);
  546. memset(&hrec.pad[0], 1, sizeof(hrec.pad));
  547. hrec.amount = 10;
  549. for (i = 1; i <= history; i++) {
  550. hrec.aid = random_id(ACCOUNT, accounts, branches, tellers);
  551. hrec.bid = random_id(BRANCH, accounts, branches, tellers);
  552. hrec.tid = random_id(TELLER, accounts, branches, tellers);
  553. if ((ret = dbp->put(dbp, NULL, &kdbt, &ddbt, DB_APPEND)) != 0) {
  554. dbp->err(dbp, ret, "dbp->put");
  555. return (ERROR_RETURN);
  556. }
  557. }
  558. return (0);
  559. }
  561. u_int32_t
  562. random_int(lo, hi)
  563. u_int32_t lo, hi;
  564. {
  565. u_int32_t ret;
  566. int t;
  568. #ifndef RAND_MAX
  569. #define RAND_MAX 0x7fffffff
  570. #endif
  571. t = rand();
  572. ret = (u_int32_t)(((double)t / ((double)(RAND_MAX) + 1)) *
  573.     (hi - lo + 1));
  574. ret += lo;
  575. return (ret);
  576. }
  578. u_int32_t
  579. random_id(type, accounts, branches, tellers)
  580. FTYPE type;
  581. int accounts, branches, tellers;
  582. {
  583. u_int32_t min, max, num;
  585. max = min = BEGID;
  586. num = accounts;
  587. switch(type) {
  588. case TELLER:
  589. min += branches;
  590. num = tellers;
  591. /* FALLTHROUGH */
  592. case BRANCH:
  593. if (type == BRANCH)
  594. num = branches;
  595. min += accounts;
  596. /* FALLTHROUGH */
  597. case ACCOUNT:
  598. max = min + num - 1;
  599. }
  600. return (random_int(min, max));
  601. }
  603. int
  604. tp_run(dbenv, n, accounts, branches, tellers, verbose)
  605. DB_ENV *dbenv;
  606. int n, accounts, branches, tellers, verbose;
  607. {
  608. DB *adb, *bdb, *hdb, *tdb;
  609. char dbname[100];
  610. double gtps, itps;
  611. int failed, ifailed, ret, txns;
  612. time_t starttime, curtime, lasttime;
  613. #ifndef DB_WIN32
  614. pid_t pid;
  616. pid = getpid();
  617. #else
  618. int pid;
  620. pid = 0;
  621. #endif
  623. /*
  624.  * Open the database files.
  625.  */
  626. if ((ret = db_create(&adb, dbenv, 0)) != 0) {
  627. dbenv->err(dbenv, ret, "db_create");
  628. return (ERROR_RETURN);
  629. }
  630. snprintf(dbname, sizeof(dbname), "account");
  631. if ((ret = adb->open(adb, dbname, NULL, DB_UNKNOWN, 0, 0)) != 0) {
  632. dbenv->err(dbenv, ret, "DB->open: account");
  633. return (ERROR_RETURN);
  634. }
  636. if ((ret = db_create(&bdb, dbenv, 0)) != 0) {
  637. dbenv->err(dbenv, ret, "db_create");
  638. return (ERROR_RETURN);
  639. }
  640. snprintf(dbname, sizeof(dbname), "branch");
  641. if ((ret = bdb->open(bdb, dbname, NULL, DB_UNKNOWN, 0, 0)) != 0) {
  642. dbenv->err(dbenv, ret, "DB->open: branch");
  643. return (ERROR_RETURN);
  644. }
  646. if ((ret = db_create(&tdb, dbenv, 0)) != 0) {
  647. dbenv->err(dbenv, ret, "db_create");
  648. return (ERROR_RETURN);
  649. }
  650. snprintf(dbname, sizeof(dbname), "teller");
  651. if ((ret = tdb->open(tdb, dbname, NULL, DB_UNKNOWN, 0, 0)) != 0) {
  652. dbenv->err(dbenv, ret, "DB->open: teller");
  653. return (ERROR_RETURN);
  654. }
  656. if ((ret = db_create(&hdb, dbenv, 0)) != 0) {
  657. dbenv->err(dbenv, ret, "db_create");
  658. return (ERROR_RETURN);
  659. }
  660. snprintf(dbname, sizeof(dbname), "history");
  661. if ((ret = hdb->open(hdb, dbname, NULL, DB_UNKNOWN, 0, 0)) != 0) {
  662. dbenv->err(dbenv, ret, "DB->open: history");
  663. return (ERROR_RETURN);
  664. }
  666. txns = failed = ifailed = 0;
  667. starttime = time(NULL);
  668. lasttime = starttime;
  669. while (n-- > 0) {
  670. txns++;
  671. ret = tp_txn(dbenv, adb, bdb, tdb, hdb,
  672.     accounts, branches, tellers, verbose);
  673. if (ret != 0) {
  674. failed++;
  675. ifailed++;
  676. }
  677. if (n % 5000 == 0) {
  678. curtime = time(NULL);
  679. gtps = (double)(txns - failed) / (curtime - starttime);
  680. itps = (double)(5000 - ifailed) / (curtime - lasttime);
  681. printf("[%d] %d txns %d failed ", (int)pid,
  682.     txns, failed);
  683. printf("%6.2f TPS (gross) %6.2f TPS (interval)n",
  684.    gtps, itps);
  685. lasttime = curtime;
  686. ifailed = 0;
  687. }
  688. }
  690. (void)adb->close(adb, 0);
  691. (void)bdb->close(bdb, 0);
  692. (void)tdb->close(tdb, 0);
  693. (void)hdb->close(hdb, 0);
  695. printf("%ld transactions begun %ld failedn", (long)txns, (long)failed);
  696. return (0);
  697. }
  699. /*
  700.  * XXX Figure out the appropriate way to pick out IDs.
  701.  */
  702. int
  703. tp_txn(dbenv, adb, bdb, tdb, hdb, accounts, branches, tellers, verbose)
  704. DB_ENV *dbenv;
  705. DB *adb, *bdb, *tdb, *hdb;
  706. int accounts, branches, tellers, verbose;
  707. {
  708. DBC *acurs, *bcurs, *tcurs;
  709. DBT d_dbt, d_histdbt, k_dbt, k_histdbt;
  710. DB_TXN *t;
  711. db_recno_t key;
  712. defrec rec;
  713. histrec hrec;
  714. int account, branch, teller;
  716. t = NULL;
  717. acurs = bcurs = tcurs = NULL;
  719. /*
  720.  * XXX We could move a lot of this into the driver to make this
  721.  * faster.
  722.  */
  723. account = random_id(ACCOUNT, accounts, branches, tellers);
  724. branch = random_id(BRANCH, accounts, branches, tellers);
  725. teller = random_id(TELLER, accounts, branches, tellers);
  727. memset(&d_histdbt, 0, sizeof(d_histdbt));
  729. memset(&k_histdbt, 0, sizeof(k_histdbt));
  730. k_histdbt.data = &key;
  731. k_histdbt.size = sizeof(key);
  733. memset(&k_dbt, 0, sizeof(k_dbt));
  734. k_dbt.size = sizeof(int);
  736. memset(&d_dbt, 0, sizeof(d_dbt));
  737. d_dbt.flags = DB_DBT_USERMEM;
  738. d_dbt.data = &rec;
  739. d_dbt.ulen = sizeof(rec);
  741. hrec.aid = account;
  742. hrec.bid = branch;
  743. hrec.tid = teller;
  744. hrec.amount = 10;
  745. /* Request 0 bytes since we're just positioning. */
  746. d_histdbt.flags = DB_DBT_PARTIAL;
  748. /* START TIMING */
  749. if (txn_begin(dbenv, NULL, &t, 0) != 0)
  750. goto err;
  752. if (adb->cursor(adb, t, &acurs, 0) != 0 ||
  753.     bdb->cursor(bdb, t, &bcurs, 0) != 0 ||
  754.     tdb->cursor(tdb, t, &tcurs, 0) != 0)
  755. goto err;
  757. /* Account record */
  758. k_dbt.data = &account;
  759. if (acurs->c_get(acurs, &k_dbt, &d_dbt, DB_SET) != 0)
  760. goto err;
  761. rec.balance += 10;
  762. if (acurs->c_put(acurs, &k_dbt, &d_dbt, DB_CURRENT) != 0)
  763. goto err;
  765. /* Branch record */
  766. k_dbt.data = &branch;
  767. if (bcurs->c_get(bcurs, &k_dbt, &d_dbt, DB_SET) != 0)
  768. goto err;
  769. rec.balance += 10;
  770. if (bcurs->c_put(bcurs, &k_dbt, &d_dbt, DB_CURRENT) != 0)
  771. goto err;
  773. /* Teller record */
  774. k_dbt.data = &teller;
  775. if (tcurs->c_get(tcurs, &k_dbt, &d_dbt, DB_SET) != 0)
  776. goto err;
  777. rec.balance += 10;
  778. if (tcurs->c_put(tcurs, &k_dbt, &d_dbt, DB_CURRENT) != 0)
  779. goto err;
  781. /* History record */
  782. d_histdbt.flags = 0;
  783. d_histdbt.data = &hrec;
  784. d_histdbt.ulen = sizeof(hrec);
  785. if (hdb->put(hdb, t, &k_histdbt, &d_histdbt, DB_APPEND) != 0)
  786. goto err;
  788. if (acurs->c_close(acurs) != 0 || bcurs->c_close(bcurs) != 0 ||
  789.     tcurs->c_close(tcurs) != 0)
  790. goto err;
  792. if (txn_commit(t, 0) != 0)
  793. goto err;
  795. /* END TIMING */
  796. return (0);
  798. err: if (acurs != NULL)
  799. (void)acurs->c_close(acurs);
  800. if (bcurs != NULL)
  801. (void)bcurs->c_close(bcurs);
  802. if (tcurs != NULL)
  803. (void)tcurs->c_close(tcurs);
  804. if (t != NULL)
  805. (void)txn_abort(t);
  807. if (verbose)
  808. printf("Transaction A=%ld B=%ld T=%ld failedn",
  809.     (long)account, (long)branch, (long)teller);
  810. return (-1);
  811. }