Disk cache: Keep a map of all open entries....

net/disk_cache/backend_impl.cc

 // Copyright (c) 2006-2008 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 "net/disk_cache/backend_impl.h"
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/histogram.h"
 #include "base/message_loop.h"
@@ skipping 408 matching lines @@
   IncreaseNumRefs();
 
   if (!cache_entry->CreateEntry(node_address, key, hash)) {
     block_files_.DeleteBlock(entry_address, false);
     block_files_.DeleteBlock(node_address, false);
     LOG(ERROR) << "Create entry failed " << key.c_str();
     stats_.OnEvent(Stats::CREATE_ERROR);
     return false;
   }
 
+  // We are not failing the operation; let's add this to the map.
+  open_entries_[entry_address.value()] = cache_entry;
+
   if (parent.get())
     parent->SetNextAddress(entry_address);
 
   block_files_.GetFile(entry_address)->Store(cache_entry->entry());
   block_files_.GetFile(node_address)->Store(cache_entry->rankings());
 
   IncreaseNumEntries();
   eviction_.OnCreateEntry(cache_entry);
   if (!parent.get())
     data_->table[hash & mask_] = entry_address.value();
@@ skipping 274 matching lines @@
   if (!new_eviction_)
     return;
 
   DCHECK(ENTRY_NORMAL != entry->entry()->Data()->state);
 
   Trace("Remove entry 0x%p", entry);
   eviction_.OnDestroyEntry(entry);
   DecreaseNumEntries();
 }
 
-void BackendImpl::CacheEntryDestroyed() {
+void BackendImpl::CacheEntryDestroyed(Addr address) {
+  EntriesMap::iterator it = open_entries_.find(address.value());

[Nicolas Sylvain, 2009/07/07 17:47:14]

why would it not be in the map? dirty maybe? should we dcheck when it's not?

[rvargas (doing something else), 2009/07/07 18:13:24]

Yes and no. We don't store dirty entries in the map, but it should be a frequent
thing to open dirty entries so we cannot dcheck here (the dirty flag is cleared
before the destruction of the entry)

+  if (it != open_entries_.end())
+    open_entries_.erase(it);
   DecreaseNumRefs();
 }
 
-int32 BackendImpl::GetCurrentEntryId() {
+bool BackendImpl::IsOpen(CacheRankingsBlock* rankings) const {
+  DCHECK(rankings->HasData());
+  EntriesMap::const_iterator it =
+      open_entries_.find(rankings->Data()->contents);
+  if (it != open_entries_.end()) {
+    // We have this entry in memory.
+    return rankings->Data()->pointer == it->second;
+  }
+
+  return false;
+}
+
+int32 BackendImpl::GetCurrentEntryId() const {
   return data_->header.this_id;
 }
 
 int BackendImpl::MaxFileSize() const {
   return max_size_ / 8;
 }
 
 void BackendImpl::ModifyStorageSize(int32 old_size, int32 new_size) {
   if (disabled_ || old_size == new_size)
     return;
@@ skipping 290 matching lines @@
   data_->header.crash = 0;
   index_ = NULL;
   data_ = NULL;
   block_files_.CloseFiles();
   rankings_.Reset();
   init_ = false;
   restarted_ = true;
 }
 
 int BackendImpl::NewEntry(Addr address, EntryImpl** entry, bool* dirty) {
+  EntriesMap::iterator it = open_entries_.find(address.value());
+  if (it != open_entries_.end()) {
+    // Easy job. This entry is already in memory.
+    EntryImpl* this_entry = it->second;
+    this_entry->AddRef();
+    *entry = this_entry;
+    *dirty = false;
+    return 0;
+  }
+
   scoped_refptr<EntryImpl> cache_entry(new EntryImpl(this, address));
   IncreaseNumRefs();
   *entry = NULL;
 
   if (!address.is_initialized() || address.is_separate_file() ||
       address.file_type() != BLOCK_256) {
     LOG(WARNING) << "Wrong entry address.";
     return ERR_INVALID_ADDRESS;
   }
 
   if (!cache_entry->entry()->Load())
     return ERR_READ_FAILURE;
 
   if (!cache_entry->SanityCheck()) {
     LOG(WARNING) << "Messed up entry found.";
     return ERR_INVALID_ENTRY;
   }
 
   if (!cache_entry->LoadNodeAddress())
     return ERR_READ_FAILURE;
 
   *dirty = cache_entry->IsDirty(GetCurrentEntryId());
 
   // Prevent overwriting the dirty flag on the destructor.
   cache_entry->ClearDirtyFlag();
 
   if (!rankings_.SanityCheck(cache_entry->rankings(), false))
     return ERR_INVALID_LINKS;
 
+  // We only add clean entries to the map.
+  if (!*dirty)
+    open_entries_[address.value()] = cache_entry;
+
   cache_entry.swap(entry);
   return 0;
 }
 
 EntryImpl* BackendImpl::MatchEntry(const std::string& key, uint32 hash,
                                    bool find_parent) {
   Addr address(data_->table[hash & mask_]);
   EntryImpl* cache_entry = NULL;
   EntryImpl* parent_entry = NULL;
   bool found = false;
@@ skipping 35 matching lines @@
       } else {
         Trace("NewEntry failed on MatchEntry 0x%x", address.value());
       }
 
       // Restart the search.
       address.set_value(data_->table[hash & mask_]);
       continue;
     }
 
     if (cache_entry->IsSameEntry(key, hash)) {
-      cache_entry = EntryImpl::Update(cache_entry);
+      if (!cache_entry->Update()) {
+        cache_entry->Release();
+        cache_entry = NULL;
+      }
       found = true;
       break;
     }
-    cache_entry = EntryImpl::Update(cache_entry);
+    if (!cache_entry->Update()) {
+      cache_entry->Release();
+      cache_entry = NULL;

[Nicolas Sylvain, 2009/07/07 17:47:14]

do you really need this here? since you do it below too. Well, i guess it makes
it clearer.

[rvargas (doing something else), 2009/07/07 18:13:24]

if I don't set it to null, we'll copy an invalid pointer into parent_entry. I
guess that now we have more calls to Release() than assignments to plain
pointers so I could see how this function looks after replacing cache_entry and
parent_entry with scoped pointers, but I'll leave that for another cl.

+    }
     if (parent_entry)
       parent_entry->Release();
     parent_entry = cache_entry;
     cache_entry = NULL;
     if (!parent_entry)
       break;
 
     address.set_value(parent_entry->GetNextAddress());
   }
 
@@ skipping 135 matching lines @@
     // path and take the appropriate action.
     std::string key = entry->GetKey();
     uint32 hash = entry->GetHash();
     entry = NULL;  // Release the entry.
     temp = MatchEntry(key, hash, false);
     if (temp)
       temp->Release();
 
     return NULL;
   }
+  if (!entry->Update())
+    return NULL;
 
   entry.swap(&temp);
-  return EntryImpl::Update(temp);  // Update returns an adref'd entry.
+  return temp;
 }
 
 bool BackendImpl::ResurrectEntry(EntryImpl* deleted_entry, Entry** entry) {
   if (ENTRY_NORMAL == deleted_entry->entry()->Data()->state) {
     deleted_entry->Release();
     stats_.OnEvent(Stats::CREATE_MISS);
     Trace("create entry miss ");
     return false;
   }
 
@@ skipping 238 matching lines @@
 
   return num_dirty;
 }
 
 bool BackendImpl::CheckEntry(EntryImpl* cache_entry) {
   RankingsNode* rankings = cache_entry->rankings()->Data();
   return !rankings->pointer;
 }
 
 }  // namespace disk_cache