PartitionAlloc: Make in-place realloc() less likely to happen

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 674 matching lines @@
     EXPECT_NE(ptr2, ptr);
     char* charPtr = static_cast<char*>(ptr);
     EXPECT_EQ('A', charPtr[0]);
     EXPECT_EQ('A', charPtr[size - 2]);
 #ifndef NDEBUG
     EXPECT_EQ(WTF::kUninitializedByte, static_cast<unsigned char>(charPtr[size - 1]));
 #endif
 
     partitionFreeGeneric(genericAllocator.root(), ptr);
 
-    // Test that shrinking a direct mapped allocation happens in-place (even
-    // though the new size is smaller than kGenericMaxBucketed).
+    // Test that shrinking a direct mapped allocation happens in-place.
     size = WTF::kGenericMaxBucketed + 16 * WTF::kSystemPageSize;
     ptr = partitionAllocGeneric(genericAllocator.root(), size);
     size_t actualSize = partitionAllocGetSize(ptr);
-    ptr2 = partitionReallocGeneric(genericAllocator.root(), ptr, WTF::kGenericMaxBucketed - 16 * WTF::kSystemPageSize);
+    ptr2 = partitionReallocGeneric(genericAllocator.root(), ptr, WTF::kGenericMaxBucketed + 8 * WTF::kSystemPageSize);
     EXPECT_EQ(ptr, ptr2);
-    EXPECT_EQ(actualSize - 32 * WTF::kSystemPageSize, partitionAllocGetSize(ptr2));
+    EXPECT_EQ(actualSize - 8 * WTF::kSystemPageSize, partitionAllocGetSize(ptr2));
 
     // Test that a previously in-place shrunk direct mapped allocation can be
     // expanded up again within its original size.
     ptr = partitionReallocGeneric(genericAllocator.root(), ptr2, size - WTF::kSystemPageSize);
     EXPECT_EQ(ptr2, ptr);
     EXPECT_EQ(actualSize - WTF::kSystemPageSize, partitionAllocGetSize(ptr));
 
-    partitionFreeGeneric(genericAllocator.root(), ptr);
+    // Test that a direct mapped allocation is performed not in-place when the
+    // new size is small enough.
+    ptr2 = partitionReallocGeneric(genericAllocator.root(), ptr, WTF::kSystemPageSize);
+    EXPECT_NE(ptr, ptr2);
+
+    partitionFreeGeneric(genericAllocator.root(), ptr2);
 
     TestShutdown();
 }
 
 // Tests the handing out of freelists for partial pages.
 TEST(PartitionAllocTest, PartialPageFreelists)
 {
     TestSetup();
 
     size_t bigSize = allocator.root()->maxAllocation - kExtraAllocSize;
@@ skipping 452 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)