From d410b39d59b222b1f24d6275c725477b8ded720e Mon Sep 17 00:00:00 2001 From: fyrz Date: Thu, 2 Oct 2014 13:21:20 +0200 Subject: [PATCH] BlockBasedTableConfig Filter policy support RocksJava As proposed by yhchiang the filter can now be set in Java for a BlockBasedTableConfig instance. --- java/Makefile | 1 + java/RocksDBSample.java | 3 +- java/org/rocksdb/BlockBasedTableConfig.java | 52 ++++++++++++--------- java/rocksjni/table.cc | 9 ++-- 4 files changed, 37 insertions(+), 28 deletions(-) diff --git a/java/Makefile b/java/Makefile index b2f3674f0..52c88fd84 100644 --- a/java/Makefile +++ b/java/Makefile @@ -26,6 +26,7 @@ test: java javac org/rocksdb/test/*.java java -ea -Djava.library.path=.:../ -cp "$(ROCKSDB_JAR):.:./*" org.rocksdb.WriteBatchTest java -ea -Djava.library.path=.:../ -cp "$(ROCKSDB_JAR):.:./*" org.rocksdb.test.BackupableDBTest + java -ea -Djava.library.path=.:../ -cp "$(ROCKSDB_JAR):.:./*" org.rocksdb.test.FilterTest java -ea -Djava.library.path=.:../ -cp "$(ROCKSDB_JAR):.:./*" org.rocksdb.test.OptionsTest java -ea -Djava.library.path=.:../ -cp "$(ROCKSDB_JAR):.:./*" org.rocksdb.test.ReadOptionsTest java -ea -Djava.library.path=.:../ -cp "$(ROCKSDB_JAR):.:./*" org.rocksdb.test.StatisticsCollectorTest diff --git a/java/RocksDBSample.java b/java/RocksDBSample.java index bd5a85076..c9a30476a 100644 --- a/java/RocksDBSample.java +++ b/java/RocksDBSample.java @@ -80,9 +80,10 @@ public class RocksDBSample { 10000, 10)); options.setRateLimiterConfig(new GenericRateLimiterConfig(10000000)); + Filter bloomFilter = new BloomFilter(10); BlockBasedTableConfig table_options = new BlockBasedTableConfig(); table_options.setBlockCacheSize(64 * SizeUnit.KB) - .setFilterBitsPerKey(10) + .setFilter(bloomFilter) .setCacheNumShardBits(6) .setBlockSizeDeviation(5) .setBlockRestartInterval(10) diff --git a/java/org/rocksdb/BlockBasedTableConfig.java b/java/org/rocksdb/BlockBasedTableConfig.java index bdb27d6c2..9a6967a95 100644 --- a/java/org/rocksdb/BlockBasedTableConfig.java +++ b/java/org/rocksdb/BlockBasedTableConfig.java @@ -18,7 +18,7 @@ public class BlockBasedTableConfig extends TableFormatConfig { blockSizeDeviation_ = 10; blockRestartInterval_ = 16; wholeKeyFiltering_ = true; - bitsPerKey_ = 10; + filter_ = null; cacheIndexAndFilterBlocks_ = false; hashIndexAllowCollision_ = true; blockCacheCompressedSize_ = 0; @@ -182,30 +182,30 @@ public class BlockBasedTableConfig extends TableFormatConfig { * * Filter instance can be re-used in multiple options instances. * - * @param Filter policy java instance. + * @param Filter Filter Policy java instance. * @return the reference to the current config. */ - public BlockBasedTableConfig setFilterBitsPerKey(int bitsPerKey) { - bitsPerKey_ = bitsPerKey; + public BlockBasedTableConfig setFilter(Filter filter) { + filter_ = filter; return this; } - + /** * Indicating if we'd put index/filter blocks to the block cache. If not specified, each "table reader" object will pre-load index/filter block during table initialization. - * + * * @return if index and filter blocks should be put in block cache. */ public boolean cacheIndexAndFilterBlocks() { return cacheIndexAndFilterBlocks_; } - + /** * Indicating if we'd put index/filter blocks to the block cache. If not specified, each "table reader" object will pre-load index/filter block during table initialization. - * + * * @param index and filter blocks should be put in block cache. * @return the reference to the current config. */ @@ -214,25 +214,25 @@ public class BlockBasedTableConfig extends TableFormatConfig { cacheIndexAndFilterBlocks_ = cacheIndexAndFilterBlocks; return this; } - + /** * Influence the behavior when kHashSearch is used. if false, stores a precise prefix to block range mapping if true, does not store prefix and allows prefix hash collision (less memory consumption) - * + * * @return if hash collisions should be allowed. */ public boolean hashIndexAllowCollision() { return hashIndexAllowCollision_; } - + /** * Influence the behavior when kHashSearch is used. if false, stores a precise prefix to block range mapping if true, does not store prefix and allows prefix hash collision (less memory consumption) - * + * * @param if hash collisions should be allowed. * @return the reference to the current config. */ @@ -241,21 +241,21 @@ public class BlockBasedTableConfig extends TableFormatConfig { hashIndexAllowCollision_ = hashIndexAllowCollision; return this; } - + /** * Size of compressed block cache. If 0, then block_cache_compressed is set * to null. - * + * * @return size of compressed block cache. */ public long blockCacheCompressedSize() { return blockCacheCompressedSize_; } - + /** * Size of compressed block cache. If 0, then block_cache_compressed is set * to null. - * + * * @param size of compressed block cache. * @return the reference to the current config. */ @@ -264,7 +264,7 @@ public class BlockBasedTableConfig extends TableFormatConfig { blockCacheCompressedSize_ = blockCacheCompressedSize; return this; } - + /** * Controls the number of shards for the block compressed cache. * This is applied only if blockCompressedCacheSize is set to non-negative. @@ -276,7 +276,7 @@ public class BlockBasedTableConfig extends TableFormatConfig { public int blockCacheCompressedNumShardBits() { return blockCacheCompressedNumShardBits_; } - + /** * Controls the number of shards for the block compressed cache. * This is applied only if blockCompressedCacheSize is set to non-negative. @@ -293,17 +293,23 @@ public class BlockBasedTableConfig extends TableFormatConfig { } @Override protected long newTableFactoryHandle() { + long filterHandle = 0; + if (filter_ != null) { + filterHandle = filter_.nativeHandle_; + } + return newTableFactoryHandle(noBlockCache_, blockCacheSize_, blockCacheNumShardBits_, blockSize_, blockSizeDeviation_, - blockRestartInterval_, wholeKeyFiltering_, bitsPerKey_, - cacheIndexAndFilterBlocks_, hashIndexAllowCollision_, - blockCacheCompressedSize_, blockCacheCompressedNumShardBits_); + blockRestartInterval_, wholeKeyFiltering_, + filterHandle, cacheIndexAndFilterBlocks_, + hashIndexAllowCollision_, blockCacheCompressedSize_, + blockCacheCompressedNumShardBits_); } private native long newTableFactoryHandle( boolean noBlockCache, long blockCacheSize, int blockCacheNumShardBits, long blockSize, int blockSizeDeviation, int blockRestartInterval, - boolean wholeKeyFiltering, int bitsPerKey, + boolean wholeKeyFiltering, long filterPolicyHandle, boolean cacheIndexAndFilterBlocks, boolean hashIndexAllowCollision, long blockCacheCompressedSize, int blockCacheCompressedNumShardBits); @@ -315,7 +321,7 @@ public class BlockBasedTableConfig extends TableFormatConfig { private int blockSizeDeviation_; private int blockRestartInterval_; private boolean wholeKeyFiltering_; - private int bitsPerKey_; + private Filter filter_; private boolean cacheIndexAndFilterBlocks_; private boolean hashIndexAllowCollision_; private long blockCacheCompressedSize_; diff --git a/java/rocksjni/table.cc b/java/rocksjni/table.cc index 500cb255e..846526292 100644 --- a/java/rocksjni/table.cc +++ b/java/rocksjni/table.cc @@ -37,7 +37,7 @@ jlong Java_org_rocksdb_BlockBasedTableConfig_newTableFactoryHandle( JNIEnv* env, jobject jobj, jboolean no_block_cache, jlong block_cache_size, jint block_cache_num_shardbits, jlong block_size, jint block_size_deviation, jint block_restart_interval, jboolean whole_key_filtering, - jint bits_per_key, jboolean cache_index_and_filter_blocks, + jlong jfilterPolicy, jboolean cache_index_and_filter_blocks, jboolean hash_index_allow_collision, jlong block_cache_compressed_size, jint block_cache_compressd_num_shard_bits) { rocksdb::BlockBasedTableOptions options; @@ -55,8 +55,9 @@ jlong Java_org_rocksdb_BlockBasedTableConfig_newTableFactoryHandle( options.block_size_deviation = block_size_deviation; options.block_restart_interval = block_restart_interval; options.whole_key_filtering = whole_key_filtering; - if (bits_per_key > 0) { - options.filter_policy.reset(rocksdb::NewBloomFilterPolicy(bits_per_key)); + if (jfilterPolicy > 0) { + options.filter_policy.reset( + reinterpret_cast(jfilterPolicy)); } options.cache_index_and_filter_blocks = cache_index_and_filter_blocks; options.hash_index_allow_collision = hash_index_allow_collision; @@ -69,6 +70,6 @@ jlong Java_org_rocksdb_BlockBasedTableConfig_newTableFactoryHandle( options.block_cache = rocksdb::NewLRUCache(block_cache_compressed_size); } } - + return reinterpret_cast(rocksdb::NewBlockBasedTableFactory(options)); }