Oilpan: Use WTF::allocPages() to allocate aligned blocks of memory

Source/platform/heap/Heap.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 21 matching lines @@
 #include "platform/heap/Heap.h"
 
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/Task.h"
 #include "platform/TraceEvent.h"
 #include "platform/heap/CallbackStack.h"
 #include "platform/heap/MarkingVisitorImpl.h"
 #include "platform/heap/SafePoint.h"
 #include "platform/heap/ThreadState.h"
 #include "public/platform/Platform.h"
-#include "wtf/AddressSpaceRandomization.h"
 #include "wtf/Assertions.h"
 #include "wtf/ContainerAnnotations.h"
 #include "wtf/LeakAnnotations.h"
+#include "wtf/PageAllocator.h"
 #include "wtf/PassOwnPtr.h"
 #if ENABLE(GC_PROFILING)
 #include "platform/TracedValue.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/StringHash.h"
 #include <stdio.h>
 #include <utility>
 #endif
@@ skipping 47 matching lines @@
         return gcInfo->m_className;
     return "unknown";
 }
 #endif
 
 static bool vTableInitialized(void* objectPointer)
 {
     return !!(*reinterpret_cast<Address*>(objectPointer));
 }
 
-static Address roundToBlinkPageBoundary(void* base)
-{
-    return reinterpret_cast<Address>((reinterpret_cast<uintptr_t>(base) + blinkPageOffsetMask) & blinkPageBaseMask);
-}
-
 static size_t roundToOsPageSize(size_t size)
 {
     return (size + WTF::kSystemPageSize - 1) & ~(WTF::kSystemPageSize - 1);
 }
 
 class MemoryRegion {
 public:
     MemoryRegion(Address base, size_t size)
         : m_base(base)
         , m_size(size)
     {
         ASSERT(size > 0);
     }
 
     bool contains(Address addr) const
     {
         return m_base <= addr && addr < (m_base + m_size);
     }
 
     bool contains(const MemoryRegion& other) const
     {
         return contains(other.m_base) && contains(other.m_base + other.m_size - 1);
     }
 
     void release()
     {
-#if OS(POSIX)
-        int err = munmap(m_base, m_size);
-        RELEASE_ASSERT(!err);
-#else
-        bool success = VirtualFree(m_base, 0, MEM_RELEASE);
-        RELEASE_ASSERT(success);
-#endif
+        WTF::freePages(m_base, m_size);
     }
 
     WARN_UNUSED_RETURN bool commit()
     {
 #if OS(POSIX)
         return !mprotect(m_base, m_size, PROT_READ | PROT_WRITE);
 #else
         void* result = VirtualAlloc(m_base, m_size, MEM_COMMIT, PAGE_READWRITE);
         return !!result;
 #endif
@@ skipping 88 matching lines @@
         ASSERT(contains(address));
         if (m_isLargePage)
             return 0;
         size_t offset = blinkPageAddress(address) - base();
         ASSERT(offset % blinkPageSize == 0);
         return offset / blinkPageSize;
     }
 
     static PageMemoryRegion* allocate(size_t size, unsigned numPages)
     {
-        // Compute a random blink page aligned address for the page memory
-        // region and attempt to get the memory there.
-        Address randomAddress = reinterpret_cast<Address>(WTF::getRandomPageBase());
-        Address alignedRandomAddress = roundToBlinkPageBoundary(randomAddress);
-
-#if OS(POSIX)
-        Address base = static_cast<Address>(mmap(alignedRandomAddress, size, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0));
-        if (base == roundToBlinkPageBoundary(base))
-            return new PageMemoryRegion(base, size, numPages);
-
-        // We failed to get a blink page aligned chunk of memory.
-        // Unmap the chunk that we got and fall back to overallocating
-        // and selecting an aligned sub part of what we allocate.
-        if (base != MAP_FAILED) {
-            int error = munmap(base, size);
-            RELEASE_ASSERT(!error);
-        }
-        size_t allocationSize = size + blinkPageSize;
-        for (int attempt = 0; attempt < 10; ++attempt) {
-            base = static_cast<Address>(mmap(alignedRandomAddress, allocationSize, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0));
-            if (base != MAP_FAILED)
-                break;
-            randomAddress = reinterpret_cast<Address>(WTF::getRandomPageBase());
-            alignedRandomAddress = roundToBlinkPageBoundary(randomAddress);
-        }
-        RELEASE_ASSERT(base != MAP_FAILED);
-
-        Address end = base + allocationSize;
-        Address alignedBase = roundToBlinkPageBoundary(base);
-        Address regionEnd = alignedBase + size;
-
-        // If the allocated memory was not blink page aligned release
-        // the memory before the aligned address.
-        if (alignedBase != base)
-            MemoryRegion(base, alignedBase - base).release();
-
-        // Free the additional memory at the end of the page if any.
-        if (regionEnd < end)
-            MemoryRegion(regionEnd, end - regionEnd).release();
-
-        return new PageMemoryRegion(alignedBase, size, numPages);
-#else
-        Address base = static_cast<Address>(VirtualAlloc(alignedRandomAddress, size, MEM_RESERVE, PAGE_NOACCESS));
-        if (base) {
-            ASSERT(base == alignedRandomAddress);
-            return new PageMemoryRegion(base, size, numPages);
-        }
-
-        // We failed to get the random aligned address that we asked
-        // for. Fall back to overallocating. On Windows it is
-        // impossible to partially release a region of memory
-        // allocated by VirtualAlloc. To avoid wasting virtual address
-        // space we attempt to release a large region of memory
-        // returned as a whole and then allocate an aligned region
-        // inside this larger region.
-        size_t allocationSize = size + blinkPageSize;
-        for (int attempt = 0; attempt < 3; ++attempt) {
-            base = static_cast<Address>(VirtualAlloc(0, allocationSize, MEM_RESERVE, PAGE_NOACCESS));
-            RELEASE_ASSERT(base);
-            VirtualFree(base, 0, MEM_RELEASE);
-
-            Address alignedBase = roundToBlinkPageBoundary(base);
-            base = static_cast<Address>(VirtualAlloc(alignedBase, size, MEM_RESERVE, PAGE_NOACCESS));
-            if (base) {
-                ASSERT(base == alignedBase);
-                return new PageMemoryRegion(alignedBase, size, numPages);
-            }
-        }
-
-        // We failed to avoid wasting virtual address space after
-        // several attempts.
-        base = static_cast<Address>(VirtualAlloc(0, allocationSize, MEM_RESERVE, PAGE_NOACCESS));
+        // Round size up to the allocation granularity.
+        size = (size + WTF::kPageAllocationGranularityOffsetMask) & WTF::kPageAllocationGranularityBaseMask;
+        Address base = static_cast<Address>(WTF::allocPages(nullptr, size, blinkPageSize));
         RELEASE_ASSERT(base);
-
-        // FIXME: If base is by accident blink page size aligned
-        // here then we can create two pages out of reserved
-        // space. Do this.
-        Address alignedBase = roundToBlinkPageBoundary(base);
-
-        return new PageMemoryRegion(alignedBase, size, numPages);
-#endif
+        WTF::setSystemPagesInaccessible(base, size);
+        return new PageMemoryRegion(base, size, numPages);
     }
 
     bool m_isLargePage;
     bool m_inUse[blinkPagesPerRegion];
     unsigned m_numPages;
 };
 
 // Representation of the memory used for a Blink heap page.
 //
 // The representation keeps track of two memory regions:
@@ skipping 2563 matching lines @@
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 
 size_t Heap::s_externallyAllocatedBytes = 0;
 size_t Heap::s_externallyAllocatedBytesAlive = 0;
 unsigned Heap::s_requestedUrgentGC = false;
 double Heap::s_markingTimeInLastGC = 0.0;
 
 } // namespace blink