Oilpan: attempt first-fit freelist allocation for backing heaps.

Source/platform/heap/Heap.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 697 matching lines @@
     virtual void prepareHeapForTermination() = 0;
 };
 
 template<typename Header>
 class FreeList {
 public:
     FreeList();
 
     void addToFreeList(Address, size_t);
     void clear();
-    FreeListEntry* takeEntry(size_t allocationSize);
 
     // Returns a bucket number for inserting a FreeListEntry of a given size.
     // All FreeListEntries in the given bucket, n, have size >= 2^n.
     static int bucketIndexForSize(size_t);
 
 private:
     int m_biggestFreeListIndex;
 
     // All FreeListEntries in the nth list have size >= 2^n.
     FreeListEntry* m_freeLists[blinkPageSizeLog2];
 
-#if ENABLE(ASSERT)
     friend class ThreadHeap<Header>;
-#endif
 };
 
 // Thread heaps represent a part of the per-thread Blink heap.
 //
 // Each Blink thread has a number of thread heaps: one general heap
 // that contains any type of object and a number of heaps specialized
 // for specific object types (such as Node).
 //
 // Each thread heap contains the functionality to allocate new objects
 // (potentially adding new pages to the heap), to find and mark
@@ skipping 28 matching lines @@
 
     ThreadState* threadState() { return m_threadState; }
 
     void addToFreeList(Address address, size_t size)
     {
         ASSERT(pageFromAddress(address));
         ASSERT(pageFromAddress(address + size - 1));
         m_freeList.addToFreeList(address, size);
     }
 
-    inline Address allocate(size_t, const GCInfo*);
+    inline Address allocate(size_t payloadSize, const GCInfo*);
     inline static size_t roundedAllocationSize(size_t size)
     {
         return allocationSizeFromSize(size) - sizeof(Header);
     }
 
     virtual void prepareHeapForTermination() override;
 
     void removePageFromHeap(HeapPage<Header>*);
 
     PLATFORM_EXPORT void promptlyFreeObject(Header*);
     PLATFORM_EXPORT bool expandObject(Header*, size_t);
     void shrinkObject(Header*, size_t);
 
 private:
     void addPageToHeap(const GCInfo*);
-    PLATFORM_EXPORT Address outOfLineAllocate(size_t payloadSize, size_t allocationSize, const GCInfo*);
+    PLATFORM_EXPORT Address outOfLineAllocate(size_t allocationSize, const GCInfo*);
     static size_t allocationSizeFromSize(size_t);
     PLATFORM_EXPORT Address allocateLargeObject(size_t, const GCInfo*);
     Address currentAllocationPoint() const { return m_currentAllocationPoint; }
     size_t remainingAllocationSize() const { return m_remainingAllocationSize; }
     bool hasCurrentAllocationArea() const { return currentAllocationPoint() && remainingAllocationSize(); }
     void setAllocationPoint(Address point, size_t size)
     {
         ASSERT(!point || pageFromAddress(point));
         ASSERT(size <= HeapPage<Header>::payloadSize());
         if (hasCurrentAllocationArea())
             addToFreeList(currentAllocationPoint(), remainingAllocationSize());
         updateRemainingAllocationSize();
         m_currentAllocationPoint = point;
         m_lastRemainingAllocationSize = m_remainingAllocationSize = size;
     }
     void updateRemainingAllocationSize();
-    bool allocateFromFreeList(size_t);
+    Address allocateFromFreeList(size_t, const GCInfo*);
 
     void freeLargeObject(LargeObject<Header>*, LargeObject<Header>**);
     void allocatePage(const GCInfo*);
 
+    inline Address allocateSize(size_t allocationSize, const GCInfo*);
+    inline Address allocateAtAddress(Address, size_t allocationSize, const GCInfo*);
+
 #if ENABLE(ASSERT)
     bool pagesToBeSweptContains(Address);
     bool pagesAllocatedDuringSweepingContains(Address);
 #endif
 
     void sweepNormalPages();
     void sweepLargePages();
     bool coalesce(size_t);
 
     Address m_currentAllocationPoint;
