[JITLink][Orc] Add MemoryMapper interface with InProcess implementation

[argentite]

Summary

MemoryMapper class takes care of cross-process and in-process address space
reservation, mapping, transferring content and applying protections.

Implementations of this class can support different ways to do this such
as using shared memory, transferring memory contents over EPC or just
mapping memory in the same process (InProcessMemoryMapper).

[lhames]

What we're looking for is a breakdown in responsibilities where:
(1) The MappingJITLinkMemoryManager is responsible for object layout (of blocks into segments), and heap management (subject to constraints that the Mapper will describe).
(2) The Mapper is responsible for address space, physical memory management (and content transfer), and recording and applying actions.

llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h

29–33

Mapping shouldn't be associated with a local address: It just represents the reserved range in the executor.

I don't think we need a separate type for this -- An ExecutorAddrRange should be ideal.

36

typos: offset, relative.

39–45

The current struct has actions associated with the segment. One allocation may contain multiple segments, but only one list of actions -- the actions are associated with the allocation, rather than any particular segment.

Initialize will also need the address of the working memory for each segment.

I think you probably want something more like:

struct AllocInfo {
  struct SegInfo {
    ExecutorAddrDiff Offset;
    const char *WorkingMem;
    size_t ContentSize;
    size_t ZeroFillSize;
    unsigned Prot;
  };
  ExecutorAddr MappingBase;
  std::vector<SegInfo> Segments;
  shared::AllocActions Actions;
};

52

We'll want a prepare method in here. This is just responsible for setting up working memory, so it can be synchronous:

prepare :: [ (executor-addr, content-size, prot) ] -> [ char * ]

58–59

Initialize just needs to return a unique address associated with the recorded dealloc actions in the executor, so under the changes proposed above this would become:

virtual ExecutorAddr initialize(AllocInfo &AI, OnInitializedFunction OnInitialized) = 0;

We'll use this ExecutorAddr as the value for the FinalizedAlloc that we return from the memory manager.

64–65

deinitialize should just take the ExecutorAddr that was returned from initialize, so:

