####################################################
# Example Berkeley DB, Java Edition property file
# Each parameter is set to its default value
####################################################

# Use ConsoleHandler in logging system.
# java.util.logging.ConsoleHandler.on=false
# (mutable at run time: false)

# Use DbLogHandler in logging system.
# java.util.logging.DbLogHandler.on=true
# (mutable at run time: false)

# Log file count for FileHandler.
# minimum = 1
# java.util.logging.FileHandler.count=10
# (mutable at run time: false)

# Log file limit for FileHandler.
# minimum = 1000
# maximum = 1000000000
# java.util.logging.FileHandler.limit=10000000
# (mutable at run time: false)

# Use FileHandler in logging system.
# java.util.logging.FileHandler.on=false
# (mutable at run time: false)

# Trace messages equal and above this level will be logged.
# Value should be one of the predefined java.util.logging.Level values
# java.util.logging.level=INFO
# (mutable at run time: false)

# Cleaner specific detailed trace messages will be issued at this
# level. The Value should be one of the predefined 
# java.util.logging.Level values
# java.util.logging.level.cleaner=FINE
# (mutable at run time: true)

# Evictor specific trace messages will be issued at this level.
# Value should be one of the predefined java.util.logging.Level values
# java.util.logging.level.evictor=FINE
# (mutable at run time: false)

# Lock manager specific trace messages will be issued at this level.
# Value should be one of the predefined java.util.logging.Level values
# java.util.logging.level.lockMgr=FINE
# (mutable at run time: false)

# Recovery specific trace messages will be issued at this level.
# Value should be one of the predefined java.util.logging.Level values
# java.util.logging.level.recovery=FINE
# (mutable at run time: false)

# By default, JE passes an entire log record to the Adler32 class
# for checksumming.  This can cause problems with the GC in some
# cases if the records are large and there is concurrency.  Setting
# this parameter will cause JE to pass chunks of the log record to
# the checksumming class so that the GC does not block.  0 means
# do not chunk.

# minimum = 0
# maximum = 1048576
# je.adler32.chunkSize=0
# (mutable at run time: true)

# Ask the checkpointer to run every time we write this many bytes
# to the log. If set, supercedes je.checkpointer.wakeupInterval. To
# use time based checkpointing, set this to 0.
# minimum = 0
# maximum = 9223372036854775807
# je.checkpointer.bytesInterval=20000000
# (mutable at run time: false)

# The number of times to retry a checkpoint if it runs into a deadlock.
# minimum = 0
# maximum = 2147483647
# je.checkpointer.deadlockRetry=3
# (mutable at run time: false)

# The checkpointer wakeup interval in microseconds. By default, this
# is inactive and we wakeup the checkpointer as a function of the
# number of bytes written to the log. (je.checkpointer.bytesInterval)
# minimum = 1000000
# maximum = 4294967296
# je.checkpointer.wakeupInterval=0
# (mutable at run time: false)

# The cleaner checks disk utilization every time we write this many
# bytes to the log.  If zero (and by default) it is set to the
# je.log.fileMax value divided by four.
# minimum = 0
# maximum = 9223372036854775807
# je.cleaner.bytesInterval=0
# (mutable at run time: true)

# *** Experimental and may be removed in a future release. ***
# If true, eviction and checkpointing will cluster records by key
# value, migrating them from low utilization files if they are
# resident.
# The cluster and clusterAll properties may not both be set to true.
# je.cleaner.cluster=false
# (mutable at run time: true)

# *** Experimental and may be removed in a future release. ***
# If true, eviction and checkpointing will cluster records by key
# value, migrating them from low utilization files whether or not
# they are resident.
# The cluster and clusterAll properties may not both be set to true.
# je.cleaner.clusterAll=false
# (mutable at run time: true)

# The number of times to retry cleaning if a deadlock occurs.
# The default is set to 3.
# minimum = 0
# maximum = 2147483647
# je.cleaner.deadlockRetry=3
# (mutable at run time: true)

