Enhancements to PartitionAlloc to support threading and arbitrary allocation sizes.

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 343 matching lines @@
                 EXPECT_EQ(0u, secondSuperPageBase & WTF::kSuperPageOffsetMask);
         }
     }
     for (i = 0; i < numPagesNeeded; ++i) {
         FreeFullPage(pages[i], kTestAllocSize);
     }
 
     TestShutdown();
 }
 
+// Test the generic allocation functions that can handle arbitrary sizes and
+// reallocing etc.
+TEST(WTF_PartitionAlloc, GenericAlloc)
+{
+    TestSetup();
+
+    void* ptr = partitionAllocGeneric(&root, 1);
+    EXPECT_TRUE(ptr);
+    partitionFreeGeneric(ptr, 1);
+    ptr = partitionAllocGeneric(&root, WTF::kMaxAllocation + 1);
+    EXPECT_TRUE(ptr);
+    partitionFreeGeneric(ptr, WTF::kMaxAllocation + 1);
+
+    ptr = partitionAllocGeneric(&root, 1);
+    EXPECT_TRUE(ptr);
+    void* origPtr = ptr;
+    char* charPtr = static_cast<char*>(ptr);
+    *charPtr = 'A';
+
+    // Change the size of the realloc, remaining inside the same bucket.
+    void* newPtr = partitionReallocGeneric(&root, ptr, 1, 2);
+    EXPECT_EQ(ptr, newPtr);
+    newPtr = partitionReallocGeneric(&root, ptr, 2, 1);
+    EXPECT_EQ(ptr, newPtr);
+
+    // Change the size of the realloc, switching buckets.
+    newPtr = partitionReallocGeneric(&root, ptr, 1, WTF::kAllocationGranularity + 1);
+    EXPECT_TRUE(newPtr != ptr);
+    // Check that the realloc copied correctly.
+    char* newCharPtr = static_cast<char*>(newPtr);
+    EXPECT_EQ(*newCharPtr, 'A');
+    *newCharPtr = 'B';
+    // The realloc moved. To check that the old allocation was freed, we can
+    // do an alloc of the old allocation size and check that the old allocation
+    // address is at the head of the freelist and reused.
+    void* reusedPtr = partitionAllocGeneric(&root, 1);
+    EXPECT_EQ(reusedPtr, origPtr);
+    partitionFreeGeneric(reusedPtr, 1);
+
+    // Downsize the realloc.
+    ptr = newPtr;
+    newPtr = partitionReallocGeneric(&root, ptr, WTF::kAllocationGranularity + 1, 1);
+    EXPECT_EQ(newPtr, origPtr);
+    newCharPtr = static_cast<char*>(newPtr);
+    EXPECT_EQ(*newCharPtr, 'B');
+    *newCharPtr = 'C';
+
+    // Upsize the realloc to outside the partition.
+    ptr = newPtr;
+    newPtr = partitionReallocGeneric(&root, ptr, 1, WTF::kMaxAllocation + 1);
+    EXPECT_TRUE(newPtr != ptr);
+    newCharPtr = static_cast<char*>(newPtr);
+    EXPECT_EQ(*newCharPtr, 'C');
+    *newCharPtr = 'D';
+
+    // Upsize and downsize the realloc, remaining outside the partition.
+    ptr = newPtr;
+    newPtr = partitionReallocGeneric(&root, ptr, WTF::kMaxAllocation + 1, WTF::kMaxAllocation * 10);
+    newCharPtr = static_cast<char*>(newPtr);
+    EXPECT_EQ(*newCharPtr, 'D');
+    *newCharPtr = 'E';
+    ptr = newPtr;
+    newPtr = partitionReallocGeneric(&root, ptr, WTF::kMaxAllocation * 10, WTF::kMaxAllocation * 2);
+    newCharPtr = static_cast<char*>(newPtr);
+    EXPECT_EQ(*newCharPtr, 'E');
+    *newCharPtr = 'F';
+
+    // Downsize the realloc to inside the partition.
+    ptr = newPtr;
+    newPtr = partitionReallocGeneric(&root, ptr, WTF::kMaxAllocation * 2, 1);
+    EXPECT_TRUE(newPtr != ptr);
+    EXPECT_EQ(newPtr, origPtr);
+    newCharPtr = static_cast<char*>(newPtr);
+    EXPECT_EQ(*newCharPtr, 'F');
+
+    partitionFreeGeneric(newPtr, 1);
+    TestShutdown();
+}
+
 #if OS(UNIX)
 
 // Test correct handling if our mapping collides with another.
 TEST(WTF_PartitionAlloc, MappingCollision)
 {
     TestSetup();
 
     WTF::PartitionPageHeader* page1 = GetFullPage(kTestAllocSize);
     char* pageBase = reinterpret_cast<char*>(page1);
     // Map a single system page either side of the mapping for our allocations,
@@ skipping 12 matching lines @@
     munmap(map2, WTF::kSystemPageSize);
 
     TestShutdown();
 }
 
 #endif // OS(UNIX)
 
 } // namespace
 
 #endif // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)