base/memory/discardable_memory_provider_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/memory/discardable_memory_provider.h"
   6
   7 #include "base/bind.h"
   8 #include "base/memory/discardable_memory.h"
   9 #include "base/run_loop.h"
  10 #include "base/synchronization/waitable_event.h"
  11 #include "base/threading/thread.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 namespace base {
  15
  16 class DiscardableMemoryProviderTestBase {
  17  public:
  18   class TestDiscardableMemory : public DiscardableMemory {
  19    public:
  20     TestDiscardableMemory(
  21         internal::DiscardableMemoryProvider* provider, size_t size)
  22         : provider_(provider),
  23           is_locked_(false) {
  24       provider_->Register(this, size);
  25     }
  26
  27     virtual ~TestDiscardableMemory() {
  28       if (is_locked_)
  29         Unlock();
  30       provider_->Unregister(this);
  31     }
  32
  33     // Overridden from DiscardableMemory:
  34     virtual DiscardableMemoryLockStatus Lock() OVERRIDE {
  35       DCHECK(!is_locked_);
  36
  37       bool purged = false;
  38       memory_ = provider_->Acquire(this, &purged);
  39       if (!memory_)
  40         return DISCARDABLE_MEMORY_LOCK_STATUS_FAILED;
  41
  42       is_locked_ = true;
  43       return purged ? DISCARDABLE_MEMORY_LOCK_STATUS_PURGED
  44                     : DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS;
  45     }
  46     virtual void Unlock() OVERRIDE {
  47       DCHECK(is_locked_);
  48       provider_->Release(this, memory_.Pass());
  49       is_locked_ = false;
  50     }
  51     virtual void* Memory() const OVERRIDE {
  52       DCHECK(memory_);
  53       return memory_.get();
  54     }
  55
  56    private:
  57     internal::DiscardableMemoryProvider* provider_;
  58     scoped_ptr<uint8, FreeDeleter> memory_;
  59     bool is_locked_;
  60
  61     DISALLOW_COPY_AND_ASSIGN(TestDiscardableMemory);
  62   };
  63
  64   DiscardableMemoryProviderTestBase()
  65       : provider_(new internal::DiscardableMemoryProvider) {
  66     provider_->RegisterMemoryPressureListener();
  67   }
  68
  69  protected:
  70   bool IsRegistered(const DiscardableMemory* discardable) {
  71     return provider_->IsRegisteredForTest(discardable);
  72   }
  73
  74   bool CanBePurged(const DiscardableMemory* discardable) {
  75     return provider_->CanBePurgedForTest(discardable);
  76   }
  77
  78   size_t BytesAllocated() const {
  79     return provider_->GetBytesAllocatedForTest();
  80   }
  81
  82   void* Memory(const DiscardableMemory* discardable) const {
  83     return discardable->Memory();
  84   }
  85
  86   void SetDiscardableMemoryLimit(size_t bytes) {
  87     provider_->SetDiscardableMemoryLimit(bytes);
  88   }
  89
  90   void SetBytesToReclaimUnderModeratePressure(size_t bytes) {
  91     provider_->SetBytesToReclaimUnderModeratePressure(bytes);
  92   }
  93
  94   scoped_ptr<DiscardableMemory> CreateLockedMemory(size_t size) {
  95     scoped_ptr<TestDiscardableMemory> memory(
  96         new TestDiscardableMemory(provider_.get(), size));
  97     if (memory->Lock() != DISCARDABLE_MEMORY_LOCK_STATUS_PURGED)
  98       return scoped_ptr<DiscardableMemory>();
  99     return memory.PassAs<DiscardableMemory>();
 100   }
 101
 102  private:
 103   MessageLoopForIO message_loop_;
 104   scoped_ptr<internal::DiscardableMemoryProvider> provider_;
 105 };
 106
 107 class DiscardableMemoryProviderTest
 108     : public DiscardableMemoryProviderTestBase,
 109       public testing::Test {
 110  public:
 111   DiscardableMemoryProviderTest() {}
 112 };
 113
 114 TEST_F(DiscardableMemoryProviderTest, CreateLockedMemory) {
 115   size_t size = 1024;
 116   const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
 117   EXPECT_TRUE(IsRegistered(discardable.get()));
 118   EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
 119   EXPECT_EQ(1024u, BytesAllocated());
 120   EXPECT_FALSE(CanBePurged(discardable.get()));
 121 }
 122
 123 TEST_F(DiscardableMemoryProviderTest, CreateLockedMemoryZeroSize) {
 124   size_t size = 0;
 125   const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
 126   EXPECT_FALSE(discardable);
 127   EXPECT_FALSE(IsRegistered(discardable.get()));
 128   EXPECT_EQ(0u, BytesAllocated());
 129 }
 130
 131 TEST_F(DiscardableMemoryProviderTest, LockAfterUnlock) {
 132   size_t size = 1024;
 133   const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
 134   EXPECT_TRUE(IsRegistered(discardable.get()));
 135   EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
 136   EXPECT_EQ(1024u, BytesAllocated());
 137   EXPECT_FALSE(CanBePurged(discardable.get()));
 138
 139   // Now unlock so we can lock later.
 140   discardable->Unlock();
 141   EXPECT_TRUE(CanBePurged(discardable.get()));
 142
 143   EXPECT_EQ(DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS, discardable->Lock());
 144   EXPECT_FALSE(CanBePurged(discardable.get()));
 145 }
 146
 147 TEST_F(DiscardableMemoryProviderTest, LockAfterPurge) {
 148   size_t size = 1024;
 149   const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
 150   EXPECT_TRUE(IsRegistered(discardable.get()));
 151   EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
 152   EXPECT_EQ(1024u, BytesAllocated());
 153   EXPECT_FALSE(CanBePurged(discardable.get()));
 154
 155   // Now unlock so we can lock later.
 156   discardable->Unlock();
 157   EXPECT_TRUE(CanBePurged(discardable.get()));
 158
 159   // Force the system to purge.
 160   MemoryPressureListener::NotifyMemoryPressure(
 161       MemoryPressureListener::MEMORY_PRESSURE_CRITICAL);
 162
 163   // Required because ObserverListThreadSafe notifies via PostTask.
 164   RunLoop().RunUntilIdle();
 165
 166   EXPECT_EQ(DISCARDABLE_MEMORY_LOCK_STATUS_PURGED, discardable->Lock());
 167   EXPECT_FALSE(CanBePurged(discardable.get()));
 168 }
 169
 170 TEST_F(DiscardableMemoryProviderTest, LockAfterPurgeAndCannotReallocate) {
 171   size_t size = 1024;
 172   const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
 173   EXPECT_TRUE(IsRegistered(discardable.get()));
 174   EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
 175   EXPECT_EQ(1024u, BytesAllocated());
 176   EXPECT_FALSE(CanBePurged(discardable.get()));
 177
 178   // Now unlock so we can lock later.
 179   discardable->Unlock();
 180   EXPECT_TRUE(CanBePurged(discardable.get()));
 181
 182   // Set max allowed allocation to 1 byte. This will make cause the memory
 183   // to be purged.
 184   SetDiscardableMemoryLimit(1);
 185
 186   EXPECT_EQ(DISCARDABLE_MEMORY_LOCK_STATUS_PURGED, discardable->Lock());
 187   EXPECT_FALSE(CanBePurged(discardable.get()));
 188 }
 189
 190 TEST_F(DiscardableMemoryProviderTest, Overflow) {
 191   {
 192     size_t size = 1024;
 193     const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
 194     EXPECT_TRUE(IsRegistered(discardable.get()));
 195     EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
 196     EXPECT_EQ(1024u, BytesAllocated());
 197
 198     size_t massive_size = std::numeric_limits<size_t>::max();
 199     const scoped_ptr<DiscardableMemory> massive_discardable(
 200         CreateLockedMemory(massive_size));
 201     EXPECT_FALSE(massive_discardable);
 202     EXPECT_EQ(1024u, BytesAllocated());
 203   }
 204   EXPECT_EQ(0u, BytesAllocated());
 205 }
 206
 207 class PermutationTestData {
 208  public:
 209   PermutationTestData(unsigned d0, unsigned d1, unsigned d2) {
 210     ordering_[0] = d0;
 211     ordering_[1] = d1;
 212     ordering_[2] = d2;
 213   }
 214
 215   const unsigned* ordering() const { return ordering_; }
 216
 217  private:
 218   unsigned ordering_[3];
 219 };
 220
 221 class DiscardableMemoryProviderPermutationTest
 222     : public DiscardableMemoryProviderTestBase,
 223       public testing::TestWithParam<PermutationTestData> {
 224  public:
 225   DiscardableMemoryProviderPermutationTest() {}
 226
 227  protected:
 228   // Use discardable memory in order specified by ordering parameter.
 229   void CreateAndUseDiscardableMemory() {
 230     for (int i = 0; i < 3; ++i) {
 231       discardables_[i] = CreateLockedMemory(1024);
 232       EXPECT_TRUE(discardables_[i]);
 233       EXPECT_NE(static_cast<void*>(NULL), Memory(discardables_[i].get()));
 234       discardables_[i]->Unlock();
 235     }
 236     for (int i = 0; i < 3; ++i) {
 237       int index = GetParam().ordering()[i];
 238       EXPECT_NE(DISCARDABLE_MEMORY_LOCK_STATUS_FAILED,
 239                 discardables_[index]->Lock());
 240       // Leave i == 0 locked.
 241       if (i > 0)
 242         discardables_[index]->Unlock();
 243     }
 244   }
 245
 246   DiscardableMemory* discardable(unsigned position) {
 247     return discardables_[GetParam().ordering()[position]].get();
 248   }
 249
 250  private:
 251   scoped_ptr<DiscardableMemory> discardables_[3];
 252 };
 253
 254 // Verify that memory was discarded in the correct order after applying
 255 // memory pressure.
 256 TEST_P(DiscardableMemoryProviderPermutationTest, LRUDiscardedModeratePressure) {
 257   CreateAndUseDiscardableMemory();
 258
 259   SetBytesToReclaimUnderModeratePressure(1024);
 260   MemoryPressureListener::NotifyMemoryPressure(
 261       MemoryPressureListener::MEMORY_PRESSURE_MODERATE);
 262   RunLoop().RunUntilIdle();
 263
 264   EXPECT_NE(DISCARDABLE_MEMORY_LOCK_STATUS_FAILED, discardable(2)->Lock());
 265   EXPECT_NE(DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS, discardable(1)->Lock());
 266   // 0 should still be locked.
 267   EXPECT_NE(static_cast<void*>(NULL), Memory(discardable(0)));
 268 }
 269
 270 // Verify that memory was discarded in the correct order after changing
 271 // memory limit.
 272 TEST_P(DiscardableMemoryProviderPermutationTest, LRUDiscardedExceedLimit) {
 273   CreateAndUseDiscardableMemory();
 274
 275   SetBytesToReclaimUnderModeratePressure(1024);
 276   SetDiscardableMemoryLimit(2048);
 277
 278   EXPECT_NE(DISCARDABLE_MEMORY_LOCK_STATUS_FAILED, discardable(2)->Lock());
 279   EXPECT_NE(DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS, discardable(1)->Lock());
 280   // 0 should still be locked.
 281   EXPECT_NE(static_cast<void*>(NULL), Memory(discardable(0)));
 282 }
 283
 284 // Verify that no more memory than necessary was discarded after changing
 285 // memory limit.
 286 TEST_P(DiscardableMemoryProviderPermutationTest, LRUDiscardedAmount) {
 287   SetBytesToReclaimUnderModeratePressure(2048);
 288   SetDiscardableMemoryLimit(4096);
 289
 290   CreateAndUseDiscardableMemory();
 291
 292   SetDiscardableMemoryLimit(2048);
 293
 294   EXPECT_EQ(DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS, discardable(2)->Lock());
 295   EXPECT_EQ(DISCARDABLE_MEMORY_LOCK_STATUS_PURGED, discardable(1)->Lock());
 296   // 0 should still be locked.
 297   EXPECT_NE(static_cast<void*>(NULL), Memory(discardable(0)));
 298 }
 299
 300 TEST_P(DiscardableMemoryProviderPermutationTest,
 301        CriticalPressureFreesAllUnlocked) {
 302   CreateAndUseDiscardableMemory();
 303
 304   MemoryPressureListener::NotifyMemoryPressure(
 305       MemoryPressureListener::MEMORY_PRESSURE_CRITICAL);
 306   RunLoop().RunUntilIdle();
 307
 308   for (int i = 0; i < 3; ++i) {
 309     if (i == 0)
 310       EXPECT_NE(static_cast<void*>(NULL), Memory(discardable(i)));
 311     else
 312       EXPECT_EQ(DISCARDABLE_MEMORY_LOCK_STATUS_PURGED, discardable(i)->Lock());
 313   }
 314 }
 315
 316 INSTANTIATE_TEST_CASE_P(DiscardableMemoryProviderPermutationTests,
 317                         DiscardableMemoryProviderPermutationTest,
 318                         ::testing::Values(PermutationTestData(0, 1, 2),
 319                                           PermutationTestData(0, 2, 1),
 320                                           PermutationTestData(1, 0, 2),
 321                                           PermutationTestData(1, 2, 0),
 322                                           PermutationTestData(2, 0, 1),
 323                                           PermutationTestData(2, 1, 0)));
 324
 325 TEST_F(DiscardableMemoryProviderTest, NormalDestruction) {
 326   {
 327     size_t size = 1024;
 328     const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
 329     EXPECT_TRUE(IsRegistered(discardable.get()));
 330     EXPECT_EQ(1024u, BytesAllocated());
 331   }
 332   EXPECT_EQ(0u, BytesAllocated());
 333 }
 334
 335 TEST_F(DiscardableMemoryProviderTest, DestructionWhileLocked) {
 336   {
 337     size_t size = 1024;
 338     const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
 339     EXPECT_TRUE(IsRegistered(discardable.get()));
 340     EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
 341     EXPECT_EQ(1024u, BytesAllocated());
 342     EXPECT_FALSE(CanBePurged(discardable.get()));
 343   }
 344   // Should have ignored the "locked" status and freed the discardable memory.
 345   EXPECT_EQ(0u, BytesAllocated());
 346 }
 347
 348 #if !defined(NDEBUG) && !defined(OS_ANDROID) && !defined(OS_IOS)
 349 // Death tests are not supported with Android APKs.
 350 TEST_F(DiscardableMemoryProviderTest, UnlockedMemoryAccessCrashesInDebugMode) {
 351   size_t size = 1024;
 352   const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
 353   EXPECT_TRUE(IsRegistered(discardable.get()));
 354   EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
 355   EXPECT_EQ(1024u, BytesAllocated());
 356   EXPECT_FALSE(CanBePurged(discardable.get()));
 357   discardable->Unlock();
 358   EXPECT_TRUE(CanBePurged(discardable.get()));
 359   // We *must* die if we are asked to vend a pointer to unlocked memory.
 360   EXPECT_DEATH(discardable->Memory(), ".*Check failed.*");
 361 }
 362 #endif
 363
 364 class ThreadedDiscardableMemoryProviderTest
 365     : public DiscardableMemoryProviderTest {
 366  public:
 367   ThreadedDiscardableMemoryProviderTest()
 368       : memory_usage_thread_("memory_usage_thread"),
 369         thread_sync_(true, false) {
 370   }
 371
 372   virtual void SetUp() OVERRIDE {
 373     memory_usage_thread_.Start();
 374   }
 375
 376   virtual void TearDown() OVERRIDE {
 377     memory_usage_thread_.Stop();
 378   }
 379
 380   void UseMemoryHelper() {
 381     size_t size = 1024;
 382     const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
 383     EXPECT_TRUE(IsRegistered(discardable.get()));
 384     EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
 385     discardable->Unlock();
 386   }
 387
 388   void SignalHelper() {
 389     thread_sync_.Signal();
 390   }
 391
 392   Thread memory_usage_thread_;
 393   WaitableEvent thread_sync_;
 394 };
 395
 396 TEST_F(ThreadedDiscardableMemoryProviderTest, UseMemoryOnThread) {
 397   memory_usage_thread_.message_loop()->PostTask(
 398       FROM_HERE,
 399       Bind(&ThreadedDiscardableMemoryProviderTest::UseMemoryHelper,
 400            Unretained(this)));
 401   memory_usage_thread_.message_loop()->PostTask(
 402       FROM_HERE,
 403       Bind(&ThreadedDiscardableMemoryProviderTest::SignalHelper,
 404            Unretained(this)));
 405   thread_sync_.Wait();
 406 }
 407
 408 }  // namespace base