[IndexedDB] Pool and evict leveldb iterators, to save memory

content/browser/indexed_db/leveldb/leveldb_database.cc

 // Copyright (c) 2013 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 "content/browser/indexed_db/leveldb/leveldb_database.h"
 
 #include <inttypes.h>
 #include <stdint.h>
 
 #include <cerrno>
@@ skipping 74 matching lines @@
     const leveldb::Slice& limit) const {}
 
 void LevelDBDatabase::ComparatorAdapter::FindShortSuccessor(
     std::string* key) const {}
 
 LevelDBSnapshot::LevelDBSnapshot(LevelDBDatabase* db)
     : db_(db->db_.get()), snapshot_(db_->GetSnapshot()) {}
 
 LevelDBSnapshot::~LevelDBSnapshot() { db_->ReleaseSnapshot(snapshot_); }
 
-LevelDBDatabase::LevelDBDatabase() {}
+LevelDBDatabase::LevelDBDatabase(size_t max_open_iterators)
+    : eviction_enabled_(max_open_iterators != NO_CURSOR_EVICTION),
+      iterator_lru_(max_open_iterators) {}

[pwnall, 2017/03/24 09:16:02]

Shouldn't the MRUCache be initialized with NO_AUTO_EVICT? I think we'd leak if
it would do its own eviction.

[dmurph, 2017/03/24 23:33:39]

Creating our own struct so we do correct eviction. let me know what you think.

 
 LevelDBDatabase::~LevelDBDatabase() {
+  LOCAL_HISTOGRAM_COUNTS_10000("Storage.IndexedDB.LevelDB.MaxIterators",
+                               max_iterators_);
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
   // db_'s destructor uses comparator_adapter_; order of deletion is important.
   CloseDatabase();
   comparator_adapter_.reset();
   env_.reset();
 }
 
 void LevelDBDatabase::CloseDatabase() {
   if (db_) {
@@ skipping 173 matching lines @@
       ->Add(leveldb_error);
   if (s.IsIOError())
     ParseAndHistogramIOErrorDetails(histogram_name, s);
   else
     ParseAndHistogramCorruptionDetails(histogram_name, s);
 }
 
 leveldb::Status LevelDBDatabase::Open(const base::FilePath& file_name,
                                       const LevelDBComparator* comparator,
                                       std::unique_ptr<LevelDBDatabase>* result,
+                                      size_t max_open_cursors,
                                       bool* is_disk_full) {
   IDB_TRACE("LevelDBDatabase::Open");
   base::TimeTicks begin_time = base::TimeTicks::Now();
 
   std::unique_ptr<ComparatorAdapter> comparator_adapter(
       base::MakeUnique<ComparatorAdapter>(comparator));
 
   std::unique_ptr<leveldb::DB> db;
   std::unique_ptr<const leveldb::FilterPolicy> filter_policy;
   const leveldb::Status s = OpenDB(comparator_adapter.get(), LevelDBEnv::Get(),
@@ skipping 10 matching lines @@
     LOG(ERROR) << "Failed to open LevelDB database from "
                << file_name.AsUTF8Unsafe() << "," << s.ToString();
     return s;
   }
 
   UMA_HISTOGRAM_MEDIUM_TIMES("WebCore.IndexedDB.LevelDB.OpenTime",
                              base::TimeTicks::Now() - begin_time);
 
   CheckFreeSpace("Success", file_name);
 
-  (*result) = base::WrapUnique(new LevelDBDatabase());
+  (*result) = base::WrapUnique(new LevelDBDatabase(max_open_cursors));
   (*result)->db_ = std::move(db);
   (*result)->comparator_adapter_ = std::move(comparator_adapter);
   (*result)->comparator_ = comparator;
   (*result)->filter_policy_ = std::move(filter_policy);
   (*result)->file_name_for_tracing = file_name.BaseName().AsUTF8Unsafe();
 
   return s;
 }
 
 std::unique_ptr<LevelDBDatabase> LevelDBDatabase::OpenInMemory(
     const LevelDBComparator* comparator) {
   std::unique_ptr<ComparatorAdapter> comparator_adapter(
       base::MakeUnique<ComparatorAdapter>(comparator));
   std::unique_ptr<leveldb::Env> in_memory_env(
       leveldb::NewMemEnv(LevelDBEnv::Get()));
 
   std::unique_ptr<leveldb::DB> db;
   std::unique_ptr<const leveldb::FilterPolicy> filter_policy;
   const leveldb::Status s = OpenDB(comparator_adapter.get(),
                                    in_memory_env.get(),
                                    base::FilePath(),
                                    &db,
                                    &filter_policy);
 
   if (!s.ok()) {
     LOG(ERROR) << "Failed to open in-memory LevelDB database: " << s.ToString();
     return std::unique_ptr<LevelDBDatabase>();
   }
 
+  // Since the database is in-memory, cursor pooling is pointless.
   std::unique_ptr<LevelDBDatabase> result =
-      base::WrapUnique(new LevelDBDatabase());
+      base::WrapUnique(new LevelDBDatabase(NO_CURSOR_EVICTION));
   result->env_ = std::move(in_memory_env);
   result->db_ = std::move(db);
   result->comparator_adapter_ = std::move(comparator_adapter);
   result->comparator_ = comparator;
   result->filter_policy_ = std::move(filter_policy);
   result->file_name_for_tracing = "in-memory-database";
 
   return result;
 }
 
@@ skipping 63 matching lines @@
   return s;
 }
 
 std::unique_ptr<LevelDBIterator> LevelDBDatabase::CreateIterator(
     const LevelDBSnapshot* snapshot) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;  // TODO(jsbell): Disable this if the
                                          // performance impact is too great.
   read_options.snapshot = snapshot ? snapshot->snapshot_ : 0;
 
