LRU cache integration

Author: mike-evolved

java/rocksjni/lru_cache.cc

@@ -16,22 +16,33 @@
 /*
  * Class:     org_rocksdb_LRUCache
  * Method:    newLRUCache
- * Signature: (JIZD)J
+ * Signature: (JIZDDJ)J
  */
 jlong Java_org_rocksdb_LRUCache_newLRUCache(JNIEnv* /*env*/, jclass /*jcls*/,
                                             jlong jcapacity,
                                             jint jnum_shard_bits,
                                             jboolean jstrict_capacity_limit,
                                             jdouble jhigh_pri_pool_ratio,
-                                            jdouble jlow_pri_pool_ratio) {
-  auto* sptr_lru_cache = new std::shared_ptr<ROCKSDB_NAMESPACE::Cache>(
-      ROCKSDB_NAMESPACE::NewLRUCache(
-          static_cast<size_t>(jcapacity), static_cast<int>(jnum_shard_bits),
-          static_cast<bool>(jstrict_capacity_limit),
-          static_cast<double>(jhigh_pri_pool_ratio),
-          nullptr /* memory_allocator */, rocksdb::kDefaultToAdaptiveMutex,
-          rocksdb::kDefaultCacheMetadataChargePolicy,
-          static_cast<double>(jlow_pri_pool_ratio)));
+                                            jdouble jlow_pri_pool_ratio,
+                                            jlong jsecondary_cache_handle) {
+  std::shared_ptr<ROCKSDB_NAMESPACE::SecondaryCache> secondary_cache;
+  if (jsecondary_cache_handle != 0) {
+    auto* secondary_cache_ptr =
+        reinterpret_cast<std::shared_ptr<ROCKSDB_NAMESPACE::SecondaryCache>*>(
+            jsecondary_cache_handle);
+    secondary_cache = *secondary_cache_ptr;
+  }
+
+  auto opts = ROCKSDB_NAMESPACE::LRUCacheOptions();
+  opts.capacity = static_cast<size_t>(jcapacity);
+  opts.num_shard_bits = static_cast<int>(jnum_shard_bits);
+  opts.strict_capacity_limit = static_cast<bool>(jstrict_capacity_limit);
+  opts.high_pri_pool_ratio = static_cast<double>(jhigh_pri_pool_ratio);
+  opts.low_pri_pool_ratio = static_cast<double>(jlow_pri_pool_ratio);
+  opts.secondary_cache = secondary_cache;
+
+  auto* sptr_lru_cache =
+      new std::shared_ptr<ROCKSDB_NAMESPACE::Cache>(opts.MakeSharedCache());
   return GET_CPLUSPLUS_POINTER(sptr_lru_cache);
 }
 

java/src/main/java/org/rocksdb/LRUCache.java

@@ -31,7 +31,7 @@ public LRUCache(final long capacity) {
    *     by hash of the key
    */
   public LRUCache(final long capacity, final int numShardBits) {
-    super(newLRUCache(capacity, numShardBits, false, 0.0, 0.0));
+    super(newLRUCache(capacity, numShardBits, false, 0.0, 0.0, 0));
   }
 
   /**
@@ -49,7 +49,7 @@ public LRUCache(final long capacity, final int numShardBits) {
    */
   public LRUCache(final long capacity, final int numShardBits,
                   final boolean strictCapacityLimit) {
-    super(newLRUCache(capacity, numShardBits, strictCapacityLimit, 0.0, 0.0));
+    super(newLRUCache(capacity, numShardBits, strictCapacityLimit, 0.0, 0.0, 0));
   }
 
   /**
@@ -71,7 +71,7 @@ public LRUCache(final long capacity, final int numShardBits,
    */
   public LRUCache(final long capacity, final int numShardBits, final boolean strictCapacityLimit,
       final double highPriPoolRatio) {
-    super(newLRUCache(capacity, numShardBits, strictCapacityLimit, highPriPoolRatio, 0.0));
+    super(newLRUCache(capacity, numShardBits, strictCapacityLimit, highPriPoolRatio, 0.0, 0));
   }
 
   /**
@@ -96,12 +96,36 @@ public LRUCache(final long capacity, final int numShardBits, final boolean stric
   public LRUCache(final long capacity, final int numShardBits, final boolean strictCapacityLimit,
       final double highPriPoolRatio, final double lowPriPoolRatio) {
     super(newLRUCache(
-        capacity, numShardBits, strictCapacityLimit, highPriPoolRatio, lowPriPoolRatio));
+        capacity, numShardBits, strictCapacityLimit, highPriPoolRatio, lowPriPoolRatio, 0));
+  }
+
+  /**
+   * Create a new cache with a secondary cache tier.
+   * Evicted entries go to secondary cache, secondary hits promote back to primary.
+   * numShardBits = -1 means it is automatically determined: every shard
+   * will be at least 512KB and number of shard bits will not exceed 6.
+   *
+   * @param capacity The fixed size capacity of the primary cache
+   * @param numShardBits The cache is sharded to 2^numShardBits shards,
+   *     by hash of the key
+   * @param strictCapacityLimit insert to the cache will fail when cache is full
+   * @param highPriPoolRatio percentage of the cache reserves for high priority
+   *     entries
+   * @param lowPriPoolRatio percentage of the cache reserves for low priority
+   *     entries
+   * @param secondaryCache the secondary cache instance, or null for no secondary cache
+   */
+  public LRUCache(final long capacity, final int numShardBits, final boolean strictCapacityLimit,
+      final double highPriPoolRatio, final double lowPriPoolRatio,
+      final SecondaryCache secondaryCache) {
+    super(newLRUCache(
+        capacity, numShardBits, strictCapacityLimit, highPriPoolRatio, lowPriPoolRatio,
+        secondaryCache == null ? 0 : secondaryCache.nativeHandle_));
   }
 
   private static native long newLRUCache(final long capacity, final int numShardBits,
       final boolean strictCapacityLimit, final double highPriPoolRatio,
-      final double lowPriPoolRatio);
+      final double lowPriPoolRatio, final long secondaryCacheHandle);
   @Override
   protected final void disposeInternal(final long handle) {
     disposeInternalJni(handle);