[sql] Experiment to enable smart-vacuum on Android.

sql/connection.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "sql/connection.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/debug/alias.h"
 #include "base/debug/dump_without_crashing.h"
+#include "base/feature_list.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 194 matching lines @@
 }
 
 std::string AsUTF8ForSQL(const base::FilePath& path) {
 #if defined(OS_WIN)
   return base::WideToUTF8(path.value());
 #elif defined(OS_POSIX)
   return path.value();
 #endif
 }
 
+// http://crbug.com/698010
+//
+// The feature enables a SQLite patch which causes SQLite to leverage
+// SQLITE_FCNTL_CHUNK_SIZE when making auto-vacuum decisions.  This should lower
+// write load (histogram Sqlite.Vfs_Write in vfs_wrapper.cc).  Only Android
+// enables auto-vacuum under Chromium.
+const base::Feature kSqliteSmartAutoVacuumEnabled{
+    "SqliteSmartAutoVacuum", base::FEATURE_DISABLED_BY_DEFAULT};
+
 }  // namespace
 
 namespace sql {
 
 // static
 Connection::ErrorExpecterCallback* Connection::current_expecter_cb_ = NULL;
 
 // static
 bool Connection::IsExpectedSqliteError(int error) {
   if (!current_expecter_cb_)
@@ skipping 1603 matching lines @@
   // databases (<20k) while other clients have a broad distribution of sizes
   // (hundreds of kilobytes to many megabytes).
   sqlite3_file* file = NULL;
   sqlite3_int64 db_size = 0;
   int rc = GetSqlite3FileAndSize(db_, &file, &db_size);
   if (rc == SQLITE_OK && db_size > 16 * 1024) {
     int chunk_size = 4 * 1024;
     if (db_size > 128 * 1024)
       chunk_size = 32 * 1024;
     sqlite3_file_control(db_, NULL, SQLITE_FCNTL_CHUNK_SIZE, &chunk_size);
+    if (base::FeatureList::IsEnabled(kSqliteSmartAutoVacuumEnabled)) {
+      // TODO(shess): The default page size is now 4096.  Before committing to
+      // this long-term, fix that.  Meanwhile, this should be fine, it might
+      // leave a few databases using a bit more disk space than expected.
+      const int page_size = page_size_ ? page_size_ : 1024;

[Maria, 2017/03/28 22:14:59]

The 1024 constant here for page_size, is this just for the unit test? To me it's
confusing that you say that the default page size is 4k, but then set a const
default to 1k.

[Scott Hess - ex-Googler, 2017/03/29 03:28:46]

Maybe I'll elaborate the comment.  SQLite's default page size is 4096, except
for platforms using system SQLite (iOS, maybe Chromium on Linux), except if
you're linking with an older SQLite (or if I have to revert the import), etc.  I
could write code to calculate the actual page size, but I believe all of our
clients actually set an explicit page size, so it wouldn't really help in
practice, so I figure it's reasonable to land that code later.

Maybe I'll just proto the code in the morning, perhaps it's easier than updating
the comment.

[Scott Hess - ex-Googler, 2017/03/29 21:11:24]

Bah, I just went with fetching the page-size from the db.  I am honestly not
sure if this is something that should be more broadly exposed or not, so I kept
it local.

+      std::string slack_sql = base::StringPrintf(
+          "PRAGMA auto_vacuum_slack_pages = %d", chunk_size / page_size);
+      ignore_result(Execute(slack_sql.c_str()));
+    }
   }
 
   // Enable memory-mapped access.  The explicit-disable case is because SQLite
   // can be built to default-enable mmap.  GetAppropriateMmapSize() calculates a
   // safe range to memory-map based on past regular I/O.  This value will be
   // capped by SQLITE_MAX_MMAP_SIZE, which could be different between 32-bit and
   // 64-bit platforms.
   size_t mmap_size = mmap_disabled_ ? 0 : GetAppropriateMmapSize();
   std::string mmap_sql =
       base::StringPrintf("PRAGMA mmap_size = %" PRIuS, mmap_size);
@@ skipping 191 matching lines @@
                                    const std::string& dump_name) {
   return memory_dump_provider_ &&
          memory_dump_provider_->ReportMemoryUsage(pmd, dump_name);
 }
 
 base::TimeTicks TimeSource::Now() {
   return base::TimeTicks::Now();
 }
 
 }  // namespace sql