SecondaryCache and MemoryAllocator

Author: mike-evolved

java/src/main/java/org/rocksdb/MemoryAllocator.java

@@ -0,0 +1,72 @@
+package org.rocksdb;
+
+/**
+ * MemoryAllocator is a custom memory allocator that can be used by RocksDB
+ * for cache blocks and other memory allocations. This allows using custom
+ * allocators like JEMalloc for better memory management and reduced fragmentation.
+ * <p>
+ * As a descendent of {@link RocksObject}, this class is {@link AutoCloseable}
+ * and will be automatically released if opened in the preamble of a try with
+ * resources block.
+ */
+public abstract class MemoryAllocator extends RocksObject {
+
+  /**
+   * Constructor for MemoryAllocator
+   *
+   * @param nativeHandle the native handle to the C++ MemoryAllocator object
+   */
+  protected MemoryAllocator(final long nativeHandle) {
+    super(nativeHandle);
+  }
+
+  @Override
+  protected final void disposeInternal(final long handle) {
+    disposeInternalJni(handle);
+  }
+
+  /**
+   * Creates a default system memory allocator
+   *
+   * @return a new DefaultMemoryAllocator instance
+   */
+  public static MemoryAllocator createDefault() {
+    return new DefaultMemoryAllocator();
+  }
+
+  /**
+   * Creates a JEMalloc-based memory allocator.
+   * This allocator can help reduce memory fragmentation.
+   * Note: Requires JEMalloc to be available on the system.
+   *
+   * @return a new JEMallocMemoryAllocator instance
+   * @throws UnsupportedOperationException if JEMalloc is not available
+   */
+  public static MemoryAllocator createJEMalloc() {
+    return new JEMallocMemoryAllocator();
+  }
+
+  /**
+   * Default memory allocator using system malloc/free
+   */
+  private static class DefaultMemoryAllocator extends MemoryAllocator {
+    private DefaultMemoryAllocator() {
+      super(newDefaultMemoryAllocatorInstance());
+    }
+
+    private static native long newDefaultMemoryAllocatorInstance();
+  }
+
+  /**
+   * JEMalloc-based memory allocator for reduced fragmentation
+   */
+  private static class JEMallocMemoryAllocator extends MemoryAllocator {
+    private JEMallocMemoryAllocator() {
+      super(newJEMallocMemoryAllocatorInstance());
+    }
+
+    private static native long newJEMallocMemoryAllocatorInstance();
+  }
+
+  private static native void disposeInternalJni(final long handle);
+}

java/src/main/java/org/rocksdb/SecondaryCache.java

@@ -0,0 +1,88 @@
+package org.rocksdb;
+
+/**
+ * SecondaryCache is a Java wrapper class for the C++ SecondaryCache.
+ * It provides a persistent cache layer that can be used as a second-tier
+ * cache below the block cache.
+ * <p>
+ * SecondaryCache allows for using non-volatile storage (like SSDs) or
+ * compressed RAM as a cache tier, providing more capacity at lower cost
+ * than keeping everything in the primary block cache.
+ * <p>
+ * As a descendent of {@link RocksObject}, this class is {@link AutoCloseable}
+ * and will be automatically released if opened in the preamble of a try with
+ * resources block.
+ */
+public abstract class SecondaryCache extends RocksObject {
+  
+  /**
+   * Constructor for SecondaryCache
+   *
+   * @param nativeHandle the native handle to the C++ SecondaryCache object
+   */
+  protected SecondaryCache(final long nativeHandle) {
+    super(nativeHandle);
+  }
+
+  @Override
+  protected final void disposeInternal(final long handle) {
+    disposeInternalJni(handle);
+  }
+
+  /**
+   * Creates a new CompressedSecondaryCache with the specified capacity.
+   * CompressedSecondaryCache stores cache items in compressed form,
+   * allowing more data to fit in memory.
+   *
+   * @param capacity the capacity of the secondary cache in bytes
+   * @return a new CompressedSecondaryCache instance
+   */
+  public static SecondaryCache newCompressedSecondaryCache(final long capacity) {
+    return new CompressedSecondaryCache(capacity);
+  }
+
+  /**
+   * Creates a new CompressedSecondaryCache with detailed options.
+   *
+   * @param capacity the capacity of the secondary cache in bytes
+   * @param numShardBits the number of bits used for sharding (controls concurrency)
+   * @param strictCapacityLimit if true, cache operations fail when capacity is exceeded
+   * @param highPriPoolRatio ratio of cache reserved for high priority entries (0.0 to 1.0)
+   * @return a new CompressedSecondaryCache instance
+   */
+  public static SecondaryCache newCompressedSecondaryCache(
+      final long capacity,
+      final int numShardBits,
+      final boolean strictCapacityLimit,
+      final double highPriPoolRatio) {
+    return new CompressedSecondaryCache(
+        capacity, numShardBits, strictCapacityLimit, highPriPoolRatio);
+  }
+
+  /**
+   * CompressedSecondaryCache implementation that stores cached items
+   * in compressed format to maximize capacity.
+   */
+  private static class CompressedSecondaryCache extends SecondaryCache {
+    
+    private CompressedSecondaryCache(final long capacity) {
+      super(newCompressedSecondaryCacheInstance(capacity));
+    }
+
+    private CompressedSecondaryCache(
+        final long capacity,
+        final int numShardBits,
+        final boolean strictCapacityLimit,
+        final double highPriPoolRatio) {
+      super(newCompressedSecondaryCacheInstance(
+          capacity, numShardBits, strictCapacityLimit, highPriPoolRatio));
+    }
+
+    private static native long newCompressedSecondaryCacheInstance(long capacity);
+    
+    private static native long newCompressedSecondaryCacheInstance(
+        long capacity, int numShardBits, boolean strictCapacityLimit, double highPriPoolRatio);
+  }
+
+  private static native void disposeInternalJni(final long handle);
+}