Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(60)

Unified Diff: net/disk_cache/v3/backend_impl_v3.h

Issue 15203004: Disk cache: Reference CL for the implementation of file format version 3. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src/
Patch Set: IndexTable review Created 7 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « net/disk_cache/trace.cc ('k') | net/disk_cache/v3/backend_impl_v3.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/disk_cache/v3/backend_impl_v3.h
===================================================================
--- net/disk_cache/v3/backend_impl_v3.h (revision 0)
+++ net/disk_cache/v3/backend_impl_v3.h (revision 0)
@@ -0,0 +1,398 @@
+// 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.
+
+// See net/disk_cache/disk_cache.h for the public interface of the cache.
+
+#ifndef NET_DISK_CACHE_V3_BACKEND_IMPL_V3_H_
+#define NET_DISK_CACHE_V3_BACKEND_IMPL_V3_H_
+
+#include "base/files/file_path.h"
+#include "base/hash_tables.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/timer.h"
+#include "net/disk_cache/block_files.h"
+#include "net/disk_cache/disk_cache.h"
+#include "net/disk_cache/stats.h"
+#include "net/disk_cache/stress_support.h"
+#include "net/disk_cache/trace.h"
+#include "net/disk_cache/v3/block_bitmaps.h"
+#include "net/disk_cache/v3/eviction_v3.h"
+#include "net/disk_cache/v3/index_table.h"
+
+namespace net {
+class NetLog;
+} // namespace net
+
+namespace disk_cache {
+
+class EntryImplV3;
+
+// This class implements the Backend interface. An object of this
+// class handles the operations of the cache for a particular profile.
+class NET_EXPORT_PRIVATE BackendImplV3
+ : public Backend,
+ public IndexTableBackend {
+ friend class EvictionV3;
+ public:
+ enum BackendFlags {
+ MAX_SIZE = 1 << 1, // A maximum size was provided.
+ UNIT_TEST_MODE = 1 << 2, // We are modifying the behavior for testing.
+ UPGRADE_MODE = 1 << 3, // This is the upgrade tool (dump).
+ EVICTION_V2 = 1 << 4, // Use of new eviction was specified.
+ BASIC_UNIT_TEST = 1 << 5, // Identifies almost all unit tests.
+ NO_LOAD_PROTECTION = 1 << 6, // Don't act conservatively under load.
+ NO_BUFFERING = 1 << 7, // Disable extended IO buffering.
+ NO_CLEAN_ON_EXIT // Avoid saving data at exit time.
+ };
+
+ BackendImplV3(const base::FilePath& path, base::MessageLoopProxy* cache_thread,
+ net::NetLog* net_log);
+ virtual ~BackendImplV3();
+
+ // Performs general initialization for this current instance of the cache.
+ int Init(const CompletionCallback& callback);
+
+ // Same behavior as OpenNextEntry but walks the list from back to front.
+ int OpenPrevEntry(void** iter, Entry** prev_entry,
+ const CompletionCallback& callback);
+
+ // Sets the maximum size for the total amount of data stored by this instance.
+ bool SetMaxSize(int max_bytes);
+
+ // Sets the cache type for this backend.
+ void SetType(net::CacheType type);
+
+ // Creates a new storage block of size block_count.
+ bool CreateBlock(FileType block_type, int block_count,
+ Addr* block_address);
+
+ // Updates the ranking information for an entry.
+ void UpdateRank(EntryImplV3* entry, bool modified);
+
+ // Permanently deletes an entry, but still keeps track of it.
+ void InternalDoomEntry(EntryImplV3* entry);
+
+ // Returns true is te entry should be deleted at this time. Otherwise, the
+ // entry will receive another Close() in later on.
+ bool ShouldDeleteNow(EntryImplV3* entry);
+
+ // Called when an entry is about to destroyed, after the data has been saved.
+ // The backend may extend the lifetime of the entry waiting for a call to
+ // OpenEntry().
+ void OnEntryCleanup(EntryImplV3* entry);
+
+ // This method must be called when an entry is released for the last time, so
+ // the entry should not be used anymore. |address| is the cache address of the
+ // entry.
+ void OnEntryDestroyBegin(Addr address);
+
+ // This method must be called after all resources for an entry have been
+ // released.
+ void OnEntryDestroyEnd();
+
+ // Callen when an entry is modified for the first time.
+ void OnEntryModified(EntryImplV3* entry);
+
+ // Methods that perform file IO. Each method result in a task posted to the
+ // cache thread, with the |callback| invoked when the operation completes.
+ // Any error would result in the |entry| being automatically deleted. Note
+ // that these methods do not operate directly on entries, but rather on the
+ // |address| provided. For example, Delete() deletes the data pointed by
+ // |address|, it doesn't delete |entry|.
+ void ReadData(EntryImplV3* entry, Addr address, int offset,
+ net::IOBuffer* buffer, int buffer_len,
+ const CompletionCallback& callback);
+ void WriteData(EntryImplV3* entry, Addr address, int offset,
+ net::IOBuffer* buffer, int buffer_len,
+ const CompletionCallback& callback);
+ void MoveData(EntryImplV3* entry, Addr source, Addr destination, int len,
+ const CompletionCallback& callback);
+ void Truncate(EntryImplV3* entry, Addr address, int offset);
+ void Delete(EntryImplV3* entry, Addr address);
+ void Close(EntryImplV3* entry, Addr address);
+
+ // Evicts the entry located at |address|, with the given |hash|. Returns true
+ // if the entry can be evicted and the caller should expect a completion
+ // notification, false otherwise.
+ // This method is used by the eviction module, and OnEvictEntryComplete() will
+ // be called to notify the end of the operation.
+ bool EvictEntry(uint32 hash, Addr address);
+
+ // If the |address| corresponds to an open entry, returns a pointer to that
+ // entry, otherwise returns NULL. Note that this method increases the ref
+ // counter for the entry.
+ EntryImplV3* GetOpenEntry(Addr address) const;
+
+ // Returns the maximum size for a file to reside on the cache.
+ int MaxFileSize() const;
+
+ // A user data block is being created, extended or truncated.
+ void ModifyStorageSize(int32 old_size, int32 new_size);
+
+ // Logs requests that are denied due to being too big.
+ void TooMuchStorageRequested(int32 size);
+
+ // Returns true if a temporary buffer is allowed to be extended.
+ bool IsAllocAllowed(int current_size, int new_size, bool force);
+
+ // Tracks the release of |size| bytes by an entry buffer.
+ void BufferDeleted(int size);
+
+ // Only intended for testing the two previous methods.
+ int GetTotalBuffersSize() const {
+ return buffer_bytes_;
+ }
+
+ // Returns true if this instance seems to be under heavy load.
+ bool IsLoaded() const;
+
+ // Returns the current time. For tests to run properly, use this method
+ // instead of calling base::Time::Now() directly.
+ base::Time GetTime() const;
+
+ // Returns the full histogram name, for the given base |name| and the current
+ // cache type. The name will be "DiskCache3.name_type".
+ std::string HistogramName(const char* name) const;
+
+ net::CacheType cache_type() const {
+ return cache_type_;
+ }
+
+ bool read_only() const {
+ return read_only_;
+ }
+
+ // Returns a weak pointer to this object.
+ base::WeakPtr<BackendImplV3> GetWeakPtr();
+
+ // Returns true if we should send histograms for this user again. The caller
+ // must call this function only once per run (because it returns always the
+ // same thing on a given run).
+ bool ShouldReportAgain();
+
+ // Reports some data when we filled up the cache.
+ void FirstEviction();
+
+ // Called when an interesting event should be logged (counted).
+ void OnEvent(Stats::Counters an_event);
+
+ // Keeps track of payload access (doesn't include metadata).
+ void OnRead(int bytes);
+ void OnWrite(int bytes);
+
+ // Increases the size of the block files.
+ void GrowBlockFiles();
+
+ // Timer callback to calculate usage statistics and perform backups.
+ void OnTimerTick();
+
+ // Sets internal parameters to enable unit testing mode.
+ void SetUnitTestMode();
+
+ // Sets internal parameters to enable upgrade mode (for internal tools).
+ void SetUpgradeMode();
+
+ // Sets the eviction algorithm to version 2.
+ void SetNewEviction();
+
+ // Sets an explicit set of BackendFlags.
+ void SetFlags(uint32 flags);
+
+ // Sends a dummy operation through the operation queue, for unit tests.
+ int FlushQueueForTest(const CompletionCallback& callback);
+
+ // Performs final cleanup, for unit tests.
+ int CleanupForTest(const CompletionCallback& callback);
+
+ // Trims an entry (all if |empty| is true) from the list of deleted
+ // entries. This method should be called directly on the cache thread.
+ void TrimForTest(bool empty);
+
+ // Trims an entry (all if |empty| is true) from the list of deleted
+ // entries. This method should be called directly on the cache thread.
+ void TrimDeletedListForTest(bool empty);
+
+ // Simulates that aditional |seconds| have elapsed, for testing purposes.
+ void AddDelayForTest(int seconds);
+
+ // Returns a net error code to inform the caller when the entry with the
+ // desired |key| is completely closed.
+ int WaitForEntryToCloseForTest(const std::string& key,
+ const CompletionCallback& callback);
+
+ // Performs a simple self-check, and returns the number of dirty items
+ // or an error code (negative value).
+ int SelfCheck();
+
+ // IndexTableBackend implementation.
+ virtual void GrowIndex() OVERRIDE;
+ virtual void SaveIndex(net::IOBuffer* buffer, int buffer_len) OVERRIDE;
+ virtual void DeleteCell(EntryCell cell) OVERRIDE;
+ virtual void FixCell(EntryCell cell) OVERRIDE;
+
+ // Backend implementation.
+ virtual net::CacheType GetCacheType() const OVERRIDE;
+ virtual int32 GetEntryCount() const OVERRIDE;
+ virtual int OpenEntry(const std::string& key, Entry** entry,
+ const CompletionCallback& callback) OVERRIDE;
+ virtual int CreateEntry(const std::string& key, Entry** entry,
+ const CompletionCallback& callback) OVERRIDE;
+ virtual int DoomEntry(const std::string& key,
+ const CompletionCallback& callback) OVERRIDE;
+ virtual int DoomAllEntries(const CompletionCallback& callback) OVERRIDE;
+ virtual int DoomEntriesBetween(base::Time initial_time,
+ base::Time end_time,
+ const CompletionCallback& callback) OVERRIDE;
+ virtual int DoomEntriesSince(base::Time initial_time,
+ const CompletionCallback& callback) OVERRIDE;
+ virtual int OpenNextEntry(void** iter, Entry** next_entry,
+ const CompletionCallback& callback) OVERRIDE;
+ virtual void EndEnumeration(void** iter) OVERRIDE;
+ virtual void GetStats(StatsItems* stats) OVERRIDE;
+ virtual void OnExternalCacheHit(const std::string& key) OVERRIDE;
+
+ private:
+ typedef base::hash_map<CacheAddr, EntryImplV3*> EntriesMap;
+ typedef base::hash_set<EntryImplV3*> EntriesSet;
+ class IOCallback;
+ class Worker;
+ class WorkItem;
+
+ void AdjustMaxCacheSize();
+ bool InitStats(void* stats_data);
+ void StoreStats();
+
+ // Deletes the cache and starts again.
+ void RestartCache(const CompletionCallback& callback);
+ void PrepareForRestart();
+
+ // Performs final cleanup.
+ void CleanupCache();
+
+ // Creates a new entry object. Returns zero on success, or a disk_cache error
+ // on failure.
+ int NewEntry(WorkItem* work_item, EntryImplV3** entry);
+
+ // Scans |entries| and the list of open entries looking for a match. Returns
+ // NULL if no match is fouond.
+ EntryImplV3* LookupOpenEntry(const EntrySet& entries, const std::string key);
+
+ // Opens the next or previous entry on a cache iteration.
+ int OpenFollowingEntry(bool forward, void** iter, Entry** next_entry,
+ const CompletionCallback& callback);
+
+ // Continue an enumeration by getting more cells or the next entry to open.
+ bool GetMoreCells(WorkItem* work_item);
+ int OpenNext(WorkItem* work_item);
+
+ // Doom |entry| if directed by the work_item.
+ void Doom(EntryImplV3* entry, WorkItem* work_item);
+
+ // Updates the user visible iterator an tell the user about it.
+ void UpdateIterator(EntryImplV3* entry, WorkItem* work_item);
+
+ // Deletes entries that are waiting for deletion.
+ void CloseDoomedEntries();
+
+ // Releases recent_entries_.
+ void ReleaseRecentEntries();
+
+ // Updates the cells for entries already gone.
+ void UpdateDeletedEntries();
+
+ // Handles the used storage count.
+ void AddStorageSize(int32 bytes);
+ void SubstractStorageSize(int32 bytes);
+
+ // Update the number of referenced cache entries.
+ void IncreaseNumRefs();
+ void DecreaseNumRefs();
+ void IncreaseNumEntries();
+ void DecreaseNumEntries();
+
+ // Methods to post and receive notifications about tasks executed on the
+ // cache thread.
+ void PostWorkItem(WorkItem* work_item);
+ void OnWorkDone(WorkItem* work_item);
+ void OnInitComplete(WorkItem* work_item);
+ void OnGrowIndexComplete(WorkItem* work_item);
+ void OnGrowFilesComplete(WorkItem* work_item);
+ void OnOperationComplete(WorkItem* work_item);
+ void OnOpenEntryComplete(WorkItem* work_item);
+ void OnOpenForResurrectComplete(WorkItem* work_item);
+ void OnEvictEntryComplete(WorkItem* work_item);
+ void OnOpenNextComplete(WorkItem* work_item);
+
+ // Last part of CreateEntry(). |short_record| may point to stored data about
+ // a previously evicted entry matching this |key|.
+ int OnCreateEntryComplete(const std::string& key, uint32 hash,
+ ShortEntryRecord* short_record, Entry** entry,
+ const CompletionCallback& callback);
+
+ // Dumps current cache statistics to the log.
+ void LogStats();
+
+ // Send UMA stats.
+ void ReportStats();
+
+ // Reports an uncommon, recoverable error.
+ void ReportError(int error);
+
+ // Performs basic checks on the index file. Returns false on failure.
+ bool CheckIndex();
+
+ // Part of the self test. Returns the number or dirty entries, or an error.
+ int CheckAllEntries();
+
+ // Part of the self test. Returns false if the entry is corrupt.
+ bool CheckEntry(EntryImplV3* cache_entry);
+
+ // Returns the maximum total memory for the memory buffers.
+ int MaxBuffersSize();
+
+ IndexTable index_;
+ base::FilePath path_; // Path to the folder used as backing storage.
+ BlockBitmaps block_files_;
+ int32 max_size_; // Maximum data size for this instance.
+ EvictionV3 eviction_; // Handler of the eviction algorithm.
+ EntriesMap open_entries_;
+ EntriesMap doomed_entries_;
+ EntriesMap entries_to_delete_;
+ EntriesSet recent_entries_; // May still be open, or recently closed.
+ CellList deleted_entries_;
+ int num_refs_; // Number of referenced cache entries.
+ int max_refs_; // Max number of referenced cache entries.
+ int entry_count_; // Number of entries accessed lately.
+ int byte_count_; // Number of bytes read/written lately.
+ int buffer_bytes_; // Total size of the temporary entries' buffers.
+ int up_ticks_; // The number of timer ticks received (OnTimerTick).
+ int test_seconds_; // The "current time" for tests.
+ net::CacheType cache_type_;
+ int uma_report_; // Controls transmission of UMA data.
+ uint32 user_flags_; // Flags set by the user.
+ bool init_; // controls the initialization of the system.
+ bool restarted_;
+ bool read_only_; // Prevents updates of the rankings data (used by tools).
+ bool disabled_;
+ bool lru_eviction_; // What eviction algorithm should be used.
+ bool first_timer_; // True if the timer has not been called.
+ bool user_load_; // True if we see a high load coming from the caller.
+ bool growing_index_;
+ bool growing_files_;
+
+ net::NetLog* net_log_;
+
+ Stats stats_; // Usage statistics.
+ scoped_ptr<base::RepeatingTimer<BackendImplV3> > timer_; // Usage timer.
+ scoped_refptr<TraceObject> trace_object_; // Initializes internal tracing.
+ scoped_refptr<base::MessageLoopProxy> cache_thread_;
+ scoped_refptr<Worker> worker_;
+ base::WeakPtrFactory<BackendImplV3> ptr_factory_;
+
+ DISALLOW_COPY_AND_ASSIGN(BackendImplV3);
+};
+
+} // namespace disk_cache
+
+#endif // NET_DISK_CACHE_V3_BACKEND_IMPL_V3_H_
Property changes on: net\disk_cache\v3\backend_impl_v3.h
___________________________________________________________________
Added: svn:eol-style
+ LF
« no previous file with comments | « net/disk_cache/trace.cc ('k') | net/disk_cache/v3/backend_impl_v3.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698