base/memory/discardable_shared_memory_unittest.cc

   1 // Copyright 2014 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/basictypes.h"
   6 #include "base/memory/discardable_shared_memory.h"
   7 #include "base/process/process_metrics.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 namespace base {
  11 namespace {
  12
  13 class TestDiscardableSharedMemory : public DiscardableSharedMemory {
  14  public:
  15   TestDiscardableSharedMemory() {}
  16
  17   explicit TestDiscardableSharedMemory(SharedMemoryHandle handle)
  18       : DiscardableSharedMemory(handle) {}
  19
  20   void SetNow(Time now) { now_ = now; }
  21
  22  private:
  23   // Overriden from DiscardableSharedMemory:
  24   Time Now() const override { return now_; }
  25
  26   Time now_;
  27 };
  28
  29 TEST(DiscardableSharedMemoryTest, CreateAndMap) {
  30   const uint32 kDataSize = 1024;
  31
  32   TestDiscardableSharedMemory memory;
  33   bool rv = memory.CreateAndMap(kDataSize);
  34   ASSERT_TRUE(rv);
  35   EXPECT_GE(memory.mapped_size(), kDataSize);
  36 }
  37
  38 TEST(DiscardableSharedMemoryTest, CreateFromHandle) {
  39   const uint32 kDataSize = 1024;
  40
  41   TestDiscardableSharedMemory memory1;
  42   bool rv = memory1.CreateAndMap(kDataSize);
  43   ASSERT_TRUE(rv);
  44
  45   SharedMemoryHandle shared_handle;
  46   ASSERT_TRUE(
  47       memory1.ShareToProcess(GetCurrentProcessHandle(), &shared_handle));
  48   ASSERT_TRUE(SharedMemory::IsHandleValid(shared_handle));
  49
  50   TestDiscardableSharedMemory memory2(shared_handle);
  51   rv = memory2.Map(kDataSize);
  52   ASSERT_TRUE(rv);
  53 }
  54
  55 TEST(DiscardableSharedMemoryTest, LockAndUnlock) {
  56   const uint32 kDataSize = 1024;
  57
  58   TestDiscardableSharedMemory memory1;
  59   bool rv = memory1.CreateAndMap(kDataSize);
  60   ASSERT_TRUE(rv);
  61
  62   // Memory is initially locked. Unlock it.
  63   memory1.SetNow(Time::FromDoubleT(1));
  64   memory1.Unlock(0, 0);
  65
  66   // Lock and unlock memory.
  67   auto lock_rv = memory1.Lock(0, 0);
  68   EXPECT_EQ(DiscardableSharedMemory::SUCCESS, lock_rv);
  69   memory1.SetNow(Time::FromDoubleT(2));
  70   memory1.Unlock(0, 0);
  71
  72   // Lock again before duplicating and passing ownership to new instance.
  73   lock_rv = memory1.Lock(0, 0);
  74   EXPECT_EQ(DiscardableSharedMemory::SUCCESS, lock_rv);
  75
  76   SharedMemoryHandle shared_handle;
  77   ASSERT_TRUE(
  78       memory1.ShareToProcess(GetCurrentProcessHandle(), &shared_handle));
  79   ASSERT_TRUE(SharedMemory::IsHandleValid(shared_handle));
  80
  81   TestDiscardableSharedMemory memory2(shared_handle);
  82   rv = memory2.Map(kDataSize);
  83   ASSERT_TRUE(rv);
  84
  85   // Unlock second instance.
  86   memory2.SetNow(Time::FromDoubleT(3));
  87   memory2.Unlock(0, 0);
  88
  89   // Lock second instance before passing ownership back to first instance.
  90   lock_rv = memory2.Lock(0, 0);
  91   EXPECT_EQ(DiscardableSharedMemory::SUCCESS, lock_rv);
  92
  93   // Memory should still be resident.
  94   rv = memory1.IsMemoryResident();
  95   EXPECT_TRUE(rv);
  96
  97   // Unlock first instance.
  98   memory1.SetNow(Time::FromDoubleT(4));
  99   memory1.Unlock(0, 0);
 100 }
 101
 102 TEST(DiscardableSharedMemoryTest, Purge) {
 103   const uint32 kDataSize = 1024;
 104
 105   TestDiscardableSharedMemory memory1;
 106   bool rv = memory1.CreateAndMap(kDataSize);
 107   ASSERT_TRUE(rv);
 108
 109   SharedMemoryHandle shared_handle;
 110   ASSERT_TRUE(
 111       memory1.ShareToProcess(GetCurrentProcessHandle(), &shared_handle));
 112   ASSERT_TRUE(SharedMemory::IsHandleValid(shared_handle));
 113
 114   TestDiscardableSharedMemory memory2(shared_handle);
 115   rv = memory2.Map(kDataSize);
 116   ASSERT_TRUE(rv);
 117
 118   // This should fail as memory is locked.
 119   rv = memory1.Purge(Time::FromDoubleT(1));
 120   EXPECT_FALSE(rv);
 121
 122   memory2.SetNow(Time::FromDoubleT(2));
 123   memory2.Unlock(0, 0);
 124
 125   ASSERT_TRUE(memory2.IsMemoryResident());
 126
 127   // Memory is unlocked, but our usage timestamp is incorrect.
 128   rv = memory1.Purge(Time::FromDoubleT(3));
 129   EXPECT_FALSE(rv);
 130
 131   ASSERT_TRUE(memory2.IsMemoryResident());
 132
 133   // Memory is unlocked and our usage timestamp should be correct.
 134   rv = memory1.Purge(Time::FromDoubleT(4));
 135   EXPECT_TRUE(rv);
 136
 137   // Lock should fail as memory has been purged.
 138   auto lock_rv = memory2.Lock(0, 0);
 139   EXPECT_EQ(DiscardableSharedMemory::FAILED, lock_rv);
 140
 141   ASSERT_FALSE(memory2.IsMemoryResident());
 142 }
 143
 144 TEST(DiscardableSharedMemoryTest, LastUsed) {
 145   const uint32 kDataSize = 1024;
 146
 147   TestDiscardableSharedMemory memory1;
 148   bool rv = memory1.CreateAndMap(kDataSize);
 149   ASSERT_TRUE(rv);
 150
 151   SharedMemoryHandle shared_handle;
 152   ASSERT_TRUE(
 153       memory1.ShareToProcess(GetCurrentProcessHandle(), &shared_handle));
 154   ASSERT_TRUE(SharedMemory::IsHandleValid(shared_handle));
 155
 156   TestDiscardableSharedMemory memory2(shared_handle);
 157   rv = memory2.Map(kDataSize);
 158   ASSERT_TRUE(rv);
 159
 160   memory2.SetNow(Time::FromDoubleT(1));
 161   memory2.Unlock(0, 0);
 162
 163   EXPECT_EQ(memory2.last_known_usage(), Time::FromDoubleT(1));
 164
 165   auto lock_rv = memory2.Lock(0, 0);
 166   EXPECT_EQ(DiscardableSharedMemory::SUCCESS, lock_rv);
 167
 168   // This should fail as memory is locked.
 169   rv = memory1.Purge(Time::FromDoubleT(2));
 170   ASSERT_FALSE(rv);
 171
 172   // Last usage should have been updated to timestamp passed to Purge above.
 173   EXPECT_EQ(memory1.last_known_usage(), Time::FromDoubleT(2));
 174
 175   memory2.SetNow(Time::FromDoubleT(3));
 176   memory2.Unlock(0, 0);
 177
 178   // Usage time should be correct for |memory2| instance.
 179   EXPECT_EQ(memory2.last_known_usage(), Time::FromDoubleT(3));
 180
 181   // However, usage time has not changed as far as |memory1| instance knows.
 182   EXPECT_EQ(memory1.last_known_usage(), Time::FromDoubleT(2));
 183
 184   // Memory is unlocked, but our usage timestamp is incorrect.
 185   rv = memory1.Purge(Time::FromDoubleT(4));
 186   EXPECT_FALSE(rv);
 187
 188   // The failed purge attempt should have updated usage time to the correct
 189   // value.
 190   EXPECT_EQ(memory1.last_known_usage(), Time::FromDoubleT(3));
 191
 192   // Purge memory through |memory2| instance. The last usage time should be
 193   // set to 0 as a result of this.
 194   rv = memory2.Purge(Time::FromDoubleT(5));
 195   EXPECT_TRUE(rv);
 196   EXPECT_TRUE(memory2.last_known_usage().is_null());
 197
 198   // This should fail as memory has already been purged and |memory1|'s usage
 199   // time is incorrect as a result.
 200   rv = memory1.Purge(Time::FromDoubleT(6));
 201   EXPECT_FALSE(rv);
 202
 203   // The failed purge attempt should have updated usage time to the correct
 204   // value.
 205   EXPECT_TRUE(memory1.last_known_usage().is_null());
 206
 207   // Purge should succeed now that usage time is correct.
 208   rv = memory1.Purge(Time::FromDoubleT(7));
 209   EXPECT_TRUE(rv);
 210 }
 211
 212 TEST(DiscardableSharedMemoryTest, LockShouldAlwaysFailAfterSuccessfulPurge) {
 213   const uint32 kDataSize = 1024;
 214
 215   TestDiscardableSharedMemory memory1;
 216   bool rv = memory1.CreateAndMap(kDataSize);
 217   ASSERT_TRUE(rv);
 218
 219   SharedMemoryHandle shared_handle;
 220   ASSERT_TRUE(
 221       memory1.ShareToProcess(GetCurrentProcessHandle(), &shared_handle));
 222   ASSERT_TRUE(SharedMemory::IsHandleValid(shared_handle));
 223
 224   TestDiscardableSharedMemory memory2(shared_handle);
 225   rv = memory2.Map(kDataSize);
 226   ASSERT_TRUE(rv);
 227
 228   memory2.SetNow(Time::FromDoubleT(1));
 229   memory2.Unlock(0, 0);
 230
 231   rv = memory2.Purge(Time::FromDoubleT(2));
 232   EXPECT_TRUE(rv);
 233
 234   // Lock should fail as memory has been purged.
 235   auto lock_rv = memory2.Lock(0, 0);
 236   EXPECT_EQ(DiscardableSharedMemory::FAILED, lock_rv);
 237 }
 238
 239 TEST(DiscardableSharedMemoryTest, LockAndUnlockRange) {
 240   const uint32 kDataSize = 32;
 241
 242   uint32 data_size_in_bytes = kDataSize * base::GetPageSize();
 243
 244   TestDiscardableSharedMemory memory1;
 245   bool rv = memory1.CreateAndMap(data_size_in_bytes);
 246   ASSERT_TRUE(rv);
 247
 248   SharedMemoryHandle shared_handle;
 249   ASSERT_TRUE(
 250       memory1.ShareToProcess(GetCurrentProcessHandle(), &shared_handle));
 251   ASSERT_TRUE(SharedMemory::IsHandleValid(shared_handle));
 252
 253   TestDiscardableSharedMemory memory2(shared_handle);
 254   rv = memory2.Map(data_size_in_bytes);
 255   ASSERT_TRUE(rv);
 256
 257   // Unlock first page.
 258   memory2.SetNow(Time::FromDoubleT(1));
 259   memory2.Unlock(0, base::GetPageSize());
 260
 261   rv = memory1.Purge(Time::FromDoubleT(2));
 262   EXPECT_FALSE(rv);
 263
 264   // Lock first page again.
 265   memory2.SetNow(Time::FromDoubleT(3));
 266   auto lock_rv = memory2.Lock(0, base::GetPageSize());
 267   EXPECT_NE(DiscardableSharedMemory::FAILED, lock_rv);
 268
 269   // Unlock first page.
 270   memory2.SetNow(Time::FromDoubleT(4));
 271   memory2.Unlock(0, base::GetPageSize());
 272
 273   rv = memory1.Purge(Time::FromDoubleT(5));
 274   EXPECT_FALSE(rv);
 275
 276   // Unlock second page.
 277   memory2.SetNow(Time::FromDoubleT(6));
 278   memory2.Unlock(base::GetPageSize(), base::GetPageSize());
 279
 280   rv = memory1.Purge(Time::FromDoubleT(7));
 281   EXPECT_FALSE(rv);
 282
 283   // Unlock anything onwards.
 284   memory2.SetNow(Time::FromDoubleT(8));
 285   memory2.Unlock(2 * base::GetPageSize(), 0);
 286
 287   // Memory is unlocked, but our usage timestamp is incorrect.
 288   rv = memory1.Purge(Time::FromDoubleT(9));
 289   EXPECT_FALSE(rv);
 290
 291   // The failed purge attempt should have updated usage time to the correct
 292   // value.
 293   EXPECT_EQ(Time::FromDoubleT(8), memory1.last_known_usage());
 294
 295   // Purge should now succeed.
 296   rv = memory1.Purge(Time::FromDoubleT(10));
 297   EXPECT_TRUE(rv);
 298 }
 299
 300 TEST(DiscardableSharedMemoryTest, MappedSize) {
 301   const uint32 kDataSize = 1024;
 302
 303   TestDiscardableSharedMemory memory;
 304   bool rv = memory.CreateAndMap(kDataSize);
 305   ASSERT_TRUE(rv);
 306
 307   EXPECT_LE(kDataSize, memory.mapped_size());
 308
 309   // Mapped size should be 0 after memory segment has been unmapped.
 310   rv = memory.Unmap();
 311   EXPECT_TRUE(rv);
 312   EXPECT_EQ(0u, memory.mapped_size());
 313 }
 314
 315 TEST(DiscardableSharedMemoryTest, Close) {
 316   const uint32 kDataSize = 1024;
 317
 318   TestDiscardableSharedMemory memory;
 319   bool rv = memory.CreateAndMap(kDataSize);
 320   ASSERT_TRUE(rv);
 321
 322   // Mapped size should be unchanged after memory segment has been closed.
 323   memory.Close();
 324   EXPECT_LE(kDataSize, memory.mapped_size());
 325
 326   // Memory is initially locked. Unlock it.
 327   memory.SetNow(Time::FromDoubleT(1));
 328   memory.Unlock(0, 0);
 329
 330   // Lock and unlock memory.
 331   auto lock_rv = memory.Lock(0, 0);
 332   EXPECT_EQ(DiscardableSharedMemory::SUCCESS, lock_rv);
 333   memory.SetNow(Time::FromDoubleT(2));
 334   memory.Unlock(0, 0);
 335 }
 336
 337 #if defined(DISCARDABLE_SHARED_MEMORY_SHRINKING)
 338 TEST(DiscardableSharedMemoryTest, Shrink) {
 339   const uint32 kDataSize = 1024;
 340
 341   TestDiscardableSharedMemory memory;
 342   bool rv = memory.CreateAndMap(kDataSize);
 343   ASSERT_TRUE(rv);
 344
 345   EXPECT_NE(0u, memory.mapped_size());
 346
 347   // Mapped size should be 0 after shrinking memory segment.
 348   memory.Shrink();
 349   EXPECT_EQ(0u, memory.mapped_size());
 350 }
 351 #endif
 352
 353 }  // namespace
 354 }  // namespace base