Java > Open Source Codes > com > sleepycat > je > config > EnvironmentParams


1 /*-
2  * See the file LICENSE for redistribution information.
3  *
4  * Copyright (c) 2002,2006 Oracle. All rights reserved.
5  *
6  * $Id: EnvironmentParams.java,v 1.84 2006/11/27 23:07:12 mark Exp $
7  */
8
9 package com.sleepycat.je.config;
10
11 import java.io.File ;
12 import java.io.FileWriter ;
13 import java.util.HashMap ;
14 import java.util.Iterator ;
15 import java.util.Map ;
16 import java.util.TreeSet ;
17
18 /**
19  * Javadoc for this public class is generated
20  * via the doc templates in the doc_src directory.
21  */
22 public class EnvironmentParams {
23
24     /*
25      * The map of supported environment parameters where the key is parameter
26      * name and the data is the configuration parameter object. Put first,
27      * before any declarations of ConfigParams.
28      */
29     public final static Map SUPPORTED_PARAMS = new HashMap ();
30
31     /*
32      * Environment
33      */
34     public static final LongConfigParam MAX_MEMORY =
35         new LongConfigParam("je.maxMemory",
36                             null, // min
37 null, // max
38 new Long (0), // default uses je.maxMemoryPercent
39 true, // mutable
40 false, // forReplication
41 "# Specify the cache size in bytes, as an absolute number. The system\n"+
42       "# attempts to stay within this budget and will evict database\n" +
43       "# objects when it comes within a prescribed margin of the limit.\n" +
44       "# By default, this parameter is 0 and JE instead sizes the cache\n" +
45       "# proportionally to the memory available to the JVM, based on\n"+
46       "# je.maxMemoryPercent.");
47
48     public static final IntConfigParam MAX_MEMORY_PERCENT =
49         new IntConfigParam("je.maxMemoryPercent",
50                            new Integer (1), // min
51 new Integer (90), // max
52 new Integer (60), // default
53 true, // mutable
54 false, // forReplication
55 "# By default, JE sizes the cache as a percentage of the maximum\n" +
56      "# memory available to the JVM. For example, if the JVM is\n" +
57      "# started with -Xmx128M, the cache size will be\n" +
58      "# (je.maxMemoryPercent * 128M) / 100\n" +
59      "# Setting je.maxMemory to an non-zero value will override\n" +
60      "# je.maxMemoryPercent");
61      
62     public static final BooleanConfigParam ENV_RECOVERY =
63         new BooleanConfigParam("je.env.recovery",
64                                true, // default
65 false, // mutable
66 false, // forReplication
67 "# If true, an environment is created with recovery and the related\n" +
68      "# daemons threads enabled.");
69      
70     public static final BooleanConfigParam ENV_RECOVERY_FORCE_CHECKPOINT =
71         new BooleanConfigParam("je.env.recoveryForceCheckpoint",
72                                false, // default
73 false, // mutable
74 false, // forReplication
75 "# If true, a checkpoint is forced following recovery, even if the\n" +
76      "# log ends with a checkpoint.");
77      
78     public static final BooleanConfigParam ENV_RUN_INCOMPRESSOR =
79         new BooleanConfigParam("je.env.runINCompressor",
80                                true, // default
81 true, // mutable
82 false, // forReplication
83 "# If true, starts up the INCompressor.\n" +
84      "# This parameter is true by default");
85      
86     /* @deprecated As of 2.0, eviction is performed in-line. */
87     public static final BooleanConfigParam ENV_RUN_EVICTOR =
88         new BooleanConfigParam("je.env.runEvictor",
89                                false, // default
90 true, // mutable
91 false, // forReplication
92 "# If true, starts up the evictor.\n" +
93      "# This parameter is false by default\n" +
94      "# (deprecated, eviction is performed in-line");
95      
96     public static final BooleanConfigParam ENV_RUN_CHECKPOINTER =
97         new BooleanConfigParam("je.env.runCheckpointer",
98                                true, // default
99 true, // mutable
100 false, // forReplication
101 "# If true, starts up the checkpointer.\n" +
102      "# This parameter is true by default");
103
104     public static final BooleanConfigParam ENV_RUN_CLEANER =
105         new BooleanConfigParam("je.env.runCleaner",
106                                true, // default
107 true, // mutable
108 false, // forReplication
109 "# If true, starts up the cleaner.\n" +
110      "# This parameter is true by default");
111      
112     public static final IntConfigParam ENV_BACKGROUND_READ_LIMIT =
113         new IntConfigParam("je.env.backgroundReadLimit",
114                             new Integer (0), // min
115 new Integer (Integer.MAX_VALUE), // max
116 new Integer (0), // default
117 true, // mutable
118 false, // forReplication
119 "# The maximum number of read operations performed by JE background\n" +
120      "# activities (e.g., cleaning) before sleeping to ensure that\n" +
121      "# application threads can perform I/O.\n" +
122      "# If zero (the default) then no limitation on I/O is enforced.\n" +
123      "# See je.env.backgroundSleepInterval.");
124      
125     public static final IntConfigParam ENV_BACKGROUND_WRITE_LIMIT =
126         new IntConfigParam("je.env.backgroundWriteLimit",
127                             new Integer (0), // min
128 new Integer (Integer.MAX_VALUE), // max
129 new Integer (0), // default
130 true, // mutable
131 false, // forReplication
132 "# The maximum number of write operations performed by JE background\n" +
133      "# activities (e.g., checkpointing and eviction) before sleeping to\n" +
134      "# ensure that application threads can perform I/O.\n" +
135      "# If zero (the default) then no limitation on I/O is enforced.\n" +
136      "# See je.env.backgroundSleepInterval.");
137      
138     public static final LongConfigParam ENV_BACKGROUND_SLEEP_INTERVAL =
139         new LongConfigParam("je.env.backgroundSleepInterval",
140                            new Long (1000), // min
141 new Long (Long.MAX_VALUE), // max
142 new Long (1000), // default
143 true, // mutable
144 false, // forReplication
145 "# The number of microseconds that JE background activities will\n" +
146      "# sleep when the je.env.backgroundWriteLimit or backgroundReadLimit\n" +
147      "# is reached. If je.env.backgroundWriteLimit and\n" +
148      "# backgroundReadLimit are zero, this setting is not used.\n" +
149      "# By default this setting is 1000 or 1 millisecond.");
150
151     public static final BooleanConfigParam ENV_CHECK_LEAKS =
152         new BooleanConfigParam("je.env.checkLeaks",
153                                true, // default
154 false, // mutable
155 false, // forReplication
156 "# Debugging support: check leaked locks and txns at env close.");
157
158     public static final BooleanConfigParam ENV_FORCED_YIELD =
159         new BooleanConfigParam("je.env.forcedYield",
160                                false, // default
161 false, // mutable
162 false, // forReplication
163 "# Debugging support: call Thread.yield() at strategic points.");
164
165     public static final BooleanConfigParam ENV_INIT_TXN =
166         new BooleanConfigParam("je.env.isTransactional",
167                                false, // default
168 false, // mutable
169 false, // forReplication
170 "# If true, create the environment w/ transactions.");
171
172     public static final BooleanConfigParam ENV_INIT_LOCKING =
173         new BooleanConfigParam("je.env.isLocking",
174                                true, // default
175 false, // mutable
176 false, // forReplication
177 "# If true, create the environment with locking.");
178
179     public static final BooleanConfigParam ENV_RDONLY =
180         new BooleanConfigParam("je.env.isReadOnly",
181                                false, // default
182 false, // mutable
183 false, // forReplication
184 "# If true, create the environment read only.");
185
186     public static final BooleanConfigParam ENV_FAIR_LATCHES =
187         new BooleanConfigParam("je.env.fairLatches",
188                                false, // default
189 false, // mutable
190 false, // forReplication
191 "# If true, use latches instead of synchronized blocks to\n" +
192      "# implement the lock table and log write mutexes. Latches require\n" +
193      "# that threads queue to obtain the mutex in question and\n" +
194      "# therefore guarantee that there will be no mutex starvation, but \n" +
195      "# do incur a performance penalty. Latches should not be necessary in\n"+
196      "# most cases, so synchronized blocks are the default. An application\n" +
197      "# that puts heavy load on JE with threads with different thread\n"+
198      "# priorities might find it useful to use latches. In a Java 5 JVM,\n" +
199      "# where java.util.concurrent.locks.ReentrantLock is used for the\n" +
200      "# latch implementation, this parameter will determine whether they\n" +
201      "# are 'fair' or not. This parameter is 'static' across all\n" +
202      "# environments.\n");
203     
204     public static final BooleanConfigParam ENV_SHARED_LATCHES =
205         new BooleanConfigParam("je.env.sharedLatches",
206                                false, // default
207 false, // mutable
208 false, // forReplication
209 "# If true, use shared latches for Internal Nodes (INs).\n");
210
211     public static final IntConfigParam ADLER32_CHUNK_SIZE =
212         new IntConfigParam("je.adler32.chunkSize",
213                            new Integer (0), // min
214 new Integer (1 << 20), // max
215 new Integer (0), // default
216 true, // mutable
217 false, // forReplication
218 "# By default, JE passes an entire log record to the Adler32 class\n" +
219      "# for checksumming. This can cause problems with the GC in some\n" +
220      "# cases if the records are large and there is concurrency. Setting\n" +
221      "# this parameter will cause JE to pass chunks of the log record to\n" +
222      "# the checksumming class so that the GC does not block. 0 means\n" +
223      "# do not chunk.\n");
224      
225     /*
226      * Database Logs
227      */
228     /* default: 2k * NUM_LOG_BUFFERS */
229     public static final int MIN_LOG_BUFFER_SIZE = 2048;
230     private static final int NUM_LOG_BUFFERS_DEFAULT = 3;
231     public static final long LOG_MEM_SIZE_MIN =
232         NUM_LOG_BUFFERS_DEFAULT * MIN_LOG_BUFFER_SIZE;
233     public static final String LOG_MEM_SIZE_MIN_STRING =
234         Long.toString(LOG_MEM_SIZE_MIN);
235
236     public static final LongConfigParam LOG_MEM_SIZE =
237         new LongConfigParam("je.log.totalBufferBytes",
238                             new Long (LOG_MEM_SIZE_MIN),// min
239 null, // max
240 new Long (0), // by default computed
241 // from je.maxMemory
242 false, // mutable
243 false, // forReplication
244 "# The total memory taken by log buffers, in bytes. If 0, use\n" +
245      "# 7% of je.maxMemory");
246
247     public static final IntConfigParam NUM_LOG_BUFFERS =
248         new IntConfigParam("je.log.numBuffers",
249                            new Integer (2), // min
250 null, // max
251 new Integer (NUM_LOG_BUFFERS_DEFAULT), // default
252 false, // mutable
253 false, // forReplication
254 "# The number of JE log buffers");
255
256     public static final IntConfigParam LOG_BUFFER_MAX_SIZE =
257         new IntConfigParam("je.log.bufferSize",
258                            new Integer (1<<10), // min
259 null, // max
260 new Integer (1<<20), // default
261 false, // mutable
262 false, // forReplication
263 "# maximum starting size of a JE log buffer");
264
265     public static final IntConfigParam LOG_FAULT_READ_SIZE =
266         new IntConfigParam("je.log.faultReadSize",
267                            new Integer (32), // min
268 null, // max
269 new Integer (2048), // default
270 false, // mutable
271 false, // forReplication
272 "# The buffer size for faulting in objects from disk, in bytes.");
273
274     public static final IntConfigParam LOG_ITERATOR_READ_SIZE =
275         new IntConfigParam("je.log.iteratorReadSize",
276                            new Integer (128), // min
277 null, // max
278 new Integer (8192), // default
279 false, // mutable
280 false, // forReplication
281 "# The read buffer size for log iterators, which are used when\n" +
282      "# scanning the log during activities like log cleaning and\n" +
283      "# environment open, in bytes. This may grow as the system encounters\n" +
284      "# larger log entries");
285
286     public static final IntConfigParam LOG_ITERATOR_MAX_SIZE =
287         new IntConfigParam("je.log.iteratorMaxSize",
288                            new Integer (128), // min
289 null, // max
290 new Integer (16777216), // default
291 false, // mutable
292 false, // forReplication
293 "# The maximum read buffer size for log iterators, which are used\n" +
294      "# when scanning the log during activities like log cleaning\n" +
295      "# and environment open, in bytes.");
296      
297     public static final LongConfigParam LOG_FILE_MAX =
298         new LongConfigParam("je.log.fileMax",
299                             new Long (1000000), // min
300 new Long (4294967296L), // max
301 new Long (10000000), // default
302 false, // mutable
303 false, // forReplication
304 "# The maximum size of each individual JE log file, in bytes.");
305      
306     public static final BooleanConfigParam LOG_CHECKSUM_READ =
307         new BooleanConfigParam("je.log.checksumRead",
308                                true, // default
309 false, // mutable
310 false, // forReplication
311 "# If true, perform a checksum check when reading entries from log.");
312      
313     public static final BooleanConfigParam LOG_MEMORY_ONLY =
314         new BooleanConfigParam("je.log.memOnly",
315                                false, // default
316 false, // mutable
317 false, // forReplication
318 "# If true, operates in an in-memory test mode without flushing\n" +
319      "# the log to disk. An environment directory must be specified, but\n" +
320      "# it need not exist and no files are written. The system operates\n" +
321      "# until it runs out of memory, at which time an OutOfMemoryError\n" +
322      "# is thrown. Because the entire log is kept in memory, this mode\n" +
323      "# is normally useful only for testing.");
324
325     public static final IntConfigParam LOG_FILE_CACHE_SIZE =
326         new IntConfigParam("je.log.fileCacheSize",
327                            new Integer (3), // min
328 null, // max
329 new Integer (100), // default
330 false, // mutable
331 false, // forReplication
332 "# The size of the file handle cache.");
333
334     public static final LongConfigParam LOG_FSYNC_TIMEOUT =
335         new LongConfigParam("je.log.fsyncTimeout",
336                             new Long (10000L), // min
337 null, // max
338 new Long (500000L), // default
339 false, // mutable
340 false, // forReplication
341 "# Timeout limit for group file sync, in microseconds.");
342      
343     public static final BooleanConfigParam LOG_USE_NIO =
344         new BooleanConfigParam("je.log.useNIO",
345                                false, // default
346 false, // mutable
347 false, // forReplication
348 "# If true (default is false) NIO is used for all file I/O.");
349      
350     public static final BooleanConfigParam LOG_DIRECT_NIO =
351         new BooleanConfigParam("je.log.directNIO",
352                                false, // default
353 false, // mutable
354 false, // forReplication
355 "# If true (default is false) direct NIO buffers are used.\n" +
356      "# This setting is only used if je.log.useNIO=true.");
357
358     public static final LongConfigParam LOG_CHUNKED_NIO =
359         new LongConfigParam("je.log.chunkedNIO",
360                             new Long (0L), // min
361 new Long (1 << 26), // max (64M)
362 new Long (0L), // default (no chunks)
363 false, // mutable
364 false, // forReplication
365 "# If non-0 (default is 0) break all IO into chunks of this size.\n" +
366      "# This setting is only used if je.log.useNIO=true.");
367
368     public static final BooleanConfigParam LOG_DEFERREDWRITE_TEMP =
369         new BooleanConfigParam("je.deferredWrite.temp",
370                                false, // default
371 false, // mutable
372 false, // forReplication
373 "# If true, assume that deferred write database will never be\n" +
374      "# used after an environment is closed. This permits a more efficient\n" +
375      "# form of logging of deferred write objects that overflow to disk\n" +
376      "# through cache eviction or Database.sync() and reduces log cleaner\n" +
377      "# overhead.");
378
379     /*
380      * Tree
381      */
382     public static final IntConfigParam NODE_MAX =
383         new IntConfigParam("je.nodeMaxEntries",
384                            new Integer (4), // min
385 new Integer (32767), // max
386 new Integer (128), // default
387 false, // mutable
388 false, // forReplication
389 "# The maximum number of entries in an internal btree node.\n" +
390      "# This can be set per-database using the DatabaseConfig object.");
391
392     public static final IntConfigParam NODE_MAX_DUPTREE =
393         new IntConfigParam("je.nodeDupTreeMaxEntries",
394                            new Integer (4), // min
395 new Integer (32767), // max
396 new Integer (128), // default
397 false, // mutable
398 false, // forReplication
399 "# The maximum number of entries in an internal dup btree node.\n" +
400      "# This can be set per-database using the DatabaseConfig object.");
401
402     public static final IntConfigParam BIN_MAX_DELTAS =
403         new IntConfigParam("je.tree.maxDelta",
404                            new Integer (0), // min
405 new Integer (100), // max
406 new Integer (10), // default
407 false, // mutable
408 false, // forReplication
409 "# After this many deltas, logs a full version.");
410      
411     public static final IntConfigParam BIN_DELTA_PERCENT =
412         new IntConfigParam("je.tree.binDelta",
413                            new Integer (0), // min
414 new Integer (75), // max
415 new Integer (25), // default
416 false, // mutable
417 false, // forReplication
418 "# If less than this percentage of entries are changed on a BIN,\n" +
419      "# logs a delta instead of a full version.");
420
421     /*
422      * IN Compressor
423      */
424     public static final LongConfigParam COMPRESSOR_WAKEUP_INTERVAL =
425         new LongConfigParam("je.compressor.wakeupInterval",
426                             new Long (1000000), // min
427 new Long (4294967296L), // max
428 new Long (5000000), // default
429 false, // mutable
430 false, // forReplication
431 "# The compressor wakeup interval in microseconds.");
432      
433     public static final IntConfigParam COMPRESSOR_RETRY =
434         new IntConfigParam("je.compressor.deadlockRetry",
435                            new Integer (0), // min
436 new Integer (Integer.MAX_VALUE),// max
437 new Integer (3), // default
438 false, // mutable
439 false, // forReplication
440 "# Number of times to retry a compression run if a deadlock occurs.");
441
442     public static final LongConfigParam COMPRESSOR_LOCK_TIMEOUT =
443         new LongConfigParam("je.compressor.lockTimeout",
444                             new Long (0), // min
445 new Long (4294967296L), // max
446 new Long (500000L), // default
447 false, // mutable
448 false, // forReplication
449 "# The lock timeout for compressor transactions in microseconds.");
450
451     public static final BooleanConfigParam COMPRESSOR_PURGE_ROOT =
452         new BooleanConfigParam("je.compressor.purgeRoot",
453                                            false, // default
454 false, // mutable
455 false, // forReplication
456 "# If true, when the compressor encounters an empty tree, the root\n" +
457      "# node of the tree is deleted.");
458      
459     /*
460      * Evictor
461      */
462     public static final LongConfigParam EVICTOR_EVICT_BYTES =
463         new LongConfigParam("je.evictor.evictBytes",
464                              new Long (1024), // min
465 null, // max
466 new Long (524288), // default
467 false, // mutable
468 false, // forReplication
469 "# When eviction happens, the evictor will push memory usage to this\n" +
470      "# number of bytes below je.maxMemory. The default is 512KB and the\n" +
471      "# minimum is 1 KB (1024).");
472
473     /* @deprecated As of 2.0, this is replaced by je.evictor.evictBytes */
474     public static final IntConfigParam EVICTOR_USEMEM_FLOOR =
475         new IntConfigParam("je.evictor.useMemoryFloor",
476                            new Integer (50), // min
477 new Integer (100), // max
478 new Integer (95), // default
479 false, // mutable
480 false, // forReplication
481 "# When eviction happens, the evictor will push memory usage to this\n" +
482      "# percentage of je.maxMemory." +
483      "# (deprecated in favor of je.evictor.evictBytes");
484
485     /* @deprecated As of 1.7.2, this is replaced by je.evictor.nodesPerScan */
486     public static final IntConfigParam EVICTOR_NODE_SCAN_PERCENTAGE =
487         new IntConfigParam("je.evictor.nodeScanPercentage",
488                            new Integer (1), // min
489 new Integer (100), // max
490 new Integer (10), // default
491 false, // mutable
492 false, // forReplication
493 "# The evictor percentage of total nodes to scan per wakeup.\n" +
494      "# (deprecated in favor of je.evictor.nodesPerScan");
495
496     /* @deprecated As of 1.7.2, 1 node is chosen per scan. */
497     public static final
498         IntConfigParam EVICTOR_EVICTION_BATCH_PERCENTAGE =
499         new IntConfigParam("je.evictor.evictionBatchPercentage",
500                            new Integer (1), // min
501 new Integer (100), // max
502 new Integer (10), // default
503 false, // mutable
504 false, // forReplication
505 "# The evictor percentage of scanned nodes to evict per wakeup.\n" +
506      "# (deprecated)");
507
508     public static final IntConfigParam EVICTOR_NODES_PER_SCAN =
509         new IntConfigParam("je.evictor.nodesPerScan",
510                            new Integer (1), // min
511 new Integer (1000), // max
512 new Integer (10), // default
513 false, // mutable
514 false, // forReplication
515 "# The number of nodes in one evictor scan");
516
517     /* @deprecated As of 2.0, eviction is performed in-line. */
518     public static final
519         IntConfigParam EVICTOR_CRITICAL_PERCENTAGE =
520         new IntConfigParam("je.evictor.criticalPercentage",
521                            new Integer (0), // min
522 new Integer (1000), // max
523 new Integer (0), // default
524 false, // mutable
525 false, // forReplication
526 "# At this percentage over the allotted cache, critical eviction\n" +
527      "# will start." +
528      "# (deprecated, eviction is performed in-line");
529
530     public static final IntConfigParam EVICTOR_RETRY =
531         new IntConfigParam("je.evictor.deadlockRetry",
532                            new Integer (0), // min
533 new Integer (Integer.MAX_VALUE),// max
534 new Integer (3), // default
535 false, // mutable
536 false, // forReplication
537 "# The number of times to retry the evictor if it runs into a deadlock.");
538       
539     public static final BooleanConfigParam EVICTOR_LRU_ONLY =
540         new BooleanConfigParam("je.evictor.lruOnly",
541                                true, // default
542 false, // mutable
543 false, // forReplication
544 "# If true (the default), use an LRU-only policy to select nodes for\n" +
545      "# eviction. If false, select by Btree level first, and then by LRU.");
546
547     /*
548      * Checkpointer
549      */
550     public static final LongConfigParam CHECKPOINTER_BYTES_INTERVAL =
551         new LongConfigParam("je.checkpointer.bytesInterval",
552                             new Long (0), // min
553 new Long (Long.MAX_VALUE), // max
554 new Long (20000000), // default
555 false, // mutable
556 false, // forReplication
557 "# Ask the checkpointer to run every time we write this many bytes\n" +
558      "# to the log. If set, supercedes je.checkpointer.wakeupInterval. To\n" +
559      "# use time based checkpointing, set this to 0.");
560
561     public static final LongConfigParam CHECKPOINTER_WAKEUP_INTERVAL =
562         new LongConfigParam("je.checkpointer.wakeupInterval",
563                             new Long (1000000), // min
564 new Long (4294967296L), // max
565 new Long (0), // default
566 false, // mutable
567 false, // forReplication
568 "# The checkpointer wakeup interval in microseconds. By default, this\n"+
569      "# is inactive and we wakeup the checkpointer as a function of the\n" +
570      "# number of bytes written to the log. (je.checkpointer.bytesInterval)");
571
572     public static final IntConfigParam CHECKPOINTER_RETRY =
573         new IntConfigParam("je.checkpointer.deadlockRetry",
574                            new Integer (0), // miyn
575 new Integer (Integer.MAX_VALUE), // max
576 new Integer (3), // default
577 false, // mutable
578 false, // forReplication
579 "# The number of times to retry a checkpoint if it runs into a deadlock.");
580     /*
581      * Cleaner
582      */
583     public static final IntConfigParam CLEANER_MIN_UTILIZATION =
584         new IntConfigParam("je.cleaner.minUtilization",
585                            new Integer (0), // min
586 new Integer (90), // max
587 new Integer (50), // default
588 true, // mutable
589 false, // forReplication
590 "# The cleaner will keep the total disk space utilization percentage\n" +
591      "# above this value. The default is set to 50 percent.");
592
593     public static final IntConfigParam CLEANER_MIN_FILE_UTILIZATION =
594         new IntConfigParam("je.cleaner.minFileUtilization",
595                            new Integer (0), // min
596 new Integer (50), // max
597 new Integer (5), // default
598