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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
tm.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：14k
源码类别：

MySQL数据库

开发平台：

Visual C++

tm.c：源码内容
  1. /*
  2.  * Standalone mutex tester for Berkeley DB mutexes.
  3.  */
  4. #include "db_config.h"
  6. #include <sys/types.h>
  7. #include <sys/mman.h>
  8. #include <sys/stat.h>
  9. #include <sys/wait.h>
  11. #include <errno.h>
  12. #include <fcntl.h>
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include <string.h>
  16. #include <unistd.h>
  18. #if defined(HAVE_MUTEX_PTHREADS) || defined(BUILD_PTHREADS_ANYWAY)
  19. #include <pthread.h>
  20. #endif
  22. #include "db_int.h"
  24. void  exec_proc();
  25. void  tm_file_init();
  26. void  map_file();
  27. void  run_proc();
  28. void *run_thread();
  29. void *run_thread_wake();
  30. void  tm_mutex_destroy();
  31. void  tm_mutex_init();
  32. void  tm_mutex_stats();
  33. void  unmap_file();
  35. #define MUTEX_WAKEME 0x80 /* Wake-me flag. */
  37. DB_ENV  dbenv; /* Fake out DB. */
  38. size_t  len; /* Backing file size. */
  39. int  align; /* Mutex alignment in file. */
  40. int  quit; /* End-of-test flag. */
  41. char *file = "mutex.file"; /* Backing file. */
  43. int  maxlocks = 20; /* -l: Backing locks. */
  44. int  nlocks = 10000; /* -n: Locks per processes. */
  45. int  nprocs = 20; /* -p: Processes. */
  46. int  child; /* -s: Slave. */
  47. int  nthreads = 1; /* -t: Threads. */
  48. int  verbose; /* -v: Verbosity. */
  50. int
  51. main(argc, argv)
  52. int argc;
  53. char *argv[];
  54. {
  55. extern int optind;
  56. extern char *optarg;
  57. pid_t pid;
  58. int ch, eval, i, status;
  59. char *tmpath;
  61. tmpath = argv[0];
  62. while ((ch = getopt(argc, argv, "l:n:p:st:v")) != EOF)
  63. switch(ch) {
  64. case 'l':
  65. maxlocks = atoi(optarg);
  66. break;
  67. case 'n':
  68. nlocks = atoi(optarg);
  69. break;
  70. case 'p':
  71. nprocs = atoi(optarg);
  72. break;
  73. case 's':
  74. child = 1;
  75. break;
  76. case 't':
  77. nthreads = atoi(optarg);
  78. #if !defined(HAVE_MUTEX_PTHREADS) && !defined(BUILD_PTHREADS_ANYWAY)
  79. if (nthreads != 1) {
  80. (void)fprintf(stderr,
  81. "tm: pthreads not available or not compiled for this platform.n");
  82. return (EXIT_FAILURE);
  83. }
  84. #endif
  85. break;
  86. case 'v':
  87. verbose = 1;
  88. break;
  89. case '?':
  90. default:
  91. (void)fprintf(stderr,
  92.     "usage: tm [-v] [-l maxlocks] [-n locks] [-p procs] [-t threads]n");
  93. return (EXIT_FAILURE);
  94. }
  95. argc -= optind;
  96. argv += optind;
  98. /*
  99.  * The file layout:
  100.  * DB_MUTEX[1] per-thread mutex array lock
  101.  * DB_MUTEX[nthreads] per-thread mutex array
  102.  * DB_MUTEX[maxlocks] per-lock mutex array
  103.  * u_long[maxlocks][2] per-lock ID array
  104.  */
  105. align = ALIGN(sizeof(DB_MUTEX) * 2, MUTEX_ALIGN);
  106. len =
  107.     align * (1 + nthreads +  maxlocks) + sizeof(u_long) * maxlocks * 2;
  108. printf(
  109.     "mutex alignment %d, structure alignment %d, backing file %lu bytesn",
  110.     MUTEX_ALIGN, align, (u_long)len);
  112. if (child) {
  113. run_proc();
  114. return (EXIT_SUCCESS);
  115. }
  117. tm_file_init();
  118. tm_mutex_init();
  120. printf(
  121.     "%d proc, %d threads/proc, %d lock requests from %d locks:n",
  122.     nprocs, nthreads, nlocks, maxlocks);
  123. for (i = 0; i < nprocs; ++i)
  124. switch (fork()) {
  125. case -1:
  126. perror("fork");
  127. return (EXIT_FAILURE);
  128. case 0:
  129. exec_proc(tmpath);
  130. break;
  131. default:
  132. break;
  133. }
  135. eval = EXIT_SUCCESS;
  136. while ((pid = wait(&status)) != (pid_t)-1) {
  137. fprintf(stderr,
  138.     "%lu: exited %dn", (u_long)pid, WEXITSTATUS(status));
  139. if (WEXITSTATUS(status) != 0)
  140. eval = EXIT_FAILURE;
  141. }
  143. tm_mutex_stats();
  144. tm_mutex_destroy();
  146. printf("tm: exit status: %sn",
  147.     eval == EXIT_SUCCESS ? "success" : "failed!");
  148. return (eval);
  149. }
  151. void
  152. exec_proc(tmpath)
  153. char *tmpath;
  154. {
  155. char *argv[10], **ap, b_l[10], b_n[10], b_t[10];
  157. ap = &argv[0];
  158. *ap++ = "tm";
  159. sprintf(b_l, "-l%d", maxlocks);
  160. *ap++ = b_l;
  161. sprintf(b_n, "-n%d", nlocks);
  162. *ap++ = b_n;
  163. *ap++ = "-s";
  164. sprintf(b_t, "-t%d", nthreads);
  165. *ap++ = b_t;
  166. if (verbose)
  167. *ap++ = "-v";
  169. *ap = NULL;
  170. execvp(tmpath, argv);
  172. fprintf(stderr, "%s: %sn", tmpath, strerror(errno));
  173. exit(EXIT_FAILURE);
  174. }
  176. void
  177. run_proc()
  178. {
  179. #if defined(HAVE_MUTEX_PTHREADS) || defined(BUILD_PTHREADS_ANYWAY)
  180. pthread_t *kidsp, wakep;
  181. int i, status;
  182. void *retp;
  183. #endif
  184. __os_sleep(&dbenv, 3, 0); /* Let everyone catch up. */
  186. srand((u_int)time(NULL) / getpid()); /* Initialize random numbers. */
  188. if (nthreads == 1) /* Simple case. */
  189. exit((int)run_thread((void *)0));
  191. #if defined(HAVE_MUTEX_PTHREADS) || defined(BUILD_PTHREADS_ANYWAY)
  192. /*
  193.  * Spawn off threads.  We have nthreads all locking and going to
  194.  * sleep, and one other thread cycling through and waking them up.
  195.  */
  196. if ((kidsp =
  197.     (pthread_t *)calloc(sizeof(pthread_t), nthreads)) == NULL) {
  198. fprintf(stderr, "tm: %sn", strerror(errno));
  199. exit(EXIT_FAILURE);
  200. }
  201. for (i = 0; i < nthreads; i++)
  202. if ((errno = pthread_create(
  203.     &kidsp[i], NULL, run_thread, (void *)i)) != 0) {
  204. fprintf(stderr, "tm: failed spawning thread %d: %sn",
  205.     i, strerror(errno));
  206. exit(EXIT_FAILURE);
  207. }
  209. if ((errno = pthread_create(
  210.     &wakep, NULL, run_thread_wake, (void *)0)) != 0) {
  211. fprintf(stderr, "tm: failed spawning wakeup thread: %sn",
  212.     strerror(errno));
  213. exit(EXIT_FAILURE);
  214. }
  216. /* Wait for the threads to exit. */
  217. status = 0;
  218. for (i = 0; i < nthreads; i++) {
  219. pthread_join(kidsp[i], &retp);
  220. if (retp != NULL) {
  221. fprintf(stderr,
  222.     "tm: thread %d exited with errorn", i);
  223. status = EXIT_FAILURE;
  224. }
  225. }
  226. free(kidsp);
  228. /* Signal wakeup thread to stop. */
  229. quit = 1;
  230. pthread_join(wakep, &retp);
  231. if (retp != NULL) {
  232. fprintf(stderr, "tm: wakeup thread exited with errorn");
  233. status = EXIT_FAILURE;
  234. }
  236. exit(status);
  237. #endif
  238. }
  240. void *
  241. run_thread(arg)
  242. void *arg;
  243. {
  244. DB_MUTEX *gm_addr, *lm_addr, *tm_addr, *mp;
  245. u_long gid1, gid2, *id_addr;
  246. int fd, i, lock, id, nl, remap;
  248. /* Set local and global per-thread ID. */
  249. id = (int)arg;
  250. gid1 = (u_long)getpid();
  251. #if defined(HAVE_MUTEX_PTHREADS) || defined(BUILD_PTHREADS_ANYWAY)
  252. gid2 = (u_long)pthread_self();
  253. #else
  254. gid2 = 0;
  255. #endif
  256. printf("tPID: %lu; TID: %lx; ID: %dn", gid1, gid2, id);
  258. nl = nlocks;
  259. for (gm_addr = NULL, remap = 0;;) {
  260. /* Map in the file as necessary. */
  261. if (gm_addr == NULL) {
  262. map_file(&gm_addr, &tm_addr, &lm_addr, &id_addr, &fd);
  263. remap = (rand() % 100) + 35;
  264. }
  266. /* Select and acquire a data lock. */
  267. lock = rand() % maxlocks;
  268. mp = (DB_MUTEX *)((u_int8_t *)lm_addr + lock * align);
  269. if (verbose)
  270. printf("%lu/%lx: %03dn", gid1, gid2, lock);
  272. if (__db_mutex_lock(&dbenv, mp)) {
  273. fprintf(stderr,
  274.     "%lu/%lx: never got lockn", gid1, gid2);
  275. return ((void *)EXIT_FAILURE);
  276. }
  277. if (id_addr[lock * 2] != 0) {
  278. fprintf(stderr,
  279.     "RACE! (%lu/%lx granted lock %d held by %lu/%lx)n",
  280.     gid1, gid2,
  281.     lock, id_addr[lock * 2], id_addr[lock * 2 + 1]);
  282. return ((void *)EXIT_FAILURE);
  283. }
  284. id_addr[lock * 2] = gid1;
  285. id_addr[lock * 2 + 1] = gid2;
  287. /*
  288.  * Pretend to do some work, periodically checking to see if
  289.  * we still hold the mutex.
  290.  */
  291. for (i = 0; i < 3; ++i) {
  292. __os_sleep(&dbenv, 0, rand() % 3);
  293. if (id_addr[lock * 2] != gid1 ||
  294.     id_addr[lock * 2 + 1] != gid2) {
  295. fprintf(stderr,
  296.     "RACE! (%lu/%lx stole lock %d from %lu/%lx)n",
  297.     id_addr[lock * 2],
  298.     id_addr[lock * 2 + 1], lock, gid1, gid2);
  299. return ((void *)EXIT_FAILURE);
  300. }
  301. }
  303. #if defined(HAVE_MUTEX_PTHREADS) || defined(BUILD_PTHREADS_ANYWAY)
  304. /*
  305.  * Test self-blocking and unlocking by other threads/processes:
  306.  *
  307.  * acquire the global lock
  308.  * set our wakeup flag
  309.  * release the global lock
  310.  * acquire our per-thread lock
  311.  *
  312.  * The wakeup thread will wake us up.
  313.  */
  314. if (__db_mutex_lock(&dbenv, gm_addr)) {
  315. fprintf(stderr, "%lu/%lx: global lockn", gid1, gid2);
  316. return ((void *)EXIT_FAILURE);
  317. }
  318. mp = (DB_MUTEX *)((u_int8_t *)tm_addr + id * align);
  319. F_SET(mp, MUTEX_WAKEME);
  320. if (__db_mutex_unlock(&dbenv, gm_addr)) {
  321. fprintf(stderr,
  322.     "%lu/%lx: per-thread wakeup failedn", gid1, gid2);
  323. return ((void *)EXIT_FAILURE);
  324. }
  325. if (__db_mutex_lock(&dbenv, mp)) {
  326. fprintf(stderr,
  327.     "%lu/%lx: per-thread lockn", gid1, gid2);
  328. return ((void *)EXIT_FAILURE);
  329. }
  330. /* Time passes... */
  331. if (F_ISSET(mp, MUTEX_WAKEME)) {
  332. fprintf(stderr, "%lu/%lx: %03d wakeup flag still setn",
  333.     gid1, gid2, id);
  334. return ((void *)EXIT_FAILURE);
  335. }
  336. #endif
  338. /* Release the data lock. */
  339. id_addr[lock * 2] = id_addr[lock * 2 + 1] = 0;
  340. mp = (DB_MUTEX *)((u_int8_t *)lm_addr + lock * align);
  341. if (__db_mutex_unlock(&dbenv, mp)) {
  342. fprintf(stderr, "%lu/%lx: wakeup failedn", gid1, gid2);
  343. return ((void *)EXIT_FAILURE);
  344. }
  346. if (--nl % 100 == 0)
  347. fprintf(stderr, "%lu/%lx: %dn", gid1, gid2, nl);
  349. if (nl == 0 || --remap == 0) {
  350. unmap_file((void *)gm_addr, fd);
  351. gm_addr = NULL;
  353. if (nl == 0)
  354. break;
  356. __os_sleep(&dbenv, rand() % 3, 0);
  357. }
  358. }
  360. return (NULL);
  361. }
  363. #if defined(HAVE_MUTEX_PTHREADS) || defined(BUILD_PTHREADS_ANYWAY)
  364. /*
  365.  * run_thread_wake --
  366.  * Thread to wake up other threads that are sleeping.
  367.  */
  368. void *
  369. run_thread_wake(arg)
  370. void *arg;
  371. {
  372. DB_MUTEX *gm_addr, *tm_addr, *mp;
  373. int fd, id;
  375. arg = NULL;
  376. map_file(&gm_addr, &tm_addr, NULL, NULL, &fd);
  378. /* Loop, waking up sleepers and periodically sleeping ourselves. */
  379. while (!quit) {
  380. id = 0;
  382. /* Acquire the global lock. */
  383. retry: if (__db_mutex_lock(&dbenv, gm_addr)) {
  384. fprintf(stderr, "wt: global lock failedn");
  385. return ((void *)EXIT_FAILURE);
  386. }
  388. next: mp = (DB_MUTEX *)((u_int8_t *)tm_addr + id * align);
  389. if (F_ISSET(mp, MUTEX_WAKEME)) {
  390. F_CLR(mp, MUTEX_WAKEME);
  391. if (__db_mutex_unlock(&dbenv, mp)) {
  392. fprintf(stderr, "wt: wakeup failedn");
  393. return ((void *)EXIT_FAILURE);
  394. }
  395. }
  397. if (++id < nthreads && id % 3 != 0)
  398. goto next;
  400. if (__db_mutex_unlock(&dbenv, gm_addr)) {
  401. fprintf(stderr, "wt: global unlock failedn");
  402. return ((void *)EXIT_FAILURE);
  403. }
  405. __os_sleep(&dbenv, 0, 500);
  407. if (id < nthreads)
  408. goto retry;
  409. }
  410. return (NULL);
  411. }
  412. #endif
  414. /*
  415.  * tm_file_init --
  416.  * Initialize the backing file.
  417.  */
  418. void
  419. tm_file_init()
  420. {
  421. int fd;
  424. /* Initialize the backing file. */
  425. printf("Create the backing file...n");
  426. #ifdef HAVE_QNX
  427. (void)shm_unlink(file);
  428. if ((fd = shm_open(file, O_CREAT | O_RDWR | O_TRUNC,
  429. #else
  430. (void)remove(file);
  431. if ((fd = open(file, O_CREAT | O_RDWR | O_TRUNC,
  432. #endif
  434.     S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)) == -1) {
  435. (void)fprintf(stderr, "%s: open: %sn", file, strerror(errno));
  436. exit(EXIT_FAILURE);
  437. }
  438. if (lseek(fd, (off_t)len, SEEK_SET) != len || write(fd, &fd, 1) != 1) {
  439. (void)fprintf(stderr,
  440.     "%s: seek/write: %sn", file, strerror(errno));
  441. exit(EXIT_FAILURE);
  442. }
  443. (void)close(fd);
  444. }
  446. /*
  447.  * tm_mutex_init --
  448.  * Initialize the mutexes.
  449.  */
  450. void
  451. tm_mutex_init()
  452. {
  453. DB_MUTEX *gm_addr, *lm_addr, *mp, *tm_addr;
  454. int fd, i;
  456. map_file(&gm_addr, &tm_addr, &lm_addr, NULL, &fd);
  458. printf("Initialize the global mutex...n");
  459. if (__db_mutex_init_int(&dbenv, gm_addr, 0, 0)) {
  460. fprintf(stderr,
  461.     "__db_mutex_init (global): %sn", strerror(errno));
  462. exit(EXIT_FAILURE);
  463. }
  465. printf("Initialize the per-thread mutexes...n");
  466. for (i = 1, mp = tm_addr;
  467.     i <= nthreads; ++i, mp = (DB_MUTEX *)((u_int8_t *)mp + align)) {
  468. if (__db_mutex_init_int(&dbenv, mp, 0, MUTEX_SELF_BLOCK)) {
  469. fprintf(stderr, "__db_mutex_init (per-thread %d): %sn",
  470.     i, strerror(errno));
  471. exit(EXIT_FAILURE);
  472. }
  473. if (__db_mutex_lock(&dbenv, mp)) {
  474. fprintf(stderr,
  475.     "__db_mutex_init (per-thread %d) lock: %sn",
  476.     i, strerror(errno));
  477. exit(EXIT_FAILURE);
  478. }
  479. }
  481. printf("Initialize the per-lock mutexes...n");
  482. for (i = 1, mp = lm_addr;
  483.     i <= maxlocks; ++i, mp = (DB_MUTEX *)((u_int8_t *)mp + align))
  484. if (__db_mutex_init_int(&dbenv, mp, 0, 0)) {
  485. fprintf(stderr, "__db_mutex_init (per-lock: %d): %sn",
  486.     i, strerror(errno));
  487. exit(EXIT_FAILURE);
  488. }
  490. unmap_file((void *)gm_addr, fd);
  491. }
  493. /*
  494.  * tm_mutex_destroy --
  495.  * Destroy the mutexes.
  496.  */
  497. void
  498. tm_mutex_destroy()
  499. {
  500. DB_MUTEX *gm_addr, *lm_addr, *mp, *tm_addr;
  501. int fd, i;
  503. map_file(&gm_addr, &tm_addr, &lm_addr, NULL, &fd);
  505. printf("Destroy the global mutex...n");
  506. if (__db_mutex_destroy(gm_addr)) {
  507. fprintf(stderr,
  508.     "__db_mutex_destroy (global): %sn", strerror(errno));
  509. exit(EXIT_FAILURE);
  510. }
  512. printf("Destroy the per-thread mutexes...n");
  513. for (i = 1, mp = tm_addr;
  514.     i <= nthreads; ++i, mp = (DB_MUTEX *)((u_int8_t *)mp + align)) {
  515. if (__db_mutex_destroy(mp)) {
  516. fprintf(stderr,
  517.     "__db_mutex_destroy (per-thread %d): %sn",
  518.     i, strerror(errno));
  519. exit(EXIT_FAILURE);
  520. }
  521. }
  523. printf("Destroy the per-lock mutexes...n");
  524. for (i = 1, mp = lm_addr;
  525.     i <= maxlocks; ++i, mp = (DB_MUTEX *)((u_int8_t *)mp + align))
  526. if (__db_mutex_destroy(mp)) {
  527. fprintf(stderr,
  528.     "__db_mutex_destroy (per-lock: %d): %sn",
  529.     i, strerror(errno));
  530. exit(EXIT_FAILURE);
  531. }
  533. unmap_file((void *)gm_addr, fd);
  534. #ifdef HAVE_QNX
  535. (void)shm_unlink(file);
  536. #endif
  537. }
  539. /*
  540.  * tm_mutex_stats --
  541.  * Display mutex statistics.
  542.  */
  543. void
  544. tm_mutex_stats()
  545. {
  546. DB_MUTEX *gm_addr, *lm_addr, *mp;
  547. int fd, i;
  549. map_file(&gm_addr, NULL, &lm_addr, NULL, &fd);
  551. printf("Per-lock mutex statistics...n");
  552. for (i = 1, mp = lm_addr;
  553.     i <= maxlocks; ++i, mp = (DB_MUTEX *)((u_int8_t *)mp + align))
  554. printf("mutex %2d: wait: %lu; no wait %lun", i,
  555.     (u_long)mp->mutex_set_wait, (u_long)mp->mutex_set_nowait);
  557. unmap_file((void *)gm_addr, fd);
  558. }
  560. /*
  561.  * map_file --
  562.  * Map in the backing file.
  563.  */
  564. void
  565. map_file(gm_addrp, tm_addrp, lm_addrp, id_addrp, fdp)
  566. DB_MUTEX **gm_addrp, **tm_addrp, **lm_addrp;
  567. u_long **id_addrp;
  568. int *fdp;
  569. {
  570. void *maddr;
  571. int fd;
  573. #ifndef MAP_FAILED
  574. #define MAP_FAILED (void *)-1
  575. #endif
  576. #ifndef MAP_FILE
  577. #define MAP_FILE 0
  578. #endif
  579. #ifdef HAVE_QNX
  580. if ((fd = shm_open(file, O_RDWR, 0)) == -1) {
  581. #else
  582. if ((fd = open(file, O_RDWR, 0)) == -1) {
  583. #endif
  584. fprintf(stderr, "%s: open %sn", file, strerror(errno));
  585. exit(EXIT_FAILURE);
  586. }
  588. maddr = mmap(NULL, len,
  589.     PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, fd, (off_t)0);
  590. if (maddr == MAP_FAILED) {
  591. fprintf(stderr, "%s: mmap: %sn", file, strerror(errno));
  592. exit(EXIT_FAILURE);
  593. }
  595. if (gm_addrp != NULL)
  596. *gm_addrp = (DB_MUTEX *)maddr;
  597. maddr = (u_int8_t *)maddr + align;
  598. if (tm_addrp != NULL)
  599. *tm_addrp = (DB_MUTEX *)maddr;
  600. maddr = (u_int8_t *)maddr + align * nthreads;
  601. if (lm_addrp != NULL)
  602. *lm_addrp = (DB_MUTEX *)maddr;
  603. maddr = (u_int8_t *)maddr + align * maxlocks;
  604. if (id_addrp != NULL)
  605. *id_addrp = (u_long *)maddr;
  606. if (fdp != NULL)
  607. *fdp = fd;
  608. }
  610. /*
  611.  * unmap_file --
  612.  * Discard backing file map.
  613.  */
  614. void
  615. unmap_file(maddr, fd)
  616. void *maddr;
  617. int fd;
  618. {
  619. if (munmap(maddr, len) != 0) {
  620. fprintf(stderr, "munmap: %sn", strerror(errno));
  621. exit(EXIT_FAILURE);
  622. }
  623. if (close(fd) != 0) {
  624. fprintf(stderr, "close: %sn", strerror(errno));
  625. exit(EXIT_FAILURE);
  626. }
  627. }