[sql] Increase database chunk size for large databases.

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 <string.h>
 
 #include "base/bind.h"
 #include "base/debug/dump_without_crashing.h"
@@ skipping 172 matching lines @@
 
   // TODO(shess): NULL in file->pMethods has been observed on android_dbg
   // content_unittests, even though it should not be possible.
   // http://crbug.com/329982
   if (!*file || !(*file)->pMethods)
     return SQLITE_ERROR;
 
   return rc;
 }
 
+// Convenience to get the sqlite3_file* and the size for the "main" database.
+int GetSqlite3FileAndSize(sqlite3* db,
+                          sqlite3_file** file, sqlite3_int64* db_size) {
+  int rc = GetSqlite3File(db, file);
+  if (rc != SQLITE_OK)
+    return rc;
+
+  return (*file)->pMethods->xFileSize(*file, db_size);
+}
+
 // This should match UMA_HISTOGRAM_MEDIUM_TIMES().
 base::HistogramBase* GetMediumTimeHistogram(const std::string& name) {
   return base::Histogram::FactoryTimeGet(
       name,
       base::TimeDelta::FromMilliseconds(10),
       base::TimeDelta::FromMinutes(3),
       50,
       base::HistogramBase::kUmaTargetedHistogramFlag);
 }
 
@@ skipping 305 matching lines @@
   }
 
   // Use local settings if provided, otherwise use documented defaults.  The
   // actual results could be fetching via PRAGMA calls.
   const int page_size = page_size_ ? page_size_ : 1024;
   sqlite3_int64 preload_size = page_size * (cache_size_ ? cache_size_ : 2000);
   if (preload_size < 1)
     return;
 
   sqlite3_file* file = NULL;
-  int rc = GetSqlite3File(db_, &file);
+  sqlite3_int64 file_size = 0;
+  int rc = GetSqlite3FileAndSize(db_, &file, &file_size);
   if (rc != SQLITE_OK)
     return;
 
-  sqlite3_int64 file_size = 0;
-  rc = file->pMethods->xFileSize(file, &file_size);
-  if (rc != SQLITE_OK)
-    return;
-
   // Don't preload more than the file contains.
   if (preload_size > file_size)
     preload_size = file_size;
 
   scoped_ptr<char[]> buf(new char[page_size]);
   for (sqlite3_int64 pos = 0; pos < preload_size; pos += page_size) {
     rc = file->pMethods->xRead(file, buf.get(), page_size, pos);
     if (rc != SQLITE_OK)
       return;
   }
@@ skipping 1112 matching lines @@
   }
 
   if (!ExecuteWithTimeout("PRAGMA secure_delete=ON", kBusyTimeout)) {
     bool was_poisoned = poisoned_;
     Close();
     if (was_poisoned && retry_flag == RETRY_ON_POISON)
       return OpenInternal(file_name, NO_RETRY);
     return false;
   }
 
+  // Set a reasonable chunk size for larger files.  This reduces churn from
+  // remapping memory on size changes.  It also reduces filesystem
+  // fragmentation.
+  // TODO(shess): It may make sense to have this be hinted by the client.
+  // Database sizes seem to be bimodal, some clients have consistently small
+  // 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);
+  }
+
   // Enable memory-mapped access.  The explicit-disable case is because SQLite
   // can be built to default-enable mmap.  This value will be capped by
   // SQLITE_MAX_MMAP_SIZE, which could be different between 32-bit and 64-bit
   // platforms.
   if (mmap_disabled_) {
     ignore_result(Execute("PRAGMA mmap_size = 0"));
   } else {
     ignore_result(Execute("PRAGMA mmap_size = 268435456"));  // 256MB.
   }
 
@@ skipping 138 matching lines @@
   ignore_result(Execute(kNoWritableSchema));
 
   return ret;
 }
 
 base::TimeTicks TimeSource::Now() {
   return base::TimeTicks::Now();
 }
 
 }  // namespace sql