Improved support for objects inside persistent memory.

base/metrics/persistent_memory_allocator_unittest.cc

 // Copyright 2015 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/metrics/persistent_memory_allocator.h"
 
 #include <memory>
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
@@ skipping 22 matching lines @@
 typedef PersistentMemoryAllocator::Reference Reference;
 
 class PersistentMemoryAllocatorTest : public testing::Test {
  public:
   // This can't be statically initialized because it's value isn't defined
   // in the PersistentMemoryAllocator header file. Instead, it's simply set
   // in the constructor.
   uint32_t kAllocAlignment;
 
   struct TestObject1 {
+    static constexpr uint32_t kPersistentTypeId = 1;
     static constexpr size_t kExpectedInstanceSize = 4 + 1 + 3;
     int32_t onething;
     char oranother;
   };
 
   struct TestObject2 {
+    static constexpr uint32_t kPersistentTypeId = 2;
     static constexpr size_t kExpectedInstanceSize = 8 + 4 + 4 + 8 + 8;
     int64_t thiis;
     int32_t that;
     float andthe;
     double other;
     char thing[8];
   };
 
   PersistentMemoryAllocatorTest() {
     kAllocAlignment = GetAllocAlignment();
@@ skipping 43 matching lines @@
             allocator_->allocs_histogram_->histogram_name());
 
   // Get base memory info for later comparison.
   PersistentMemoryAllocator::MemoryInfo meminfo0;
   allocator_->GetMemoryInfo(&meminfo0);
   EXPECT_EQ(TEST_MEMORY_SIZE, meminfo0.total);
   EXPECT_GT(meminfo0.total, meminfo0.free);
 
   // Validate allocation of test object and make sure it can be referenced
   // and all metadata looks correct.
-  Reference block1 = allocator_->Allocate(sizeof(TestObject1), 1);
-  EXPECT_NE(0U, block1);
-  EXPECT_NE(nullptr, allocator_->GetAsObject<TestObject1>(block1, 1));
-  EXPECT_EQ(nullptr, allocator_->GetAsObject<TestObject2>(block1, 1));
+  TestObject1* obj1 = allocator_->AllocateObject<TestObject1>();
+  ASSERT_TRUE(obj1);
+  Reference block1 = allocator_->GetAsReference(obj1);
+  ASSERT_NE(0U, block1);
+  EXPECT_NE(nullptr, allocator_->GetAsObject<TestObject1>(block1));
+  EXPECT_EQ(nullptr, allocator_->GetAsObject<TestObject2>(block1));
   EXPECT_LE(sizeof(TestObject1), allocator_->GetAllocSize(block1));
   EXPECT_GT(sizeof(TestObject1) + kAllocAlignment,
             allocator_->GetAllocSize(block1));
   PersistentMemoryAllocator::MemoryInfo meminfo1;
   allocator_->GetMemoryInfo(&meminfo1);
   EXPECT_EQ(meminfo0.total, meminfo1.total);
   EXPECT_GT(meminfo0.free, meminfo1.free);
 
   // Verify that pointers can be turned back into references and that invalid
   // addresses return null.
@@ skipping 14 matching lines @@
   EXPECT_EQ(0U, iter1a.GetNext(&type));
   allocator_->MakeIterable(block1);
   EXPECT_EQ(block1, iter1a.GetNext(&type));
   EXPECT_EQ(1U, type);
   EXPECT_EQ(block1, iter1a.GetLast());
   EXPECT_EQ(0U, iter1a.GetNext(&type));
   EXPECT_EQ(block1, iter1a.GetLast());
 
   // Create second test-object and ensure everything is good and it cannot
   // be confused with test-object of another type.
-  Reference block2 = allocator_->Allocate(sizeof(TestObject2), 2);
-  EXPECT_NE(0U, block2);
-  EXPECT_NE(nullptr, allocator_->GetAsObject<TestObject2>(block2, 2));
-  EXPECT_EQ(nullptr, allocator_->GetAsObject<TestObject2>(block2, 1));
+  TestObject2* obj2 = allocator_->AllocateObject<TestObject2>();
+  ASSERT_TRUE(obj2);
+  Reference block2 = allocator_->GetAsReference(obj2);
+  ASSERT_NE(0U, block2);
+  EXPECT_NE(nullptr, allocator_->GetAsObject<TestObject2>(block2));
+  EXPECT_EQ(nullptr, allocator_->GetAsObject<TestObject1>(block2));
   EXPECT_LE(sizeof(TestObject2), allocator_->GetAllocSize(block2));
   EXPECT_GT(sizeof(TestObject2) + kAllocAlignment,
             allocator_->GetAllocSize(block2));
   PersistentMemoryAllocator::MemoryInfo meminfo2;
   allocator_->GetMemoryInfo(&meminfo2);
   EXPECT_EQ(meminfo1.total, meminfo2.total);
   EXPECT_GT(meminfo1.free, meminfo2.free);
 
   // Ensure that second test-object can also be made iterable.
-  allocator_->MakeIterable(block2);
+  allocator_->MakeIterable(obj2);
   EXPECT_EQ(block2, iter1a.GetNext(&type));
   EXPECT_EQ(2U, type);
   EXPECT_EQ(block2, iter1a.GetLast());
   EXPECT_EQ(0U, iter1a.GetNext(&type));
   EXPECT_EQ(block2, iter1a.GetLast());
 
   // Check that the iterator can be reset to the beginning.
   iter1a.Reset();
   EXPECT_EQ(0U, iter1a.GetLast());
   EXPECT_EQ(block1, iter1a.GetNext(&type));
@@ skipping 33 matching lines @@
   EXPECT_EQ(0, allocs_samples->GetCount(0));
   EXPECT_EQ(1, allocs_samples->GetCount(sizeof(TestObject1)));
   EXPECT_EQ(1, allocs_samples->GetCount(sizeof(TestObject2)));
 #if !DCHECK_IS_ON()  // DCHECK builds will die at a NOTREACHED().
   EXPECT_EQ(0U, allocator_->Allocate(TEST_MEMORY_SIZE + 1, 0));
   allocs_samples = allocator_->allocs_histogram_->SnapshotSamples();
   EXPECT_EQ(3, allocs_samples->TotalCount());
   EXPECT_EQ(1, allocs_samples->GetCount(0));
 #endif
 
-  // Check that an objcet's type can be changed.
+  // Check that an object's type can be changed.
   EXPECT_EQ(2U, allocator_->GetType(block2));
   allocator_->ChangeType(block2, 3, 2);
   EXPECT_EQ(3U, allocator_->GetType(block2));
-  allocator_->ChangeType(block2, 2, 3);
+  allocator_->ChangeObject<TestObject2>(block2, 3);
   EXPECT_EQ(2U, allocator_->GetType(block2));
 
   // Create second allocator (read/write) using the same memory segment.
   std::unique_ptr<PersistentMemoryAllocator> allocator2(
       new PersistentMemoryAllocator(mem_segment_.get(), TEST_MEMORY_SIZE,
                                     TEST_MEMORY_PAGE, 0, "", false));
   EXPECT_EQ(TEST_ID, allocator2->Id());
   EXPECT_FALSE(allocator2->used_histogram_);
   EXPECT_FALSE(allocator2->allocs_histogram_);
   EXPECT_NE(allocator2->allocs_histogram_, allocator_->allocs_histogram_);
 
   // Ensure that iteration and access through second allocator works.
   PersistentMemoryAllocator::Iterator iter2(allocator2.get());
   EXPECT_EQ(block1, iter2.GetNext(&type));
   EXPECT_EQ(block2, iter2.GetNext(&type));
   EXPECT_EQ(0U, iter2.GetNext(&type));
-  EXPECT_NE(nullptr, allocator2->GetAsObject<TestObject1>(block1, 1));
-  EXPECT_NE(nullptr, allocator2->GetAsObject<TestObject2>(block2, 2));
+  EXPECT_NE(nullptr, allocator2->GetAsObject<TestObject1>(block1));
+  EXPECT_NE(nullptr, allocator2->GetAsObject<TestObject2>(block2));
 
   // Create a third allocator (read-only) using the same memory segment.
   std::unique_ptr<const PersistentMemoryAllocator> allocator3(
       new PersistentMemoryAllocator(mem_segment_.get(), TEST_MEMORY_SIZE,
                                     TEST_MEMORY_PAGE, 0, "", true));
   EXPECT_EQ(TEST_ID, allocator3->Id());
   EXPECT_FALSE(allocator3->used_histogram_);
   EXPECT_FALSE(allocator3->allocs_histogram_);
 
   // Ensure that iteration and access through third allocator works.
   PersistentMemoryAllocator::Iterator iter3(allocator3.get());
   EXPECT_EQ(block1, iter3.GetNext(&type));
   EXPECT_EQ(block2, iter3.GetNext(&type));
   EXPECT_EQ(0U, iter3.GetNext(&type));
-  EXPECT_NE(nullptr, allocator3->GetAsObject<TestObject1>(block1, 1));
-  EXPECT_NE(nullptr, allocator3->GetAsObject<TestObject2>(block2, 2));
+  EXPECT_NE(nullptr, allocator3->GetAsObject<TestObject1>(block1));
+  EXPECT_NE(nullptr, allocator3->GetAsObject<TestObject2>(block2));
 
   // Ensure that GetNextOfType works.
   PersistentMemoryAllocator::Iterator iter1c(allocator_.get());
-  EXPECT_EQ(block2, iter1c.GetNextOfType(2));
+  EXPECT_EQ(block2, iter1c.GetNextOfType<TestObject2>());
   EXPECT_EQ(0U, iter1c.GetNextOfType(2));
+
+  // Ensure that GetNextOfObject works.
+  PersistentMemoryAllocator::Iterator iter1d(allocator_.get());
+  EXPECT_EQ(obj2, iter1d.GetNextOfObject<TestObject2>());
+  EXPECT_EQ(nullptr, iter1d.GetNextOfObject<TestObject2>());
+
+  // Ensure that deleting an object works.
+  allocator_->DeleteObject(obj2);
+  PersistentMemoryAllocator::Iterator iter1z(allocator_.get());
+  EXPECT_EQ(nullptr, iter1z.GetNextOfObject<TestObject2>());
 }
 
 TEST_F(PersistentMemoryAllocatorTest, PageTest) {
   // This allocation will go into the first memory page.
   Reference block1 = allocator_->Allocate(TEST_MEMORY_PAGE / 2, 1);
   EXPECT_LT(0U, block1);
   EXPECT_GT(TEST_MEMORY_PAGE, block1);
 
   // This allocation won't fit in same page as previous block.
   Reference block2 =
@@ skipping 571 matching lines @@
       // For filesize >= minsize, the file must be acceptable. This
       // else clause (file-not-acceptable) should be reached only if
       // filesize < minsize.
       EXPECT_GT(minsize, filesize);
     }
   }
 }
 #endif  // !defined(OS_NACL)
 
 }  // namespace base