| Index: net/disk_cache/v3/backend_impl_v3.h
|
| ===================================================================
|
| --- net/disk_cache/v3/backend_impl_v3.h (revision 232523)
|
| +++ net/disk_cache/v3/backend_impl_v3.h (working copy)
|
| @@ -4,20 +4,21 @@
|
|
|
| // See net/disk_cache/disk_cache.h for the public interface of the cache.
|
|
|
| -#ifndef NET_DISK_CACHE_BACKEND_IMPL_H_
|
| -#define NET_DISK_CACHE_BACKEND_IMPL_H_
|
| +#ifndef NET_DISK_CACHE_V3_BACKEND_IMPL_V3_H_
|
| +#define NET_DISK_CACHE_V3_BACKEND_IMPL_V3_H_
|
|
|
| #include "base/containers/hash_tables.h"
|
| #include "base/files/file_path.h"
|
| +#include "base/synchronization/waitable_event.h"
|
| #include "base/timer/timer.h"
|
| #include "net/disk_cache/block_files.h"
|
| #include "net/disk_cache/disk_cache.h"
|
| -#include "net/disk_cache/eviction.h"
|
| -#include "net/disk_cache/in_flight_backend_io.h"
|
| -#include "net/disk_cache/rankings.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;
|
| @@ -25,29 +26,29 @@
|
|
|
| namespace disk_cache {
|
|
|
| -enum BackendFlags {
|
| - kNone = 0,
|
| - kMask = 1, // A mask (for the index table) was specified.
|
| - kMaxSize = 1 << 1, // A maximum size was provided.
|
| - kUnitTestMode = 1 << 2, // We are modifying the behavior for testing.
|
| - kUpgradeMode = 1 << 3, // This is the upgrade tool (dump).
|
| - kNewEviction = 1 << 4, // Use of new eviction was specified.
|
| - kNoRandom = 1 << 5, // Don't add randomness to the behavior.
|
| - kNoLoadProtection = 1 << 6, // Don't act conservatively under load.
|
| - kNoBuffering = 1 << 7 // Disable extended IO buffering.
|
| -};
|
| +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 BackendImpl : public Backend {
|
| - friend class Eviction;
|
| +class NET_EXPORT_PRIVATE BackendImplV3
|
| + : public Backend,
|
| + public IndexTableBackend {
|
| + friend class EvictionV3;
|
| public:
|
| - BackendImpl(const base::FilePath& path, base::MessageLoopProxy* cache_thread,
|
| + 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);
|
| - // mask can be used to limit the usable size of the hash table, for testing.
|
| - BackendImpl(const base::FilePath& path, uint32 mask,
|
| - base::MessageLoopProxy* cache_thread, net::NetLog* net_log);
|
| - virtual ~BackendImpl();
|
| + virtual ~BackendImplV3();
|
|
|
| // Performs general initialization for this current instance of the cache.
|
| int Init(const CompletionCallback& callback);
|
| @@ -67,11 +68,20 @@
|
| Addr* block_address);
|
|
|
| // Updates the ranking information for an entry.
|
| - void UpdateRank(EntryImpl* entry, bool modified);
|
| + void UpdateRank(EntryImplV3* entry, bool modified);
|
|
|
| // Permanently deletes an entry, but still keeps track of it.
|
| - void InternalDoomEntry(EntryImpl* entry);
|
| + 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.
|
| @@ -81,14 +91,39 @@
|
| // released.
|
| void OnEntryDestroyEnd();
|
|
|
| - // If the data stored by the provided |rankings| points to an open entry,
|
| - // returns a pointer to that entry, otherwise returns NULL. Note that this
|
| - // method does NOT increase the ref counter for the entry.
|
| - EntryImpl* GetOpenEntry(CacheRankingsBlock* rankings) const;
|
| + // Callen when an entry is modified for the first time.
|
| + void OnEntryModified(EntryImplV3* entry);
|
|
|
| - // Returns the id being used on this run of the cache.
|
| - int32 GetCurrentEntryId() const;
|
| + // 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;
|
|
|
| @@ -99,7 +134,7 @@
|
| void TooMuchStorageRequested(int32 size);
|
|
|
| // Returns true if a temporary buffer is allowed to be extended.
|
| - bool IsAllocAllowed(int current_size, int new_size);
|
| + bool IsAllocAllowed(int current_size, int new_size, bool force);
|
|
|
| // Tracks the release of |size| bytes by an entry buffer.
|
| void BufferDeleted(int size);
|
| @@ -112,6 +147,10 @@
|
| // 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 GetCurrentTime() const;
|
| +
|
| // Returns the full histogram name, for the given base |name| and experiment,
|
| // and the current cache type. The name will be "DiskCache.t.name_e" where n
|
| // is the cache type and e the provided |experiment|.
|
| @@ -126,7 +165,7 @@
|
| }
|
|
|
| // Returns a weak pointer to this object.
|
| - base::WeakPtr<BackendImpl> GetWeakPtr();
|
| + 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
|
| @@ -143,9 +182,12 @@
|
| void OnRead(int bytes);
|
| void OnWrite(int bytes);
|
|
|
| - // Timer callback to calculate usage statistics.
|
| - void OnStatsTimer();
|
| + // 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();
|
|
|
| @@ -161,6 +203,9 @@
|
| // 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);
|
| @@ -169,10 +214,24 @@
|
| // 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;
|
| @@ -195,26 +254,54 @@
|
| virtual void OnExternalCacheHit(const std::string& key) OVERRIDE;
|
|
|
| private:
|
| - typedef base::hash_map<CacheAddr, EntryImpl*> EntriesMap;
|
| + typedef base::hash_map<CacheAddr, EntryImplV3*> EntriesMap;
|
| + typedef base::hash_set<EntryImplV3*> EntriesSet;
|
| + class IOCallback;
|
| + class Worker;
|
| + class WorkItem;
|
|
|
| - void AdjustMaxCacheSize(int table_len);
|
| -
|
| - bool InitStats();
|
| + void AdjustMaxCacheSize();
|
| + bool InitStats(void* stats_data);
|
| void StoreStats();
|
|
|
| // Deletes the cache and starts again.
|
| - void RestartCache(bool failure);
|
| + 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(Addr address, EntryImpl** entry);
|
| + 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.
|
| - EntryImpl* OpenFollowingEntry(bool forward, void** iter);
|
| + 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);
|
| @@ -225,6 +312,25 @@
|
| 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();
|
|
|
| @@ -241,48 +347,53 @@
|
| int CheckAllEntries();
|
|
|
| // Part of the self test. Returns false if the entry is corrupt.
|
| - bool CheckEntry(EntryImpl* cache_entry);
|
| + bool CheckEntry(EntryImplV3* cache_entry);
|
|
|
| // Returns the maximum total memory for the memory buffers.
|
| int MaxBuffersSize();
|
|
|
| - scoped_refptr<MappedFile> index_; // The main cache index.
|
| + IndexTable index_;
|
| base::FilePath path_; // Path to the folder used as backing storage.
|
| - BlockFiles block_files_; // Set of files used to store all data.
|
| + BlockBitmaps block_files_;
|
| int32 max_size_; // Maximum data size for this instance.
|
| - Eviction eviction_; // Handler of the eviction algorithm.
|
| - EntriesMap open_entries_; // Map of open entries.
|
| + 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 (OnStatsTimer).
|
| + 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 unit_test_;
|
| bool read_only_; // Prevents updates of the rankings data (used by tools).
|
| bool disabled_;
|
| - bool new_eviction_; // What eviction algorithm should be used.
|
| + 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<BackendImpl> > timer_; // Usage timer.
|
| + scoped_ptr<base::RepeatingTimer<BackendImplV3> > timer_; // Usage timer.
|
| scoped_refptr<TraceObject> trace_object_; // Initializes internal tracing.
|
| - base::WeakPtrFactory<BackendImpl> ptr_factory_;
|
| + scoped_refptr<base::MessageLoopProxy> cache_thread_;
|
| + scoped_refptr<Worker> worker_;
|
| + base::WeakPtrFactory<BackendImplV3> ptr_factory_;
|
|
|
| - DISALLOW_COPY_AND_ASSIGN(BackendImpl);
|
| + DISALLOW_COPY_AND_ASSIGN(BackendImplV3);
|
| };
|
|
|
| -// Returns the preferred max cache size given the available disk space.
|
| -NET_EXPORT_PRIVATE int PreferedCacheSize(int64 available);
|
| -
|
| } // namespace disk_cache
|
|
|
| -#endif // NET_DISK_CACHE_BACKEND_IMPL_H_
|
| +#endif // NET_DISK_CACHE_V3_BACKEND_IMPL_V3_H_
|
|
|
Chromium Code Reviews
