base: Add soft memory limit to DiscardableMemoryManager.

base/memory/discardable_memory_manager.h

Index: base/memory/discardable_memory_manager.h
diff --git a/base/memory/discardable_memory_manager.h b/base/memory/discardable_memory_manager.h
index 8297b81b0408c2123ee6a141cc7435c4a0292875..1449009e3da3e8b15f3453d28686c910db2abcc5 100644
--- a/base/memory/discardable_memory_manager.h
+++ b/base/memory/discardable_memory_manager.h
@@ -10,6 +10,7 @@
 #include "base/containers/mru_cache.h"
 #include "base/memory/memory_pressure_listener.h"
 #include "base/synchronization/lock.h"
+#include "base/time/time.h"
 
 namespace base {
 namespace internal {
@@ -63,13 +64,18 @@ namespace internal {
 // When notified of memory pressure, the manager either purges the LRU memory --
 // if the pressure is moderate -- or all discardable memory if the pressure is
 // critical.
+//
+// When notified that idle, the manager purges memory not used since the hard
+// memory limit cutoff.
 class BASE_EXPORT_PRIVATE DiscardableMemoryManager {
  public:
   typedef DiscardableMemoryManagerAllocation Allocation;
 
   DiscardableMemoryManager(size_t memory_limit,
-                           size_t bytes_to_keep_under_moderate_pressure);
-  ~DiscardableMemoryManager();
+                           size_t soft_memory_limit,
+                           size_t bytes_to_keep_under_moderate_pressure,
+                           TimeDelta hard_memory_limit_expiration_time);
+  virtual ~DiscardableMemoryManager();
 
   // Call this to register memory pressure listener. Must be called on a thread
   // with a MessageLoop current.
@@ -79,13 +85,26 @@ class BASE_EXPORT_PRIVATE DiscardableMemoryManager {
   void UnregisterMemoryPressureListener();
 
   // The maximum number of bytes of memory that may be allocated before we force
-  // a purge. If this amount is zero, it is interpreted as having no limit at
-  // all.
+  // a purge.
   void SetMemoryLimit(size_t bytes);
 
+  // The number of bytes of memory that may be allocated but unused for the hard
+  // limit expiration time without getting purged.
+  void SetSoftMemoryLimit(size_t bytes);
+
   // Sets the amount of memory to keep when we're under moderate pressure.
   void SetBytesToKeepUnderModeratePressure(size_t bytes);
 
+  // Sets the memory usage cutoff time for hard memory limit.
+  void SetHardMemoryLimitExpirationTime(
+      TimeDelta hard_memory_limit_expiration_time);
+
+  // Call this when idle. Will attempt to reduce memory footprint until within
+  // soft memory limit.
+  // Returns true if there's no need to call this again until allocations
+  // have been used.
+  bool IdleNotification();
+
   // Adds the given allocation to the manager's collection.
   void Register(Allocation* allocation, size_t bytes);
 
@@ -116,12 +135,17 @@ class BASE_EXPORT_PRIVATE DiscardableMemoryManager {
   // used by tests.
   size_t GetBytesAllocatedForTest() const;
 
+ protected:

[willchan no longer on Chromium, 2014/06/27 14:12:57]

I don't think this needs to be protected. Private functions can still be
overridden, just not called by derived classes. The test subclass does not
appear to call Now().

[reveman, 2014/06/27 20:38:02]

Done.

+  // Virtual for tests.
+  virtual TimeTicks Now() const;
+
  private:
   struct AllocationInfo {
     explicit AllocationInfo(size_t bytes) : bytes(bytes), purgable(false) {}
 
     const size_t bytes;
     bool purgable;
+    TimeTicks last_usage;
   };
   typedef HashingMRUCache<Allocation*, AllocationInfo> AllocationMap;
 
@@ -129,20 +153,25 @@ class BASE_EXPORT_PRIVATE DiscardableMemoryManager {
   void OnMemoryPressure(
       MemoryPressureListener::MemoryPressureLevel pressure_level);
 
-  // Purges memory until usage is within
+  // Purges memory until usage is less or equal to
   // |bytes_to_keep_under_moderate_pressure_|.
-  void Purge();
+  void PurgeUntilWithinBytesToKeepUnderModeratePressure();
 
-  // Purges least recently used memory until usage is less or equal to |limit|.
-  // Caller must acquire |lock_| prior to calling this function.
-  void PurgeLRUWithLockAcquiredUntilUsageIsWithin(size_t limit);
+  // Purges memory not used since |hard_memory_limit_expiration_time_| before
+  // "right now" until usage is less or equal to |soft_memory_limit_|.
+  // Returns true if total amount of memory is less or equal to soft memory
+  // limit.
+  bool PurgeIfNotUsedSinceHardLimitCutoffUntilWithinSoftMemoryLimit();
 
-  // Ensures that we don't allocate beyond our memory limit. Caller must acquire
-  // |lock_| prior to calling this function.
-  void EnforcePolicyWithLockAcquired();
+  // Purges memory that has not been used since |timestamp| until usage is less
+  // or equal to |limit|.
+  // Caller must acquire |lock_| prior to calling this function.
+  void PurgeIfNotUsedSinceTimestampUntilUsageIsWithinLimitWithLockAcquired(

[willchan no longer on Chromium, 2014/06/24 16:33:00]

Nice function name.

+      TimeTicks timestamp,
+      size_t limit);
 
   // Called when a change to |bytes_allocated_| has been made.
-  void BytesAllocatedChanged() const;
+  void BytesAllocatedChanged(size_t new_bytes_allocated) const;

[willchan no longer on Chromium, 2014/06/27 14:12:57]

Why is it necessary to pass this? If it's better for some reason (I actually
like passing things explicitly, so it seems good to me), then maybe we should
make this a static function so it's clear this is the only state exchanged here?

[reveman, 2014/06/27 20:38:02]

This function previously assumed that it was always called while it's safe to
read bytes_allocated_ without causing a race. I could have fixed that by adding
WithLockAcquired to the name but that adds some confusion to the ctor where we
can call this without acquiring the lock.

Passing the value as a function argument solves this but I think it's still
cleaner to keep it a normal member function as we're using the instance address
as unique id for the trace counter.

 
   // Needs to be held when accessing members.
   mutable Lock lock_;
@@ -156,6 +185,11 @@ class BASE_EXPORT_PRIVATE DiscardableMemoryManager {
   // The maximum number of bytes of memory that may be allocated.
   size_t memory_limit_;
 
+  // The number of bytes of memory that may be allocated but not used for
+  // |hard_memory_limit_expiration_time_| amount of time when receiving an idle
+  // notification.
+  size_t soft_memory_limit_;
+
   // Under moderate memory pressure, we will purge memory until usage is within
   // this limit.
   size_t bytes_to_keep_under_moderate_pressure_;
@@ -164,6 +198,10 @@ class BASE_EXPORT_PRIVATE DiscardableMemoryManager {
   // pressure.
   scoped_ptr<MemoryPressureListener> memory_pressure_listener_;
 
+  // Amount of time it takes for an allocation to become affected by
+  // |soft_memory_limit_|.
+  TimeDelta hard_memory_limit_expiration_time_;
+
   DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryManager);
 };