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