From 63d74d2bfac888d6a09aa29b560b88bf8ca692a4 Mon Sep 17 00:00:00 2001 From: Ankit Gupta Date: Sun, 6 Apr 2014 09:33:31 -0700 Subject: [PATCH 1/5] Expose JNI layer for these options: block_size, max_write_buffer_number, write_buffer_size, disable_seek_compaction, max_background_compactions. --- java/RocksDBSample.java | 13 +++++ java/org/rocksdb/Options.java | 107 +++++++++++++++++++++++++++++++++- java/rocksjni/options.cc | 105 +++++++++++++++++++++++++++++++++ 3 files changed, 222 insertions(+), 3 deletions(-) diff --git a/java/RocksDBSample.java b/java/RocksDBSample.java index e6421778c..8a1a3ccbc 100644 --- a/java/RocksDBSample.java +++ b/java/RocksDBSample.java @@ -33,6 +33,19 @@ public class RocksDBSample { } options.setCreateIfMissing(true); + options.setWriteBufferSize(8*1024); + options.setMaxWriteBufferNumber(3); + options.setDisableSeekCompaction(true); + options.setBlockSize(64*1024); + options.setMaxBackgroundCompactions(10); + + assert(options.createIfMissing() == true); + assert(options.writeBufferSize() == 8192); + assert(options.maxWriteBufferNumber() == 3); + assert(options.disableSeekCompaction() == true); + assert(options.blockSize() == 65536); + assert(options.maxBackgroundCompactions() == 10); + try { db = RocksDB.open(options, db_path_not_found); db.put("hello".getBytes(), "world".getBytes()); diff --git a/java/org/rocksdb/Options.java b/java/org/rocksdb/Options.java index af759ae8d..94498cead 100644 --- a/java/org/rocksdb/Options.java +++ b/java/org/rocksdb/Options.java @@ -34,7 +34,7 @@ public class Options { * @see RocksDB::Open() */ public void setCreateIfMissing(boolean flag) { - assert(nativeHandle_ != 0); + checkInitialization(); setCreateIfMissing(nativeHandle_, flag); } @@ -45,10 +45,97 @@ public class Options { * @return return true if the create_if_missing flag is set to true. * @see setCreateIfMissing() */ - public boolean craeteIfMissing() { - assert(nativeHandle_ != 0); + public boolean createIfMissing() { + checkInitialization(); return createIfMissing(nativeHandle_); } + + /** + * Amount of data to build up in memory (backed by an unsorted log + * on disk) before converting to a sorted on-disk file. + * + * Larger values increase performance, especially during bulk loads. + * Up to max_write_buffer_number write buffers may be held in memory + * at the same time, so you may wish to adjust this parameter + * to control memory usage. + * + * Also, a larger write buffer will result in a longer recovery time + * the next time the database is opened. + * + * Default: 4MB + * @param size of write buffer + * @see RocksDB::Open() + */ + public void setWriteBufferSize(int writeBufferSize) { + checkInitialization(); + setWriteBufferSize(nativeHandle_, writeBufferSize); + } + + /** + * Return size of write buffer size. + * + * @return size of write buffer. + * @see setWriteBufferSize() + */ + public int writeBufferSize() { + checkInitialization(); + return writeBufferSize(nativeHandle_); + } + + /** + * The maximum number of write buffers that are built up in memory. + * The default is 2, so that when 1 write buffer is being flushed to + * storage, new writes can continue to the other write buffer. + * Default: 2 + * + * @param maximum number of write buffers + * @see RocksDB::Open() + */ + public void setMaxWriteBufferNumber(int maxWriteBufferNumber) { + checkInitialization(); + setMaxWriteBufferNumber(nativeHandle_, maxWriteBufferNumber); + } + + /** + * Returns maximum number of write buffers. + * + * @return maximum number of write buffers. + * @see setMaxWriteBufferNumber() + */ + public int maxWriteBufferNumber() { + checkInitialization(); + return maxWriteBufferNumber(nativeHandle_); + } + + public void setBlockSize(int blockSize) { + checkInitialization(); + setBlockSize(nativeHandle_, blockSize); + } + + public int blockSize() { + checkInitialization(); + return blockSize(nativeHandle_); + } + + public void setDisableSeekCompaction(boolean disableSeekCompaction) { + checkInitialization(); + setDisableSeekCompaction(nativeHandle_, disableSeekCompaction); + } + + public boolean disableSeekCompaction() { + checkInitialization(); + return disableSeekCompaction(nativeHandle_); + } + + public void setMaxBackgroundCompactions(int maxBackgroundCompactions) { + checkInitialization(); + setMaxBackgroundCompactions(nativeHandle_, maxBackgroundCompactions); + } + + public int maxBackgroundCompactions() { + checkInitialization(); + return maxBackgroundCompactions(nativeHandle_); + } /** * Release the memory allocated for the current instance @@ -59,11 +146,25 @@ public class Options { dispose0(); } } + + private void checkInitialization() { + assert(nativeHandle_ != 0); + } private native void newOptions(); private native void dispose0(); private native void setCreateIfMissing(long handle, boolean flag); private native boolean createIfMissing(long handle); + private native void setWriteBufferSize(long handle, int writeBufferSize); + private native int writeBufferSize(long handle); + private native void setMaxWriteBufferNumber(long handle, int maxWriteBufferNumber); + private native int maxWriteBufferNumber(long handle); + private native void setBlockSize(long handle, int blockSize); + private native int blockSize(long handle); + private native void setDisableSeekCompaction(long handle, boolean disableSeekCompaction); + private native boolean disableSeekCompaction(long handle); + private native void setMaxBackgroundCompactions(long handle, int maxBackgroundCompactions); + private native int maxBackgroundCompactions(long handle); long nativeHandle_; } diff --git a/java/rocksjni/options.cc b/java/rocksjni/options.cc index 69224f6d0..50ea53e39 100644 --- a/java/rocksjni/options.cc +++ b/java/rocksjni/options.cc @@ -58,6 +58,111 @@ jboolean Java_org_rocksdb_Options_createIfMissing( return reinterpret_cast(jhandle)->create_if_missing; } +/* + * Class: org_rocksdb_Options + * Method: setWriteBufferSize + * Signature: (JZ)I + */ +void Java_org_rocksdb_Options_setWriteBufferSize( + JNIEnv* env, jobject jobj, jlong jhandle, jint jwrite_buffer_size) { + reinterpret_cast(jhandle)->write_buffer_size = + static_cast(jwrite_buffer_size); +} + + +/* + * Class: org_rocksdb_Options + * Method: writeBufferSize + * Signature: (J)I + */ +jint Java_org_rocksdb_Options_writeBufferSize( + JNIEnv* env, jobject jobj, jlong jhandle) { + return reinterpret_cast(jhandle)->write_buffer_size; +} + +/* + * Class: org_rocksdb_Options + * Method: setMaxWriteBufferNumber + * Signature: (JI)V + */ +void Java_org_rocksdb_Options_setMaxWriteBufferNumber( + JNIEnv* env, jobject jobj, jlong jhandle, jint jmax_write_buffer_number) { + reinterpret_cast(jhandle)->max_write_buffer_number = jmax_write_buffer_number; +} + + +/* + * Class: org_rocksdb_Options + * Method: maxWriteBufferNumber + * Signature: (J)I + */ +jint Java_org_rocksdb_Options_maxWriteBufferNumber( + JNIEnv* env, jobject jobj, jlong jhandle) { + return reinterpret_cast(jhandle)->max_write_buffer_number; +} + +/* + * Class: org_rocksdb_Options + * Method: setBlockSize + * Signature: (JI)V + */ +void Java_org_rocksdb_Options_setBlockSize( + JNIEnv* env, jobject jobj, jlong jhandle, jint jblock_size) { + reinterpret_cast(jhandle)->block_size = + static_cast(jblock_size); +} + +/* + * Class: org_rocksdb_Options + * Method: blockSize + * Signature: (J)I + */ +jint Java_org_rocksdb_Options_blockSize( + JNIEnv* env, jobject jobj, jlong jhandle) { + return reinterpret_cast(jhandle)->block_size; +} + +/* + * Class: org_rocksdb_Options + * Method: setDisableSeekCompaction + * Signature: (JZ)V + */ +void Java_org_rocksdb_Options_setDisableSeekCompaction( + JNIEnv* env, jobject jobj, jlong jhandle, jboolean jdisable_seek_compaction) { + reinterpret_cast(jhandle)->disable_seek_compaction = jdisable_seek_compaction; +} + +/* + * Class: org_rocksdb_Options + * Method: disableSeekCompaction + * Signature: (J)Z + */ +jboolean Java_org_rocksdb_Options_disableSeekCompaction( + JNIEnv* env, jobject jobj, jlong jhandle) { + return reinterpret_cast(jhandle)->disable_seek_compaction; +} + +/* + * Class: org_rocksdb_Options + * Method: setMaxBackgroundCompactions + * Signature: (JI)V + */ +void Java_org_rocksdb_Options_setMaxBackgroundCompactions( + JNIEnv* env, jobject jobj, jlong jhandle, jint jmax_background_compactions) { + reinterpret_cast(jhandle)->max_background_compactions = jmax_background_compactions; +} + +/* + * Class: org_rocksdb_Options + * Method: maxBackgroundCompactions + * Signature: (J)I + */ +jint Java_org_rocksdb_Options_maxBackgroundCompactions( + JNIEnv* env, jobject jobj, jlong jhandle) { + return reinterpret_cast(jhandle)->max_background_compactions; +} + + ////////////////////////////////////////////////////////////////////////////// // WriteOptions From c990a7645a4628d562f6a237f7ed3e94bf957c68 Mon Sep 17 00:00:00 2001 From: Ankit Gupta Date: Sun, 6 Apr 2014 09:55:48 -0700 Subject: [PATCH 2/5] Add documentation for JNI options --- java/org/rocksdb/Options.java | 46 +++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) diff --git a/java/org/rocksdb/Options.java b/java/org/rocksdb/Options.java index 94498cead..8d1e1ed78 100644 --- a/java/org/rocksdb/Options.java +++ b/java/org/rocksdb/Options.java @@ -107,31 +107,77 @@ public class Options { return maxWriteBufferNumber(nativeHandle_); } + /* + * Approximate size of user data packed per block. Note that the + * block size specified here corresponds to uncompressed data. The + * actual size of the unit read from disk may be smaller if + * compression is enabled. This parameter can be changed dynamically. + * + * Default: 4K + * + * @param block size + * @see RocksDB::Open() + */ public void setBlockSize(int blockSize) { checkInitialization(); setBlockSize(nativeHandle_, blockSize); } + /* + * Returns block size. + * + * @return block size. + * @see setBlockSize() + */ public int blockSize() { checkInitialization(); return blockSize(nativeHandle_); } + /* + * Disable compaction triggered by seek. + * With bloomfilter and fast storage, a miss on one level + * is very cheap if the file handle is cached in table cache + * (which is true if max_open_files is large). + * + * @param disable seek compaction + * @see RocksDB::Open() + */ public void setDisableSeekCompaction(boolean disableSeekCompaction) { checkInitialization(); setDisableSeekCompaction(nativeHandle_, disableSeekCompaction); } + /* + * Returns true if disable seek compaction is set to true. + * + * @return true if disable seek compaction is set to true. + * @see setDisableSeekCompaction() + */ public boolean disableSeekCompaction() { checkInitialization(); return disableSeekCompaction(nativeHandle_); } + /* + * Maximum number of concurrent background jobs, submitted to + * the default LOW priority thread pool + * Default: 1 + * + * @param maximum number of concurrent background jobs. + * @see RocksDB::Open() + */ public void setMaxBackgroundCompactions(int maxBackgroundCompactions) { checkInitialization(); setMaxBackgroundCompactions(nativeHandle_, maxBackgroundCompactions); } + /* + * Returns maximum number of background concurrent jobs + * + * @return maximum number of background concurrent jobs + * @see setMaxBackgroundCompactions + */ public int maxBackgroundCompactions() { checkInitialization(); return maxBackgroundCompactions(nativeHandle_); From 22d45de2ed4f24339271154bbca0d9f90421be53 Mon Sep 17 00:00:00 2001 From: Ankit Gupta Date: Mon, 7 Apr 2014 18:32:09 -0700 Subject: [PATCH 3/5] Fix formatting errors --- java/RocksDBSample.java | 4 +- java/org/rocksdb/Options.java | 85 ++++++++++++++++++----------------- java/rocksjni/options.cc | 28 +++++++----- 3 files changed, 62 insertions(+), 55 deletions(-) diff --git a/java/RocksDBSample.java b/java/RocksDBSample.java index 8a1a3ccbc..a457701a5 100644 --- a/java/RocksDBSample.java +++ b/java/RocksDBSample.java @@ -38,14 +38,14 @@ public class RocksDBSample { options.setDisableSeekCompaction(true); options.setBlockSize(64*1024); options.setMaxBackgroundCompactions(10); - + assert(options.createIfMissing() == true); assert(options.writeBufferSize() == 8192); assert(options.maxWriteBufferNumber() == 3); assert(options.disableSeekCompaction() == true); assert(options.blockSize() == 65536); assert(options.maxBackgroundCompactions() == 10); - + try { db = RocksDB.open(options, db_path_not_found); db.put("hello".getBytes(), "world".getBytes()); diff --git a/java/org/rocksdb/Options.java b/java/org/rocksdb/Options.java index 8d1e1ed78..d33b5b424 100644 --- a/java/org/rocksdb/Options.java +++ b/java/org/rocksdb/Options.java @@ -34,7 +34,7 @@ public class Options { * @see RocksDB::Open() */ public void setCreateIfMissing(boolean flag) { - checkInitialization(); + assert(isInitialized()); setCreateIfMissing(nativeHandle_, flag); } @@ -46,31 +46,31 @@ public class Options { * @see setCreateIfMissing() */ public boolean createIfMissing() { - checkInitialization(); + assert(isInitialized()); return createIfMissing(nativeHandle_); } - + /** * Amount of data to build up in memory (backed by an unsorted log * on disk) before converting to a sorted on-disk file. - * + * * Larger values increase performance, especially during bulk loads. * Up to max_write_buffer_number write buffers may be held in memory - * at the same time, so you may wish to adjust this parameter + * at the same time, so you may wish to adjust this parameter * to control memory usage. - * + * * Also, a larger write buffer will result in a longer recovery time * the next time the database is opened. - * + * * Default: 4MB * @param size of write buffer * @see RocksDB::Open() - */ + */ public void setWriteBufferSize(int writeBufferSize) { - checkInitialization(); + assert(isInitialized()); setWriteBufferSize(nativeHandle_, writeBufferSize); } - + /** * Return size of write buffer size. * @@ -78,108 +78,109 @@ public class Options { * @see setWriteBufferSize() */ public int writeBufferSize() { - checkInitialization(); + assert(isInitialized()); return writeBufferSize(nativeHandle_); } - + /** * The maximum number of write buffers that are built up in memory. * The default is 2, so that when 1 write buffer is being flushed to * storage, new writes can continue to the other write buffer. * Default: 2 - * + * * @param maximum number of write buffers * @see RocksDB::Open() */ public void setMaxWriteBufferNumber(int maxWriteBufferNumber) { - checkInitialization(); + assert(isInitialized()); setMaxWriteBufferNumber(nativeHandle_, maxWriteBufferNumber); } - + /** * Returns maximum number of write buffers. - * + * * @return maximum number of write buffers. * @see setMaxWriteBufferNumber() */ public int maxWriteBufferNumber() { - checkInitialization(); + assert(isInitialized()); return maxWriteBufferNumber(nativeHandle_); } - + /* * Approximate size of user data packed per block. Note that the * block size specified here corresponds to uncompressed data. The * actual size of the unit read from disk may be smaller if * compression is enabled. This parameter can be changed dynamically. - * + * * Default: 4K - * + * * @param block size * @see RocksDB::Open() */ public void setBlockSize(int blockSize) { - checkInitialization(); + assert(isInitialized()); setBlockSize(nativeHandle_, blockSize); } - + /* * Returns block size. - * + * * @return block size. - * @see setBlockSize() + * @see setBlockSize() */ public int blockSize() { - checkInitialization(); + assert(isInitialized()); return blockSize(nativeHandle_); } - + /* * Disable compaction triggered by seek. * With bloomfilter and fast storage, a miss on one level * is very cheap if the file handle is cached in table cache * (which is true if max_open_files is large). - * + * Default: true + * * @param disable seek compaction * @see RocksDB::Open() */ public void setDisableSeekCompaction(boolean disableSeekCompaction) { - checkInitialization(); + assert(isInitialized()); setDisableSeekCompaction(nativeHandle_, disableSeekCompaction); } - + /* * Returns true if disable seek compaction is set to true. - * + * * @return true if disable seek compaction is set to true. * @see setDisableSeekCompaction() */ public boolean disableSeekCompaction() { - checkInitialization(); + assert(isInitialized()); return disableSeekCompaction(nativeHandle_); } - + /* * Maximum number of concurrent background jobs, submitted to * the default LOW priority thread pool * Default: 1 - * + * * @param maximum number of concurrent background jobs. * @see RocksDB::Open() */ public void setMaxBackgroundCompactions(int maxBackgroundCompactions) { - checkInitialization(); + assert(isInitialized()); setMaxBackgroundCompactions(nativeHandle_, maxBackgroundCompactions); } - + /* * Returns maximum number of background concurrent jobs - * + * * @return maximum number of background concurrent jobs * @see setMaxBackgroundCompactions */ public int maxBackgroundCompactions() { - checkInitialization(); + assert(isInitialized()); return maxBackgroundCompactions(nativeHandle_); } @@ -192,9 +193,9 @@ public class Options { dispose0(); } } - - private void checkInitialization() { - assert(nativeHandle_ != 0); + + private boolean isInitialized() { + return (nativeHandle_ != 0); } private native void newOptions(); @@ -202,7 +203,7 @@ public class Options { private native void setCreateIfMissing(long handle, boolean flag); private native boolean createIfMissing(long handle); private native void setWriteBufferSize(long handle, int writeBufferSize); - private native int writeBufferSize(long handle); + private native int writeBufferSize(long handle); private native void setMaxWriteBufferNumber(long handle, int maxWriteBufferNumber); private native int maxWriteBufferNumber(long handle); private native void setBlockSize(long handle, int blockSize); @@ -210,7 +211,7 @@ public class Options { private native void setDisableSeekCompaction(long handle, boolean disableSeekCompaction); private native boolean disableSeekCompaction(long handle); private native void setMaxBackgroundCompactions(long handle, int maxBackgroundCompactions); - private native int maxBackgroundCompactions(long handle); + private native int maxBackgroundCompactions(long handle); long nativeHandle_; } diff --git a/java/rocksjni/options.cc b/java/rocksjni/options.cc index 50ea53e39..925613fef 100644 --- a/java/rocksjni/options.cc +++ b/java/rocksjni/options.cc @@ -65,7 +65,7 @@ jboolean Java_org_rocksdb_Options_createIfMissing( */ void Java_org_rocksdb_Options_setWriteBufferSize( JNIEnv* env, jobject jobj, jlong jhandle, jint jwrite_buffer_size) { - reinterpret_cast(jhandle)->write_buffer_size = + reinterpret_cast(jhandle)->write_buffer_size = static_cast(jwrite_buffer_size); } @@ -77,7 +77,7 @@ void Java_org_rocksdb_Options_setWriteBufferSize( */ jint Java_org_rocksdb_Options_writeBufferSize( JNIEnv* env, jobject jobj, jlong jhandle) { - return reinterpret_cast(jhandle)->write_buffer_size; + return reinterpret_cast(jhandle)->write_buffer_size; } /* @@ -87,7 +87,8 @@ jint Java_org_rocksdb_Options_writeBufferSize( */ void Java_org_rocksdb_Options_setMaxWriteBufferNumber( JNIEnv* env, jobject jobj, jlong jhandle, jint jmax_write_buffer_number) { - reinterpret_cast(jhandle)->max_write_buffer_number = jmax_write_buffer_number; + reinterpret_cast(jhandle)->max_write_buffer_number = + jmax_write_buffer_number; } @@ -98,7 +99,7 @@ void Java_org_rocksdb_Options_setMaxWriteBufferNumber( */ jint Java_org_rocksdb_Options_maxWriteBufferNumber( JNIEnv* env, jobject jobj, jlong jhandle) { - return reinterpret_cast(jhandle)->max_write_buffer_number; + return reinterpret_cast(jhandle)->max_write_buffer_number; } /* @@ -108,7 +109,7 @@ jint Java_org_rocksdb_Options_maxWriteBufferNumber( */ void Java_org_rocksdb_Options_setBlockSize( JNIEnv* env, jobject jobj, jlong jhandle, jint jblock_size) { - reinterpret_cast(jhandle)->block_size = + reinterpret_cast(jhandle)->block_size = static_cast(jblock_size); } @@ -119,7 +120,7 @@ void Java_org_rocksdb_Options_setBlockSize( */ jint Java_org_rocksdb_Options_blockSize( JNIEnv* env, jobject jobj, jlong jhandle) { - return reinterpret_cast(jhandle)->block_size; + return reinterpret_cast(jhandle)->block_size; } /* @@ -128,8 +129,10 @@ jint Java_org_rocksdb_Options_blockSize( * Signature: (JZ)V */ void Java_org_rocksdb_Options_setDisableSeekCompaction( - JNIEnv* env, jobject jobj, jlong jhandle, jboolean jdisable_seek_compaction) { - reinterpret_cast(jhandle)->disable_seek_compaction = jdisable_seek_compaction; + JNIEnv* env, jobject jobj, jlong jhandle, + jboolean jdisable_seek_compaction) { + reinterpret_cast(jhandle)->disable_seek_compaction = + jdisable_seek_compaction; } /* @@ -148,8 +151,10 @@ jboolean Java_org_rocksdb_Options_disableSeekCompaction( * Signature: (JI)V */ void Java_org_rocksdb_Options_setMaxBackgroundCompactions( - JNIEnv* env, jobject jobj, jlong jhandle, jint jmax_background_compactions) { - reinterpret_cast(jhandle)->max_background_compactions = jmax_background_compactions; + JNIEnv* env, jobject jobj, jlong jhandle, + jint jmax_background_compactions) { + reinterpret_cast(jhandle)->max_background_compactions = + jmax_background_compactions; } /* @@ -159,7 +164,8 @@ void Java_org_rocksdb_Options_setMaxBackgroundCompactions( */ jint Java_org_rocksdb_Options_maxBackgroundCompactions( JNIEnv* env, jobject jobj, jlong jhandle) { - return reinterpret_cast(jhandle)->max_background_compactions; + return + reinterpret_cast(jhandle)->max_background_compactions; } From 14220442a71209db028823beebead4e8dd536a7a Mon Sep 17 00:00:00 2001 From: Ankit Gupta Date: Tue, 8 Apr 2014 09:27:24 -0700 Subject: [PATCH 4/5] Fix formatting --- java/org/rocksdb/Options.java | 15 +++++++++------ java/rocksjni/options.cc | 4 ++-- 2 files changed, 11 insertions(+), 8 deletions(-) diff --git a/java/org/rocksdb/Options.java b/java/org/rocksdb/Options.java index d33b5b424..c56856de2 100644 --- a/java/org/rocksdb/Options.java +++ b/java/org/rocksdb/Options.java @@ -162,7 +162,7 @@ public class Options { /* * Maximum number of concurrent background jobs, submitted to - * the default LOW priority thread pool + * the default LOW priority thread pool. * Default: 1 * * @param maximum number of concurrent background jobs. @@ -174,9 +174,9 @@ public class Options { } /* - * Returns maximum number of background concurrent jobs + * Returns maximum number of background concurrent jobs. * - * @return maximum number of background concurrent jobs + * @return maximum number of background concurrent jobs. * @see setMaxBackgroundCompactions */ public int maxBackgroundCompactions() { @@ -204,13 +204,16 @@ public class Options { private native boolean createIfMissing(long handle); private native void setWriteBufferSize(long handle, int writeBufferSize); private native int writeBufferSize(long handle); - private native void setMaxWriteBufferNumber(long handle, int maxWriteBufferNumber); + private native void setMaxWriteBufferNumber( + long handle, int maxWriteBufferNumber); private native int maxWriteBufferNumber(long handle); private native void setBlockSize(long handle, int blockSize); private native int blockSize(long handle); - private native void setDisableSeekCompaction(long handle, boolean disableSeekCompaction); + private native void setDisableSeekCompaction( + long handle, boolean disableSeekCompaction); private native boolean disableSeekCompaction(long handle); - private native void setMaxBackgroundCompactions(long handle, int maxBackgroundCompactions); + private native void setMaxBackgroundCompactions( + long handle, int maxBackgroundCompactions); private native int maxBackgroundCompactions(long handle); long nativeHandle_; diff --git a/java/rocksjni/options.cc b/java/rocksjni/options.cc index 925613fef..a6e392c1f 100644 --- a/java/rocksjni/options.cc +++ b/java/rocksjni/options.cc @@ -130,7 +130,7 @@ jint Java_org_rocksdb_Options_blockSize( */ void Java_org_rocksdb_Options_setDisableSeekCompaction( JNIEnv* env, jobject jobj, jlong jhandle, - jboolean jdisable_seek_compaction) { + jboolean jdisable_seek_compaction) { reinterpret_cast(jhandle)->disable_seek_compaction = jdisable_seek_compaction; } @@ -152,7 +152,7 @@ jboolean Java_org_rocksdb_Options_disableSeekCompaction( */ void Java_org_rocksdb_Options_setMaxBackgroundCompactions( JNIEnv* env, jobject jobj, jlong jhandle, - jint jmax_background_compactions) { + jint jmax_background_compactions) { reinterpret_cast(jhandle)->max_background_compactions = jmax_background_compactions; } From 8a509717b7753b384548814840e6da8ad144e450 Mon Sep 17 00:00:00 2001 From: Ankit Gupta Date: Tue, 8 Apr 2014 09:30:35 -0700 Subject: [PATCH 5/5] Fix formatting issues --- java/org/rocksdb/Options.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/java/org/rocksdb/Options.java b/java/org/rocksdb/Options.java index c56856de2..b93ffb128 100644 --- a/java/org/rocksdb/Options.java +++ b/java/org/rocksdb/Options.java @@ -63,7 +63,7 @@ public class Options { * the next time the database is opened. * * Default: 4MB - * @param size of write buffer + * @param size of write buffer. * @see RocksDB::Open() */ public void setWriteBufferSize(int writeBufferSize) { @@ -88,7 +88,7 @@ public class Options { * storage, new writes can continue to the other write buffer. * Default: 2 * - * @param maximum number of write buffers + * @param maximum number of write buffers. * @see RocksDB::Open() */ public void setMaxWriteBufferNumber(int maxWriteBufferNumber) { @@ -115,7 +115,7 @@ public class Options { * * Default: 4K * - * @param block size + * @param block size. * @see RocksDB::Open() */ public void setBlockSize(int blockSize) { @@ -141,7 +141,7 @@ public class Options { * (which is true if max_open_files is large). * Default: true * - * @param disable seek compaction + * @param disable seek compaction. * @see RocksDB::Open() */ public void setDisableSeekCompaction(boolean disableSeekCompaction) {