PartitionAlloc: simplify PartitionPage structure some more.

Source/wtf/PartitionAlloc.h

 /*
  * 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 205 matching lines @@
 // The significant page transitions are:
 // - free() will detect when a full page has a slot free()'d and immediately
 // return the page to the head of the active list.
 // - free() will detect when a page is fully emptied. It _may_ add it to the
 // free list and it _may_ leave it on the active list until a future list scan.
 // - malloc() _may_ scan the active page list in order to fulfil the request.
 // If it does this, full and free pages encountered will be booted out of the
 // active list. If there are no suitable active pages found, a free page (if one
 // exists) will be pulled from the free list on to the active list.
 struct PartitionPage {
-    union { // Accessed most in hot path => goes first.
-        PartitionFreelistEntry* freelistHead; // If the page is active.
-        PartitionPage* freePageNext; // If the page is free.
-    } u;
-    PartitionPage* activePageNext;
+    PartitionFreelistEntry* freelistHead;
+    PartitionPage* next;

[Tom Sepez, 2014/01/13 18:15:55]

nit: nextPage or some such.  Too many lists to simply have a next variable.

     PartitionBucket* bucket;
     int16_t numAllocatedSlots; // Deliberately signed, -1 for free page, -n for full pages.
     uint16_t numUnprovisionedSlots;
     uint16_t pageOffset;
-    uint16_t flags;
 };
 static uint16_t kPartitionPageFlagFree = 1;
 
 struct PartitionBucket {
     PartitionPage* activePagesHead; // Accessed most in hot path => goes first.
     PartitionPage* freePagesHead;
     uint16_t slotSize;
     uint16_t numSystemPagesPerSlotSpan;
     uint32_t numFullPages;
 };
@@ skipping 218 matching lines @@
     PartitionSuperPageExtentEntry* entry = firstExtent->next;
     while (UNLIKELY(entry != 0)) {
         if (ptr >= entry->superPageBase && ptr < entry->superPagesEnd)
             return true;
         entry = entry->next;
     }
 
     return false;
 }
 
-ALWAYS_INLINE bool partitionPageIsFree(PartitionPage* page)
-{
-    return (page->flags & kPartitionPageFlagFree);
-}
-
-ALWAYS_INLINE PartitionFreelistEntry* partitionPageFreelistHead(PartitionPage* page)
-{
-    ASSERT((page == &PartitionRootBase::gSeedPage && !page->u.freelistHead) || !partitionPageIsFree(page));
-    return page->u.freelistHead;
-}
-
-ALWAYS_INLINE void partitionPageSetFreelistHead(PartitionPage* page, PartitionFreelistEntry* newHead)
-{
-    ASSERT(!partitionPageIsFree(page));
-    page->u.freelistHead = newHead;
-}
-
 ALWAYS_INLINE void* partitionBucketAlloc(PartitionRootBase* root, size_t size, PartitionBucket* bucket)
 {
     PartitionPage* page = bucket->activePagesHead;
-    ASSERT(page == &PartitionRootBase::gSeedPage || page->numAllocatedSlots >= 0);
-    void* ret = partitionPageFreelistHead(page);
+    ASSERT(page->numAllocatedSlots >= 0);
+    void* ret = page->freelistHead;
     if (LIKELY(ret != 0)) {
         // If these asserts fire, you probably corrupted memory.
         ASSERT(partitionPointerIsValid(root, ret));
         ASSERT(partitionPointerToPage(ret));
         PartitionFreelistEntry* newHead = partitionFreelistMask(static_cast<PartitionFreelistEntry*>(ret)->next);
-        partitionPageSetFreelistHead(page, newHead);
+        page->freelistHead = newHead;
         ASSERT(!ret || partitionPointerIsValid(root, ret));
         ASSERT(!ret || partitionPointerToPage(ret));
         page->numAllocatedSlots++;
     } else {
         ret = partitionAllocSlowPath(root, size, bucket);
     }
 #ifndef NDEBUG
     // This will go away once we don't use tcmalloc to back larger allocations.
     if (!partitionPointerIsValid(root, ret))
         return ret;
@@ skipping 35 matching lines @@
 ALWAYS_INLINE void partitionFreeWithPage(void* ptr, PartitionPage* page)
 {
     // If these asserts fire, you probably corrupted memory.
 #ifndef NDEBUG
     size_t bucketSize = page->bucket->slotSize;
     void* ptrEnd = static_cast<char*>(ptr) + bucketSize;
     ASSERT(*(static_cast<uintptr_t*>(ptr)) == kCookieValue);
     ASSERT(*(static_cast<uintptr_t*>(ptrEnd) - 1) == kCookieValue);
     memset(ptr, kFreedByte, bucketSize);
 #endif
-    PartitionFreelistEntry* freelistHead = partitionPageFreelistHead(page);
+    ASSERT(page->numAllocatedSlots);
+    PartitionFreelistEntry* freelistHead = page->freelistHead;
     ASSERT(!freelistHead || partitionPointerIsValid(partitionPageToRoot(page), freelistHead));
     ASSERT(!freelistHead || partitionPointerToPage(freelistHead));
     RELEASE_ASSERT(ptr != freelistHead); // Catches an immediate double free.
     ASSERT(!freelistHead || ptr != partitionFreelistMask(freelistHead->next)); // Look for double free one level deeper in debug.
     PartitionFreelistEntry* entry = static_cast<PartitionFreelistEntry*>(ptr);
     entry->next = partitionFreelistMask(freelistHead);
-    partitionPageSetFreelistHead(page, entry);
+    page->freelistHead = entry;
     --page->numAllocatedSlots;
     if (UNLIKELY(page->numAllocatedSlots <= 0))
         partitionFreeSlowPath(page);
 }
 
 ALWAYS_INLINE void partitionFree(void* ptr)
 {
 #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
     free(ptr);
 #else
@@ skipping 88 matching lines @@
 using WTF::PartitionRoot;
 using WTF::partitionAllocInit;
 using WTF::partitionAllocShutdown;
 using WTF::partitionAlloc;
 using WTF::partitionFree;
 using WTF::partitionAllocGeneric;
 using WTF::partitionFreeGeneric;
 using WTF::partitionReallocGeneric;
 
 #endif // WTF_PartitionAlloc_h