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

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

MySQL数据库

开发平台：

Visual C++

mp_stat.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996, 1997, 1998, 1999, 2000
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. #include "db_config.h"
  9. #ifndef lint
  10. static const char revid[] = "$Id: mp_stat.c,v 11.21 2001/01/09 16:59:30 bostic Exp $";
  11. #endif /* not lint */
  13. #ifndef NO_SYSTEM_INCLUDES
  14. #include <sys/types.h>
  16. #include <stdio.h>
  17. #include <string.h>
  18. #include <unistd.h>
  19. #endif
  21. #ifdef  HAVE_RPC
  22. #include "db_server.h"
  23. #endif
  25. #include "db_int.h"
  26. #include "db_page.h"
  27. #include "db_shash.h"
  28. #include "db_am.h"
  29. #include "mp.h"
  31. #ifdef HAVE_RPC
  32. #include "gen_client_ext.h"
  33. #include "rpc_client_ext.h"
  34. #endif
  36. static void __memp_dumpcache
  37. __P((DB_MPOOL *, REGINFO *, size_t *, FILE *, u_int32_t));
  38. static void __memp_pbh __P((DB_MPOOL *, BH *, size_t *, FILE *));
  40. /*
  41.  * memp_stat --
  42.  * Display MPOOL statistics.
  43.  */
  44. int
  45. memp_stat(dbenv, gspp, fspp, db_malloc)
  46. DB_ENV *dbenv;
  47. DB_MPOOL_STAT **gspp;
  48. DB_MPOOL_FSTAT ***fspp;
  49. void *(*db_malloc) __P((size_t));
  50. {
  51. DB_MPOOL *dbmp;
  52. DB_MPOOL_FSTAT **tfsp, *tstruct;
  53. DB_MPOOL_STAT *sp;
  54. MPOOL *c_mp, *mp;
  55. MPOOLFILE *mfp;
  56. char *tname;
  57. size_t len, nlen;
  58. u_int32_t i;
  59. int ret;
  60. char *name;
  62. #ifdef HAVE_RPC
  63. if (F_ISSET(dbenv, DB_ENV_RPCCLIENT))
  64. return (__dbcl_memp_stat(dbenv, gspp, fspp, db_malloc));
  65. #endif
  67. PANIC_CHECK(dbenv);
  68. ENV_REQUIRES_CONFIG(dbenv, dbenv->mp_handle, DB_INIT_MPOOL);
  70. dbmp = dbenv->mp_handle;
  71. sp = NULL;
  73. /* Global statistics. */
  74. mp = dbmp->reginfo[0].primary;
  75. if (gspp != NULL) {
  76. *gspp = NULL;
  78. if ((ret = __os_calloc(dbenv, 1, sizeof(**gspp), gspp)) != 0)
  79. return (ret);
  80. sp = *gspp;
  82. /*
  83.  * Initialization and information that is not maintained on
  84.  * a per-cache basis.
  85.  */
  86. sp->st_hash_longest = 0;
  87. sp->st_region_wait = dbmp->reginfo[0].rp->mutex.mutex_set_wait;
  88. sp->st_region_nowait =
  89.     dbmp->reginfo[0].rp->mutex.mutex_set_nowait;
  90. sp->st_gbytes = dbenv->mp_gbytes;
  91. sp->st_bytes = dbenv->mp_bytes;
  92. sp->st_ncache = dbmp->nreg;
  93. sp->st_regsize = dbmp->reginfo[0].rp->size;
  95. R_LOCK(dbenv, dbmp->reginfo);
  97. /* Walk the cache list and accumulate the global information. */
  98. for (i = 0; i < mp->nreg; ++i) {
  99. c_mp = dbmp->reginfo[i].primary;
  100. sp->st_cache_hit += c_mp->stat.st_cache_hit;
  101. sp->st_cache_miss += c_mp->stat.st_cache_miss;
  102. sp->st_map += c_mp->stat.st_map;
  103. sp->st_page_create += c_mp->stat.st_page_create;
  104. sp->st_page_in += c_mp->stat.st_page_in;
  105. sp->st_page_out += c_mp->stat.st_page_out;
  106. sp->st_ro_evict += c_mp->stat.st_ro_evict;
  107. sp->st_rw_evict += c_mp->stat.st_rw_evict;
  108. sp->st_hash_buckets += c_mp->stat.st_hash_buckets;
  109. sp->st_hash_searches += c_mp->stat.st_hash_searches;
  110. if (c_mp->stat.st_hash_longest > sp->st_hash_longest)
  111. sp->st_hash_longest =
  112.     c_mp->stat.st_hash_longest;
  113. sp->st_hash_examined += c_mp->stat.st_hash_examined;
  114. sp->st_page_clean += c_mp->stat.st_page_clean;
  115. sp->st_page_dirty += c_mp->stat.st_page_dirty;
  116. sp->st_page_trickle += c_mp->stat.st_page_trickle;
  117. sp->st_region_wait += c_mp->stat.st_region_wait;
  118. sp->st_region_nowait += c_mp->stat.st_region_nowait;
  119. }
  121. /*
  122.  * We have duplicate statistics fields in the cache and
  123.  * per-file structures.  The counters are only incremented
  124.  * in the per-file structures, though.  The intent is that
  125.  * if we ever flush files from the pool we can save their
  126.  * last known totals in the cache structure.
  127.  */
  128. for (mfp = SH_TAILQ_FIRST(&mp->mpfq, __mpoolfile);
  129.     mfp != NULL; mfp = SH_TAILQ_NEXT(mfp, q, __mpoolfile)) {
  130. sp->st_cache_hit += mfp->stat.st_cache_hit;
  131. sp->st_cache_miss += mfp->stat.st_cache_miss;
  132. sp->st_map += mfp->stat.st_map;
  133. sp->st_page_create += mfp->stat.st_page_create;
  134. sp->st_page_in += mfp->stat.st_page_in;
  135. sp->st_page_out += mfp->stat.st_page_out;
  136. }
  138. R_UNLOCK(dbenv, dbmp->reginfo);
  139. }
  141. /* Per-file statistics. */
  142. if (fspp != NULL) {
  143. *fspp = NULL;
  145. R_LOCK(dbenv, dbmp->reginfo);
  147. /* Count the MPOOLFILE structures. */
  148. for (i = 0, len = 0,
  149.     mfp = SH_TAILQ_FIRST(&mp->mpfq, __mpoolfile);
  150.     mfp != NULL;
  151.     ++i, mfp = SH_TAILQ_NEXT(mfp, q, __mpoolfile))
  152. len += sizeof(DB_MPOOL_FSTAT *) +
  153.     sizeof(DB_MPOOL_FSTAT) +
  154.     strlen(__memp_fns(dbmp, mfp)) + 1;
  155. len += sizeof(DB_MPOOL_FSTAT *); /* Trailing NULL */
  157. R_UNLOCK(dbenv, dbmp->reginfo);
  159. if (len == 0)
  160. return (0);
  162. /* Allocate space */
  163. if ((ret = __os_malloc(dbenv, len, db_malloc, fspp)) != 0)
  164. return (ret);
  166. R_LOCK(dbenv, dbmp->reginfo);
  168. /*
  169.  * Build each individual entry.  We assume that an array of
  170.  * pointers are aligned correctly to be followed by an array
  171.  * of structures, which should be safe (in this particular
  172.  * case, the first element of the structure is a pointer, so
  173.  * we're doubly safe).  The array is followed by space for
  174.  * the text file names.
  175.  *
  176.  * Add 1 to i because we need to skip over the NULL.
  177.  */
  178. tfsp = *fspp;
  179. tstruct = (DB_MPOOL_FSTAT *)(tfsp + i + 1);
  180. tname = (char *)(tstruct + i);
  182. for (mfp = SH_TAILQ_FIRST(&mp->mpfq, __mpoolfile);
  183.     mfp != NULL;
  184.     ++tfsp, ++tstruct, tname += nlen,
  185.     mfp = SH_TAILQ_NEXT(mfp, q, __mpoolfile)) {
  186. name = __memp_fns(dbmp, mfp);
  187. nlen = strlen(name) + 1;
  188. *tfsp = tstruct;
  189. *tstruct = mfp->stat;
  190. tstruct->file_name = tname;
  191. memcpy(tname, name, nlen);
  192. }
  193. *tfsp = NULL;
  195. R_UNLOCK(dbenv, dbmp->reginfo);
  196. }
  197. return (0);
  198. }
  200. #define FMAP_ENTRIES 200 /* Files we map. */
  202. #define MPOOL_DUMP_HASH 0x01 /* Debug hash chains. */
  203. #define MPOOL_DUMP_LRU 0x02 /* Debug LRU chains. */
  204. #define MPOOL_DUMP_MEM 0x04 /* Debug region memory. */
  205. #define MPOOL_DUMP_ALL 0x07 /* Debug all. */
  207. /*
  208.  * __memp_dump_region --
  209.  * Display MPOOL structures.
  210.  *
  211.  * PUBLIC: void __memp_dump_region __P((DB_ENV *, char *, FILE *));
  212.  */
  213. void
  214. __memp_dump_region(dbenv, area, fp)
  215. DB_ENV *dbenv;
  216. char *area;
  217. FILE *fp;
  218. {
  219. DB_MPOOL *dbmp;
  220. DB_MPOOLFILE *dbmfp;
  221. MPOOL *mp;
  222. MPOOLFILE *mfp;
  223. size_t fmap[FMAP_ENTRIES + 1];
  224. u_int32_t i, flags;
  225. int cnt;
  226. u_int8_t *p;
  228. dbmp = dbenv->mp_handle;
  230. /* Make it easy to call from the debugger. */
  231. if (fp == NULL)
  232. fp = stderr;
  234. for (flags = 0; *area != ''; ++area)
  235. switch (*area) {
  236. case 'A':
  237. LF_SET(MPOOL_DUMP_ALL);
  238. break;
  239. case 'h':
  240. LF_SET(MPOOL_DUMP_HASH);
  241. break;
  242. case 'l':
  243. LF_SET(MPOOL_DUMP_LRU);
  244. break;
  245. case 'm':
  246. LF_SET(MPOOL_DUMP_MEM);
  247. break;
  248. }
  250. R_LOCK(dbenv, dbmp->reginfo);
  252. mp = dbmp->reginfo[0].primary;
  254. /* Display MPOOL structures. */
  255. (void)fprintf(fp, "%snPool (region addr 0x%lx)n",
  256.     DB_LINE, (u_long)dbmp->reginfo[0].addr);
  258. /* Display the MPOOLFILE structures. */
  259. cnt = 0;
  260. for (mfp = SH_TAILQ_FIRST(&mp->mpfq, __mpoolfile);
  261.     mfp != NULL; mfp = SH_TAILQ_NEXT(mfp, q, __mpoolfile), ++cnt) {
  262. (void)fprintf(fp, "File #%d: %s: type %ld, %snt [UID: ",
  263.     cnt + 1, __memp_fns(dbmp, mfp), (long)mfp->ftype,
  264.     F_ISSET(mfp, MP_CAN_MMAP) ? "mmap" : "read/write");
  265. p = R_ADDR(dbmp->reginfo, mfp->fileid_off);
  266. for (i = 0; i < DB_FILE_ID_LEN; ++i) {
  267. (void)fprintf(fp, "%x", *p++);
  268. if (i < DB_FILE_ID_LEN - 1)
  269. (void)fprintf(fp, " ");
  270. }
  271. (void)fprintf(fp, "]n");
  272. if (cnt < FMAP_ENTRIES)
  273. fmap[cnt] = R_OFFSET(dbmp->reginfo, mfp);
  274. }
  276. for (dbmfp = TAILQ_FIRST(&dbmp->dbmfq);
  277.     dbmfp != NULL; dbmfp = TAILQ_NEXT(dbmfp, q), ++cnt) {
  278. (void)fprintf(fp, "File #%d: %s: per-process, %sn",
  279.     cnt + 1, __memp_fn(dbmfp),
  280.     F_ISSET(dbmfp, MP_READONLY) ? "readonly" : "read/write");
  281.     if (cnt < FMAP_ENTRIES)
  282. fmap[cnt] = R_OFFSET(dbmp->reginfo, mfp);
  283. }
  284. if (cnt < FMAP_ENTRIES)
  285. fmap[cnt] = INVALID_ROFF;
  286. else
  287. fmap[FMAP_ENTRIES] = INVALID_ROFF;
  289. /* Dump the memory pools. */
  290. for (i = 0; i < mp->nreg; ++i) {
  291. (void)fprintf(fp, "%snCache #%d:n", DB_LINE, i + 1);
  292. __memp_dumpcache(dbmp, &dbmp->reginfo[i], fmap, fp, flags);
  293. }
  295. R_UNLOCK(dbenv, dbmp->reginfo);
  297. /* Flush in case we're debugging. */
  298. (void)fflush(fp);
  299. }
  301. /*
  302.  * __memp_dumpcache --
  303.  * Display statistics for a cache.
  304.  */
  305. static void
  306. __memp_dumpcache(dbmp, reginfo, fmap, fp, flags)
  307. DB_MPOOL *dbmp;
  308. REGINFO *reginfo;
  309. size_t *fmap;
  310. FILE *fp;
  311. u_int32_t flags;
  312. {
  313. BH *bhp;
  314. DB_HASHTAB *dbht;
  315. MPOOL *c_mp;
  316. int bucket;
  318. c_mp = reginfo->primary;
  320. /* Display the hash table list of BH's. */
  321. if (LF_ISSET(MPOOL_DUMP_HASH)) {
  322. (void)fprintf(fp,
  323.     "%snBH hash table (%lu hash slots)npageno, file, ref, addressn",
  324.     DB_LINE, (u_long)c_mp->htab_buckets);
  325. for (dbht = R_ADDR(reginfo, c_mp->htab),
  326.     bucket = 0; bucket < c_mp->htab_buckets; ++dbht, ++bucket) {
  327. if (SH_TAILQ_FIRST(dbht, __bh) != NULL)
  328. (void)fprintf(fp, "%lu:n", (u_long)bucket);
  329. for (bhp = SH_TAILQ_FIRST(dbht, __bh);
  330.     bhp != NULL; bhp = SH_TAILQ_NEXT(bhp, hq, __bh))
  331. __memp_pbh(dbmp, bhp, fmap, fp);
  332. }
  333. }
  335. /* Display the LRU list of BH's. */
  336. if (LF_ISSET(MPOOL_DUMP_LRU)) {
  337. (void)fprintf(fp, "%snBH LRU listn", DB_LINE);
  338. (void)fprintf(fp, "pageno, file, ref, addressn");
  339. for (bhp = SH_TAILQ_FIRST(&c_mp->bhq, __bh);
  340.     bhp != NULL; bhp = SH_TAILQ_NEXT(bhp, q, __bh))
  341. __memp_pbh(dbmp, bhp, fmap, fp);
  342. }
  344. /* Dump the memory pool. */
  345. if (LF_ISSET(MPOOL_DUMP_MEM))
  346. __db_shalloc_dump(reginfo->addr, fp);
  347. }
  349. /*
  350.  * __memp_pbh --
  351.  * Display a BH structure.
  352.  */
  353. static void
  354. __memp_pbh(dbmp, bhp, fmap, fp)
  355. DB_MPOOL *dbmp;
  356. BH *bhp;
  357. size_t *fmap;
  358. FILE *fp;
  359. {
  360. static const FN fn[] = {
  361. { BH_CALLPGIN, "callpgin" },
  362. { BH_DIRTY, "dirty" },
  363. { BH_DISCARD, "discard" },
  364. { BH_LOCKED, "locked" },
  365. { BH_SYNC, "sync" },
  366. { BH_SYNC_LOGFLSH, "sync:logflush" },
  367. { BH_TRASH, "trash" },
  368. { 0, NULL }
  369. };
  370. int i;
  372. for (i = 0; i < FMAP_ENTRIES; ++i)
  373. if (fmap[i] == INVALID_ROFF || fmap[i] == bhp->mf_offset)
  374. break;
  376. if (fmap[i] == INVALID_ROFF)
  377. (void)fprintf(fp, "  %4lu, %lu, %2lu, %lu",
  378.     (u_long)bhp->pgno, (u_long)bhp->mf_offset,
  379.     (u_long)bhp->ref, (u_long)R_OFFSET(dbmp->reginfo, bhp));
  380. else
  381. (void)fprintf(fp, "  %4lu,   #%d,  %2lu, %lu",
  382.     (u_long)bhp->pgno, i + 1,
  383.     (u_long)bhp->ref, (u_long)R_OFFSET(dbmp->reginfo, bhp));
  385. __db_prflags(bhp->flags, fn, fp);
  387. (void)fprintf(fp, "n");
  388. }