# Tracking of detailed cleaning information will use no more than
# this percentage of the cache.  The default value is two percent.
# This setting is only used if je.cleaner.trackDetail=true.
# minimum = 1
# maximum = 90
# je.cleaner.detailMaxMemoryPercentage=2
# (mutable at run time: true)

# If true, the cleaner deletes log files after successful cleaning.
# If false, the cleaner changes log file extensions to .DEL
# instead of deleting them. The default is set to true.
# je.cleaner.expunge=true
# (mutable at run time: true)

# If true, the cleaner will fetch records to determine their size
# to more accurately calculate log utilization.  This setting is
# used during DB truncation/removal and during recovery, and will
# cause more I/O during those operations when set to true.
# je.cleaner.fetchObsoleteSize=false
# (mutable at run time: true)

# Specifies a list of files or file ranges to force clean.  This is
# intended for use in forcing the cleaning of a large number of log
# files.  File numbers are in hex and are comma separated or hyphen
# separated to specify ranges, e.g.: '9,a,b-d' will clean 5 files.
# je.cleaner.forceCleanFiles=
# (mutable at run time: false)

# The lock timeout for cleaner transactions in microseconds.
# The default is set to 0.5 seconds.
# minimum = 0
# maximum = 4294967296
# je.cleaner.lockTimeout=500000
# (mutable at run time: true)

# The look ahead cache size for cleaning in bytes.  Increasing this
# value can reduce the number of Btree lookups.
# minimum = 0
# je.cleaner.lookAheadCacheSize=8192
# (mutable at run time: true)

# The maximum number of log files in the cleaner's backlog, or
# zero if there is no limit.  Changing this property can impact the
# performance of some out-of-memory applications.
# minimum = 0
# maximum = 100000
# je.cleaner.maxBatchFiles=0
# (mutable at run time: true)

# The minimum age of a file (number of files between it and the
# active file) to qualify it for cleaning under any conditions.
# The default is set to 2.
# minimum = 1
# maximum = 1000
# je.cleaner.minAge=2
# (mutable at run time: true)

# A log file will be cleaned if its utilization percentage is below
# this value, irrespective of total utilization. The default is
# set to 5 percent.
# minimum = 0
# maximum = 50
# je.cleaner.minFileUtilization=5
# (mutable at run time: true)

# (deprecated, no longer used
# minimum = 1
# maximum = 1000000
# je.cleaner.minFilesToDelete=5
# (mutable at run time: false)

# The cleaner will keep the total disk space utilization percentage
# above this value. The default is set to 50 percent.
# minimum = 0
# maximum = 90
# je.cleaner.minUtilization=50
# (mutable at run time: true)

# The read buffer size for cleaning.  If zero (the default), then
# je.log.iteratorReadSize value is used.
# minimum = 128
# je.cleaner.readSize=0
# (mutable at run time: true)

# (deprecated, no longer used
# minimum = 0
# maximum = 1000
# je.cleaner.restartRetries=5
# (mutable at run time: false)

# (deprecated, no longer used
# minimum = 0
# maximum = 1000
# je.cleaner.retries=10
# (mutable at run time: false)

# If true, detail information is discarded that was added by earlier
# versions of JE if it may be invalid.  This may be set to false
# for increased performance, but only if LockMode.RMW was never used.
# je.cleaner.rmwFix=true
# (mutable at run time: false)

# The number of threads allocated by the cleaner for log file
# processing.  If the cleaner backlog becomes large, increase this
# value.  The default is set to 1.
# minimum = 1
# je.cleaner.threads=1
# (mutable at run time: true)

# If true, the cleaner tracks and stores detailed information that
# is used to decrease the cost of cleaning.
# je.cleaner.trackDetail=true
# (mutable at run time: false)

# Number of times to retry a compression run if a deadlock occurs.
# minimum = 0
# maximum = 2147483647
# je.compressor.deadlockRetry=3
# (mutable at run time: false)

# The lock timeout for compressor transactions in microseconds.
# minimum = 0
# maximum = 4294967296
# je.compressor.lockTimeout=500000
# (mutable at run time: false)

