[llvm] r351916 - MemoryBlock: Do not automatically extend a given size to a multiple of page size.

[Rui Ueyama via llvm-commits]

Author: ruiu
Date: Tue Jan 22 18:03:26 2019
New Revision: 351916

URL: http://llvm.org/viewvc/llvm-project?rev=351916&view=rev
Log:
MemoryBlock: Do not automatically extend a given size to a multiple of page size.

Previously, MemoryBlock automatically extends a requested buffer size to a
multiple of page size because (I believe) doing it was thought to be harmless
and with that you could get more memory (on average 2KiB on 4KiB-page systems)
"for free".

That programming interface turned out to be error-prone. If you request N
bytes, you usually expect that a resulting object returns N for `size()`.
That's not the case for MemoryBlock.

Looks like there is only one place where we take the advantage of
allocating more memory than the requested size. So, with this patch, I
simply removed the automatic size expansion feature from MemoryBlock
and do it on the caller side when needed. MemoryBlock now always
returns a buffer whose size is equal to the requested size.

Differential Revision: https://reviews.llvm.org/D56941

Modified:
    llvm/trunk/lib/ExecutionEngine/SectionMemoryManager.cpp
    llvm/trunk/lib/Support/Unix/Memory.inc

Modified: llvm/trunk/lib/ExecutionEngine/SectionMemoryManager.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/SectionMemoryManager.cpp?rev=351916&r1=351915&r2=351916&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/SectionMemoryManager.cpp (original)
+++ llvm/trunk/lib/ExecutionEngine/SectionMemoryManager.cpp Tue Jan 22 18:03:26 2019
@@ -242,7 +242,11 @@ public:
   allocateMappedMemory(SectionMemoryManager::AllocationPurpose Purpose,
                        size_t NumBytes, const sys::MemoryBlock *const NearBlock,
                        unsigned Flags, std::error_code &EC) override {
-    return sys::Memory::allocateMappedMemory(NumBytes, NearBlock, Flags, EC);
+    // allocateMappedMemory calls mmap(2). We round up a request size
+    // to page size to get extra space for free.
+    static const size_t PageSize = sys::Process::getPageSize();
+    size_t ReqBytes = (NumBytes + PageSize - 1) & ~(PageSize - 1);
+    return sys::Memory::allocateMappedMemory(ReqBytes, NearBlock, Flags, EC);
   }
 
   std::error_code protectMappedMemory(const sys::MemoryBlock &Block,

Modified: llvm/trunk/lib/Support/Unix/Memory.inc
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Support/Unix/Memory.inc?rev=351916&r1=351915&r2=351916&view=diff
==============================================================================
--- llvm/trunk/lib/Support/Unix/Memory.inc (original)
+++ llvm/trunk/lib/Support/Unix/Memory.inc Tue Jan 22 18:03:26 2019
@@ -91,9 +91,6 @@ Memory::allocateMappedMemory(size_t NumB
   if (NumBytes == 0)
     return MemoryBlock();
 
-  static const size_t PageSize = Process::getPageSize();
-  const size_t NumPages = (NumBytes+PageSize-1)/PageSize;
-
   int fd = -1;
 
   int MMFlags = MAP_PRIVATE |
@@ -113,11 +110,12 @@ Memory::allocateMappedMemory(size_t NumB
   // Use any near hint and the page size to set a page-aligned starting address
   uintptr_t Start = NearBlock ? reinterpret_cast<uintptr_t>(NearBlock->base()) +
                                       NearBlock->size() : 0;
+  static const size_t PageSize = Process::getPageSize();
   if (Start && Start % PageSize)
     Start += PageSize - Start % PageSize;
 
-  void *Addr = ::mmap(reinterpret_cast<void*>(Start), PageSize*NumPages,
-                      Protect, MMFlags, fd, 0);
+  void *Addr = ::mmap(reinterpret_cast<void *>(Start), NumBytes, Protect,
+                      MMFlags, fd, 0);
   if (Addr == MAP_FAILED) {
     if (NearBlock) //Try again without a near hint
       return allocateMappedMemory(NumBytes, nullptr, PFlags, EC);
@@ -128,7 +126,7 @@ Memory::allocateMappedMemory(size_t NumB
 
   MemoryBlock Result;
   Result.Address = Addr;
-  Result.Size = NumPages*PageSize;
+  Result.Size = NumBytes;
 
   // Rely on protectMappedMemory to invalidate instruction cache.
   if (PFlags & MF_EXEC) {