mirror of
https://github.com/XRPLF/rippled.git
synced 2026-01-08 16:56:56 +00:00
Merge branch 'master' of https://github.com/facebook/rocksdb
Conflicts: Makefile java/Makefile java/org/rocksdb/Options.java java/rocksjni/portal.h
This commit is contained in:
Ankit Gupta
@@ -173,32 +173,341 @@ public class Options {
|
||||
return disableSeekCompaction(nativeHandle_);
|
||||
}
|
||||
|
||||
/*
|
||||
* Maximum number of concurrent background jobs, submitted to
|
||||
* the default LOW priority thread pool.
|
||||
* Default: 1
|
||||
/**
|
||||
* Set the amount of cache in bytes that will be used by RocksDB.
|
||||
* If cacheSize is non-positive, then cache will not be used.
|
||||
*
|
||||
* @param maxBackgroundCompactions the maximum number of concurrent
|
||||
* background jobs.
|
||||
* @return the instance of the current Options.
|
||||
* @see RocksDB.open()
|
||||
* DEFAULT: 8M
|
||||
*/
|
||||
public Options setMaxBackgroundCompactions(int maxBackgroundCompactions) {
|
||||
assert(isInitialized());
|
||||
setMaxBackgroundCompactions(nativeHandle_, maxBackgroundCompactions);
|
||||
public Options setCacheSize(long cacheSize) {
|
||||
cacheSize_ = cacheSize;
|
||||
return this;
|
||||
}
|
||||
|
||||
/*
|
||||
* Returns maximum number of background concurrent jobs.
|
||||
/**
|
||||
* @return the amount of cache in bytes that will be used by RocksDB.
|
||||
*/
|
||||
public long cacheSize() {
|
||||
return cacheSize_;
|
||||
}
|
||||
|
||||
/**
|
||||
* If true, an error will be thrown during RocksDB.open() if the
|
||||
* database already exists.
|
||||
*
|
||||
* @return maximum number of background concurrent jobs.
|
||||
* @see setMaxBackgroundCompactions
|
||||
* @return if true, an error is raised when the specified database
|
||||
* already exists before open.
|
||||
*/
|
||||
public boolean errorIfExists() {
|
||||
assert(isInitialized());
|
||||
return errorIfExists(nativeHandle_);
|
||||
}
|
||||
private native boolean errorIfExists(long handle);
|
||||
|
||||
/**
|
||||
* If true, an error will be thrown during RocksDB.open() if the
|
||||
* database already exists.
|
||||
* Default: false
|
||||
*
|
||||
* @param errorIfExists if true, an exception will be thrown
|
||||
* during RocksDB.open() if the database already exists.
|
||||
* @return the reference to the current option.
|
||||
* @see RocksDB.open()
|
||||
*/
|
||||
public Options setErrorIfExists(boolean errorIfExists) {
|
||||
assert(isInitialized());
|
||||
setErrorIfExists(nativeHandle_, errorIfExists);
|
||||
return this;
|
||||
}
|
||||
private native void setErrorIfExists(long handle, boolean errorIfExists);
|
||||
|
||||
/**
|
||||
* If true, the implementation will do aggressive checking of the
|
||||
* data it is processing and will stop early if it detects any
|
||||
* errors. This may have unforeseen ramifications: for example, a
|
||||
* corruption of one DB entry may cause a large number of entries to
|
||||
* become unreadable or for the entire DB to become unopenable.
|
||||
* If any of the writes to the database fails (Put, Delete, Merge, Write),
|
||||
* the database will switch to read-only mode and fail all other
|
||||
* Write operations.
|
||||
*
|
||||
* @return a boolean indicating whether paranoid-check is on.
|
||||
*/
|
||||
public boolean paranoidChecks() {
|
||||
assert(isInitialized());
|
||||
return paranoidChecks(nativeHandle_);
|
||||
}
|
||||
private native boolean paranoidChecks(long handle);
|
||||
|
||||
/**
|
||||
* If true, the implementation will do aggressive checking of the
|
||||
* data it is processing and will stop early if it detects any
|
||||
* errors. This may have unforeseen ramifications: for example, a
|
||||
* corruption of one DB entry may cause a large number of entries to
|
||||
* become unreadable or for the entire DB to become unopenable.
|
||||
* If any of the writes to the database fails (Put, Delete, Merge, Write),
|
||||
* the database will switch to read-only mode and fail all other
|
||||
* Write operations.
|
||||
* Default: true
|
||||
*
|
||||
* @param paranoidChecks a flag to indicate whether paranoid-check
|
||||
* is on.
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setParanoidChecks(boolean paranoidChecks) {
|
||||
assert(isInitialized());
|
||||
setParanoidChecks(nativeHandle_, paranoidChecks);
|
||||
return this;
|
||||
}
|
||||
private native void setParanoidChecks(
|
||||
long handle, boolean paranoidChecks);
|
||||
|
||||
/**
|
||||
* Number of open files that can be used by the DB. You may need to
|
||||
* increase this if your database has a large working set. Value -1 means
|
||||
* files opened are always kept open. You can estimate number of files based
|
||||
* on target_file_size_base and target_file_size_multiplier for level-based
|
||||
* compaction. For universal-style compaction, you can usually set it to -1.
|
||||
*
|
||||
* @return the maximum number of open files.
|
||||
*/
|
||||
public int maxOpenFiles() {
|
||||
assert(isInitialized());
|
||||
return maxOpenFiles(nativeHandle_);
|
||||
}
|
||||
private native int maxOpenFiles(long handle);
|
||||
|
||||
/**
|
||||
* Number of open files that can be used by the DB. You may need to
|
||||
* increase this if your database has a large working set. Value -1 means
|
||||
* files opened are always kept open. You can estimate number of files based
|
||||
* on target_file_size_base and target_file_size_multiplier for level-based
|
||||
* compaction. For universal-style compaction, you can usually set it to -1.
|
||||
* Default: 5000
|
||||
*
|
||||
* @param maxOpenFiles the maximum number of open files.
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setMaxOpenFiles(int maxOpenFiles) {
|
||||
assert(isInitialized());
|
||||
setMaxOpenFiles(nativeHandle_, maxOpenFiles);
|
||||
return this;
|
||||
}
|
||||
private native void setMaxOpenFiles(long handle, int maxOpenFiles);
|
||||
|
||||
/**
|
||||
* If true, then the contents of data files are not synced
|
||||
* to stable storage. Their contents remain in the OS buffers till the
|
||||
* OS decides to flush them. This option is good for bulk-loading
|
||||
* of data. Once the bulk-loading is complete, please issue a
|
||||
* sync to the OS to flush all dirty buffesrs to stable storage.
|
||||
*
|
||||
* @return if true, then data-sync is disabled.
|
||||
*/
|
||||
public boolean disableDataSync() {
|
||||
assert(isInitialized());
|
||||
return disableDataSync(nativeHandle_);
|
||||
}
|
||||
private native boolean disableDataSync(long handle);
|
||||
|
||||
/**
|
||||
* If true, then the contents of data files are not synced
|
||||
* to stable storage. Their contents remain in the OS buffers till the
|
||||
* OS decides to flush them. This option is good for bulk-loading
|
||||
* of data. Once the bulk-loading is complete, please issue a
|
||||
* sync to the OS to flush all dirty buffesrs to stable storage.
|
||||
* Default: false
|
||||
*
|
||||
* @param disableDataSync a boolean flag to specify whether to
|
||||
* disable data sync.
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setDisableDataSync(boolean disableDataSync) {
|
||||
assert(isInitialized());
|
||||
setDisableDataSync(nativeHandle_, disableDataSync);
|
||||
return this;
|
||||
}
|
||||
private native void setDisableDataSync(long handle, boolean disableDataSync);
|
||||
|
||||
/**
|
||||
* If true, then every store to stable storage will issue a fsync.
|
||||
* If false, then every store to stable storage will issue a fdatasync.
|
||||
* This parameter should be set to true while storing data to
|
||||
* filesystem like ext3 that can lose files after a reboot.
|
||||
*
|
||||
* @return true if fsync is used.
|
||||
*/
|
||||
public boolean useFsync() {
|
||||
assert(isInitialized());
|
||||
return useFsync(nativeHandle_);
|
||||
}
|
||||
private native boolean useFsync(long handle);
|
||||
|
||||
/**
|
||||
* If true, then every store to stable storage will issue a fsync.
|
||||
* If false, then every store to stable storage will issue a fdatasync.
|
||||
* This parameter should be set to true while storing data to
|
||||
* filesystem like ext3 that can lose files after a reboot.
|
||||
* Default: false
|
||||
*
|
||||
* @param useFsync a boolean flag to specify whether to use fsync
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setUseFsync(boolean useFsync) {
|
||||
assert(isInitialized());
|
||||
setUseFsync(nativeHandle_, useFsync);
|
||||
return this;
|
||||
}
|
||||
private native void setUseFsync(long handle, boolean useFsync);
|
||||
|
||||
/**
|
||||
* The time interval in seconds between each two consecutive stats logs.
|
||||
* This number controls how often a new scribe log about
|
||||
* db deploy stats is written out.
|
||||
* -1 indicates no logging at all.
|
||||
*
|
||||
* @return the time interval in seconds between each two consecutive
|
||||
* stats logs.
|
||||
*/
|
||||
public int dbStatsLogInterval() {
|
||||
assert(isInitialized());
|
||||
return dbStatsLogInterval(nativeHandle_);
|
||||
}
|
||||
private native int dbStatsLogInterval(long handle);
|
||||
|
||||
/**
|
||||
* The time interval in seconds between each two consecutive stats logs.
|
||||
* This number controls how often a new scribe log about
|
||||
* db deploy stats is written out.
|
||||
* -1 indicates no logging at all.
|
||||
* Default value is 1800 (half an hour).
|
||||
*
|
||||
* @param dbStatsLogInterval the time interval in seconds between each
|
||||
* two consecutive stats logs.
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setDbStatsLogInterval(int dbStatsLogInterval) {
|
||||
assert(isInitialized());
|
||||
setDbStatsLogInterval(nativeHandle_, dbStatsLogInterval);
|
||||
return this;
|
||||
}
|
||||
private native void setDbStatsLogInterval(
|
||||
long handle, int dbStatsLogInterval);
|
||||
|
||||
/**
|
||||
* Returns the directory of info log.
|
||||
*
|
||||
* If it is empty, the log files will be in the same dir as data.
|
||||
* If it is non empty, the log files will be in the specified dir,
|
||||
* and the db data dir's absolute path will be used as the log file
|
||||
* name's prefix.
|
||||
*
|
||||
* @return the path to the info log directory
|
||||
*/
|
||||
public String dbLogDir() {
|
||||
assert(isInitialized());
|
||||
return dbLogDir(nativeHandle_);
|
||||
}
|
||||
private native String dbLogDir(long handle);
|
||||
|
||||
/**
|
||||
* This specifies the info LOG dir.
|
||||
* If it is empty, the log files will be in the same dir as data.
|
||||
* If it is non empty, the log files will be in the specified dir,
|
||||
* and the db data dir's absolute path will be used as the log file
|
||||
* name's prefix.
|
||||
*
|
||||
* @param dbLogDir the path to the info log directory
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setDbLogDir(String dbLogDir) {
|
||||
assert(isInitialized());
|
||||
setDbLogDir(nativeHandle_, dbLogDir);
|
||||
return this;
|
||||
}
|
||||
private native void setDbLogDir(long handle, String dbLogDir);
|
||||
|
||||
/**
|
||||
* Returns the path to the write-ahead-logs (WAL) directory.
|
||||
*
|
||||
* If it is empty, the log files will be in the same dir as data,
|
||||
* dbname is used as the data dir by default
|
||||
* If it is non empty, the log files will be in kept the specified dir.
|
||||
* When destroying the db,
|
||||
* all log files in wal_dir and the dir itself is deleted
|
||||
*
|
||||
* @return the path to the write-ahead-logs (WAL) directory.
|
||||
*/
|
||||
public String walDir() {
|
||||
assert(isInitialized());
|
||||
return walDir(nativeHandle_);
|
||||
}
|
||||
private native String walDir(long handle);
|
||||
|
||||
/**
|
||||
* This specifies the absolute dir path for write-ahead logs (WAL).
|
||||
* If it is empty, the log files will be in the same dir as data,
|
||||
* dbname is used as the data dir by default
|
||||
* If it is non empty, the log files will be in kept the specified dir.
|
||||
* When destroying the db,
|
||||
* all log files in wal_dir and the dir itself is deleted
|
||||
*
|
||||
* @param walDir the path to the write-ahead-log directory.
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setWalDir(String walDir) {
|
||||
assert(isInitialized());
|
||||
setWalDir(nativeHandle_, walDir);
|
||||
return this;
|
||||
}
|
||||
private native void setWalDir(long handle, String walDir);
|
||||
|
||||
/**
|
||||
* The periodicity when obsolete files get deleted. The default
|
||||
* value is 6 hours. The files that get out of scope by compaction
|
||||
* process will still get automatically delete on every compaction,
|
||||
* regardless of this setting
|
||||
*
|
||||
* @return the time interval in micros when obsolete files will be deleted.
|
||||
*/
|
||||
public long deleteObsoleteFilesPeriodMicros() {
|
||||
assert(isInitialized());
|
||||
return deleteObsoleteFilesPeriodMicros(nativeHandle_);
|
||||
}
|
||||
private native long deleteObsoleteFilesPeriodMicros(long handle);
|
||||
|
||||
/**
|
||||
* The periodicity when obsolete files get deleted. The default
|
||||
* value is 6 hours. The files that get out of scope by compaction
|
||||
* process will still get automatically delete on every compaction,
|
||||
* regardless of this setting
|
||||
*
|
||||
* @param micros the time interval in micros
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setDeleteObsoleteFilesPeriodMicros(long micros) {
|
||||
assert(isInitialized());
|
||||
setDeleteObsoleteFilesPeriodMicros(nativeHandle_, micros);
|
||||
return this;
|
||||
}
|
||||
private native void setDeleteObsoleteFilesPeriodMicros(
|
||||
long handle, long micros);
|
||||
|
||||
/**
|
||||
* Returns the maximum number of concurrent background compaction jobs,
|
||||
* submitted to the default LOW priority thread pool.
|
||||
* When increasing this number, we may also want to consider increasing
|
||||
* number of threads in LOW priority thread pool.
|
||||
* Default: 1
|
||||
*
|
||||
* @return the maximum number of concurrent background compaction jobs.
|
||||
* @see Env.setBackgroundThreads()
|
||||
*/
|
||||
public int maxBackgroundCompactions() {
|
||||
assert(isInitialized());
|
||||
return maxBackgroundCompactions(nativeHandle_);
|
||||
}
|
||||
private native int maxBackgroundCompactions(long handle);
|
||||
|
||||
/*
|
||||
* Creates statistics object which collects metrics about database operations.
|
||||
@@ -234,22 +543,594 @@ public class Options {
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the amount of cache in bytes that will be used by RocksDB.
|
||||
* If cacheSize is non-positive, then cache will not be used.
|
||||
* Specifies the maximum number of concurrent background compaction jobs,
|
||||
* submitted to the default LOW priority thread pool.
|
||||
* If you're increasing this, also consider increasing number of threads in
|
||||
* LOW priority thread pool. For more information, see
|
||||
* Default: 1
|
||||
*
|
||||
* DEFAULT: 8M
|
||||
* @param maxBackgroundCompactions the maximum number of background
|
||||
* compaction jobs.
|
||||
* @return the reference to the current option.
|
||||
*
|
||||
* @see Env.setBackgroundThreads()
|
||||
* @see maxBackgroundFlushes()
|
||||
*/
|
||||
public Options setCacheSize(long cacheSize) {
|
||||
cacheSize_ = cacheSize;
|
||||
public Options setMaxBackgroundCompactions(int maxBackgroundCompactions) {
|
||||
assert(isInitialized());
|
||||
setMaxBackgroundCompactions(nativeHandle_, maxBackgroundCompactions);
|
||||
return this;
|
||||
}
|
||||
private native void setMaxBackgroundCompactions(
|
||||
long handle, int maxBackgroundCompactions);
|
||||
|
||||
/**
|
||||
* @return the amount of cache in bytes that will be used by RocksDB.
|
||||
* Returns the maximum number of concurrent background flush jobs.
|
||||
* If you're increasing this, also consider increasing number of threads in
|
||||
* HIGH priority thread pool. For more information, see
|
||||
* Default: 1
|
||||
*
|
||||
* @return the maximum number of concurrent background flush jobs.
|
||||
* @see Env.setBackgroundThreads()
|
||||
*/
|
||||
public long cacheSize() {
|
||||
return cacheSize_;
|
||||
public int maxBackgroundFlushes() {
|
||||
assert(isInitialized());
|
||||
return maxBackgroundFlushes(nativeHandle_);
|
||||
}
|
||||
private native int maxBackgroundFlushes(long handle);
|
||||
|
||||
/**
|
||||
* Specifies the maximum number of concurrent background flush jobs.
|
||||
* If you're increasing this, also consider increasing number of threads in
|
||||
* HIGH priority thread pool. For more information, see
|
||||
* Default: 1
|
||||
*
|
||||
* @param maxBackgroundFlushes
|
||||
* @return the reference to the current option.
|
||||
*
|
||||
* @see Env.setBackgroundThreads()
|
||||
* @see maxBackgroundCompactions()
|
||||
*/
|
||||
public Options setMaxBackgroundFlushes(int maxBackgroundFlushes) {
|
||||
assert(isInitialized());
|
||||
setMaxBackgroundFlushes(nativeHandle_, maxBackgroundFlushes);
|
||||
return this;
|
||||
}
|
||||
private native void setMaxBackgroundFlushes(
|
||||
long handle, int maxBackgroundFlushes);
|
||||
|
||||
/**
|
||||
* Returns the maximum size of a info log file. If the current log file
|
||||
* is larger than this size, a new info log file will be created.
|
||||
* If 0, all logs will be written to one log file.
|
||||
*
|
||||
* @return the maximum size of the info log file.
|
||||
*/
|
||||
public long maxLogFileSize() {
|
||||
assert(isInitialized());
|
||||
return maxLogFileSize(nativeHandle_);
|
||||
}
|
||||
private native long maxLogFileSize(long handle);
|
||||
|
||||
/**
|
||||
* Specifies the maximum size of a info log file. If the current log file
|
||||
* is larger than `max_log_file_size`, a new info log file will
|
||||
* be created.
|
||||
* If 0, all logs will be written to one log file.
|
||||
*
|
||||
* @param maxLogFileSize the maximum size of a info log file.
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setMaxLogFileSize(long maxLogFileSize) {
|
||||
assert(isInitialized());
|
||||
setMaxLogFileSize(nativeHandle_, maxLogFileSize);
|
||||
return this;
|
||||
}
|
||||
private native void setMaxLogFileSize(long handle, long maxLogFileSize);
|
||||
|
||||
/**
|
||||
* Returns the time interval for the info log file to roll (in seconds).
|
||||
* If specified with non-zero value, log file will be rolled
|
||||
* if it has been active longer than `log_file_time_to_roll`.
|
||||
* Default: 0 (disabled)
|
||||
*
|
||||
* @return the time interval in seconds.
|
||||
*/
|
||||
public long logFileTimeToRoll() {
|
||||
assert(isInitialized());
|
||||
return logFileTimeToRoll(nativeHandle_);
|
||||
}
|
||||
private native long logFileTimeToRoll(long handle);
|
||||
|
||||
/**
|
||||
* Specifies the time interval for the info log file to roll (in seconds).
|
||||
* If specified with non-zero value, log file will be rolled
|
||||
* if it has been active longer than `log_file_time_to_roll`.
|
||||
* Default: 0 (disabled)
|
||||
*
|
||||
* @param logFileTimeToRoll the time interval in seconds.
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setLogFileTimeToRoll(long logFileTimeToRoll) {
|
||||
assert(isInitialized());
|
||||
setLogFileTimeToRoll(nativeHandle_, logFileTimeToRoll);
|
||||
return this;
|
||||
}
|
||||
private native void setLogFileTimeToRoll(
|
||||
long handle, long logFileTimeToRoll);
|
||||
|
||||
/**
|
||||
* Returns the maximum number of info log files to be kept.
|
||||
* Default: 1000
|
||||
*
|
||||
* @return the maximum number of info log files to be kept.
|
||||
*/
|
||||
public long keepLogFileNum() {
|
||||
assert(isInitialized());
|
||||
return keepLogFileNum(nativeHandle_);
|
||||
}
|
||||
private native long keepLogFileNum(long handle);
|
||||
|
||||
/**
|
||||
* Specifies the maximum number of info log files to be kept.
|
||||
* Default: 1000
|
||||
*
|
||||
* @param keepLogFileNum the maximum number of info log files to be kept.
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setKeepLogFileNum(long keepLogFileNum) {
|
||||
assert(isInitialized());
|
||||
setKeepLogFileNum(nativeHandle_, keepLogFileNum);
|
||||
return this;
|
||||
}
|
||||
private native void setKeepLogFileNum(long handle, long keepLogFileNum);
|
||||
|
||||
/**
|
||||
* Manifest file is rolled over on reaching this limit.
|
||||
* The older manifest file be deleted.
|
||||
* The default value is MAX_INT so that roll-over does not take place.
|
||||
*
|
||||
* @return the size limit of a manifest file.
|
||||
*/
|
||||
public long maxManifestFileSize() {
|
||||
assert(isInitialized());
|
||||
return maxManifestFileSize(nativeHandle_);
|
||||
}
|
||||
private native long maxManifestFileSize(long handle);
|
||||
|
||||
/**
|
||||
* Manifest file is rolled over on reaching this limit.
|
||||
* The older manifest file be deleted.
|
||||
* The default value is MAX_INT so that roll-over does not take place.
|
||||
*
|
||||
* @param maxManifestFileSize the size limit of a manifest file.
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setMaxManifestFileSize(long maxManifestFileSize) {
|
||||
assert(isInitialized());
|
||||
setMaxManifestFileSize(nativeHandle_, maxManifestFileSize);
|
||||
return this;
|
||||
}
|
||||
private native void setMaxManifestFileSize(
|
||||
long handle, long maxManifestFileSize);
|
||||
|
||||
/**
|
||||
* Number of shards used for table cache.
|
||||
*
|
||||
* @return the number of shards used for table cache.
|
||||
*/
|
||||
public int tableCacheNumshardbits() {
|
||||
assert(isInitialized());
|
||||
return tableCacheNumshardbits(nativeHandle_);
|
||||
}
|
||||
private native int tableCacheNumshardbits(long handle);
|
||||
|
||||
/**
|
||||
* Number of shards used for table cache.
|
||||
*
|
||||
* @param tableCacheNumshardbits the number of chards
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setTableCacheNumshardbits(int tableCacheNumshardbits) {
|
||||
assert(isInitialized());
|
||||
setTableCacheNumshardbits(nativeHandle_, tableCacheNumshardbits);
|
||||
return this;
|
||||
}
|
||||
private native void setTableCacheNumshardbits(
|
||||
long handle, int tableCacheNumshardbits);
|
||||
|
||||
/**
|
||||
* During data eviction of table's LRU cache, it would be inefficient
|
||||
* to strictly follow LRU because this piece of memory will not really
|
||||
* be released unless its refcount falls to zero. Instead, make two
|
||||
* passes: the first pass will release items with refcount = 1,
|
||||
* and if not enough space releases after scanning the number of
|
||||
* elements specified by this parameter, we will remove items in LRU
|
||||
* order.
|
||||
*
|
||||
* @return scan count limit
|
||||
*/
|
||||
public int tableCacheRemoveScanCountLimit() {
|
||||
assert(isInitialized());
|
||||
return tableCacheRemoveScanCountLimit(nativeHandle_);
|
||||
}
|
||||
private native int tableCacheRemoveScanCountLimit(long handle);
|
||||
|
||||
/**
|
||||
* During data eviction of table's LRU cache, it would be inefficient
|
||||
* to strictly follow LRU because this piece of memory will not really
|
||||
* be released unless its refcount falls to zero. Instead, make two
|
||||
* passes: the first pass will release items with refcount = 1,
|
||||
* and if not enough space releases after scanning the number of
|
||||
* elements specified by this parameter, we will remove items in LRU
|
||||
* order.
|
||||
*
|
||||
* @param limit scan count limit
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setTableCacheRemoveScanCountLimit(int limit) {
|
||||
assert(isInitialized());
|
||||
setTableCacheRemoveScanCountLimit(nativeHandle_, limit);
|
||||
return this;
|
||||
}
|
||||
private native void setTableCacheRemoveScanCountLimit(
|
||||
long handle, int limit);
|
||||
|
||||
/**
|
||||
* The following two fields affect how archived logs will be deleted.
|
||||
* 1. If both set to 0, logs will be deleted asap and will not get into
|
||||
* the archive.
|
||||
* 2. If WAL_ttl_seconds is 0 and WAL_size_limit_MB is not 0,
|
||||
* WAL files will be checked every 10 min and if total size is greater
|
||||
* then WAL_size_limit_MB, they will be deleted starting with the
|
||||
* earliest until size_limit is met. All empty files will be deleted.
|
||||
* 3. If WAL_ttl_seconds is not 0 and WAL_size_limit_MB is 0, then
|
||||
* WAL files will be checked every WAL_ttl_secondsi / 2 and those that
|
||||
* are older than WAL_ttl_seconds will be deleted.
|
||||
* 4. If both are not 0, WAL files will be checked every 10 min and both
|
||||
* checks will be performed with ttl being first.
|
||||
*
|
||||
* @return the wal-ttl seconds
|
||||
*/
|
||||
public long walTtlSeconds() {
|
||||
assert(isInitialized());
|
||||
return walTtlSeconds(nativeHandle_);
|
||||
}
|
||||
private native long walTtlSeconds(long handle);
|
||||
|
||||
/**
|
||||
* The following two fields affect how archived logs will be deleted.
|
||||
* 1. If both set to 0, logs will be deleted asap and will not get into
|
||||
* the archive.
|
||||
* 2. If WAL_ttl_seconds is 0 and WAL_size_limit_MB is not 0,
|
||||
* WAL files will be checked every 10 min and if total size is greater
|
||||
* then WAL_size_limit_MB, they will be deleted starting with the
|
||||
* earliest until size_limit is met. All empty files will be deleted.
|
||||
* 3. If WAL_ttl_seconds is not 0 and WAL_size_limit_MB is 0, then
|
||||
* WAL files will be checked every WAL_ttl_secondsi / 2 and those that
|
||||
* are older than WAL_ttl_seconds will be deleted.
|
||||
* 4. If both are not 0, WAL files will be checked every 10 min and both
|
||||
* checks will be performed with ttl being first.
|
||||
*
|
||||
* @param walTtlSeconds the ttl seconds
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setWALTtlSeconds(long walTtlSeconds) {
|
||||
assert(isInitialized());
|
||||
setWALTtlSeconds(nativeHandle_, walTtlSeconds);
|
||||
return this;
|
||||
}
|
||||
private native void setWALTtlSeconds(long handle, long walTtlSeconds);
|
||||
|
||||
/**
|
||||
* Number of bytes to preallocate (via fallocate) the manifest
|
||||
* files. Default is 4mb, which is reasonable to reduce random IO
|
||||
* as well as prevent overallocation for mounts that preallocate
|
||||
* large amounts of data (such as xfs's allocsize option).
|
||||
*
|
||||
* @return size in bytes.
|
||||
*/
|
||||
public long manifestPreallocationSize() {
|
||||
assert(isInitialized());
|
||||
return manifestPreallocationSize(nativeHandle_);
|
||||
}
|
||||
private native long manifestPreallocationSize(long handle);
|
||||
|
||||
/**
|
||||
* Number of bytes to preallocate (via fallocate) the manifest
|
||||
* files. Default is 4mb, which is reasonable to reduce random IO
|
||||
* as well as prevent overallocation for mounts that preallocate
|
||||
* large amounts of data (such as xfs's allocsize option).
|
||||
*
|
||||
* @param size the size in byte
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setManifestPreallocationSize(long size) {
|
||||
assert(isInitialized());
|
||||
setManifestPreallocationSize(nativeHandle_, size);
|
||||
return this;
|
||||
}
|
||||
private native void setManifestPreallocationSize(
|
||||
long handle, long size);
|
||||
|
||||
/**
|
||||
* Data being read from file storage may be buffered in the OS
|
||||
* Default: true
|
||||
*
|
||||
* @return if true, then OS buffering is allowed.
|
||||
*/
|
||||
public boolean allowOsBuffer() {
|
||||
assert(isInitialized());
|
||||
return allowOsBuffer(nativeHandle_);
|
||||
}
|
||||
private native boolean allowOsBuffer(long handle);
|
||||
|
||||
/**
|
||||
* Data being read from file storage may be buffered in the OS
|
||||
* Default: true
|
||||
*
|
||||
* @param allowOsBufferif true, then OS buffering is allowed.
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setAllowOsBuffer(boolean allowOsBuffer) {
|
||||
assert(isInitialized());
|
||||
setAllowOsBuffer(nativeHandle_, allowOsBuffer);
|
||||
return this;
|
||||
}
|
||||
private native void setAllowOsBuffer(
|
||||
long handle, boolean allowOsBuffer);
|
||||
|
||||
/**
|
||||
* Allow the OS to mmap file for reading sst tables.
|
||||
* Default: false
|
||||
*
|
||||
* @return true if mmap reads are allowed.
|
||||
*/
|
||||
public boolean allowMmapReads() {
|
||||
assert(isInitialized());
|
||||
return allowMmapReads(nativeHandle_);
|
||||
}
|
||||
private native boolean allowMmapReads(long handle);
|
||||
|
||||
/**
|
||||
* Allow the OS to mmap file for reading sst tables.
|
||||
* Default: false
|
||||
*
|
||||
* @param allowMmapReads true if mmap reads are allowed.
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setAllowMmapReads(boolean allowMmapReads) {
|
||||
assert(isInitialized());
|
||||
setAllowMmapReads(nativeHandle_, allowMmapReads);
|
||||
return this;
|
||||
}
|
||||
private native void setAllowMmapReads(
|
||||
long handle, boolean allowMmapReads);
|
||||
|
||||
/**
|
||||
* Allow the OS to mmap file for writing. Default: false
|
||||
*
|
||||
* @return true if mmap writes are allowed.
|
||||
*/
|
||||
public boolean allowMmapWrites() {
|
||||
assert(isInitialized());
|
||||
return allowMmapWrites(nativeHandle_);
|
||||
}
|
||||
private native boolean allowMmapWrites(long handle);
|
||||
|
||||
/**
|
||||
* Allow the OS to mmap file for writing. Default: false
|
||||
*
|
||||
* @param allowMmapWrites true if mmap writes are allowd.
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setAllowMmapWrites(boolean allowMmapWrites) {
|
||||
assert(isInitialized());
|
||||
setAllowMmapWrites(nativeHandle_, allowMmapWrites);
|
||||
return this;
|
||||
}
|
||||
private native void setAllowMmapWrites(
|
||||
long handle, boolean allowMmapWrites);
|
||||
|
||||
/**
|
||||
* Disable child process inherit open files. Default: true
|
||||
*
|
||||
* @return true if child process inheriting open files is disabled.
|
||||
*/
|
||||
public boolean isFdCloseOnExec() {
|
||||
assert(isInitialized());
|
||||
return isFdCloseOnExec(nativeHandle_);
|
||||
}
|
||||
private native boolean isFdCloseOnExec(long handle);
|
||||
|
||||
/**
|
||||
* Disable child process inherit open files. Default: true
|
||||
*
|
||||
* @param isFdCloseOnExec true if child process inheriting open
|
||||
* files is disabled.
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setIsFdCloseOnExec(boolean isFdCloseOnExec) {
|
||||
assert(isInitialized());
|
||||
setIsFdCloseOnExec(nativeHandle_, isFdCloseOnExec);
|
||||
return this;
|
||||
}
|
||||
private native void setIsFdCloseOnExec(
|
||||
long handle, boolean isFdCloseOnExec);
|
||||
|
||||
/**
|
||||
* Skip log corruption error on recovery (If client is ok with
|
||||
* losing most recent changes)
|
||||
* Default: false
|
||||
*
|
||||
* @return true if log corruption errors are skipped during recovery.
|
||||
*/
|
||||
public boolean skipLogErrorOnRecovery() {
|
||||
assert(isInitialized());
|
||||
return skipLogErrorOnRecovery(nativeHandle_);
|
||||
}
|
||||
private native boolean skipLogErrorOnRecovery(long handle);
|
||||
|
||||
/**
|
||||
* Skip log corruption error on recovery (If client is ok with
|
||||
* losing most recent changes)
|
||||
* Default: false
|
||||
*
|
||||
* @param skip true if log corruption errors are skipped during recovery.
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setSkipLogErrorOnRecovery(boolean skip) {
|
||||
assert(isInitialized());
|
||||
setSkipLogErrorOnRecovery(nativeHandle_, skip);
|
||||
return this;
|
||||
}
|
||||
private native void setSkipLogErrorOnRecovery(
|
||||
long handle, boolean skip);
|
||||
|
||||
/**
|
||||
* If not zero, dump rocksdb.stats to LOG every stats_dump_period_sec
|
||||
* Default: 3600 (1 hour)
|
||||
*
|
||||
* @return time interval in seconds.
|
||||
*/
|
||||
public int statsDumpPeriodSec() {
|
||||
assert(isInitialized());
|
||||
return statsDumpPeriodSec(nativeHandle_);
|
||||
}
|
||||
private native int statsDumpPeriodSec(long handle);
|
||||
|
||||
/**
|
||||
* if not zero, dump rocksdb.stats to LOG every stats_dump_period_sec
|
||||
* Default: 3600 (1 hour)
|
||||
*
|
||||
* @param statsDumpPeriodSec time interval in seconds.
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setStatsDumpPeriodSec(int statsDumpPeriodSec) {
|
||||
assert(isInitialized());
|
||||
setStatsDumpPeriodSec(nativeHandle_, statsDumpPeriodSec);
|
||||
return this;
|
||||
}
|
||||
private native void setStatsDumpPeriodSec(
|
||||
long handle, int statsDumpPeriodSec);
|
||||
|
||||
/**
|
||||
* If set true, will hint the underlying file system that the file
|
||||
* access pattern is random, when a sst file is opened.
|
||||
* Default: true
|
||||
*
|
||||
* @return true if hinting random access is on.
|
||||
*/
|
||||
public boolean adviseRandomOnOpen() {
|
||||
return adviseRandomOnOpen(nativeHandle_);
|
||||
}
|
||||
private native boolean adviseRandomOnOpen(long handle);
|
||||
|
||||
/**
|
||||
* If set true, will hint the underlying file system that the file
|
||||
* access pattern is random, when a sst file is opened.
|
||||
* Default: true
|
||||
*
|
||||
* @param adviseRandomOnOpen true if hinting random access is on.
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setAdviseRandomOnOpen(boolean adviseRandomOnOpen) {
|
||||
assert(isInitialized());
|
||||
setAdviseRandomOnOpen(nativeHandle_, adviseRandomOnOpen);
|
||||
return this;
|
||||
}
|
||||
private native void setAdviseRandomOnOpen(
|
||||
long handle, boolean adviseRandomOnOpen);
|
||||
|
||||
/**
|
||||
* Use adaptive mutex, which spins in the user space before resorting
|
||||
* to kernel. This could reduce context switch when the mutex is not
|
||||
* heavily contended. However, if the mutex is hot, we could end up
|
||||
* wasting spin time.
|
||||
* Default: false
|
||||
*
|
||||
* @return true if adaptive mutex is used.
|
||||
*/
|
||||
public boolean useAdaptiveMutex() {
|
||||
assert(isInitialized());
|
||||
return useAdaptiveMutex(nativeHandle_);
|
||||
}
|
||||
private native boolean useAdaptiveMutex(long handle);
|
||||
|
||||
/**
|
||||
* Use adaptive mutex, which spins in the user space before resorting
|
||||
* to kernel. This could reduce context switch when the mutex is not
|
||||
* heavily contended. However, if the mutex is hot, we could end up
|
||||
* wasting spin time.
|
||||
* Default: false
|
||||
*
|
||||
* @param useAdaptiveMutex true if adaptive mutex is used.
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setUseAdaptiveMutex(boolean useAdaptiveMutex) {
|
||||
assert(isInitialized());
|
||||
setUseAdaptiveMutex(nativeHandle_, useAdaptiveMutex);
|
||||
return this;
|
||||
}
|
||||
private native void setUseAdaptiveMutex(
|
||||
long handle, boolean useAdaptiveMutex);
|
||||
|
||||
/**
|
||||
* Allows OS to incrementally sync files to disk while they are being
|
||||
* written, asynchronously, in the background.
|
||||
* Issue one request for every bytes_per_sync written. 0 turns it off.
|
||||
* Default: 0
|
||||
*
|
||||
* @return size in bytes
|
||||
*/
|
||||
public long bytesPerSync() {
|
||||
return bytesPerSync(nativeHandle_);
|
||||
}
|
||||
private native long bytesPerSync(long handle);
|
||||
|
||||
/**
|
||||
* Allows OS to incrementally sync files to disk while they are being
|
||||
* written, asynchronously, in the background.
|
||||
* Issue one request for every bytes_per_sync written. 0 turns it off.
|
||||
* Default: 0
|
||||
*
|
||||
* @param bytesPerSync size in bytes
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setBytesPerSync(long bytesPerSync) {
|
||||
assert(isInitialized());
|
||||
setBytesPerSync(nativeHandle_, bytesPerSync);
|
||||
return this;
|
||||
}
|
||||
private native void setBytesPerSync(
|
||||
long handle, long bytesPerSync);
|
||||
|
||||
/**
|
||||
* Allow RocksDB to use thread local storage to optimize performance.
|
||||
* Default: true
|
||||
*
|
||||
* @return true if thread-local storage is allowed
|
||||
*/
|
||||
public boolean allowThreadLocal() {
|
||||
assert(isInitialized());
|
||||
return allowThreadLocal(nativeHandle_);
|
||||
}
|
||||
private native boolean allowThreadLocal(long handle);
|
||||
|
||||
/**
|
||||
* Allow RocksDB to use thread local storage to optimize performance.
|
||||
* Default: true
|
||||
*
|
||||
* @param allowThreadLocal true if thread-local storage is allowed.
|
||||
* @return the reference to the current option.
|
||||
*/
|
||||
public Options setAllowThreadLocal(boolean allowThreadLocal) {
|
||||
assert(isInitialized());
|
||||
setAllowThreadLocal(nativeHandle_, allowThreadLocal);
|
||||
return this;
|
||||
}
|
||||
private native void setAllowThreadLocal(
|
||||
long handle, boolean allowThreadLocal);
|
||||
|
||||
/**
|
||||
* Release the memory allocated for the current instance
|
||||
@@ -261,6 +1142,10 @@ public class Options {
|
||||
}
|
||||
}
|
||||
|
||||
@Override protected void finalize() {
|
||||
dispose();
|
||||
}
|
||||
|
||||
private boolean isInitialized() {
|
||||
return (nativeHandle_ != 0);
|
||||
}
|
||||
@@ -279,11 +1164,14 @@ public class Options {
|
||||
private native void setDisableSeekCompaction(
|
||||
long handle, boolean disableSeekCompaction);
|
||||
private native boolean disableSeekCompaction(long handle);
|
||||
<<<<<<< HEAD
|
||||
private native void setMaxBackgroundCompactions(
|
||||
long handle, int maxBackgroundCompactions);
|
||||
private native int maxBackgroundCompactions(long handle);
|
||||
private native void createStatistics(long optHandle);
|
||||
private native long statisticsPtr(long optHandle);
|
||||
=======
|
||||
>>>>>>> 1a8abe72768b2b5cea800aa390c28e5ace6a552e
|
||||
|
||||
long nativeHandle_;
|
||||
long cacheSize_;
|
||||
|
||||
Reference in New Issue
Block a user