[sql] Use memory-mapped I/O for sql::Connection.

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/files/file_path.h"
@@ skipping 264 matching lines @@
 Connection::Connection()
     : db_(NULL),
       page_size_(0),
       cache_size_(0),
       exclusive_locking_(false),
       restrict_to_user_(false),
       transaction_nesting_(0),
       needs_rollback_(false),
       in_memory_(false),
       poisoned_(false),
+      mmap_disabled_(false),
+      mmap_enabled_(false),
+      total_changes_at_last_release_(0),
       stats_histogram_(NULL),
       commit_time_histogram_(NULL),
       autocommit_time_histogram_(NULL),
       update_time_histogram_(NULL),
       query_time_histogram_(NULL),
       clock_(new TimeSource()) {
 }
 
 Connection::~Connection() {
   Close();
@@ skipping 164 matching lines @@
     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;
   }
 }
 
+// SQLite keeps unused pages associated with a connection in a cache.  It asks
+// the cache for pages by an id, and if the page is present and the database is
+// unchanged, it considers the content of the page valid and doesn't read it
+// from disk.  When memory-mapped I/O is enabled, on read SQLite uses page
+// structures created from the memory map data before consulting the cache.  On
+// write SQLite creates a new in-memory page structure, copies the data from the
+// memory map, and later writes it, releasing the updated page back to the
+// cache.
+//
+// This means that in memory-mapped mode, the contents of the cached pages are
+// not re-used for reads, but they are re-used for writes if the re-written page
+// is still in the cache. The implementation of sqlite3_db_release_memory() as
+// of SQLite 3.8.7.4 frees all pages from pcaches associated with the
+// connection, so it should free these pages.
+//
+// Unfortunately, the zero page is also freed.  That page is never accessed
+// using memory-mapped I/O, and the cached copy can be re-used after verifying
+// the file change counter on disk.  Also, fresh pages from cache receive some
+// pager-level initialization before they can be used.  Since the information
+// involved will immediately be accessed in various ways, it is unclear if the
+// additional overhead is material, or just moving processor cache effects
+// around.
+//
+// TODO(shess): It would be better to release the pages immediately when they
+// are no longer needed.  This would basically happen after SQLite commits a
+// transaction.  I had implemented a pcache wrapper to do this, but it involved
+// layering violations, and it had to be setup before any other sqlite call,
+// which was brittle.  Also, for large files it would actually make sense to
+// maintain the existing pcache behavior for blocks past the memory-mapped
+// segment.  I think drh would accept a reasonable implementation of the overall
+// concept for upstreaming to SQLite core.
+//
+// TODO(shess): Another possibility would be to set the cache size small, which
+// would keep the zero page around, plus some pre-initialized pages, and SQLite
+// can manage things.  The downside is that updates larger than the cache would
+// spill to the journal.  That could be compensated by setting cache_spill to
+// false.  The downside then is that it allows open-ended use of memory for
+// large transactions.
+//
+// TODO(shess): The TrimMemory() trick of bouncing the cache size would also
+// work.  There could be two prepared statements, one for cache_size=1 one for
+// cache_size=goal.
+void Connection::ReleaseCacheMemoryIfNeeded(bool implicit_change_performed) {
+  DCHECK(is_open());
+
+  // If memory-mapping is not enabled, the page cache helps performance.
+  if (!mmap_enabled_)
+    return;
+
+  // On caller request, force the change comparison to fail.  Done before the
+  // transaction-nesting test so that the signal can carry to transaction
+  // commit.
+  if (implicit_change_performed)
+    --total_changes_at_last_release_;
+
+  // Cached pages may be re-used within the same transaction.
+  if (transaction_nesting())
+    return;
+
+  // If no changes have been made, skip flushing.  This allows the first page of
+  // the database to remain in cache across multiple reads.
+  const int total_changes = sqlite3_total_changes(db_);
+  if (total_changes == total_changes_at_last_release_)
+    return;
+
+  total_changes_at_last_release_ = total_changes;
+  sqlite3_db_release_memory(db_);
+}
+
 void Connection::TrimMemory(bool aggressively) {
   if (!db_)
     return;
 
   // TODO(shess): investigate using sqlite3_db_release_memory() when possible.
   int original_cache_size;
   {
     Statement sql_get_original(GetUniqueStatement("PRAGMA cache_size"));
     if (!sql_get_original.Step()) {
       DLOG(WARNING) << "Could not get cache size " << GetErrorMessage();
@@ skipping 290 matching lines @@
 
   // Collect the commit time manually, sql::Statement would register it as query
   // time only.
   const base::TimeTicks before = Now();
   bool ret = commit.RunWithoutTimers();
   const base::TimeDelta delta = Now() - before;
 
   RecordCommitTime(delta);
   RecordOneEvent(EVENT_COMMIT);
 
+  // Release dirty cache pages after the transaction closes.
+  ReleaseCacheMemoryIfNeeded(false);
+
   return ret;
 }
 
 void Connection::RollbackAllTransactions() {
   if (transaction_nesting_ > 0) {
     transaction_nesting_ = 0;
     DoRollback();
   }
 }
 
@@ skipping 70 matching lines @@
     // sqlite3_exec() does this, presumably to avoid spinning the parser for
     // trailing whitespace.
     // TODO(shess): Audit to see if this can become a DCHECK.
     while (base::IsAsciiWhitespace(*sql)) {
       sql++;
     }
 
     const base::TimeDelta delta = Now() - before;
     RecordTimeAndChanges(delta, read_only);
   }
+
+  // Most calls to Execute() modify the database.  The main exceptions would be
+  // calls such as CREATE TABLE IF NOT EXISTS which could modify the database
+  // but sometimes don't.
+  ReleaseCacheMemoryIfNeeded(true);
+
   return rc;
 }
 
 bool Connection::Execute(const char* sql) {
   if (!db_) {
     DLOG_IF(FATAL, !poisoned_) << "Illegal use of connection without a db";
     return false;
   }
 
   int error = ExecuteAndReturnErrorCode(sql);
@@ skipping 344 matching lines @@
 
   // http://www.sqlite.org/pragma.html#pragma_journal_mode
   // DELETE (default) - delete -journal file to commit.
   // TRUNCATE - truncate -journal file to commit.
   // PERSIST - zero out header of -journal file to commit.
   // TRUNCATE should be faster than DELETE because it won't need directory
   // changes for each transaction.  PERSIST may break the spirit of using
   // secure_delete.
   ignore_result(Execute("PRAGMA journal_mode = TRUNCATE"));
 
+  // Enable memory-mapped access.  This value will be capped by
+  // SQLITE_MAX_MMAP_SIZE, which could be different between 32-bit and 64-bit
+  // platforms.
+  mmap_enabled_ = false;
+  if (!mmap_disabled_)
+    ignore_result(Execute("PRAGMA mmap_size = 268435456"));  // 256MB.
+  {
+    Statement s(GetUniqueStatement("PRAGMA mmap_size"));
+    if (s.Step() && s.ColumnInt64(0) > 0)
+      mmap_enabled_ = true;
+  }
+
   const base::TimeDelta kBusyTimeout =
     base::TimeDelta::FromSeconds(kBusyTimeoutSeconds);
 
   if (page_size_ != 0) {
     // Enforce SQLite restrictions on |page_size_|.
     DCHECK(!(page_size_ & (page_size_ - 1)))
         << " page_size_ " << page_size_ << " is not a power of two.";
     const int kSqliteMaxPageSize = 32768;  // from sqliteLimit.h
     DCHECK_LE(page_size_, kSqliteMaxPageSize);
     const std::string sql =
@@ skipping 23 matching lines @@
 
   // Collect the rollback time manually, sql::Statement would register it as
   // query time only.
   const base::TimeTicks before = Now();
   rollback.RunWithoutTimers();
   const base::TimeDelta delta = Now() - before;
 
   RecordUpdateTime(delta);
   RecordOneEvent(EVENT_ROLLBACK);
 
+  // The cache may have been accumulating dirty pages for commit.  Note that in
+  // some cases sql::Transaction can fire rollback after a database is closed.

[Scott Hess - ex-Googler, 2015/10/02 23:42:44]

This test _could_ be at the top of this method, but the ROLLBACK itself could
cause the error handler to close things.

+  if (is_open())
+    ReleaseCacheMemoryIfNeeded(false);
+
   needs_rollback_ = false;
 }
 
 void Connection::StatementRefCreated(StatementRef* ref) {
   DCHECK(open_statements_.find(ref) == open_statements_.end());
   open_statements_.insert(ref);
 }
 
 void Connection::StatementRefDeleted(StatementRef* ref) {
   StatementRefSet::iterator i = open_statements_.find(ref);
@@ skipping 99 matching lines @@
   ignore_result(Execute(kNoWritableSchema));
 
   return ret;
 }
 
 base::TimeTicks TimeSource::Now() {
   return base::TimeTicks::Now();
 }
 
 }  // namespace sql