IndexedDB: Limit the size of a leveldb write buffer to minimize disk space.

third_party/leveldatabase/env_chromium.cc

 // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #include "third_party/leveldatabase/env_chromium.h"
 
 #include <memory>
 #include <utility>
 
 #if defined(OS_POSIX)
 #include <dirent.h>
 #include <sys/types.h>
 #endif
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram.h"
 #include "base/process/process_metrics.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/trace_event.h"
 #include "third_party/leveldatabase/chromium_logger.h"
+#include "third_party/leveldatabase/src/include/leveldb/options.h"
 #include "third_party/re2/src/re2/re2.h"
 
 using base::FilePath;
 using leveldb::FileLock;
 using leveldb::Slice;
 using leveldb::Status;
 
 namespace leveldb_env {
 
 namespace {
@@ skipping 448 matching lines @@
     return false;
   leveldb_env::MethodID method;
   base::File::Error error = base::File::FILE_OK;
   leveldb_env::ErrorParsingResult result =
       leveldb_env::ParseMethodAndError(status, &method, &error);
   return (result == leveldb_env::METHOD_AND_BFE &&
           static_cast<base::File::Error>(error) ==
               base::File::FILE_ERROR_NO_SPACE);
 }
 
+// Given the size of the disk, identified by |disk_size| in bytes, determine the
+// appropriate write_buffer_size. Ignoring snapshots, if the current set of
+// tables in a database contains a set of key/value pairs identified by {A}, and
+// a set of key/value pairs identified by {B} has been written and is in the log
+// file, then during compaction you will have {A} + {B} + {A, B} = 2A + 2B.
+// There is no way to know the size of A, so minimizing the size of B will
+// maximize the likelihood of a successful compaction.
+size_t WriteBufferSize(int64_t disk_size) {
+  const leveldb::Options default_options;
+  const int64_t kMinBufferSize = 1024 * 1024;
+  const int64_t kMaxBufferSize = default_options.write_buffer_size;
+  const int64_t kDiskMinBuffSize = 10 * 1024 * 1024;
+  const int64_t kDiskMaxBuffSize = 40 * 1024 * 1024;
+
+  if (disk_size == -1)
+    return default_options.write_buffer_size;
+
+  if (disk_size <= kDiskMinBuffSize)
+    return kMinBufferSize;
+
+  if (disk_size >= kDiskMaxBuffSize)
+    return kMaxBufferSize;
+
+  // A linear equation to intersect (kDiskMinBuffSize, kMinBufferSize) and
+  // (kDiskMaxBuffSize, kMaxBufferSize).
+  return static_cast<size_t>(
+      kMinBufferSize +
+      ((kMaxBufferSize - kMinBufferSize) * (disk_size - kDiskMinBuffSize)) /
+          (kDiskMaxBuffSize - kDiskMinBuffSize));
+}
+
 ChromiumEnv::ChromiumEnv() : ChromiumEnv("LevelDBEnv") {}
 
 ChromiumEnv::ChromiumEnv(const std::string& name)
     : kMaxRetryTimeMillis(1000),
       name_(name),
       bgsignal_(&mu_),
       started_bgthread_(false) {
   uma_ioerror_base_name_ = name_ + ".IOError.BFE";
 }
 
@@ skipping 517 matching lines @@
 
 }  // namespace leveldb_env
 
 namespace leveldb {
 
 Env* Env::Default() {
   return leveldb_env::default_env.Pointer();
 }
 
 }  // namespace leveldb