Add discardable memory emulation for non-android/mac platforms

base/memory/discardable_memory_provider.h

+// Copyright 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.
+
+#ifndef BASE_MEMORY_DISCARDABLE_MEMORY_PROVIDER_H_

[willchan no longer on Chromium, 2013/08/27 03:23:15]

I don't like to bikeshed too much on naming, but when I first saw this, it
wasn't clear to me that this was only for emulated memory. Maybe name
DiscardableMemoryEmulatedProvider? If you strongly prefer as is, I don't mind.

[Ian Vollick, 2013/09/24 17:15:25]

I've updated the class level comment. I'm hoping it more clearly articulates
that what the provider provides is emulated discardable memory. If you're
willing to deal with it, I'd really prefer to keep the current name. I
appreciate that it's a bit ambiguous, but I find the name to be a bit less
clunky and I'm hoping that since it's an implementation detail, folks won't
interact with this class frequently and that it won't be a confusion factory.

+#define BASE_MEMORY_DISCARDABLE_MEMORY_PROVIDER_H_

[willchan no longer on Chromium, 2013/08/27 03:23:15]

It'd be great if there was a file level comment describing what this is actually
doing under the hood. This is an implementation detail class, and some higher
level explanation of the purge policy and what not would be good. There seems to
be a fair amount of fine grained usage of locks in EnforcePolicy(), which
results in ignoring multiple EnforcePolicy() calls while one is in effect. And
combined with Lock() not actually purging unlocked discardable memory, this
seems to allow for many situations where DiscardableMemory cannot be acquired.
What do callers do in this case?

[Ian Vollick, 2013/09/24 17:15:25]

I've beefed up the big comment above the class definition. Is this better, or
should I write a larger piece up here?
Consumers of DiscardableMemory need to be prepared for their requests to fail
(they fall back to conventional allocation in this case). There are some
existing consumers and they're set up this way.

That said, your point about not purging in Lock was a great one. Hopefully the
purge I've added there will make this a less common occurrence.

