Add partitionAllocGetSize() for determining actual size of allocation

Source/wtf/PartitionAllocTest.cpp

Index: Source/wtf/PartitionAllocTest.cpp
diff --git a/Source/wtf/PartitionAllocTest.cpp b/Source/wtf/PartitionAllocTest.cpp
index aef6f5c86b35ca3d8c32e08be56288b9d716ef1f..0fe399aa72a5890419360a5e5d036570c280e9c4 100644
--- a/Source/wtf/PartitionAllocTest.cpp
+++ b/Source/wtf/PartitionAllocTest.cpp
@@ -574,6 +574,53 @@ TEST(WTF_PartitionAlloc, GenericAllocSizes)
     TestShutdown();
 }
 
+// Test that we can fetch the real allocated size after an allocation.
+TEST(WTF_PartitionAlloc, GenericAllocGetSize)
+{
+    TestSetup();
+
+    void* ptr;
+    size_t requestedSize, actualSize;
+
+    // Allocate something small.
+    requestedSize = 512;

[Chris Evans, 2014/02/18 22:19:59]

I think you might need to adjust the size depending on whether it's debug or
release. Otherwise you'll be testing two different underlying bucket sizes. You
can use the existing "adjustment" constant as used elsewhere in the file.

[Chris Evans, 2014/02/18 22:19:59]

I have another idea. Can we make all the sizes odd? i.e. 511 instead of 512. We
guarantee better-than-even alignment so we can tighten the conditions to
EXPECT_LT(), gaining a better test.

+    ptr = partitionAllocGeneric(genericAllocator.root(), requestedSize);
+    EXPECT_TRUE(ptr);
+    actualSize = partitionAllocGetSize(genericAllocator.root(), ptr);
+    EXPECT_LE(requestedSize, actualSize);
+    partitionFreeGeneric(genericAllocator.root(), ptr);
+
+    // Allocate something slightly larger.
+    requestedSize = 200 * 1024;
+    ptr = partitionAllocGeneric(genericAllocator.root(), requestedSize);
+    EXPECT_TRUE(ptr);
+    actualSize = partitionAllocGetSize(genericAllocator.root(), ptr);
+    EXPECT_LE(requestedSize, actualSize);
+    partitionFreeGeneric(genericAllocator.root(), ptr);
+
+    // Allocate something slightly larger and uneven. GetSize() should return a
+    // larger size than we asked for now.
+    requestedSize = 200 * 1024 + 250;

[Chris Evans, 2014/02/18 22:19:59]

A nicer size to test might be (256 * 1024) - kSystemPageSize. Should in theory
round up to 256KB. For now, I'd also be OK hard-coding this round-up in to the
test. I don't see the design ever changing such that a perfect power-of-two is
not an exact allocation size.

+    ptr = partitionAllocGeneric(genericAllocator.root(), requestedSize);
+    EXPECT_TRUE(ptr);
+    actualSize = partitionAllocGetSize(genericAllocator.root(), ptr);
+    EXPECT_LT(requestedSize, actualSize);
+    // Check that we can write at the end of the reported size too.
+    char* charPtr = reinterpret_cast<char*>(ptr);
+    *(charPtr + (actualSize - 1)) = 'A';
+    partitionFreeGeneric(genericAllocator.root(), ptr);
+
+    // Allocate something very large. GetSize() should return zero.

[Chris Evans, 2014/02/18 22:19:59]

Does this actually happen? I see that you're testing with EXPECT_LE so maybe it
does not return zero. It should not.

+    requestedSize = 512 * 1024 * 1024;
+    ptr = partitionAllocGeneric(genericAllocator.root(), requestedSize);
+    EXPECT_TRUE(ptr);
+    actualSize = partitionAllocGetSize(genericAllocator.root(), ptr);
+    EXPECT_LE(requestedSize, actualSize);
+    partitionFreeGeneric(genericAllocator.root(), ptr);
+
+    TestShutdown();
+}
+
 // Test the realloc() contract.
 TEST(WTF_PartitionAlloc, Realloc)
 {