[Support] Renamed member 'Size' to 'AllocatedSize' in MemoryBlock and OwningMemoryBlock.

Rename member 'Size' to 'AllocatedSize' in order to provide a hint that the
allocated size may be different than the requested size. Comments are added to
clarify this point.  Updated the InMemoryBuffer in FileOutputBuffer.cpp to track
the requested buffer size.

Patch by Machiel van Hooren. Thanks Machiel!

https://reviews.llvm.org/D61599

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@361195 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Support/Memory.h b/include/llvm/Support/Memory.h
index ad72692272f700ba3beda1a8072fe9936ad2b34c..6f22dd7080cd563d57b92c63f7285132a7ec80bb 100644 (file)
--- a/include/llvm/Support/Memory.h
+++ b/include/llvm/Support/Memory.h
@@ -31,14 +31,17 @@ namespace sys {
   /// Memory block abstraction.
   class MemoryBlock {
   public:
-    MemoryBlock() : Address(nullptr), Size(0) { }
-    MemoryBlock(void *addr, size_t size) : Address(addr), Size(size) { }
+    MemoryBlock() : Address(nullptr), AllocatedSize(0) {}
+    MemoryBlock(void *addr, size_t allocatedSize)
+        : Address(addr), AllocatedSize(allocatedSize) {}
     void *base() const { return Address; }
-    size_t size() const { return Size; }
-
+    /// The size as it was allocated. This is always greater or equal to the
+    /// size that was originally requested.
+    size_t allocatedSize() const { return AllocatedSize; }
+  
   private:
     void *Address;    ///< Address of first byte of memory area
-    size_t Size;      ///< Size, in bytes of the memory area
+    size_t AllocatedSize; ///< Size, in bytes of the memory area
     unsigned Flags = 0;
     friend class Memory;
   };
@@ -139,7 +142,9 @@ namespace sys {
       Memory::releaseMappedMemory(M);
     }
     void *base() const { return M.base(); }
-    size_t size() const { return M.size(); }
+    /// The size as it was allocated. This is always greater or equal to the
+    /// size that was originally requested.
+    size_t allocatedSize() const { return M.allocatedSize(); }
     MemoryBlock getMemoryBlock() const { return M; }
   private:
     MemoryBlock M;

diff --git a/lib/ExecutionEngine/JITLink/JITLink.cpp b/lib/ExecutionEngine/JITLink/JITLink.cpp
index 1cea043f761334d9c8205487ea1b7e78676c3196..16ef4c603ce2712bde26e12a2e9e75fcaaac3bef 100644 (file)
--- a/lib/ExecutionEngine/JITLink/JITLink.cpp
+++ b/lib/ExecutionEngine/JITLink/JITLink.cpp
@@ -154,7 +154,7 @@ InProcessMemoryManager::allocate(const SegmentsRequestMap &Request) {
     MutableArrayRef<char> getWorkingMemory(ProtectionFlags Seg) override {
       assert(SegBlocks.count(Seg) && "No allocation for segment");
       return {static_cast<char *>(SegBlocks[Seg].base()),
-              SegBlocks[Seg].size()};
+              SegBlocks[Seg].allocatedSize()};
     }
     JITTargetAddress getTargetMemory(ProtectionFlags Seg) override {
       assert(SegBlocks.count(Seg) && "No allocation for segment");
@@ -178,7 +178,8 @@ InProcessMemoryManager::allocate(const SegmentsRequestMap &Request) {
         if (auto EC = sys::Memory::protectMappedMemory(Block, Prot))
           return errorCodeToError(EC);
         if (Prot & sys::Memory::MF_EXEC)
-          sys::Memory::InvalidateInstructionCache(Block.base(), Block.size());
+          sys::Memory::InvalidateInstructionCache(Block.base(),
+                                                  Block.allocatedSize());
       }
       return Error::success();
     }

diff --git a/lib/ExecutionEngine/SectionMemoryManager.cpp b/lib/ExecutionEngine/SectionMemoryManager.cpp
index 2c0cfeb8a9accb3210f5ae657f584d2d50d1244a..925049b2a1b4fccfb789bfb6d971dad78cb48192 100644 (file)
--- a/lib/ExecutionEngine/SectionMemoryManager.cpp
+++ b/lib/ExecutionEngine/SectionMemoryManager.cpp
@@ -64,9 +64,9 @@ uint8_t *SectionMemoryManager::allocateSection(
   // Look in the list of free memory regions and use a block there if one
   // is available.
   for (FreeMemBlock &FreeMB : MemGroup.FreeMem) {
-    if (FreeMB.Free.size() >= RequiredSize) {
+    if (FreeMB.Free.allocatedSize() >= RequiredSize) {
       Addr = (uintptr_t)FreeMB.Free.base();
-      uintptr_t EndOfBlock = Addr + FreeMB.Free.size();
+      uintptr_t EndOfBlock = Addr + FreeMB.Free.allocatedSize();
       // Align the address.
       Addr = (Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1);
 
@@ -115,7 +115,7 @@ uint8_t *SectionMemoryManager::allocateSection(
   // Remember that we allocated this memory
   MemGroup.AllocatedMem.push_back(MB);
   Addr = (uintptr_t)MB.base();
-  uintptr_t EndOfBlock = Addr + MB.size();
+  uintptr_t EndOfBlock = Addr + MB.allocatedSize();
 
   // Align the address.
   Addr = (Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1);
@@ -177,7 +177,7 @@ static sys::MemoryBlock trimBlockToPageSize(sys::MemoryBlock M) {
   size_t StartOverlap =
       (PageSize - ((uintptr_t)M.base() % PageSize)) % PageSize;
 
-  size_t TrimmedSize = M.size();
+  size_t TrimmedSize = M.allocatedSize();
   TrimmedSize -= StartOverlap;
   TrimmedSize -= TrimmedSize % PageSize;
 
@@ -185,8 +185,9 @@ static sys::MemoryBlock trimBlockToPageSize(sys::MemoryBlock M) {
                            TrimmedSize);
 
   assert(((uintptr_t)Trimmed.base() % PageSize) == 0);
-  assert((Trimmed.size() % PageSize) == 0);
-  assert(M.base() <= Trimmed.base() && Trimmed.size() <= M.size());
+  assert((Trimmed.allocatedSize() % PageSize) == 0);
+  assert(M.base() <= Trimmed.base() &&
+         Trimmed.allocatedSize() <= M.allocatedSize());
 
   return Trimmed;
 }
@@ -209,17 +210,19 @@ SectionMemoryManager::applyMemoryGroupPermissions(MemoryGroup &MemGroup,
   }
 
   // Remove all blocks which are now empty
-  MemGroup.FreeMem.erase(
-      remove_if(MemGroup.FreeMem,
-                [](FreeMemBlock &FreeMB) { return FreeMB.Free.size() == 0; }),
-      MemGroup.FreeMem.end());
+  MemGroup.FreeMem.erase(remove_if(MemGroup.FreeMem,
+                                   [](FreeMemBlock &FreeMB) {
+                                     return FreeMB.Free.allocatedSize() == 0;
+                                   }),
+                         MemGroup.FreeMem.end());
 
   return std::error_code();
 }
 
 void SectionMemoryManager::invalidateInstructionCache() {
   for (sys::MemoryBlock &Block : CodeMem.PendingMem)
-    sys::Memory::InvalidateInstructionCache(Block.base(), Block.size());
+    sys::Memory::InvalidateInstructionCache(Block.base(),
+                                            Block.allocatedSize());
 }
 
 SectionMemoryManager::~SectionMemoryManager() {
@@ -242,11 +245,7 @@ public:
   allocateMappedMemory(SectionMemoryManager::AllocationPurpose Purpose,
                        size_t NumBytes, const sys::MemoryBlock *const NearBlock,
                        unsigned Flags, std::error_code &EC) override {
-    // 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::getPageSizeEstimate();
-    size_t ReqBytes = (NumBytes + PageSize - 1) & ~(PageSize - 1);
-    return sys::Memory::allocateMappedMemory(ReqBytes, NearBlock, Flags, EC);
+    return sys::Memory::allocateMappedMemory(NumBytes, NearBlock, Flags, EC);
   }
 
   std::error_code protectMappedMemory(const sys::MemoryBlock &Block,

diff --git a/lib/Support/FileOutputBuffer.cpp b/lib/Support/FileOutputBuffer.cpp
index b0b817b4bdd03bf9b753654f6eda5f4f1cd29163..19ab2e9917ab3944d85ba4047bbbe0a86a01ab1d 100644 (file)
--- a/lib/Support/FileOutputBuffer.cpp
+++ b/lib/Support/FileOutputBuffer.cpp
@@ -75,20 +75,22 @@ private:
 // output file on commit(). This is used only when we cannot use OnDiskBuffer.
 class InMemoryBuffer : public FileOutputBuffer {
 public:
-  InMemoryBuffer(StringRef Path, MemoryBlock Buf, unsigned Mode)
-      : FileOutputBuffer(Path), Buffer(Buf), Mode(Mode) {}
+  InMemoryBuffer(StringRef Path, MemoryBlock Buf, std::size_t BufSize,
+                 unsigned Mode)
+      : FileOutputBuffer(Path), Buffer(Buf), BufferSize(BufSize),
+        Mode(Mode) {}
 
   uint8_t *getBufferStart() const override { return (uint8_t *)Buffer.base(); }
 
   uint8_t *getBufferEnd() const override {
-    return (uint8_t *)Buffer.base() + Buffer.size();
+    return (uint8_t *)Buffer.base() + BufferSize;
   }
 
-  size_t getBufferSize() const override { return Buffer.size(); }
+  size_t getBufferSize() const override { return BufferSize; }
 
   Error commit() override {
     if (FinalPath == "-") {
-      llvm::outs() << StringRef((const char *)Buffer.base(), Buffer.size());
+      llvm::outs() << StringRef((const char *)Buffer.base(), BufferSize);
       llvm::outs().flush();
       return Error::success();
     }
@@ -100,12 +102,14 @@ public:
             openFileForWrite(FinalPath, FD, CD_CreateAlways, OF_None, Mode))
       return errorCodeToError(EC);
     raw_fd_ostream OS(FD, /*shouldClose=*/true, /*unbuffered=*/true);
-    OS << StringRef((const char *)Buffer.base(), Buffer.size());
+    OS << StringRef((const char *)Buffer.base(), BufferSize);
     return Error::success();
   }
 
 private:
+  // Buffer may actually contain a larger memory block than BufferSize
   OwningMemoryBlock Buffer;
+  size_t BufferSize;
   unsigned Mode;
 };
 } // namespace
@@ -117,7 +121,7 @@ createInMemoryBuffer(StringRef Path, size_t Size, unsigned Mode) {
       Size, nullptr, sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC);
   if (EC)
     return errorCodeToError(EC);
-  return llvm::make_unique<InMemoryBuffer>(Path, MB, Mode);
+  return llvm::make_unique<InMemoryBuffer>(Path, MB, Size, Mode);
 }
 
 static Expected<std::unique_ptr<FileOutputBuffer>>

diff --git a/lib/Support/Memory.cpp b/lib/Support/Memory.cpp
index 4a84247abf4b9e77a87c1d40ec9aecedb7ee0ce2..581484268cd87685d0e384fe49b7421a4465b0ea 100644 (file)
--- a/lib/Support/Memory.cpp
+++ b/lib/Support/Memory.cpp
@@ -43,8 +43,8 @@ raw_ostream &operator<<(raw_ostream &OS, const Memory::ProtectionFlags &PF) {
 
 raw_ostream &operator<<(raw_ostream &OS, const MemoryBlock &MB) {
   return OS << "[ " << MB.base() << " .. "
-            << (void *)((char *)MB.base() + MB.size()) << " ] (" << MB.size()
-            << " bytes)";
+            << (void *)((char *)MB.base() + MB.allocatedSize()) << " ] ("
+            << MB.allocatedSize() << " bytes)";
 }
 
 } // end namespace sys

diff --git a/lib/Support/Unix/Memory.inc b/lib/Support/Unix/Memory.inc
index 05c5ccbdb3dec13dc0d499c28fde12eacb1411bd..3b0033629597a5e048a136c2bebe4c5c8b98744a 100644 (file)
--- a/lib/Support/Unix/Memory.inc
+++ b/lib/Support/Unix/Memory.inc
@@ -117,13 +117,15 @@ Memory::allocateMappedMemory(size_t NumBytes,
 
   // 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;
+                                      NearBlock->allocatedSize() : 0;
   static const size_t PageSize = Process::getPageSizeEstimate();
+  const size_t NumPages = (NumBytes+PageSize-1)/PageSize;
+
   if (Start && Start % PageSize)
     Start += PageSize - Start % PageSize;
 
   // FIXME: Handle huge page requests (MF_HUGE_HINT).
-  void *Addr = ::mmap(reinterpret_cast<void *>(Start), NumBytes, Protect,
+  void *Addr = ::mmap(reinterpret_cast<void *>(Start), PageSize*NumPages, Protect,
                       MMFlags, fd, 0);
   if (Addr == MAP_FAILED) {
     if (NearBlock) { //Try again without a near hint
@@ -146,7 +148,7 @@ Memory::allocateMappedMemory(size_t NumBytes,
 
   MemoryBlock Result;
   Result.Address = Addr;
-  Result.Size = NumBytes;
+  Result.AllocatedSize = PageSize*NumPages;
   Result.Flags = PFlags;
 
   // Rely on protectMappedMemory to invalidate instruction cache.
@@ -161,14 +163,14 @@ Memory::allocateMappedMemory(size_t NumBytes,
 
 std::error_code
 Memory::releaseMappedMemory(MemoryBlock &M) {
-  if (M.Address == nullptr || M.Size == 0)
+  if (M.Address == nullptr || M.AllocatedSize == 0)
     return std::error_code();
 
-  if (0 != ::munmap(M.Address, M.Size))
+  if (0 != ::munmap(M.Address, M.AllocatedSize))
     return std::error_code(errno, std::generic_category());
 
   M.Address = nullptr;
-  M.Size = 0;
+  M.AllocatedSize = 0;
 
   return std::error_code();
 }
@@ -176,7 +178,7 @@ Memory::releaseMappedMemory(MemoryBlock &M) {
 std::error_code
 Memory::protectMappedMemory(const MemoryBlock &M, unsigned Flags) {
   static const size_t PageSize = Process::getPageSizeEstimate();
-  if (M.Address == nullptr || M.Size == 0)
+  if (M.Address == nullptr || M.AllocatedSize == 0)
     return std::error_code();
 
   if (!Flags)
@@ -184,7 +186,7 @@ Memory::protectMappedMemory(const MemoryBlock &M, unsigned Flags) {
 
   int Protect = getPosixProtectionFlags(Flags);
   uintptr_t Start = alignAddr((uint8_t *)M.Address - PageSize + 1, PageSize);
-  uintptr_t End = alignAddr((uint8_t *)M.Address + M.Size, PageSize);
+  uintptr_t End = alignAddr((uint8_t *)M.Address + M.AllocatedSize, PageSize);
 
   bool InvalidateCache = (Flags & MF_EXEC);
 
@@ -197,7 +199,7 @@ Memory::protectMappedMemory(const MemoryBlock &M, unsigned Flags) {
     if (Result != 0)
       return std::error_code(errno, std::generic_category());
 
-    Memory::InvalidateInstructionCache(M.Address, M.Size);
+    Memory::InvalidateInstructionCache(M.Address, M.AllocatedSize);
     InvalidateCache = false;
   }
 #endif
@@ -208,7 +210,7 @@ Memory::protectMappedMemory(const MemoryBlock &M, unsigned Flags) {
     return std::error_code(errno, std::generic_category());
 
   if (InvalidateCache)
-    Memory::InvalidateInstructionCache(M.Address, M.Size);
+    Memory::InvalidateInstructionCache(M.Address, M.AllocatedSize);
 
   return std::error_code();
 }

diff --git a/lib/Support/Windows/Memory.inc b/lib/Support/Windows/Memory.inc
index b1d68596f5c0a5d3807149341edee18d95daefa3..a67f9c7d0f35b74e0b1c1de4668456745685802e 100644 (file)
--- a/lib/Support/Windows/Memory.inc
+++ b/lib/Support/Windows/Memory.inc
@@ -125,7 +125,7 @@ MemoryBlock Memory::allocateMappedMemory(size_t NumBytes,
   size_t NumBlocks = (NumBytes + Granularity - 1) / Granularity;
 
   uintptr_t Start = NearBlock ? reinterpret_cast<uintptr_t>(NearBlock->base()) +
-                                NearBlock->size()
+                                NearBlock->allocatedSize()
                            : 0;
 
   // If the requested address is not aligned to the allocation granularity,
@@ -149,7 +149,7 @@ MemoryBlock Memory::allocateMappedMemory(size_t NumBytes,
 
   MemoryBlock Result;
   Result.Address = PA;
-  Result.Size = NumBytes;
+  Result.AllocatedSize = AllocSize;
   Result.Flags = (Flags & ~MF_HUGE_HINT) | (HugePages ? MF_HUGE_HINT : 0);
 
   if (Flags & MF_EXEC)
@@ -159,31 +159,31 @@ MemoryBlock Memory::allocateMappedMemory(size_t NumBytes,
 }
 
   std::error_code Memory::releaseMappedMemory(MemoryBlock &M) {
-  if (M.Address == 0 || M.Size == 0)
+  if (M.Address == 0 || M.AllocatedSize == 0)
     return std::error_code();
 
   if (!VirtualFree(M.Address, 0, MEM_RELEASE))
     return mapWindowsError(::GetLastError());
 
   M.Address = 0;
-  M.Size = 0;
+  M.AllocatedSize = 0;
 
   return std::error_code();
 }
 
   std::error_code Memory::protectMappedMemory(const MemoryBlock &M,
                                        unsigned Flags) {
-  if (M.Address == 0 || M.Size == 0)
+  if (M.Address == 0 || M.AllocatedSize == 0)
     return std::error_code();
 
   DWORD Protect = getWindowsProtectionFlags(Flags);
 
   DWORD OldFlags;
-  if (!VirtualProtect(M.Address, M.Size, Protect, &OldFlags))
+  if (!VirtualProtect(M.Address, M.AllocatedSize, Protect, &OldFlags))
     return mapWindowsError(::GetLastError());
 
   if (Flags & MF_EXEC)
-    Memory::InvalidateInstructionCache(M.Address, M.Size);
+    Memory::InvalidateInstructionCache(M.Address, M.AllocatedSize);
 
   return std::error_code();
 }

diff --git a/tools/llvm-rtdyld/llvm-rtdyld.cpp b/tools/llvm-rtdyld/llvm-rtdyld.cpp
index a52650b941d27e2da34f97a59088d4664f294464..a7cc1deb8cf63c771055025e2879a006fcb3db03 100644 (file)
--- a/tools/llvm-rtdyld/llvm-rtdyld.cpp
+++ b/tools/llvm-rtdyld/llvm-rtdyld.cpp
@@ -644,7 +644,7 @@ static void remapSectionsAndSymbols(const llvm::Triple &TargetTriple,
       // reason (e.g. zero byte COFF sections). Don't include those sections in
       // the allocation map.
       if (LoadAddr != 0)
-        AlreadyAllocated[LoadAddr] = (*Tmp)->MB.size();
+        AlreadyAllocated[LoadAddr] = (*Tmp)->MB.allocatedSize();
       Worklist.erase(Tmp);
     }
   }
@@ -668,13 +668,14 @@ static void remapSectionsAndSymbols(const llvm::Triple &TargetTriple,
     uint64_t NextSectionAddr = TargetAddrStart;
 
     for (const auto &Alloc : AlreadyAllocated)
-      if (NextSectionAddr + CurEntry->MB.size() + TargetSectionSep <= Alloc.first)
+      if (NextSectionAddr + CurEntry->MB.allocatedSize() + TargetSectionSep <=
+          Alloc.first)
         break;
       else
         NextSectionAddr = Alloc.first + Alloc.second + TargetSectionSep;
 
     Dyld.mapSectionAddress(CurEntry->MB.base(), NextSectionAddr);
-    AlreadyAllocated[NextSectionAddr] = CurEntry->MB.size();
+    AlreadyAllocated[NextSectionAddr] = CurEntry->MB.allocatedSize();
   }
 
   // Add dummy symbols to the memory manager.

diff --git a/unittests/Support/MemoryTest.cpp b/unittests/Support/MemoryTest.cpp
index dc5f606688f9c9326527cf60d274eb71d209c81d..af33dc32c81b6e0af285775281f9c9cd0a73ca7e 100644 (file)
--- a/unittests/Support/MemoryTest.cpp
+++ b/unittests/Support/MemoryTest.cpp
@@ -76,9 +76,9 @@ protected:
       return true;
 
     if (M1.base() > M2.base())
-      return (unsigned char *)M2.base() + M2.size() > M1.base();
+      return (unsigned char *)M2.base() + M2.allocatedSize() > M1.base();
 
-    return (unsigned char *)M1.base() + M1.size() > M2.base();
+    return (unsigned char *)M1.base() + M1.allocatedSize() > M2.base();
   }
 
   unsigned Flags;
@@ -100,7 +100,7 @@ TEST_P(MappedMemoryTest, AllocAndRelease) {
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(sizeof(int), M1.size());
+  EXPECT_LE(sizeof(int), M1.allocatedSize());
 
   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 }
@@ -116,7 +116,7 @@ TEST_P(MappedMemoryTest, AllocAndReleaseHuge) {
   // returned, if large pages aren't available.
 
   EXPECT_NE((void *)nullptr, M1.base());
-  EXPECT_LE(sizeof(int), M1.size());
+  EXPECT_LE(sizeof(int), M1.allocatedSize());
 
   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 }
@@ -132,11 +132,11 @@ TEST_P(MappedMemoryTest, MultipleAllocAndRelease) {
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(16U, M1.size());
+  EXPECT_LE(16U, M1.allocatedSize());
   EXPECT_NE((void*)nullptr, M2.base());
-  EXPECT_LE(64U, M2.size());
+  EXPECT_LE(64U, M2.allocatedSize());
   EXPECT_NE((void*)nullptr, M3.base());
-  EXPECT_LE(32U, M3.size());
+  EXPECT_LE(32U, M3.allocatedSize());
 
   EXPECT_FALSE(doesOverlap(M1, M2));
   EXPECT_FALSE(doesOverlap(M2, M3));
@@ -147,7 +147,7 @@ TEST_P(MappedMemoryTest, MultipleAllocAndRelease) {
   MemoryBlock M4 = Memory::allocateMappedMemory(16, nullptr, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
   EXPECT_NE((void*)nullptr, M4.base());
-  EXPECT_LE(16U, M4.size());
+  EXPECT_LE(16U, M4.allocatedSize());
   EXPECT_FALSE(Memory::releaseMappedMemory(M4));
   EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 }
@@ -164,7 +164,7 @@ TEST_P(MappedMemoryTest, BasicWrite) {
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(sizeof(int), M1.size());
+  EXPECT_LE(sizeof(int), M1.allocatedSize());
 
   int *a = (int*)M1.base();
   *a = 1;
@@ -196,11 +196,11 @@ TEST_P(MappedMemoryTest, MultipleWrite) {
   EXPECT_FALSE(doesOverlap(M1, M3));
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(1U * sizeof(int), M1.size());
+  EXPECT_LE(1U * sizeof(int), M1.allocatedSize());
   EXPECT_NE((void*)nullptr, M2.base());
-  EXPECT_LE(8U * sizeof(int), M2.size());
+  EXPECT_LE(8U * sizeof(int), M2.allocatedSize());
   EXPECT_NE((void*)nullptr, M3.base());
-  EXPECT_LE(4U * sizeof(int), M3.size());
+  EXPECT_LE(4U * sizeof(int), M3.allocatedSize());
 
   int *x = (int*)M1.base();
   *x = 1;
@@ -224,7 +224,7 @@ TEST_P(MappedMemoryTest, MultipleWrite) {
                                                 Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
   EXPECT_NE((void*)nullptr, M4.base());
-  EXPECT_LE(64U * sizeof(int), M4.size());
+  EXPECT_LE(64U * sizeof(int), M4.allocatedSize());
   x = (int*)M4.base();
   *x = 4;
   EXPECT_EQ(4, *x);
@@ -255,11 +255,11 @@ TEST_P(MappedMemoryTest, EnabledWrite) {
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(2U * sizeof(int), M1.size());
+  EXPECT_LE(2U * sizeof(int), M1.allocatedSize());
   EXPECT_NE((void*)nullptr, M2.base());
-  EXPECT_LE(8U * sizeof(int), M2.size());
+  EXPECT_LE(8U * sizeof(int), M2.allocatedSize());
   EXPECT_NE((void*)nullptr, M3.base());
-  EXPECT_LE(4U * sizeof(int), M3.size());
+  EXPECT_LE(4U * sizeof(int), M3.allocatedSize());
 
   EXPECT_FALSE(Memory::protectMappedMemory(M1, getTestableEquivalent(Flags)));
   EXPECT_FALSE(Memory::protectMappedMemory(M2, getTestableEquivalent(Flags)));
@@ -289,7 +289,7 @@ TEST_P(MappedMemoryTest, EnabledWrite) {
   MemoryBlock M4 = Memory::allocateMappedMemory(16, nullptr, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
   EXPECT_NE((void*)nullptr, M4.base());
-  EXPECT_LE(16U, M4.size());
+  EXPECT_LE(16U, M4.allocatedSize());
   EXPECT_EQ(std::error_code(),
             Memory::protectMappedMemory(M4, getTestableEquivalent(Flags)));
   x = (int*)M4.base();
@@ -310,11 +310,11 @@ TEST_P(MappedMemoryTest, SuccessiveNear) {
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(16U, M1.size());
+  EXPECT_LE(16U, M1.allocatedSize());
   EXPECT_NE((void*)nullptr, M2.base());
-  EXPECT_LE(64U, M2.size());
+  EXPECT_LE(64U, M2.allocatedSize());
   EXPECT_NE((void*)nullptr, M3.base());
-  EXPECT_LE(32U, M3.size());
+  EXPECT_LE(32U, M3.allocatedSize());
 
   EXPECT_FALSE(doesOverlap(M1, M2));
   EXPECT_FALSE(doesOverlap(M2, M3));
@@ -337,11 +337,11 @@ TEST_P(MappedMemoryTest, DuplicateNear) {
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(16U, M1.size());
+  EXPECT_LE(16U, M1.allocatedSize());
   EXPECT_NE((void*)nullptr, M2.base());
-  EXPECT_LE(64U, M2.size());
+  EXPECT_LE(64U, M2.allocatedSize());
   EXPECT_NE((void*)nullptr, M3.base());
-  EXPECT_LE(32U, M3.size());
+  EXPECT_LE(32U, M3.allocatedSize());
 
   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
   EXPECT_FALSE(Memory::releaseMappedMemory(M3));
@@ -360,11 +360,11 @@ TEST_P(MappedMemoryTest, ZeroNear) {
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(16U, M1.size());
+  EXPECT_LE(16U, M1.allocatedSize());
   EXPECT_NE((void*)nullptr, M2.base());
-  EXPECT_LE(64U, M2.size());
+  EXPECT_LE(64U, M2.allocatedSize());
   EXPECT_NE((void*)nullptr, M3.base());
-  EXPECT_LE(32U, M3.size());
+  EXPECT_LE(32U, M3.allocatedSize());
 
   EXPECT_FALSE(doesOverlap(M1, M2));
   EXPECT_FALSE(doesOverlap(M2, M3));
@@ -387,11 +387,11 @@ TEST_P(MappedMemoryTest, ZeroSizeNear) {
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(16U, M1.size());
+  EXPECT_LE(16U, M1.allocatedSize());
   EXPECT_NE((void*)nullptr, M2.base());
-  EXPECT_LE(64U, M2.size());
+  EXPECT_LE(64U, M2.allocatedSize());
   EXPECT_NE((void*)nullptr, M3.base());
-  EXPECT_LE(32U, M3.size());
+  EXPECT_LE(32U, M3.allocatedSize());
 
   EXPECT_FALSE(doesOverlap(M1, M2));
   EXPECT_FALSE(doesOverlap(M2, M3));
@@ -410,7 +410,7 @@ TEST_P(MappedMemoryTest, UnalignedNear) {
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(sizeof(int), M1.size());
+  EXPECT_LE(sizeof(int), M1.allocatedSize());
 
   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 }