@@ skipping 438 matching lines @@
     // therefore has to happen before any calculation on the size.
     RELEASE_ASSERT(size < maxHeapObjectSize);
 
     // Add space for header.
     size_t allocationSize = size + sizeof(Header);
     // Align size with allocation granularity.
     allocationSize = (allocationSize + allocationMask) & ~allocationMask;
     return allocationSize;
 }
 
+

[haraken, 2014/12/16 02:26:33]

Unnecessary empty line.

+template<typename Header>
+inline Address ThreadHeap<Header>::allocateAtAddress(Address headerAddress, size_t allocationSize, const GCInfo* gcInfo)
+{
+    new (NotNull, headerAddress) Header(allocationSize, gcInfo);
+    Address result = headerAddress + sizeof(Header);
+    ASSERT(!(reinterpret_cast<uintptr_t>(result) & allocationMask));
+
+    // Unpoison the memory used for the object (payload).
+    ASAN_UNPOISON_MEMORY_REGION(result, allocationSize - sizeof(Header));
+#if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
+    memset(result, 0, allocationSize - sizeof(Header));
+#endif
+    ASSERT(pageFromAddress(headerAddress + allocationSize - 1));
+    return result;
+}
+
+template<typename Header>
+Address ThreadHeap<Header>::allocateSize(size_t allocationSize, const GCInfo* gcInfo)
+{
+    if (LIKELY(allocationSize <= m_remainingAllocationSize)) {
+        Address headerAddress = m_currentAllocationPoint;
+        m_currentAllocationPoint += allocationSize;
+        m_remainingAllocationSize -= allocationSize;
+        return allocateAtAddress(headerAddress, allocationSize, gcInfo);
+    }
+    return outOfLineAllocate(allocationSize, gcInfo);
+}
+
 template<typename Header>
 Address ThreadHeap<Header>::allocate(size_t size, const GCInfo* gcInfo)
 {
-    size_t allocationSize = allocationSizeFromSize(size);
-    if (LIKELY(allocationSize <= m_remainingAllocationSize)) {
-        Address headerAddress = m_currentAllocationPoint;
-        m_currentAllocationPoint += allocationSize;
-        m_remainingAllocationSize -= allocationSize;
-        new (NotNull, headerAddress) Header(allocationSize, gcInfo);
-        Address result = headerAddress + sizeof(Header);
-        ASSERT(!(reinterpret_cast<uintptr_t>(result) & allocationMask));
-
-        // Unpoison the memory used for the object (payload).
-        ASAN_UNPOISON_MEMORY_REGION(result, allocationSize - sizeof(Header));
-#if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
-        memset(result, 0, allocationSize - sizeof(Header));
-#endif
-        ASSERT(pageFromAddress(headerAddress + allocationSize - 1));
-        return result;
-    }
-    return outOfLineAllocate(size, allocationSize, gcInfo);
+    return allocateSize(allocationSizeFromSize(size), gcInfo);
 }
 
 template<typename T, typename HeapTraits>
 Address Heap::allocate(size_t size)
 {
     ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
     ASSERT(state->isAllocationAllowed());
     const GCInfo* gcInfo = GCInfoTrait<T>::get();
     int heapIndex = HeapTraits::index(gcInfo->hasFinalizer(), size);
     BaseHeap* heap = state->heap(heapIndex);
@@ skipping 1022 matching lines @@
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapVector<T, inlineCapacity>> : public GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapDeque<T, inlineCapacity>> : public GCInfoTrait<Deque<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HeapHashCountedSet<T, U, V>> : public GCInfoTrait<HashCountedSet<T, U, V, HeapAllocator>> { };
 
 } // namespace blink
 
 #endif // Heap_h