# If true, when the compressor encounters an empty tree, the root
# node of the tree is deleted.
# je.compressor.purgeRoot=false
# (mutable at run time: false)

# The compressor wakeup interval in microseconds.
# minimum = 1000000
# maximum = 4294967296
# je.compressor.wakeupInterval=5000000
# (mutable at run time: false)

# *** Experimental and may be removed in a future release. ***
# If true, assume that deferred write database will never be
# used after an environment is closed. This permits a more efficient
# form of logging of deferred write objects that overflow to disk
# through cache eviction or Database.sync() and reduces log cleaner
# overhead.
# je.deferredWrite.temp=false
# (mutable at run time: false)

# The maximum number of read operations performed by JE background
# activities (e.g., cleaning) before sleeping to ensure that
# application threads can perform I/O.
# If zero (the default) then no limitation on I/O is enforced.
# See je.env.backgroundSleepInterval.
# minimum = 0
# maximum = 2147483647
# je.env.backgroundReadLimit=0
# (mutable at run time: true)

# The number of microseconds that JE background activities will
# sleep when the je.env.backgroundWriteLimit or backgroundReadLimit
# is reached.  If  je.env.backgroundWriteLimit and
# backgroundReadLimit are zero, this setting is not used.
# By default this setting is 1000 or 1 millisecond.
# minimum = 1000
# maximum = 9223372036854775807
# je.env.backgroundSleepInterval=1000
# (mutable at run time: true)

# The maximum number of write operations performed by JE background
# activities (e.g., checkpointing and eviction) before sleeping to
# ensure that application threads can perform I/O.
# If zero (the default) then no limitation on I/O is enforced.
# See je.env.backgroundSleepInterval.
# minimum = 0
# maximum = 2147483647
# je.env.backgroundWriteLimit=0
# (mutable at run time: true)

# Debugging support: check leaked locks and txns at env close.
# je.env.checkLeaks=true
# (mutable at run time: false)

# *** Experimental and not fully tested in 3.2.x. ***
# If true, enable eviction of metadata for closed databases.
# The default for JE 3.2.x is false but will be changed to true
# in JE 3.3 and above.
# je.env.dbEviction=false
# (mutable at run time: false)

# If true, use latches instead of synchronized blocks to
# implement the lock table and log write mutexes. Latches require
# that threads queue to obtain the mutex in question and
# therefore guarantee that there will be no mutex starvation, but 
# do incur a performance penalty. Latches should not be necessary in
# most cases, so synchronized blocks are the default. An application
# that puts heavy load on JE with threads with different thread
# priorities might find it useful to use latches.  In a Java 5 JVM,
# where java.util.concurrent.locks.ReentrantLock is used for the
# latch implementation, this parameter will determine whether they
# are 'fair' or not.  This parameter is 'static' across all
# environments.

# je.env.fairLatches=false
# (mutable at run time: false)

# Debugging support: call Thread.yield() at strategic points.
# je.env.forcedYield=false
# (mutable at run time: false)

# If true, create the environment with locking.
# je.env.isLocking=true
# (mutable at run time: false)

# If true, create the environment read only.
# je.env.isReadOnly=false
# (mutable at run time: false)

# If true, create the environment w/ transactions.
# je.env.isTransactional=false
# (mutable at run time: false)

# If true, an environment is created with recovery and the related
# daemons threads enabled.
# je.env.recovery=true
# (mutable at run time: false)

# If true, a checkpoint is forced following recovery, even if the
# log ends with a checkpoint.
# je.env.recoveryForceCheckpoint=false
# (mutable at run time: false)

# If true, starts up the checkpointer.
# This parameter is true by default
# je.env.runCheckpointer=true
# (mutable at run time: true)

# If true, starts up the cleaner.
# This parameter is true by default
# je.env.runCleaner=true
# (mutable at run time: true)

# If true, starts up the evictor.
# This parameter is false by default
# (deprecated, eviction is performed in-line
# je.env.runEvictor=false
# (mutable at run time: true)