+  num_iterators_++;
+  max_iterators_ = std::max(max_iterators_, num_iterators_);
   std::unique_ptr<leveldb::Iterator> i(db_->NewIterator(read_options));
   return std::unique_ptr<LevelDBIterator>(
-      IndexedDBClassFactory::Get()->CreateIteratorImpl(std::move(i)));
+      IndexedDBClassFactory::Get()->CreateIteratorImpl(std::move(i), this,
+                                                       read_options.snapshot));

[pwnall, 2017/03/24 09:16:02]

Why doesn't the newly created iterator get added to the LRU here?

[dmurph, 2017/03/24 23:33:39]

We don't actually allocated memory in the iterator until we do a Seek operation.
So I don't add it until it's actually doing a costly operation. Do you think I
should change that?

[pwnall, 2017/03/27 17:08:03]

I would at the very least document the assumption. I guess the main downside is
that the system is a tad more difficult to reason about ("we have at most 50
seeked iterators", vs "we have at most 50 iterators") but, as long as you're
sure about the resource usage, I suppose this is fine.

[dmurph, 2017/03/27 21:32:04]

Done.

 }
 
 const LevelDBComparator* LevelDBDatabase::Comparator() const {
   return comparator_;
 }
 
 void LevelDBDatabase::Compact(const base::StringPiece& start,
                               const base::StringPiece& stop) {
   IDB_TRACE("LevelDBDatabase::Compact");
   const leveldb::Slice start_slice = MakeSlice(start);
@@ skipping 23 matching lines @@
                   base::trace_event::MemoryAllocatorDump::kUnitsBytes, size);
   dump->AddString("file_name", "", file_name_for_tracing);
 
   // Memory is allocated from system allocator (malloc).
   pmd->AddSuballocation(dump->guid(),
                         base::trace_event::MemoryDumpManager::GetInstance()
                             ->system_allocator_pool_name());
   return true;
 }
 
+std::unique_ptr<leveldb::Iterator> LevelDBDatabase::CreateLevelDBIterator(
+    const leveldb::Snapshot* snapshot) {
+  leveldb::ReadOptions read_options;
+  read_options.verify_checksums = true;
+  read_options.snapshot = snapshot;
+  return std::unique_ptr<leveldb::Iterator>(db_->NewIterator(read_options));
+}
+
+void LevelDBDatabase::NotifyIteratorUsed(LevelDBIterator* iter) {
+  // This line updates the LRU if the item exists.
+  if (!eviction_enabled_ || iterator_lru_.Get(iter) != iterator_lru_.end())
+    return;
+  if (iterator_lru_.size() == iterator_lru_.max_size()) {
+    auto to_evict_iter = iterator_lru_.rbegin();
+    LevelDBIterator* to_evict = to_evict_iter->first;
+    to_evict->PurgeMemory();
+    iterator_lru_.Erase(to_evict_iter);
+  }
+  iterator_lru_.Put(iter, iter);
+}
+
+void LevelDBDatabase::NotifyIteratorDestroyed(LevelDBIterator* iter) {
+  DCHECK_GT(num_iterators_, 0u);
+  --num_iterators_;
+  if (!eviction_enabled_)
+    return;
+  auto it = iterator_lru_.Peek(iter);
+  if (it == iterator_lru_.end())
+    return;
+  iterator_lru_.Erase(it);
+}
 }  // namespace content