Enhancements to PartitionAlloc to support threading and arbitrary allocation sizes.

Source/wtf/PartitionAlloc.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 28 matching lines @@
 #endif
 
 COMPILE_ASSERT(WTF::kPartitionPageSize < WTF::kSuperPageSize, ok_partition_page_size);
 
 namespace WTF {
 
 void partitionAllocInit(PartitionRoot* root)
 {
     ASSERT(!root->initialized);
     root->initialized = true;
+    root->lock = 0;
     size_t i;
     for (i = 0; i < kNumBuckets; ++i) {
         PartitionBucket* bucket = &root->buckets[i];
         bucket->root = root;
         bucket->currPage = &root->seedPage;
         bucket->freePages = 0;
         bucket->numFullPages = 0;
     }
 
     root->nextSuperPage = 0;
@@ skipping 257 matching lines @@
     } else {
         // Fully used page became partially used. It must be put back on the
         // non-full page list.
         partitionLinkPage(page, bucket->currPage);
         page->numAllocatedSlots = -page->numAllocatedSlots - 2;
         ASSERT(page->numAllocatedSlots == partitionBucketSlots(bucket) - 1);
         --bucket->numFullPages;
     }
 }
 
+void* partitionReallocGeneric(PartitionRoot* root, void* ptr, size_t oldSize, size_t newSize)
+{
+#if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
+    return realloc(ptr, newSize);
+#else
+    size_t oldIndex = oldSize >> kBucketShift;
+    if (oldIndex > kNumBuckets)
+        oldIndex = kNumBuckets;
+    size_t newIndex = newSize >> kBucketShift;
+    if (newIndex > kNumBuckets)
+        newIndex = kNumBuckets;
+
+    if (oldIndex == newIndex) {
+        // Same bucket. But kNumBuckets indicates the fastMalloc "bucket" so in
+        // that case we're not done; we have to forward to fastRealloc.
+        if (oldIndex == kNumBuckets)
+            return WTF::fastRealloc(ptr, newSize);
+        return ptr;
+    }
+    // This realloc cannot be resized in-place. Sadness.
+    void* ret = partitionAllocGeneric(root, newSize);
+    size_t copySize = oldSize;
+    if (newSize < oldSize)
+        copySize = newSize;
+    memcpy(ret, ptr, copySize);
+    partitionFreeGeneric(ptr, oldSize);
+    return ret;
+#endif
+}
+
 #ifndef NDEBUG
 
 void partitionDumpStats(const PartitionRoot& root)
 {
     size_t i;
     for (i = 0; i < kNumBuckets; ++i) {
         const PartitionBucket& bucket = root.buckets[i];
         if (bucket.currPage == &bucket.root->seedPage && !bucket.freePages) {
             // Empty bucket with no freelist pages. Skip reporting it.
             continue;
@@ skipping 16 matching lines @@
             }
             page = page->next;
         } while (page != bucket.currPage);
         printf("bucket size %ld: %ld/%ld bytes, %ld free pages\n", bucketSlotSize, numActiveBytes, numActivePages * kPartitionPageSize, numFreePages);
     }
 }
 #endif // !NDEBUG
 
 } // namespace WTF