mp_method.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:4k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. #include "db_config.h"
  8. #ifndef lint
  9. static const char revid[] = "$Id: mp_method.c,v 11.29 2002/03/27 04:32:27 bostic Exp $";
  10. #endif /* not lint */
  11. #ifndef NO_SYSTEM_INCLUDES
  12. #include <sys/types.h>
  13. #ifdef HAVE_RPC
  14. #include <rpc/rpc.h>
  15. #endif
  16. #endif
  17. #include "db_int.h"
  18. #include "dbinc/db_shash.h"
  19. #include "dbinc/mp.h"
  20. #ifdef HAVE_RPC
  21. #include "dbinc_auto/db_server.h"
  22. #include "dbinc_auto/rpc_client_ext.h"
  23. #endif
  24. static int __memp_set_cachesize __P((DB_ENV *, u_int32_t, u_int32_t, int));
  25. static int __memp_set_mp_mmapsize __P((DB_ENV *, size_t));
  26. /*
  27.  * __memp_dbenv_create --
  28.  * Mpool specific creation of the DB_ENV structure.
  29.  *
  30.  * PUBLIC: void __memp_dbenv_create __P((DB_ENV *));
  31.  */
  32. void
  33. __memp_dbenv_create(dbenv)
  34. DB_ENV *dbenv;
  35. {
  36. /*
  37.  * !!!
  38.  * Our caller has not yet had the opportunity to reset the panic
  39.  * state or turn off mutex locking, and so we can neither check
  40.  * the panic state or acquire a mutex in the DB_ENV create path.
  41.  *
  42.  * We default to 32 8K pages.  We don't default to a flat 256K, because
  43.  * some systems require significantly more memory to hold 32 pages than
  44.  * others.  For example, HP-UX with POSIX pthreads needs 88 bytes for
  45.  * a POSIX pthread mutex and almost 200 bytes per buffer header, while
  46.  * Solaris needs 24 and 52 bytes for the same structures.  The minimum
  47.  * number of hash buckets is 37.  These contain a mutex also.
  48.  */
  49. dbenv->mp_bytes =
  50.     32 * ((8 * 1024) + sizeof(BH)) + 37 * sizeof(DB_MPOOL_HASH);
  51. dbenv->mp_ncache = 1;
  52. #ifdef HAVE_RPC
  53. if (F_ISSET(dbenv, DB_ENV_RPCCLIENT)) {
  54. dbenv->set_cachesize = __dbcl_env_cachesize;
  55. dbenv->set_mp_mmapsize = __dbcl_set_mp_mmapsize;
  56. dbenv->memp_dump_region = NULL;
  57. dbenv->memp_fcreate = __dbcl_memp_fcreate;
  58. dbenv->memp_nameop = NULL;
  59. dbenv->memp_register = __dbcl_memp_register;
  60. dbenv->memp_stat = __dbcl_memp_stat;
  61. dbenv->memp_sync = __dbcl_memp_sync;
  62. dbenv->memp_trickle = __dbcl_memp_trickle;
  63. } else
  64. #endif
  65. {
  66. dbenv->set_cachesize = __memp_set_cachesize;
  67. dbenv->set_mp_mmapsize = __memp_set_mp_mmapsize;
  68. dbenv->memp_dump_region = __memp_dump_region;
  69. dbenv->memp_fcreate = __memp_fcreate;
  70. dbenv->memp_nameop = __memp_nameop;
  71. dbenv->memp_register = __memp_register;
  72. dbenv->memp_stat = __memp_stat;
  73. dbenv->memp_sync = __memp_sync;
  74. dbenv->memp_trickle = __memp_trickle;
  75. }
  76. }
  77. /*
  78.  * __memp_set_cachesize --
  79.  * Initialize the cache size.
  80.  */
  81. static int
  82. __memp_set_cachesize(dbenv, gbytes, bytes, ncache)
  83. DB_ENV *dbenv;
  84. u_int32_t gbytes, bytes;
  85. int ncache;
  86. {
  87. ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_cachesize");
  88. /* Normalize the values. */
  89. if (ncache == 0)
  90. ncache = 1;
  91. /*
  92.  * You can only store 4GB-1 in an unsigned 32-bit value, so correct for
  93.  * applications that specify 4GB cache sizes -- we know what they meant.
  94.  */
  95. if (gbytes / ncache == 4 && bytes == 0) {
  96. --gbytes;
  97. bytes = GIGABYTE - 1;
  98. } else {
  99. gbytes += bytes / GIGABYTE;
  100. bytes %= GIGABYTE;
  101. }
  102. /* Avoid too-large cache sizes, they result in a region size of zero. */
  103. if (gbytes / ncache > 4 || (gbytes / ncache == 4 && bytes != 0)) {
  104. __db_err(dbenv, "individual cache size too large");
  105. return (EINVAL);
  106. }
  107. /*
  108.  * If the application requested less than 500Mb, increase the cachesize
  109.  * by 25% and factor in the size of the hash buckets to account for our
  110.  * overhead.  (I'm guessing caches over 500Mb are specifically sized,
  111.  * that is, it's a large server and the application actually knows how
  112.  * much memory is available.  We only document the 25% overhead number,
  113.  * not the hash buckets, but I don't see a reason to confuse the issue,
  114.  * it shouldn't matter to an application.)
  115.  *
  116.  * There is a minimum cache size, regardless.
  117.  */
  118. if (gbytes == 0) {
  119. if (bytes < 500 * MEGABYTE)
  120. bytes += (bytes / 4) + 37 * sizeof(DB_MPOOL_HASH);
  121. if (bytes / ncache < DB_CACHESIZE_MIN)
  122. bytes = ncache * DB_CACHESIZE_MIN;
  123. }
  124. dbenv->mp_gbytes = gbytes;
  125. dbenv->mp_bytes = bytes;
  126. dbenv->mp_ncache = ncache;
  127. return (0);
  128. }
  129. /*
  130.  * __memp_set_mp_mmapsize --
  131.  * Set the maximum mapped file size.
  132.  */
  133. static int
  134. __memp_set_mp_mmapsize(dbenv, mp_mmapsize )
  135. DB_ENV *dbenv;
  136. size_t mp_mmapsize;
  137. {
  138. dbenv->mp_mmapsize = mp_mmapsize;
  139. return (0);
  140. }