Add partitionAllocGetSize() for determining actual size of allocation

Source/wtf/PartitionAllocTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 556 matching lines @@
 
     // Can we free null?
     partitionFreeGeneric(genericAllocator.root(), 0);
 
     // Do we correctly get a null for a failed allocation?
     EXPECT_EQ(0, partitionAllocGenericFlags(genericAllocator.root(), WTF::PartitionAllocReturnNull, 3u * 1024 * 1024 * 1024));
 
     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)
 {
     TestSetup();
 
     // realloc(0, size) should be equivalent to malloc().
     void* ptr = partitionReallocGeneric(genericAllocator.root(), 0, kTestAllocSize);
     memset(ptr, 'A', kTestAllocSize);
     WTF::PartitionPage* page = WTF::partitionPointerToPage(WTF::partitionCookieFreePointerAdjust(ptr));
     // realloc(ptr, 0) should be equivalent to free().
@@ skipping 399 matching lines @@
     EXPECT_EQ(32u, WTF::countLeadingZerosSizet(0));
     EXPECT_EQ(31u, WTF::countLeadingZerosSizet(1));
     EXPECT_EQ(1u, WTF::countLeadingZerosSizet(1 << 30));
     EXPECT_EQ(0u, WTF::countLeadingZerosSizet(1 << 31));
 #endif
 }
 
 } // namespace
 
 #endif // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)