# If true, starts up the INCompressor.
# This parameter is true by default
# je.env.runINCompressor=true
# (mutable at run time: true)

# If true, use shared latches for Internal Nodes (INs).

# je.env.sharedLatches=false
# (mutable at run time: false)

# At this percentage over the allotted cache, critical eviction
# will start.# (deprecated, eviction is performed in-line
# minimum = 0
# maximum = 1000
# je.evictor.criticalPercentage=0
# (mutable at run time: false)

# The number of times to retry the evictor if it runs into a deadlock.
# minimum = 0
# maximum = 2147483647
# je.evictor.deadlockRetry=3
# (mutable at run time: false)

# When eviction occurs, the evictor will push memory usage to this
# number of bytes below je.maxMemory.  The default is 512 KB and the
# minimum is 1 KB (1024).  No more than 50% of je.maxMemory will be
# evicted per eviction cycle, regardless of this setting.
# minimum = 1024
# je.evictor.evictBytes=524288
# (mutable at run time: false)

# The evictor percentage of scanned nodes to evict per wakeup.
# (deprecated)
# minimum = 1
# maximum = 100
# je.evictor.evictionBatchPercentage=10
# (mutable at run time: false)

# Call Thread.yield() at each check for cache overflow. This
# improves GC performance on some systems.  The default is false.
# je.evictor.forcedYield=false
# (mutable at run time: false)

# If true (the default), use an LRU-only policy to select nodes for
# eviction.  If false, select by Btree level first, and then by LRU.
# je.evictor.lruOnly=true
# (mutable at run time: false)

# The evictor percentage of total nodes to scan per wakeup.
# (deprecated in favor of je.evictor.nodesPerScan
# minimum = 1
# maximum = 100
# je.evictor.nodeScanPercentage=10
# (mutable at run time: false)

# The number of nodes in one evictor scan
# minimum = 1
# maximum = 1000
# je.evictor.nodesPerScan=10
# (mutable at run time: false)

# When eviction happens, the evictor will push memory usage to this
# percentage of je.maxMemory.# (deprecated in favor of je.evictor.evictBytes
# minimum = 50
# maximum = 100
# je.evictor.useMemoryFloor=95
# (mutable at run time: false)

# Number of Lock Tables.  Set this to a value other than 1 when
# an application has multiple threads performing concurrent JE
# operations.  It should be set to a prime number, and in general
# not higher than the number of application threads performing JE
# operations.
# minimum = 1
# maximum = 32767
# je.lock.nLockTables=1
# (mutable at run time: false)

# The lock timeout in microseconds.
# minimum = 0
# maximum = 4294967296
# je.lock.timeout=500000
# (mutable at run time: false)

# maximum starting size of a JE log buffer
# minimum = 1024
# je.log.bufferSize=1048576
# (mutable at run time: false)

# If true, perform a checksum check when reading entries from log.
# je.log.checksumRead=true
# (mutable at run time: false)

# If non-0 (default is 0) break all IO into chunks of this size.
# This setting is only used if je.log.useNIO=true.
# minimum = 0
# maximum = 67108864
# je.log.chunkedNIO=0
# (mutable at run time: false)

# If true (default is false) direct NIO buffers are used.
# This setting is only used if je.log.useNIO=true.
# je.log.directNIO=false
# (mutable at run time: false)

# The buffer size for faulting in objects from disk, in bytes.
# minimum = 32
# je.log.faultReadSize=2048
# (mutable at run time: false)

# The size of the file handle cache.
# minimum = 3
# je.log.fileCacheSize=100
# (mutable at run time: false)

# The maximum size of each individual JE log file, in bytes.
# minimum = 1000000
# maximum = 4294967296
# je.log.fileMax=10000000
# (mutable at run time: false)

# Timeout limit for group file sync, in microseconds.
# minimum = 10000
# je.log.fsyncTimeout=500000
# (mutable at run time: false)