virtual void `deinitialize(ExecutorAddr A, OnDeInitialized) = 0;

[argentite]

Introduced prepare() and Allocation to contain multiple segments and actions

[lhames]

Today was busier than anticipated -- I've read the new patch, but haven't had a chance to try it out yet.

I've added some notes on the prepare method, and will try it out tomorrow morning.

llvm/lib/ExecutionEngine/Orc/MemoryMapper.cpp

39–42

The protection change should still be part of initialize, and prepare can drop the Protections argument.

The prepare method's job is just to associate _working memory_ with the given _executor address_ in such a way that we can follow-up with the content transfer during initialize. For InProcessMapper the executor address doubles as the address of the working memory, so prepare really does reduce to nothing but a char* cast.

For something like EPCMemoryMapper it'll be more interesting: prepare will malloc some memory (or more likely allocate it using the LinkGraphs allocator), and record the association between that allocated working memory and the target address. Then in initialize we'll issue an EPC call to copy the content from working memory over to the executor.

[argentite]

Removed unnecessary protection argument

[lhames]

Finally got to check this out -- I've added some more feedback comments.

This is looking great. I think it's ready for public review, with the aim that we land it in-tree this week.

What do you think? Are you happy with it?

llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h

49

I think you can probably simplify this further and just return a char * -- I don't know of any situation where our working memory allocation could fail.

71–97

Synchronous versions of the APIs? Very interesting. I've been assuming that Mapper would _only_ have MappingJITLinkMemoryManager as a client, and that we'd eventually end up moving the interface into that class (or making it a concept and having MappingJITLinkMemoryManager take a template argument), but maybe it's worth having as a utility in its own right.

Did you have a use-case in mind?

llvm/lib/ExecutionEngine/Orc/MemoryMapper.cpp

66–74

I think you can use runFinalizeActions from AllocationActions.h here.

89–99

I think you can use runDeallocActions from AllocationActions.h here.

133–137

This looks like runDeallocActions again.

llvm/unittests/ExecutionEngine/Orc/MemoryMapperTest.cpp

32

Could you add some comments to this function describing the steps? E.g.

// Define counters -- these will be incremented/decremented in
// finalize/dealloc actions to verify that the actions are run.

38–39

You can write this as:

auto PageSize = cantFail(sys::Process::getPageSize());

That will auto-unwrap the Expected for you.

[argentite]

Simplified prepare return type
Used runFinalizeActions and runDeallocActions instead of reimplementing
Changed some mutex lock scopes

llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h

71–97

Not really. it just felt nicer when writing the tests. We can remove them.

[lhames]

llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h

71–97

I think you should sink them into the testcase as free functions for now. We can lift them back into the class later if we decide we want to encourage this kind of direct use of the Mapper interface.

llvm/unittests/ExecutionEngine/Orc/MemoryMapperTest.cpp

32

Just noticed -- this test should be renamed too. :)

[argentite]

Moved synchronous functions to test and renamed test

[sgraenitz]

Overall, I think this looks pretty good! I didn't follow the design discussions closely, so please bare with me in case some of my questions are dumb :-) In a way it makes sure other people will understand your code as well.

llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h

61

Nit: typo deinitialization

63

In which case do we have multiple ExecutorAddr here? initialize() only returns a single one -- can it run multiple times for a single MemoryMapper? If this is the case, it may deserve a test case and/or a comment.

If we keep the std::vector I guess it should be passed as const std::vector<ExecutorAddr> & -- or is there a design reason for mutability here?

69

The base class doesn't deal with processes. And release() is the inverse operation for reserve() right? Then we might want the comment to reflect that and say something like Release address space in the executor process.

78

What is the reason for the using MemoryMapper::... statements when we only have one base class? My first thought was that it's a hint for another overload in the base class, but it doesn't seem to be the case.

92

Maybe we can add a comment for implict vs. explicit deinit/release somewhere? This seems to be specific for the InProcessMemoryMapper. It took me a while to figure out that the destructor reimplements them (instead of calling) for the implicit case.

llvm/lib/ExecutionEngine/Orc/MemoryMapper.cpp

51

Base = AI.MappingBase + Segment.Offset

69

Can we add a comment that explains the special role of MinAddr in regard to allocation actions here? Thanks

llvm/unittests/ExecutionEngine/Orc/MemoryMapperTest.cpp

145

Alloc1 is testing: explicit deinit + implicit release
Alloc2 is testing: implicit deinit + implicit release

I think they are both good to have. However, the explicit release case has no coverage yet.

[argentite]

Explicit release test and minor fixes

[argentite]

llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h

63

As I understand the a single MemoryMapper should live for the whole duration of JITLink use. When terminating, we can pass the results of multiple initialize to a single deinitialize to save RPC overhead. I have made the vectors const for both deinitialize and release.

78

Ah there were synchronous overloads that we moved to unit test. I forgot to delete them.

92

The plan is to have some kind of implicit deinitialization in all MemoryMappers. The release() and deinitialize() are there for cases where we want to release early without terminating the program. Do you think anything specific that we should mention?

llvm/unittests/ExecutionEngine/Orc/MemoryMapperTest.cpp

145

I have added a test for explicit deinit + explicit release but note that explicit release does not implicitly deinitialize because allocations are not directly tied to a reservation. (Should it?)

[argentite]

release() will implicitly deinitialize() all suballocations to maintain consistency

[lhames]

A couple of small comments, but otherwise LGTM. I think this is ready to land in tree.

Stefan — did you have any other feedback?

llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h

56

I think we want to keep the contract on the address returned by initialize loose:

/// Returns a unique address identifying the allocation. This address should
/// be passed to deinitialize to run deallocation actions (and reset permissions
/// where possible).

The InProcessAllocator uses the lowest allocated address as a key into a DenseMap, but you could imagine schemes that return a pointer to a bookkeeping struct instead.

63

I think that an ArrayRef would do — that way any array-like list of addresses would work.

[sgraenitz]

LGTM. Let's go and land this once Lang's two latest comment got addressed.

llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h

92

With the comments on deinitialize()/release() I think it's ok now.

[argentite]

Used ArrayRef instead of const std::vector& and relaxed initialize() return address restriction

llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h

56

Should we reset permissions? And if so what should we reset to? PROT_NONE?

[sgraenitz]

llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h

56

No, I don't think so. None of the other uses of releaseMappedMemory() in LLVM does it. And if it's relevant for a use-case it could always be done in a dealloc action right?

[thakis]

This breaks the build on Windows: http://45.33.8.238/win/60587/step_4.txt

Please take a look, and revert for now if it takes a while to fix.

[thakis]

Reverted in 6a4056ab2ada0046ff97a55a5fb34c2c59504fd1 for now.

[sgraenitz]

Thanks for taking care of reverting.

The issue is that MSVC's std::future implementation requires default constructible types. It's a known issue, but I had not thought about it during the review. When defining a std::promise we have to use MSVCPError and MSVCPExpected<T> instead of Error and Expected<T> respectively. I will fix it and re-apply the patch.

llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h

+//===- MemoryMapper.h - Cross-process memory mapper -------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Cross-process (and in-process) memory mapping and transfer
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_MEMORYMAPPER_H
+#define LLVM_EXECUTIONENGINE_ORC_MEMORYMAPPER_H
+
+#include "llvm/ExecutionEngine/Orc/Core.h"
+
+#include <mutex>
+
+namespace llvm {
+namespace orc {
+
+/// Manages mapping, content transfer and protections for JIT memory
+class MemoryMapper {
+public:
+  /// Represents a single allocation containing multiple segments and
+  /// initialization and deinitialization actions
+  struct AllocInfo {
+    struct SegInfo {
+      ExecutorAddrDiff Offset;
+      const char *WorkingMem;
+      size_t ContentSize;
+      size_t ZeroFillSize;
+      unsigned Prot;
+    };
+
+    ExecutorAddr MappingBase;
+    std::vector<SegInfo> Segments;
+    shared::AllocActions Actions;
+  };
+
+  using OnReservedFunction = unique_function<void(Expected<ExecutorAddrRange>)>;
+
+  /// Reserves address space in executor process
+  virtual void reserve(size_t NumBytes, OnReservedFunction OnReserved) = 0;
+
+  /// Provides working memory
+  virtual char *prepare(ExecutorAddr Addr, size_t ContentSize) = 0;
+
+  using OnInitializedFunction = unique_function<void(Expected<ExecutorAddr>)>;
+
+  /// Ensures executor memory is synchronized with working copy memory, sends
+  /// functions to be called after initilization and before deinitialization and
+  /// applies memory protections
+  /// Returns minimum address of all the segments as an unique identifier for
+  /// the allocation
+  virtual void initialize(AllocInfo &AI,
+                          OnInitializedFunction OnInitialized) = 0;
+
+  using OnDeinitializedFunction = unique_function<void(Error)>;
+
+  /// Runs previously specified deinitialization actions
+  /// Executor addresses returned by initialize should be passed
+  virtual void deinitialize(const std::vector<ExecutorAddr> &Allocations,
+                            OnDeinitializedFunction OnDeInitialized) = 0;
+
+  using OnReleasedFunction = unique_function<void(Error)>;
+
+  /// Release address space acquired through reserve()
+  virtual void release(const std::vector<ExecutorAddr> &Reservations,
+                       OnReleasedFunction OnRelease) = 0;
+
+  virtual ~MemoryMapper();
+};
+
+class InProcessMemoryMapper final : public MemoryMapper {
+public:
+  InProcessMemoryMapper() {}
+
+  void reserve(size_t NumBytes, OnReservedFunction OnReserved) override;
+
+  void initialize(AllocInfo &AI, OnInitializedFunction OnInitialized) override;
+
+  char *prepare(ExecutorAddr Addr, size_t ContentSize) override;
+
+  void deinitialize(const std::vector<ExecutorAddr> &Allocations,
+                    OnDeinitializedFunction OnDeInitialized) override;
+
+  void release(const std::vector<ExecutorAddr> &Reservations,
+               OnReleasedFunction OnRelease) override;
+
+  ~InProcessMemoryMapper() override;
+
+private:
+  struct Allocation {
+    std::vector<shared::WrapperFunctionCall> DeinitializationActions;
+  };
+  using AllocationMap = DenseMap<ExecutorAddr, Allocation>;
+
+  using ReservationMap = DenseMap<void *, size_t>;
+
+  std::mutex Mutex;
+  ReservationMap Reservations;
+  AllocationMap Allocations;
+};
+
+} // namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_MEMORYMAPPER_H

llvm/lib/ExecutionEngine/Orc/CMakeLists.txt

add_llvm_component_library(LLVMOrcJIT
   IRCompileLayer.cpp
   IRTransformLayer.cpp
   JITTargetMachineBuilder.cpp
   LazyReexports.cpp
   Layer.cpp
   LookupAndRecordAddrs.cpp
   LLJIT.cpp
   MachOPlatform.cpp
+  MemoryMapper.cpp
   ELFNixPlatform.cpp
   Mangling.cpp
   ObjectLinkingLayer.cpp
   ObjectTransformLayer.cpp
   OrcABISupport.cpp
   OrcV2CBindings.cpp
   RTDyldObjectLinkingLayer.cpp
   SimpleRemoteEPC.cpp

llvm/lib/ExecutionEngine/Orc/MemoryMapper.cpp

+//===- MemoryMapper.cpp - Cross-process memory mapper ------------*- C++ -*-==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/Orc/MemoryMapper.h"
+
+namespace llvm {
+namespace orc {
+
+MemoryMapper::~MemoryMapper() {}
+
+void InProcessMemoryMapper::reserve(size_t NumBytes,
+                                    OnReservedFunction OnReserved) {
+  std::error_code EC;
+  auto MB = sys::Memory::allocateMappedMemory(
+      NumBytes, nullptr, sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC);
+
+  if (EC)
+    return OnReserved(errorCodeToError(EC));
+
+  {
+    std::lock_guard<std::mutex> Lock(Mutex);
+    Reservations[MB.base()] = MB.allocatedSize();
+  }
+
+  OnReserved(
+      ExecutorAddrRange(ExecutorAddr::fromPtr(MB.base()), MB.allocatedSize()));
+}
+
+char *InProcessMemoryMapper::prepare(ExecutorAddr Addr, size_t ContentSize) {
+  return Addr.toPtr<char *>();
+}
+
+void InProcessMemoryMapper::initialize(MemoryMapper::AllocInfo &AI,
+                                       OnInitializedFunction OnInitialized) {
+  ExecutorAddr MinAddr(~0ULL);
+
+  for (auto &Segment : AI.Segments) {
+    auto Base = AI.MappingBase + Segment.Offset;
+    auto Size = Segment.ContentSize + Segment.ZeroFillSize;
+
+    if (Base < MinAddr)
+      MinAddr = Base;
+
+    std::memset((Base + Segment.ContentSize).toPtr<void *>(), 0,
+                Segment.ZeroFillSize);
+
+    if (auto EC = sys::Memory::protectMappedMemory({Base.toPtr<void *>(), Size},
+                                                   Segment.Prot)) {
+      return OnInitialized(errorCodeToError(EC));
+    }
+    if (Segment.Prot & sys::Memory::MF_EXEC)
+      sys::Memory::InvalidateInstructionCache(Base.toPtr<void *>(), Size);
+  }
+
+  auto DeinitializeActions = shared::runFinalizeActions(AI.Actions);
+  if (!DeinitializeActions)
+    return OnInitialized(DeinitializeActions.takeError());
+
+  {
+    std::lock_guard<std::mutex> Lock(Mutex);
+    Allocations[MinAddr].DeinitializationActions =
+        std::move(*DeinitializeActions);
+  }
+
+  OnInitialized(MinAddr);
+}
+
+void InProcessMemoryMapper::deinitialize(
+    const std::vector<ExecutorAddr> &Bases,
+    MemoryMapper::OnDeinitializedFunction OnDeinitialized) {
+  Error AllErr = Error::success();
+
+  {
+    std::lock_guard<std::mutex> Lock(Mutex);
+
+    for (auto Base : Bases) {
+
+      if (Error Err = shared::runDeallocActions(
+              Allocations[Base].DeinitializationActions)) {
+        AllErr = joinErrors(std::move(AllErr), std::move(Err));
+        continue;
+      }
+
+      Allocations.erase(Base);
+    }
+  }
+
+  OnDeinitialized(std::move(AllErr));
+}
+
+void InProcessMemoryMapper::release(const std::vector<ExecutorAddr> &Bases,
+                                    OnReleasedFunction OnReleased) {
+  Error Err = Error::success();
+
+  {
+    std::lock_guard<std::mutex> Lock(Mutex);
+
+    for (auto Base : Bases) {
+      auto MB = sys::MemoryBlock(Base.toPtr<void *>(),
+                                 Reservations[Base.toPtr<void *>()]);
+
+      auto EC = sys::Memory::releaseMappedMemory(MB);
+      if (EC) {
+        Err = joinErrors(std::move(Err), errorCodeToError(EC));
+      }
+
+      Reservations.erase(Base.toPtr<void *>());
+    }
+  }
+
+  OnReleased(std::move(Err));
+}
+
+InProcessMemoryMapper::~InProcessMemoryMapper() {
+  std::lock_guard<std::mutex> Lock(Mutex);
+
+  for (auto &A : Allocations)
+    cantFail(shared::runDeallocActions(A.second.DeinitializationActions));
+
+  for (auto &R : Reservations) {
+    sys::MemoryBlock MB = {R.first, R.second};
+    auto EC = sys::Memory::releaseMappedMemory(MB);
+    cantFail(errorCodeToError(EC));
+  }
+}
+
+} // namespace orc
+
+} // namespace llvm

llvm/unittests/ExecutionEngine/Orc/CMakeLists.txt

add_llvm_unittest(OrcJITTests
   ExecutorAddressTest.cpp
   ExecutionSessionWrapperFunctionCallsTest.cpp
   EPCGenericJITLinkMemoryManagerTest.cpp
   EPCGenericMemoryAccessTest.cpp
   IndirectionUtilsTest.cpp
   JITTargetMachineBuilderTest.cpp
   LazyCallThroughAndReexportsTest.cpp
   LookupAndRecordAddrsTest.cpp
+  MemoryMapperTest.cpp
   ObjectLinkingLayerTest.cpp
   OrcCAPITest.cpp
   OrcTestCommon.cpp
   ResourceTrackerTest.cpp
   RTDyldObjectLinkingLayerTest.cpp
   SimpleExecutorMemoryManagerTest.cpp
   SimplePackedSerializationTest.cpp
   SymbolStringPoolTest.cpp

llvm/unittests/ExecutionEngine/Orc/MemoryMapperTest.cpp

+//===------------------------ MemoryMapperTest.cpp ------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/Orc/MemoryMapper.h"
+#include "llvm/Support/Process.h"
+#include "llvm/Testing/Support/Error.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::orc;
+using namespace llvm::orc::shared;
+
+namespace {
+
+Expected<ExecutorAddrRange> reserve(MemoryMapper &M, size_t NumBytes) {
+  std::promise<Expected<ExecutorAddrRange>> P;
+  auto F = P.get_future();
+  M.reserve(NumBytes, [&](auto R) { P.set_value(std::move(R)); });
+  return F.get();
+}
+
+Expected<ExecutorAddr> initialize(MemoryMapper &M,
+                                  MemoryMapper::AllocInfo &AI) {
+  std::promise<Expected<ExecutorAddr>> P;
+  auto F = P.get_future();
+  M.initialize(AI, [&](auto R) { P.set_value(std::move(R)); });
+  return F.get();
+}
+
+Error deinitialize(MemoryMapper &M,
+                   const std::vector<ExecutorAddr> &Allocations) {
+  std::promise<Error> P;
+  auto F = P.get_future();
+  M.deinitialize(Allocations, [&](auto R) { P.set_value(std::move(R)); });
+  return F.get();
+}
+
+Error release(MemoryMapper &M, const std::vector<ExecutorAddr> &Reservations) {
+  std::promise<Error> P;
+  auto F = P.get_future();
+  M.release(Reservations, [&](auto R) { P.set_value(std::move(R)); });
+  return F.get();
+}
+
+// A basic function to be used as both initializer/deinitializer
+orc::shared::CWrapperFunctionResult incrementWrapper(const char *ArgData,
+                                                     size_t ArgSize) {
+  return WrapperFunction<SPSError(SPSExecutorAddr)>::handle(
+             ArgData, ArgSize,
+             [](ExecutorAddr A) -> Error {
+               *A.toPtr<int *>() += 1;
+               return Error::success();
+             })
+      .release();
+}
+
+TEST(MemoryMapperTest, InitializeDeinitialize) {
+  // These counters are used to track how many times the initializer and
+  // deinitializer functions are called
+  int InitializeCounter = 0;
+  int DeinitializeCounter = 0;
+  {
+    std::unique_ptr<MemoryMapper> Mapper =
+        std::make_unique<InProcessMemoryMapper>();
+
+    // We will do two separate allocations
+    auto PageSize = cantFail(sys::Process::getPageSize());
+    auto TotalSize = PageSize * 2;
+
+    // Reserve address space
+    auto Mem1 = reserve(*Mapper, TotalSize);
+    EXPECT_THAT_ERROR(Mem1.takeError(), Succeeded());
+
+    // Test string for memory transfer
+    std::string HW = "Hello, world!";
+
+    {
+      // Provide working memory
+      char *WA1 = Mapper->prepare(Mem1->Start, HW.size() + 1);
+      std::strcpy(static_cast<char *>(WA1), HW.c_str());
+    }
+
+    // A structure to be passed to initialize
+    MemoryMapper::AllocInfo Alloc1;
+    {
+      MemoryMapper::AllocInfo::SegInfo Seg1;
+      Seg1.Offset = 0;
+      Seg1.ContentSize = HW.size();
+      Seg1.ZeroFillSize = PageSize - Seg1.ContentSize;
+      Seg1.Prot = sys::Memory::MF_READ | sys::Memory::MF_WRITE;
+
+      Alloc1.MappingBase = Mem1->Start;
+      Alloc1.Segments.push_back(Seg1);
+      Alloc1.Actions.push_back(
+          {cantFail(WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddr>>(
+               ExecutorAddr::fromPtr(incrementWrapper),
+               ExecutorAddr::fromPtr(&InitializeCounter))),
+           cantFail(WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddr>>(
+               ExecutorAddr::fromPtr(incrementWrapper),
+               ExecutorAddr::fromPtr(&DeinitializeCounter)))});
+    }
+
+    {
+      char *WA2 = Mapper->prepare(Mem1->Start + PageSize, HW.size() + 1);
+      std::strcpy(static_cast<char *>(WA2), HW.c_str());
+    }
+
+    MemoryMapper::AllocInfo Alloc2;
+    {
+      MemoryMapper::AllocInfo::SegInfo Seg2;
+      Seg2.Offset = PageSize;
+      Seg2.ContentSize = HW.size();
+      Seg2.ZeroFillSize = PageSize - Seg2.ContentSize;
+      Seg2.Prot = sys::Memory::MF_READ | sys::Memory::MF_WRITE;
+
+      Alloc2.MappingBase = Mem1->Start;
+      Alloc2.Segments.push_back(Seg2);
+      Alloc2.Actions.push_back(
+          {cantFail(WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddr>>(
+               ExecutorAddr::fromPtr(incrementWrapper),
+               ExecutorAddr::fromPtr(&InitializeCounter))),
+           cantFail(WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddr>>(
+               ExecutorAddr::fromPtr(incrementWrapper),
+               ExecutorAddr::fromPtr(&DeinitializeCounter)))});
+    }
+
+    EXPECT_EQ(InitializeCounter, 0);
+    EXPECT_EQ(DeinitializeCounter, 0);
+
+    // Set memory protections and run initializers
+    auto Init1 = initialize(*Mapper, Alloc1);
+    EXPECT_THAT_ERROR(Init1.takeError(), Succeeded());
+    EXPECT_EQ(HW, std::string(static_cast<char *>(Init1->toPtr<char *>())));
+
+    EXPECT_EQ(InitializeCounter, 1);
+    EXPECT_EQ(DeinitializeCounter, 0);
+
+    auto Init2 = initialize(*Mapper, Alloc2);
+    EXPECT_THAT_ERROR(Init2.takeError(), Succeeded());
+    EXPECT_EQ(HW, std::string(static_cast<char *>(Init2->toPtr<char *>())));
+
+    EXPECT_EQ(InitializeCounter, 2);
+    EXPECT_EQ(DeinitializeCounter, 0);
+
+    // Explicit deinitialization of first allocation
+    std::vector<ExecutorAddr> DeinitAddr = {*Init1};
+    EXPECT_THAT_ERROR(deinitialize(*Mapper, DeinitAddr), Succeeded());
+
+    EXPECT_EQ(InitializeCounter, 2);
+    EXPECT_EQ(DeinitializeCounter, 1);
+
+    // Test explicit release
+    {
+      auto Mem2 = reserve(*Mapper, PageSize);
+      EXPECT_THAT_ERROR(Mem2.takeError(), Succeeded());
+
+      char *WA = Mapper->prepare(Mem2->Start, HW.size() + 1);
+      std::strcpy(static_cast<char *>(WA), HW.c_str());
+
+      MemoryMapper::AllocInfo Alloc3;
+      {
+        MemoryMapper::AllocInfo::SegInfo Seg3;
+        Seg3.Offset = 0;
+        Seg3.ContentSize = HW.size();
+        Seg3.ZeroFillSize = PageSize - Seg3.ContentSize;
+        Seg3.Prot = sys::Memory::MF_READ | sys::Memory::MF_WRITE;
+
+        Alloc3.MappingBase = Mem2->Start;
+        Alloc3.Segments.push_back(Seg3);
+        Alloc3.Actions.push_back(
+            {cantFail(WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddr>>(
+                 ExecutorAddr::fromPtr(incrementWrapper),
+                 ExecutorAddr::fromPtr(&InitializeCounter))),
+             cantFail(WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddr>>(
+                 ExecutorAddr::fromPtr(incrementWrapper),
+                 ExecutorAddr::fromPtr(&DeinitializeCounter)))});
+      }
+      auto Init3 = initialize(*Mapper, Alloc3);
+      EXPECT_THAT_ERROR(Init3.takeError(), Succeeded());
+      EXPECT_EQ(HW, std::string(static_cast<char *>(Init3->toPtr<char *>())));
+
+      EXPECT_EQ(InitializeCounter, 3);
+      EXPECT_EQ(DeinitializeCounter, 1);
+
+      std::vector<ExecutorAddr> DeinitAddrs = {*Init3};
+      EXPECT_THAT_ERROR(deinitialize(*Mapper, DeinitAddrs), Succeeded());
+
+      EXPECT_EQ(InitializeCounter, 3);
+      EXPECT_EQ(DeinitializeCounter, 2);
+
+      std::vector<ExecutorAddr> ReleaseAddrs = {Mem2->Start};
+      EXPECT_THAT_ERROR(release(*Mapper, ReleaseAddrs), Succeeded());
+    }
+  }
+
+  // Implicit deinitialization by the destructor
+  EXPECT_EQ(InitializeCounter, 3);
+  EXPECT_EQ(DeinitializeCounter, 3);
+}
+
+} // namespace