Revert "Deprecate random access max buffer size references (#13278)"

This reverts commit d4bd67f.

env/env.cc

@@ -1087,6 +1087,8 @@ void AssignEnvOptions(EnvOptions* env_options, const DBOptions& options) {
   env_options->set_fd_cloexec = options.is_fd_close_on_exec;
   env_options->bytes_per_sync = options.bytes_per_sync;
   env_options->compaction_readahead_size = options.compaction_readahead_size;
+  env_options->random_access_max_buffer_size =
+      options.random_access_max_buffer_size;
   env_options->rate_limiter = options.rate_limiter.get();
   env_options->writable_file_max_buffer_size =
       options.writable_file_max_buffer_size;

examples/rocksdb_option_file_example.ini

@@ -48,6 +48,7 @@
   table_cache_numshardbits=4
   max_file_opening_threads=1
   writable_file_max_buffer_size=1048576
+  random_access_max_buffer_size=1048576
   use_fsync=false
   max_total_wal_size=0
   max_open_files=-1

include/rocksdb/env.h

@@ -133,6 +133,9 @@ struct EnvOptions {
   // See DBOptions doc
   size_t compaction_readahead_size = 0;
 
+  // See DBOptions doc
+  size_t random_access_max_buffer_size = 0;
+
   // See DBOptions doc
   size_t writable_file_max_buffer_size = 1024 * 1024;
 

include/rocksdb/options.h

@@ -1065,6 +1065,23 @@ struct DBOptions {
   // Dynamically changeable through SetDBOptions() API.
   size_t compaction_readahead_size = 2 * 1024 * 1024;
 
+  // This is a maximum buffer size that is used by WinMmapReadableFile in
+  // unbuffered disk I/O mode. We need to maintain an aligned buffer for
+  // reads. We allow the buffer to grow until the specified value and then
+  // for bigger requests allocate one shot buffers. In unbuffered mode we
+  // always bypass read-ahead buffer at ReadaheadRandomAccessFile
+  // When read-ahead is required we then make use of compaction_readahead_size
+  // value and always try to read ahead. With read-ahead we always
+  // pre-allocate buffer to the size instead of growing it up to a limit.
+  //
+  // This option is currently honored only on Windows
+  //
+  // Default: 1 Mb
+  //
+  // Special value: 0 - means do not maintain per instance buffer. Allocate
+  //                per request buffer and avoid locking.
+  size_t random_access_max_buffer_size = 1024 * 1024;
+
   // This is the maximum buffer size that is used by WritableFileWriter.
   // With direct IO, we need to maintain an aligned buffer for writes.
   // We allow the buffer to grow until it's size hits the limit in buffered

java/rocksjni/env_options.cc

@@ -249,6 +249,26 @@ jlong Java_org_rocksdb_EnvOptions_compactionReadaheadSize(JNIEnv *, jclass,
   return ENV_OPTIONS_GET(jhandle, compaction_readahead_size);
 }
 
+/*
+ * Class:     org_rocksdb_EnvOptions
+ * Method:    setRandomAccessMaxBufferSize
+ * Signature: (JJ)V
+ */
+void Java_org_rocksdb_EnvOptions_setRandomAccessMaxBufferSize(
+    JNIEnv *, jclass, jlong jhandle, jlong random_access_max_buffer_size) {
+  ENV_OPTIONS_SET_SIZE_T(jhandle, random_access_max_buffer_size);
+}
+
+/*
+ * Class:     org_rocksdb_EnvOptions
+ * Method:    randomAccessMaxBufferSize
+ * Signature: (J)J
+ */
+jlong Java_org_rocksdb_EnvOptions_randomAccessMaxBufferSize(JNIEnv *, jclass,
+                                                            jlong jhandle) {
+  return ENV_OPTIONS_GET(jhandle, random_access_max_buffer_size);
+}
+
 /*
  * Class:     org_rocksdb_EnvOptions
  * Method:    setWritableFileMaxBufferSize

java/rocksjni/options.cc

@@ -1577,6 +1577,29 @@ jlong Java_org_rocksdb_Options_compactionReadaheadSize(JNIEnv*, jclass,
   return static_cast<jlong>(opt->compaction_readahead_size);
 }
 
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    setRandomAccessMaxBufferSize
+ * Signature: (JJ)V
+ */
+void Java_org_rocksdb_Options_setRandomAccessMaxBufferSize(
+    JNIEnv*, jclass, jlong jhandle, jlong jrandom_access_max_buffer_size) {
+  auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
+  opt->random_access_max_buffer_size =
+      static_cast<size_t>(jrandom_access_max_buffer_size);
+}
+
+/*
+ * Class:     org_rocksdb_Options
+ * Method:    randomAccessMaxBufferSize
+ * Signature: (J)J
+ */
+jlong Java_org_rocksdb_Options_randomAccessMaxBufferSize(JNIEnv*, jclass,
+                                                         jlong jhandle) {
+  auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::Options*>(jhandle);
+  return static_cast<jlong>(opt->random_access_max_buffer_size);
+}
+
 /*
  * Class:     org_rocksdb_Options
  * Method:    setWritableFileMaxBufferSize
@@ -7089,6 +7112,29 @@ jlong Java_org_rocksdb_DBOptions_compactionReadaheadSize(JNIEnv*, jclass,
   return static_cast<jlong>(opt->compaction_readahead_size);
 }
 
+/*
+ * Class:     org_rocksdb_DBOptions
+ * Method:    setRandomAccessMaxBufferSize
+ * Signature: (JJ)V
+ */
+void Java_org_rocksdb_DBOptions_setRandomAccessMaxBufferSize(
+    JNIEnv*, jclass, jlong jhandle, jlong jrandom_access_max_buffer_size) {
+  auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
+  opt->random_access_max_buffer_size =
+      static_cast<size_t>(jrandom_access_max_buffer_size);
+}
+
+/*
+ * Class:     org_rocksdb_DBOptions
+ * Method:    randomAccessMaxBufferSize
+ * Signature: (J)J
+ */
+jlong Java_org_rocksdb_DBOptions_randomAccessMaxBufferSize(JNIEnv*, jclass,
+                                                           jlong jhandle) {
+  auto* opt = reinterpret_cast<ROCKSDB_NAMESPACE::DBOptions*>(jhandle);
+  return static_cast<jlong>(opt->random_access_max_buffer_size);
+}
+
 /*
  * Class:     org_rocksdb_DBOptions
  * Method:    setWritableFileMaxBufferSize

java/src/main/java/org/rocksdb/DBOptions.java

@@ -772,6 +772,19 @@ public String dailyOffpeakTimeUTC() {
     return dailyOffpeakTimeUTC(nativeHandle_);
   }
 
+  @Override
+  public DBOptions setRandomAccessMaxBufferSize(final long randomAccessMaxBufferSize) {
+    assert (isOwningHandle());
+    setRandomAccessMaxBufferSize(nativeHandle_, randomAccessMaxBufferSize);
+    return this;
+  }
+
+  @Override
+  public long randomAccessMaxBufferSize() {
+    assert (isOwningHandle());
+    return randomAccessMaxBufferSize(nativeHandle_);
+  }
+
   @Override
   public DBOptions setWritableFileMaxBufferSize(final long writableFileMaxBufferSize) {
     assert(isOwningHandle());
@@ -1351,6 +1364,9 @@ private static native void setCompactionReadaheadSize(
   private static native void setDailyOffpeakTimeUTC(
       final long handle, final String dailyOffpeakTimeUTC);
   private static native String dailyOffpeakTimeUTC(final long handle);
+  private static native void setRandomAccessMaxBufferSize(
+      final long handle, final long randomAccessMaxBufferSize);
+  private static native long randomAccessMaxBufferSize(final long handle);
   private static native void setWritableFileMaxBufferSize(
       final long handle, final long writableFileMaxBufferSize);
   private static native long writableFileMaxBufferSize(final long handle);

java/src/main/java/org/rocksdb/DBOptionsInterface.java

@@ -938,6 +938,54 @@ public interface DBOptionsInterface<T extends DBOptionsInterface<T>> {
    */
   long dbWriteBufferSize();
 
+  /**
+   * This is a maximum buffer size that is used by WinMmapReadableFile in
+   * unbuffered disk I/O mode. We need to maintain an aligned buffer for
+   * reads. We allow the buffer to grow until the specified value and then
+   * for bigger requests allocate one shot buffers. In unbuffered mode we
+   * always bypass read-ahead buffer at ReadaheadRandomAccessFile
+   * When read-ahead is required we then make use of
+   * {@link MutableDBOptionsInterface#compactionReadaheadSize()} value and
+   * always try to read ahead.
+   * With read-ahead we always pre-allocate buffer to the size instead of
+   * growing it up to a limit.
+   *
+   * This option is currently honored only on Windows
+   *
+   * Default: 1 Mb
+   *
+   * Special value: 0 - means do not maintain per instance buffer. Allocate
+   *                per request buffer and avoid locking.
+   *
+   * @param randomAccessMaxBufferSize the maximum size of the random access
+   *     buffer
+   *
+   * @return the reference to the current options.
+   */
+  T setRandomAccessMaxBufferSize(long randomAccessMaxBufferSize);
+
+  /**
+   * This is a maximum buffer size that is used by WinMmapReadableFile in
+   * unbuffered disk I/O mode. We need to maintain an aligned buffer for
+   * reads. We allow the buffer to grow until the specified value and then
+   * for bigger requests allocate one shot buffers. In unbuffered mode we
+   * always bypass read-ahead buffer at ReadaheadRandomAccessFile
+   * When read-ahead is required we then make use of
+   * {@link MutableDBOptionsInterface#compactionReadaheadSize()} value and
+   * always try to read ahead. With read-ahead we always pre-allocate buffer
+   * to the size instead of growing it up to a limit.
+   *
+   * This option is currently honored only on Windows
+   *
+   * Default: 1 Mb
+   *
+   * Special value: 0 - means do not maintain per instance buffer. Allocate
+   *                per request buffer and avoid locking.
+   *
+   * @return the maximum size of the random access buffer
+   */
+  long randomAccessMaxBufferSize();
+
   /**
    * Use adaptive mutex, which spins in the user space before resorting
    * to kernel. This could reduce context switch when the mutex is not

java/src/main/java/org/rocksdb/EnvOptions.java

@@ -250,6 +250,28 @@ public long compactionReadaheadSize() {
     return compactionReadaheadSize(nativeHandle_);
   }
 
+  /**
+   * See {@link DBOptions#setRandomAccessMaxBufferSize(long)}.
+   *
+   * @param randomAccessMaxBufferSize the max buffer size for random access.
+   *
+   * @return the reference to these options.
+   */
+  public EnvOptions setRandomAccessMaxBufferSize(final long randomAccessMaxBufferSize) {
+    setRandomAccessMaxBufferSize(nativeHandle_, randomAccessMaxBufferSize);
+    return this;
+  }
+
+  /**
+   * See {@link DBOptions#randomAccessMaxBufferSize()}.
+   *
+   * @return the max buffer size for random access.
+   */
+  public long randomAccessMaxBufferSize() {
+    assert (isOwningHandle());
+    return randomAccessMaxBufferSize(nativeHandle_);
+  }
+
   /**
    * See {@link DBOptions#setWritableFileMaxBufferSize(long)}.
    *
@@ -328,6 +350,9 @@ private static native void setFallocateWithKeepSize(
   private static native void setCompactionReadaheadSize(
       final long handle, final long compactionReadaheadSize);
   private static native long compactionReadaheadSize(final long handle);
+  private static native void setRandomAccessMaxBufferSize(
+      final long handle, final long randomAccessMaxBufferSize);
+  private static native long randomAccessMaxBufferSize(final long handle);
   private static native void setWritableFileMaxBufferSize(
       final long handle, final long writableFileMaxBufferSize);
   private static native long writableFileMaxBufferSize(final long handle);

java/src/main/java/org/rocksdb/Options.java

@@ -860,6 +860,19 @@ public String dailyOffpeakTimeUTC() {
     return dailyOffpeakTimeUTC(nativeHandle_);
   }
 
+  @Override
+  public Options setRandomAccessMaxBufferSize(final long randomAccessMaxBufferSize) {
+    assert (isOwningHandle());
+    setRandomAccessMaxBufferSize(nativeHandle_, randomAccessMaxBufferSize);
+    return this;
+  }
+
+  @Override
+  public long randomAccessMaxBufferSize() {
+    assert (isOwningHandle());
+    return randomAccessMaxBufferSize(nativeHandle_);
+  }
+
   @Override
   public Options setWritableFileMaxBufferSize(final long writableFileMaxBufferSize) {
     assert(isOwningHandle());
@@ -2258,6 +2271,9 @@ private static native void setCompactionReadaheadSize(
   private static native long compactionReadaheadSize(final long handle);
   private static native void setDailyOffpeakTimeUTC(final long handle, final String offpeakTimeUTC);
   private static native String dailyOffpeakTimeUTC(final long handle);
+  private static native void setRandomAccessMaxBufferSize(
+      final long handle, final long randomAccessMaxBufferSize);
+  private static native long randomAccessMaxBufferSize(final long handle);
   private static native void setWritableFileMaxBufferSize(
       final long handle, final long writableFileMaxBufferSize);
   private static native long writableFileMaxBufferSize(final long handle);

java/src/test/java/org/rocksdb/DBOptionsTest.java

@@ -462,6 +462,15 @@ public void compactionReadaheadSize() {
     }
   }
 
+  @Test
+  public void randomAccessMaxBufferSize() {
+    try (final DBOptions opt = new DBOptions()) {
+      final long longValue = rand.nextLong();
+      opt.setRandomAccessMaxBufferSize(longValue);
+      assertThat(opt.randomAccessMaxBufferSize()).isEqualTo(longValue);
+    }
+  }
+
   @Test
   public void writableFileMaxBufferSize() {
     try(final DBOptions opt = new DBOptions()) {

java/src/test/java/org/rocksdb/EnvOptionsTest.java

@@ -111,6 +111,15 @@ public void compactionReadaheadSize() {
     }
   }
 
+  @Test
+  public void randomAccessMaxBufferSize() {
+    try (final EnvOptions envOptions = new EnvOptions()) {
+      final int intValue = rand.nextInt(2147483647);
+      envOptions.setRandomAccessMaxBufferSize(intValue);
+      assertThat(envOptions.randomAccessMaxBufferSize()).isEqualTo(intValue);
+    }
+  }
+
   @Test
   public void writableFileMaxBufferSize() {
     try (final EnvOptions envOptions = new EnvOptions()) {

java/src/test/java/org/rocksdb/OptionsTest.java

@@ -708,6 +708,15 @@ public void compactionReadaheadSize() {
     }
   }
 
+  @Test
+  public void randomAccessMaxBufferSize() {
+    try (final Options opt = new Options()) {
+      final long longValue = rand.nextLong();
+      opt.setRandomAccessMaxBufferSize(longValue);
+      assertThat(opt.randomAccessMaxBufferSize()).isEqualTo(longValue);
+    }
+  }
+
   @Test
   public void writableFileMaxBufferSize() {
     try (final Options opt = new Options()) {

options/db_options.cc

@@ -253,6 +253,10 @@ static std::unordered_map<std::string, OptionTypeInfo>
         {"new_table_reader_for_compaction_inputs",
          {0, OptionType::kBoolean, OptionVerificationType::kDeprecated,
           OptionTypeFlags::kNone}},
+        {"random_access_max_buffer_size",
+         {offsetof(struct ImmutableDBOptions, random_access_max_buffer_size),
+          OptionType::kSizeT, OptionVerificationType::kNormal,
+          OptionTypeFlags::kNone}},
         {"use_adaptive_mutex",
          {offsetof(struct ImmutableDBOptions, use_adaptive_mutex),
           OptionType::kBoolean, OptionVerificationType::kNormal,
@@ -751,6 +755,7 @@ ImmutableDBOptions::ImmutableDBOptions(const DBOptions& options)
       advise_random_on_open(options.advise_random_on_open),
       db_write_buffer_size(options.db_write_buffer_size),
       write_buffer_manager(options.write_buffer_manager),
+      random_access_max_buffer_size(options.random_access_max_buffer_size),
       use_adaptive_mutex(options.use_adaptive_mutex),
       listeners(options.listeners),
       enable_thread_tracking(options.enable_thread_tracking),
@@ -900,6 +905,9 @@ void ImmutableDBOptions::Dump(Logger* log) const {
       db_write_buffer_size);
   ROCKS_LOG_HEADER(log, "                   Options.write_buffer_manager: %p",
                    write_buffer_manager.get());
+  ROCKS_LOG_HEADER(
+      log, "          Options.random_access_max_buffer_size: %" ROCKSDB_PRIszt,
+      random_access_max_buffer_size);
   ROCKS_LOG_HEADER(log, "                     Options.use_adaptive_mutex: %d",
                    use_adaptive_mutex);
   ROCKS_LOG_HEADER(log, "                           Options.rate_limiter: %p",

options/db_options.h

@@ -62,6 +62,7 @@ struct ImmutableDBOptions {
   bool advise_random_on_open;
   size_t db_write_buffer_size;
   std::shared_ptr<WriteBufferManager> write_buffer_manager;
+  size_t random_access_max_buffer_size;
   bool use_adaptive_mutex;
   std::vector<std::shared_ptr<EventListener>> listeners;
   bool enable_thread_tracking;

options/options_helper.cc

@@ -124,6 +124,8 @@ void BuildDBOptions(const ImmutableDBOptions& immutable_db_options,
   options.write_buffer_manager = immutable_db_options.write_buffer_manager;
   options.compaction_readahead_size =
       mutable_db_options.compaction_readahead_size;
+  options.random_access_max_buffer_size =
+      immutable_db_options.random_access_max_buffer_size;
   options.writable_file_max_buffer_size =
       mutable_db_options.writable_file_max_buffer_size;
   options.use_adaptive_mutex = immutable_db_options.use_adaptive_mutex;

options/options_settable_test.cc

@@ -430,6 +430,7 @@ TEST_F(OptionsSettableTest, DBOptionsAllFieldsSettable) {
                              "use_direct_reads=false;"
                              "use_direct_io_for_flush_and_compaction=false;"
                              "max_log_file_size=4607;"
+                             "random_access_max_buffer_size=1048576;"
                              "advise_random_on_open=true;"
                              "fail_if_options_file_error=false;"
                              "enable_pipelined_write=false;"