Add discardable memory emulation for non-android/mac platforms

base/memory/discardable_memory_provider_unittest.cc

+// 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.
+
+#include "base/memory/discardable_memory_provider.h"
+
+#include "base/bind.h"
+#include "base/memory/discardable_memory.h"
+#include "base/run_loop.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/threading/thread.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using base::internal::DiscardableMemoryProvider;
+
+namespace base {
+
+class DiscardableMemoryProviderTest : public testing::Test {
+ public:
+  DiscardableMemoryProviderTest()
+      : message_loop_(MessageLoop::TYPE_IO),
+        provider_(new DiscardableMemoryProvider) {
+    // We set a provider here for two reasons:
+    //   1. It ensures that one test cannot affect the next, and
+    //   2. Since the provider listens for pressure notifications on the thread
+    //      it was created on, if we create it on the test thread, we can run
+    //      the test thread's message loop until idle when we want to process
+    //      one of these notifications.
+    DiscardableMemoryProvider::SetInstanceForTest(provider_.get());
+  }
+
+  virtual ~DiscardableMemoryProviderTest() {
+    DiscardableMemoryProvider::SetInstanceForTest(NULL);
+  }
+
+ protected:
+  bool IsRegistered(const DiscardableMemory* discardable) {
+    return DiscardableMemoryProvider::GetInstance()->IsRegisteredForTest(
+        discardable);
+  }
+
+  bool CanBePurged(const DiscardableMemory* discardable) {
+    return DiscardableMemoryProvider::GetInstance()->CanBePurgedForTest(
+        discardable);
+  }
+
+  size_t BytesAllocated() const {
+    return DiscardableMemoryProvider::GetInstance()->
+        GetBytesAllocatedForTest();
+  }
+
+  void* Memory(const DiscardableMemory* discardable) const {
+    return discardable->Memory();
+  }
+
+  void SetDiscardableMemoryLimit(size_t bytes) {
+    DiscardableMemoryProvider::GetInstance()->
+        SetDiscardableMemoryLimit(bytes);
+  }
+
+  void SetBytesToReclaimUnderModeratePressure(size_t bytes) {
+    DiscardableMemoryProvider::GetInstance()->
+        SetBytesToReclaimUnderModeratePressure(bytes);
+  }
+
+ private:
+  MessageLoop message_loop_;
+  scoped_ptr<DiscardableMemoryProvider> provider_;
+};
+
+TEST_F(DiscardableMemoryProviderTest, CreateLockedMemory) {
+  size_t size = 1024;
+  const scoped_ptr<DiscardableMemory> discardable(
+      DiscardableMemory::CreateLockedMemory(size));
+  EXPECT_TRUE(IsRegistered(discardable.get()));
+  EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
+  EXPECT_EQ(1024u, BytesAllocated());
+  EXPECT_FALSE(CanBePurged(discardable.get()));
+}
+
+TEST_F(DiscardableMemoryProviderTest, CreateLockedMemoryZeroSize) {
+  size_t size = 0;
+  const scoped_ptr<DiscardableMemory> discardable(
+      DiscardableMemory::CreateLockedMemory(size));
+  EXPECT_FALSE(discardable);
+  EXPECT_FALSE(IsRegistered(discardable.get()));
+  EXPECT_EQ(0u, BytesAllocated());
+}
+
+TEST_F(DiscardableMemoryProviderTest, LockAfterUnlock) {
+  size_t size = 1024;
+  const scoped_ptr<DiscardableMemory> discardable(
+      DiscardableMemory::CreateLockedMemory(size));
+  EXPECT_TRUE(IsRegistered(discardable.get()));
+  EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
+  EXPECT_EQ(1024u, BytesAllocated());
+  EXPECT_FALSE(CanBePurged(discardable.get()));
+
+  // Now unlock so we can lock later.
+  discardable->Unlock();
+  EXPECT_TRUE(CanBePurged(discardable.get()));
+
+  EXPECT_EQ(DISCARDABLE_MEMORY_SUCCESS, discardable->Lock());
+  EXPECT_FALSE(CanBePurged(discardable.get()));
+}
+
+TEST_F(DiscardableMemoryProviderTest, LockAfterPurge) {
+  size_t size = 1024;
+  const scoped_ptr<DiscardableMemory> discardable(
+      DiscardableMemory::CreateLockedMemory(size));
+  EXPECT_TRUE(IsRegistered(discardable.get()));
+  EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
+  EXPECT_EQ(1024u, BytesAllocated());
+  EXPECT_FALSE(CanBePurged(discardable.get()));
+
+  // Now unlock so we can lock later.
+  discardable->Unlock();
+  EXPECT_TRUE(CanBePurged(discardable.get()));
+
+  // Force the system to purge.
+  MemoryPressureListener::NotifyMemoryPressure(
+      MemoryPressureListener::MEMORY_PRESSURE_CRITICAL);
+
+  // Required because ObserverListThreadSafe notifies via PostTask.
+  RunLoop().RunUntilIdle();
+
+  EXPECT_EQ(DISCARDABLE_MEMORY_PURGED, discardable->Lock());
+  EXPECT_FALSE(CanBePurged(discardable.get()));
+}
+
+TEST_F(DiscardableMemoryProviderTest, LockAfterPurgeAndCannotReallocate) {
+  size_t size = 1024;
+  const scoped_ptr<DiscardableMemory> discardable(
+      DiscardableMemory::CreateLockedMemory(size));
+  EXPECT_TRUE(IsRegistered(discardable.get()));
+  EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
+  EXPECT_EQ(1024u, BytesAllocated());
+  EXPECT_FALSE(CanBePurged(discardable.get()));
+
+  // Now unlock so we can lock later.
+  discardable->Unlock();
+  EXPECT_TRUE(CanBePurged(discardable.get()));
+
+  // Set max allowed allocation to 1 byte. This will make cause the memory
+  // to be purged.
+  SetDiscardableMemoryLimit(1);
+
+  EXPECT_EQ(DISCARDABLE_MEMORY_PURGED, discardable->Lock());
+  EXPECT_FALSE(CanBePurged(discardable.get()));
+}
+
+// Use discardable memory in order specified by d0, d1 and d2 then apply
+// memory pressure and verify that memory was discarded in the correct order.
+#define DiscardableMemoryProviderPermutionTest(name, d0, d1, d2, pressure)    \
+TEST_F(DiscardableMemoryProviderTest, name##_##d0##_##d1##_##d2) {            \
+  scoped_ptr<DiscardableMemory> discardables[3];                              \
+  for (int i = 0; i < 3; ++i) {                                               \
+    discardables[i] = DiscardableMemory::CreateLockedMemory(1024);            \
+    EXPECT_TRUE(discardables[i]);                                             \
+    EXPECT_NE(static_cast<void*>(NULL), Memory(discardables[i].get()));       \
+    discardables[i]->Unlock();                                                \
+  }                                                                           \
+  int ordering[] = { d0, d1, d2 };                                            \
+  for (int i = 0; i < 3; ++i) {                                               \
+    int current_index = ordering[i];                                          \
+    EXPECT_NE(DISCARDABLE_MEMORY_FAILED,                                      \
+              discardables[current_index]->Lock());                           \
+    if (i > 0)                                                                \
+      discardables[current_index]->Unlock();                                  \
+  }                                                                           \
+  SetBytesToReclaimUnderModeratePressure(1024);                               \
+  if (pressure) {                                                             \
+    MemoryPressureListener::NotifyMemoryPressure(                             \
+        MemoryPressureListener::MEMORY_PRESSURE_MODERATE);                    \
+    RunLoop().RunUntilIdle();                                                 \
+  } else {                                                                    \
+    SetDiscardableMemoryLimit(2048);                                          \
+  }                                                                           \
+  EXPECT_NE(DISCARDABLE_MEMORY_FAILED, discardables[ordering[2]]->Lock());    \
+  EXPECT_NE(DISCARDABLE_MEMORY_SUCCESS, discardables[ordering[1]]->Lock());   \
+  EXPECT_NE(static_cast<void*>(NULL),                                         \
+            Memory(discardables[ordering[0]].get()));                         \
+}
+
+#define DiscardableMemoryProviderPermutions(name, pressure)      \

[willchan no longer on Chromium, 2013/10/29 01:44:59]

My instinct is that you can replace this with value parameterized tests
(https://code.google.com/p/googletest/wiki/AdvancedGuide#Value_Parameterized_T...),
but I don't know for sure. I'm adding jyasskin for his advice here.

[reveman, 2013/10/29 15:22:23]

I went ahead and parameterized these tests in latest patch as that makes a lot
of sense. I'll still wait for feedback from jyasskin in case he has some
additional advice.

+DiscardableMemoryProviderPermutionTest(name, 0, 1, 2, pressure); \
+DiscardableMemoryProviderPermutionTest(name, 0, 2, 1, pressure); \
+DiscardableMemoryProviderPermutionTest(name, 1, 0, 2, pressure); \
+DiscardableMemoryProviderPermutionTest(name, 1, 2, 0, pressure); \
+DiscardableMemoryProviderPermutionTest(name, 2, 0, 1, pressure); \
+DiscardableMemoryProviderPermutionTest(name, 2, 1, 0, pressure);
+
+DiscardableMemoryProviderPermutions(LRUDiscardedModeratePressure, true);
+DiscardableMemoryProviderPermutions(LRUDiscardedExceedLimit, false);
+
+TEST_F(DiscardableMemoryProviderTest, CriticalPressureFreesAllUnlocked) {
+  scoped_ptr<DiscardableMemory> discardables[3];
+  for (int i = 0; i < 3; ++i) {
+    discardables[i] = DiscardableMemory::CreateLockedMemory(1024);
+    EXPECT_TRUE(discardables[i]);
+    EXPECT_NE(static_cast<void*>(NULL), Memory(discardables[i].get()));
+    discardables[i]->Unlock();
+  }
+
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_NE(DISCARDABLE_MEMORY_FAILED, discardables[i]->Lock());
+    if (i > 0)
+      discardables[i]->Unlock();
+  }
+
+  MemoryPressureListener::NotifyMemoryPressure(
+      MemoryPressureListener::MEMORY_PRESSURE_CRITICAL);
+  RunLoop().RunUntilIdle();
+
+  for (int i = 0; i < 3; ++i) {
+    if (i == 0)
+      EXPECT_NE(static_cast<void*>(NULL), Memory(discardables[i].get()));
+    else
+      EXPECT_EQ(DISCARDABLE_MEMORY_PURGED, discardables[i]->Lock());
+  }
+}
+
+TEST_F(DiscardableMemoryProviderTest, NormalDestruction) {
+  {
+    size_t size = 1024;
+    const scoped_ptr<DiscardableMemory> discardable(
+        DiscardableMemory::CreateLockedMemory(size));
+    EXPECT_TRUE(IsRegistered(discardable.get()));
+    EXPECT_EQ(1024u, BytesAllocated());
+  }
+  EXPECT_EQ(0u, BytesAllocated());
+}
+
+TEST_F(DiscardableMemoryProviderTest, DestructionWhileLocked) {
+  {
+    size_t size = 1024;
+    const scoped_ptr<DiscardableMemory> discardable(
+        DiscardableMemory::CreateLockedMemory(size));
+    EXPECT_TRUE(IsRegistered(discardable.get()));
+    EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
+    EXPECT_EQ(1024u, BytesAllocated());
+    EXPECT_FALSE(CanBePurged(discardable.get()));
+  }
+  // Should have ignored the "locked" status and freed the discardable memory.
+  EXPECT_EQ(0u, BytesAllocated());
+}
+
+TEST_F(DiscardableMemoryProviderTest, MemoryAfterUnlock) {
+  size_t size = 1024;
+  const scoped_ptr<DiscardableMemory> discardable(
+      DiscardableMemory::CreateLockedMemory(size));
+  EXPECT_TRUE(IsRegistered(discardable.get()));
+  EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
+  EXPECT_EQ(1024u, BytesAllocated());
+  EXPECT_FALSE(CanBePurged(discardable.get()));
+  discardable->Unlock();
+  EXPECT_TRUE(CanBePurged(discardable.get()));
+  // We *must* die if we are asked to vend a pointer to unlocked memory.
+  EXPECT_DEATH(discardable->Memory(), ".*Check failed.*");
+}
+
+class ThreadedDiscardableMemoryProviderTest
+    : public DiscardableMemoryProviderTest {
+ public:
+  ThreadedDiscardableMemoryProviderTest()
+      : memory_usage_thread_("memory_usage_thread"),
+        thread_sync_(true, false) {
+  }
+
+  virtual void SetUp() OVERRIDE {
+    memory_usage_thread_.Start();
+  }
+
+  virtual void TearDown() OVERRIDE {
+    memory_usage_thread_.Stop();
+  }
+
+  void UseMemoryHelper() {
+    size_t size = 1024;
+    const scoped_ptr<DiscardableMemory> discardable(
+        DiscardableMemory::CreateLockedMemory(size));
+    EXPECT_TRUE(IsRegistered(discardable.get()));
+    EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
+    discardable->Unlock();
+  }
+
+  void SignalHelper() {
+    thread_sync_.Signal();
+  }
+
+  Thread memory_usage_thread_;
+  WaitableEvent thread_sync_;
+};
+
+TEST_F(ThreadedDiscardableMemoryProviderTest, UseMemoryOnThread) {
+  memory_usage_thread_.message_loop()->PostTask(
+      FROM_HERE,
+      Bind(&ThreadedDiscardableMemoryProviderTest::UseMemoryHelper,
+           Unretained(this)));
+  memory_usage_thread_.message_loop()->PostTask(
+      FROM_HERE,
+      Bind(&ThreadedDiscardableMemoryProviderTest::SignalHelper,
+           Unretained(this)));
+  thread_sync_.Wait();
+}
+
+}  // namespace base