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;
+
+    EXPECT_TRUE(partitionAllocSupportsGetSize());
+
+    // Allocate something small.
+    requestedSize = 511 - kExtraAllocSize;
+    ptr = partitionAllocGeneric(genericAllocator.root(), requestedSize);
+    EXPECT_TRUE(ptr);
+    actualSize = partitionAllocGetSize(ptr);
+    EXPECT_LT(requestedSize, actualSize);
+    partitionFreeGeneric(genericAllocator.root(), ptr);
+
+    // Allocate a size that should be a perfect match for a bucket, because it
+    // is an exact power of 2.
+    requestedSize = (256 * 1024) - kExtraAllocSize;
+    ptr = partitionAllocGeneric(genericAllocator.root(), requestedSize);
+    EXPECT_TRUE(ptr);
+    actualSize = partitionAllocGetSize(ptr);
+    EXPECT_EQ(requestedSize, actualSize);
+    partitionFreeGeneric(genericAllocator.root(), ptr);
+
+    // Allocate a size that is a system page smaller than a bucket. GetSize()
+    // should return a larger size than we asked for now.
+    requestedSize = (256 * 1024) - WTF::kSystemPageSize - kExtraAllocSize;
+    ptr = partitionAllocGeneric(genericAllocator.root(), requestedSize);
+    EXPECT_TRUE(ptr);
+    actualSize = partitionAllocGetSize(ptr);
+    EXPECT_EQ(requestedSize + WTF::kSystemPageSize, 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, and uneven.
+    requestedSize = 512 * 1024 * 1024 - 1;
+    ptr = partitionAllocGeneric(genericAllocator.root(), requestedSize);
+    EXPECT_TRUE(ptr);
+    actualSize = partitionAllocGetSize(ptr);
+    EXPECT_LT(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)