# The maximum read buffer size for log iterators, which are used
# when scanning the log during activities like log cleaning
# and environment open, in bytes.
# minimum = 128
# je.log.iteratorMaxSize=16777216
# (mutable at run time: false)

# The read buffer size for log iterators, which are used when
# scanning the log during activities like log cleaning and
# environment open, in bytes. This may grow as the system encounters
# larger log entries
# minimum = 128
# je.log.iteratorReadSize=8192
# (mutable at run time: false)

# If true, operates in an in-memory test mode without flushing
# the log to disk. An environment directory must be specified, but
# it need not exist and no files are written.  The system operates
# until it runs out of memory, at which time an OutOfMemoryError
# is thrown.  Because the entire log is kept in memory, this mode
# is normally useful only for testing.
# je.log.memOnly=false
# (mutable at run time: false)

# The number of JE log buffers
# minimum = 2
# je.log.numBuffers=3
# (mutable at run time: false)

# The total memory taken by log buffers, in bytes. If 0, use
# 7% of je.maxMemory
# minimum = 6144
# je.log.totalBufferBytes=0
# (mutable at run time: false)

# If true (default is false) NIO is used for all file I/O.
# je.log.useNIO=false
# (mutable at run time: false)

# If true (default is false) O_DSYNC is used to open JE log files.
# je.log.useODSYNC=false
# (mutable at run time: false)

# Specify the cache size in bytes, as an absolute number. The system
# attempts to stay within this budget and will evict database
# objects when it comes within a prescribed margin of the limit.
# By default, this parameter is 0 and JE instead sizes the cache
# proportionally to the memory available to the JVM, based on
# je.maxMemoryPercent.

# je.maxMemory=0
# (mutable at run time: true)

# By default, JE sizes the cache as a percentage of the maximum
# memory available to the JVM. For example, if the JVM is
# started with -Xmx128M, the cache size will be
#           (je.maxMemoryPercent * 128M) / 100
# Setting je.maxMemory to an non-zero value will override
# je.maxMemoryPercent
# minimum = 1
# maximum = 90
# je.maxMemoryPercent=60
# (mutable at run time: true)

# The maximum number of entries in an internal dup btree node.
# This can be set per-database using the DatabaseConfig object.
# minimum = 4
# maximum = 32767
# je.nodeDupTreeMaxEntries=128
# (mutable at run time: false)

# The maximum number of entries in an internal btree node.
# This can be set per-database using the DatabaseConfig object.
# minimum = 4
# maximum = 32767
# je.nodeMaxEntries=128
# (mutable at run time: false)

# If less than this percentage of entries are changed on a BIN,
# logs a delta instead of a full version.
# minimum = 0
# maximum = 75
# je.tree.binDelta=25
# (mutable at run time: false)

# After this many deltas, logs a full version.
# minimum = 0
# maximum = 100
# je.tree.maxDelta=10
# (mutable at run time: false)

# The minimum bytes allocated out of the memory cache to hold
# Btree data including internal nodes and record keys and data.
# If the specified value is larger than the size initially available
# in the cache, it will be truncated to the amount available.
# By default, 500 KB or the size initially available in the cache is
# used, whichever is smaller.
# minimum = 51200
# je.tree.minMemory=512000
# (mutable at run time: true)

# Set this parameter to true to add stacktrace information to deadlock
# (lock timeout) exception messages.  The stack trace will show where
# each lock was taken.  The default is false, and true should only be
# used during debugging because of the added memory/processing cost.
# This parameter is 'static' across all environments.
# je.txn.deadlockStackTrace=false
# (mutable at run time: true)

# Dump the lock table when a lock timeout is encountered, for
# debugging assistance.
# je.txn.dumpLocks=false
# (mutable at run time: true)

# Transactions have the Serializable (Degree 3) isolation level.  The
# default is false, which implies the Repeatable Read isolation level.
# je.txn.serializableIsolation=false
# (mutable at run time: false)

# The transaction timeout, in microseconds. A value of 0 means no limit.
# minimum = 0
# maximum = 4294967296
# je.txn.timeout=0
# (mutable at run time: false)