+
+#include "base/base_export.h"
+#include "base/containers/hash_tables.h"
+#include "base/containers/mru_cache.h"
+#include "base/memory/memory_pressure_listener.h"
+#include "base/memory/singleton.h"
+#include "base/synchronization/lock.h"
+
+namespace base {
+class DiscardableMemory;
+}  // namespace base
+
+#if defined(COMPILER_GCC)
+namespace BASE_HASH_NAMESPACE {
+template <>
+struct hash<base::DiscardableMemory*> {
+  size_t operator()(base::DiscardableMemory* ptr) const {
+    return hash<size_t>()(reinterpret_cast<size_t>(ptr));
+  }
+};
+}  // namespace BASE_HASH_NAMESPACE
+#endif  // COMPILER
+
+namespace base {
+
+// The DiscardableMemoryProvider is used on platforms that do not support
+// discardable memory natively. It keeps track of all DiscardableMemory
+// instances (in case they need to be purged), and the total amount of allocated
+// memory (in case this forces a purge).
+//
+// NB - this class is an implementation detail. It has been exposed for testing

[willchan no longer on Chromium, 2013/08/27 03:23:15]

Please throw this class into the base::internal namespace. That's one of the
main uses for it. See
https://code.google.com/p/chromium/codesearch#search/&q=internal::%20test.cc&...
for examples of this practice elsewhere in our code base.

[Ian Vollick, 2013/09/24 17:15:25]

Done.

+// purposes. You should not need to use this class directly.
+class BASE_EXPORT DiscardableMemoryProvider {
+ public:
+  DiscardableMemoryProvider();
+  virtual ~DiscardableMemoryProvider();

[willchan no longer on Chromium, 2013/08/27 03:23:15]

Why is this virtual?

[Ian Vollick, 2013/09/24 17:15:25]

No good reason. Removed.

+
+  // The bool here is just a placeholder. The MRU cache acts like a map, but we
+  // only actually care about the keys.
+  typedef HashingMRUCache<DiscardableMemory*, bool> AllocationMap;

[willchan no longer on Chromium, 2013/08/27 03:23:15]

Types go before constructors/destructor in the class definition according to the
style guide.

[Ian Vollick, 2013/09/24 17:15:25]

Done.

+
+  // The maximum number of bytes of discardable memory that may be allocated
+  // before we assume moderate memory pressure. If this amount is zero, it is
+  // interpreted as having no limit at all.
+  void SetDiscardableMemoryLimit(size_t bytes);
+
+  // Gets the maximum amount of discardable memory that may be allocated.
+  size_t discardable_memory_limit() const;
+
+  // Sets the amount of memory to reclaim when we're under moderate pressure.
+  void SetBytesToReclaimUnderModeratePressure(size_t bytes);
+
+  // Gets the amount of memory to reclaim when we're under moderate pressure.
+  size_t bytes_to_reclaim_under_moderate_pressure() const;
+
+ private:
+  friend class DiscardableMemory;
+  friend class DiscardableMemoryProviderTest;
+  friend class Singleton<DiscardableMemoryProvider>;
+
+  static DiscardableMemoryProvider* GetInstance();
+
+  // This can be called as a hint that the system is under memory pressure.
+  static void NotifyMemoryPressure(
+      MemoryPressureListener::MemoryPressureLevel pressure_level);
+
+  // Sets the instance of DiscardableMemoryProvider to be returned by
+  // GetInstance. This should only be used by tests. The ownership of the given
+  // provider is retained by the caller.
+  static void SetInstanceForTest(DiscardableMemoryProvider* provider);
+
+  // Adds the given discardable memory to the provider's collection. If the
+  // discardable has already been added, it is first unregistered and its
+  // memory deallocated.
+  void Register(DiscardableMemory* discardable);
+
+  // Removes the given discardable memory from the provider's collection.
+  void Unregister(DiscardableMemory* discardable);
+
+  // Called by discardable memory instances to allow the provider to keep track
+  // of the total amout of discardable memory allocated.
+  void DidAllocate(size_t bytes);
+
+  // Called by discardable memory instances to allow the provider to keep track
+  // of the total amount of discardable memory allocated.
+  void DidDeallocate(size_t bytes);
+
+  // Called by discardable memory instances to allow the provider to maintain
+  // its MRU cache. Returns false if the discardable has not been registered.
+  bool DidAccess(DiscardableMemory* discardable);
+
+  // Purges all discardable memory.
+  void PurgeAll();
+
+  // Purges least recently used memory.
+  void PurgeLRU();
+
+  // Ensures that we don't allocate beyond our memory limit.
+  void EnforcePolicy();
+
+  // A MRU cache of all allocated bits of discardable memory. Used for purging.
+  AllocationMap allocations_;
+
+  // The total amount of allocated discardable memory.
+  size_t bytes_allocated_;
+
+  // The maximum number of bytes of discardable memory that may be allocated
+  // before we assume moderate memory pressure.
+  size_t discardable_memory_limit_;
+
+  // Under moderate memory pressure, we will purge this amount of memory.
+  size_t bytes_to_reclaim_under_moderate_pressure_;
+
+  // Used to avoid reentry into EnforcePolicy.
+  bool enforcing_policy_;
+
+  // Needs to be held when accessing |allocations_|.
+  Lock allocations_lock_;
+
+  // Needs to be held when accessing |bytes_allocated_| or the two limits above.
+  // It's mutable because it must be accessed in a const function.
+  mutable Lock bytes_allocated_lock_;
+
+  // Allows us to be respond when the system reports that it is under memory
+  // pressure.
+  MemoryPressureListener memory_pressure_listener_;

[willchan no longer on Chromium, 2013/08/27 03:23:15]

This is only implemented on Android right now, right? And Android doesn't use
emulated discardable memory, right? So is this code never going to be exercised,
or will be unused when you commit?

[Ian Vollick, 2013/09/24 17:15:25]

Android is the only platform that listens to real system memory pressure, but we
apply artificial memory pressure on other platforms, too (see
render_thread_impl.cc).

+
+  DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryProvider);
+};
+
+}  // namespace base
+
+#endif  // BASE_MEMORY_DISCARDABLE_MEMORY_PROVIDER_H_