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

content/browser/indexed_db/leveldb/leveldb_transaction.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_transaction.h"
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/time/time.h"
@@ skipping 23 matching lines @@
 LevelDBTransaction::LevelDBTransaction(LevelDBDatabase* db)
     : db_(db),
       snapshot_(db),
       comparator_(db->Comparator()),
       data_comparator_(comparator_),
       data_(data_comparator_) {}
 
 LevelDBTransaction::Record::Record() {}
 LevelDBTransaction::Record::~Record() {}
 
-LevelDBTransaction::~LevelDBTransaction() {}
+LevelDBTransaction::~LevelDBTransaction() {
+  for (TransactionIterator* iter : iterators_) {

[jsbell, 2017/03/22 23:55:32]

I left a comment before... can this be a DCHECK since iterators should not
outlive transactions? Or was I wrong?

[dmurph, 2017/03/23 20:56:48]

removed.

+    db_->NotifyIteratorDestroyed(iter);
+  }
+}
 
 void LevelDBTransaction::Set(const StringPiece& key,
                              std::string* value,
                              bool deleted) {
   DCHECK(!finished_);
   DataType::iterator it = data_.find(key);
 
   if (it == data_.end()) {
     std::unique_ptr<Record> record = base::MakeUnique<Record>();
     record->key.assign(key.begin(), key.end() - key.begin());
@@ skipping 182 matching lines @@
       db_iterator_(
           transaction_->db_->CreateIterator(&transaction_->snapshot_)) {
   transaction_->RegisterIterator(this);
 }
 
 LevelDBTransaction::TransactionIterator::~TransactionIterator() {
   transaction_->UnregisterIterator(this);
 }
 
 bool LevelDBTransaction::TransactionIterator::IsValid() const {
-  return !!current_;
+  return !!current_ || db_iterator_state_ == DBIteratorState::EVICTED_AND_VALID;
 }
 
 leveldb::Status LevelDBTransaction::TransactionIterator::SeekToLast() {
+  LoadDBIteratorIfEvicted();
   leveldb::Status s = data_iterator_->SeekToLast();
   DCHECK(s.ok());
   s = db_iterator_->SeekToLast();
   if (!s.ok())
     return s;
   direction_ = REVERSE;
 
   HandleConflictsAndDeletes();
   SetCurrentIteratorToLargestKey();
   return s;
 }
 
 leveldb::Status LevelDBTransaction::TransactionIterator::Seek(
     const StringPiece& target) {
+  LoadDBIteratorIfEvicted();
   leveldb::Status s = data_iterator_->Seek(target);
   DCHECK(s.ok());
   s = db_iterator_->Seek(target);
   if (!s.ok())
     return s;
   direction_ = FORWARD;
 
   HandleConflictsAndDeletes();
   SetCurrentIteratorToSmallestKey();
   return s;
 }
 
 leveldb::Status LevelDBTransaction::TransactionIterator::Next() {
+  LoadDBIteratorIfEvicted();
   DCHECK(IsValid());
   if (data_changed_)
     RefreshDataIterator();
 
   leveldb::Status s;
   if (direction_ != FORWARD) {
     // Ensure the non-current iterator is positioned after Key().
 
     LevelDBIterator* non_current = (current_ == db_iterator_.get())
                                        ? data_iterator_.get()
@@ skipping 16 matching lines @@
 
   s = current_->Next();
   if (!s.ok())
     return s;
   HandleConflictsAndDeletes();
   SetCurrentIteratorToSmallestKey();
   return leveldb::Status::OK();
 }
 
 leveldb::Status LevelDBTransaction::TransactionIterator::Prev() {
+  LoadDBIteratorIfEvicted();
   DCHECK(IsValid());
   leveldb::Status s;
   if (data_changed_)
     RefreshDataIterator();
 
   if (direction_ != REVERSE) {
     // Ensure the non-current iterator is positioned before Key().
 
     LevelDBIterator* non_current = (current_ == db_iterator_.get())
                                        ? data_iterator_.get()
@@ skipping 23 matching lines @@
     return s;
   HandleConflictsAndDeletes();
   SetCurrentIteratorToLargestKey();
   return leveldb::Status::OK();
 }
 
 StringPiece LevelDBTransaction::TransactionIterator::Key() const {
   DCHECK(IsValid());
   if (data_changed_)
     RefreshDataIterator();
+  if (current_ == nullptr && db_iterator_state_ != DBIteratorState::ACTIVE) {

[jsbell, 2017/03/22 23:55:32]

Nit: no need for {} on single line.

or do we want DCHECK_EQ(db_iterator_state_, DBIteratorState::EVICTED_AND_VALID)
?

[dmurph, 2017/03/23 20:56:48]

Changed due to moving to impl.

+    return db_key_before_eviction_;
+  }
   return current_->Key();
 }
 
 StringPiece LevelDBTransaction::TransactionIterator::Value() const {
+  if (db_iterator_state_ != DBIteratorState::ACTIVE && current_ == nullptr) {

[jsbell, 2017/03/22 23:55:32]

This logic is subtle and probably deserves a comment.

[dmurph, 2017/03/23 20:56:48]

Made better by moving to impl.

+    const_cast<LevelDBTransaction::TransactionIterator*>(this)

[jsbell, 2017/03/22 23:55:32]

Comment about the const_cast

Explain (for future readers) why making members `mutable` is not enough.

[dmurph, 2017/03/23 20:56:48]

done.

+        ->LoadDBIteratorIfEvicted();
+  }
+  DCHECK(current_);
   DCHECK(IsValid());
   if (data_changed_)
     RefreshDataIterator();
   return current_->Value();
 }
 
+void LevelDBTransaction::TransactionIterator::PurgeMemory() {
+  DCHECK_EQ(db_iterator_state_, DBIteratorState::ACTIVE);
+  if (db_iterator_->IsValid()) {
+    db_iterator_state_ = DBIteratorState::EVICTED_AND_VALID;
+    db_key_before_eviction_ = db_iterator_->Key().as_string();
+  } else {
+    db_iterator_state_ = DBIteratorState::EVICTED_AND_INVALID;
+  }
+  if (current_ == db_iterator_.get())
+    current_ = nullptr;
+  db_iterator_.reset();
+}
+
+bool LevelDBTransaction::TransactionIterator::IsMemoryPurged() const {
+  return db_iterator_state_ != DBIteratorState::ACTIVE;
+};
+
 void LevelDBTransaction::TransactionIterator::DataChanged() {
   data_changed_ = true;
 }
 
 void LevelDBTransaction::TransactionIterator::Delete() {
   DCHECK(IsValid());
   if (current_ == data_iterator_.get()) {
     data_iterator_->Delete();
   } else {
     std::unique_ptr<Record> record = base::MakeUnique<Record>();
@@ skipping 27 matching lines @@
       // If going backward, seek to a key less than the db iterator.
       DCHECK_EQ(REVERSE, direction_);
       data_iterator_->Seek(db_iterator_->Key());
       if (data_iterator_->IsValid())
         data_iterator_->Prev();
     }
   }
 }
 
 bool LevelDBTransaction::TransactionIterator::DataIteratorIsLower() const {
+  DCHECK_EQ(db_iterator_state_, DBIteratorState::ACTIVE);
   return comparator_->Compare(data_iterator_->Key(), db_iterator_->Key()) < 0;
 }
 
 bool LevelDBTransaction::TransactionIterator::DataIteratorIsHigher() const {
+  DCHECK_EQ(db_iterator_state_, DBIteratorState::ACTIVE);
   return comparator_->Compare(data_iterator_->Key(), db_iterator_->Key()) > 0;
 }
 
+void LevelDBTransaction::TransactionIterator::LoadDBIteratorIfEvicted() {
+  transaction_->db_->NotifyIteratorUsed(this);
+
+  if (db_iterator_state_ == DBIteratorState::ACTIVE)
+    return;
+
+  db_iterator_ = transaction_->db_->CreateIterator(&transaction_->snapshot_);
+  if (db_iterator_state_ == DBIteratorState::EVICTED_AND_VALID) {
+    db_iterator_->Seek(db_key_before_eviction_);
+    db_key_before_eviction_.clear();
+  }
+  if (current_ == nullptr)
+    current_ = db_iterator_.get();
+  db_iterator_state_ = DBIteratorState::ACTIVE;
+}
+
 void LevelDBTransaction::TransactionIterator::HandleConflictsAndDeletes() {
+  LoadDBIteratorIfEvicted();
   bool loop = true;
 
   while (loop) {
     loop = false;
 
     if (data_iterator_->IsValid() && db_iterator_->IsValid() &&
         !comparator_->Compare(data_iterator_->Key(), db_iterator_->Key())) {
       // For equal keys, the data iterator takes precedence, so move the
       // database iterator another step.
       if (direction_ == FORWARD)
@@ skipping 13 matching lines @@
                  (!db_iterator_->IsValid() || DataIteratorIsHigher())) {
         data_iterator_->Prev();
         loop = true;
       }
     }
   }
 }
 
 void
 LevelDBTransaction::TransactionIterator::SetCurrentIteratorToSmallestKey() {
+  DCHECK_EQ(db_iterator_state_, DBIteratorState::ACTIVE);
   LevelDBIterator* smallest = nullptr;
 
   if (data_iterator_->IsValid())
     smallest = data_iterator_.get();
 
   if (db_iterator_->IsValid()) {
     if (!smallest ||
         comparator_->Compare(db_iterator_->Key(), smallest->Key()) < 0)
       smallest = db_iterator_.get();
   }
@@ skipping 12 matching lines @@
         comparator_->Compare(db_iterator_->Key(), largest->Key()) > 0)
       largest = db_iterator_.get();
   }
 
   current_ = largest;
 }
 
 void LevelDBTransaction::RegisterIterator(TransactionIterator* iterator) {
   DCHECK(iterators_.find(iterator) == iterators_.end());
   iterators_.insert(iterator);
+  db_->NotifyIteratorCreated(iterator);
 }
 
 void LevelDBTransaction::UnregisterIterator(TransactionIterator* iterator) {
   DCHECK(iterators_.find(iterator) != iterators_.end());
   iterators_.erase(iterator);
+  db_->NotifyIteratorDestroyed(iterator);
 }
 
 void LevelDBTransaction::NotifyIterators() {
   for (auto* transaction_iterator : iterators_)
     transaction_iterator->DataChanged();
 }
 
 std::unique_ptr<LevelDBDirectTransaction> LevelDBDirectTransaction::Create(
     LevelDBDatabase* db) {
   return base::WrapUnique(new LevelDBDirectTransaction(db));
@@ skipping 34 matching lines @@
 
   leveldb::Status s = db_->Write(*write_batch_);
   if (s.ok()) {
     finished_ = true;
     write_batch_->Clear();
   }
   return s;
 }
 
 }  // namespace content