[llvm] 6a4056a - Revert "[JITLink][Orc] Add MemoryMapper interface with InProcess implementation"
Nico Weber via llvm-commits
llvm-commits at lists.llvm.org
Tue Jun 21 06:57:16 PDT 2022
Author: Nico Weber
Date: 2022-06-21T09:56:49-04:00
New Revision: 6a4056ab2ada0046ff97a55a5fb34c2c59504fd1
URL: https://github.com/llvm/llvm-project/commit/6a4056ab2ada0046ff97a55a5fb34c2c59504fd1
DIFF: https://github.com/llvm/llvm-project/commit/6a4056ab2ada0046ff97a55a5fb34c2c59504fd1.diff
LOG: Revert "[JITLink][Orc] Add MemoryMapper interface with InProcess implementation"
This reverts commit 6ede65205073d3cf6b1ed4d101e66eae3e0fc8e6.
Doesn't build on Windows, see https://reviews.llvm.org/D127491#3598773
Added:
Modified:
llvm/lib/ExecutionEngine/Orc/CMakeLists.txt
llvm/unittests/ExecutionEngine/Orc/CMakeLists.txt
Removed:
llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h
llvm/lib/ExecutionEngine/Orc/MemoryMapper.cpp
llvm/unittests/ExecutionEngine/Orc/MemoryMapperTest.cpp
################################################################################
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h b/llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h
deleted file mode 100644
index d023bfbdb5b6f..0000000000000
--- a/llvm/include/llvm/ExecutionEngine/Orc/MemoryMapper.h
+++ /dev/null
@@ -1,115 +0,0 @@
-//===- 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 a unique address identifying the allocation. This address should
- /// be passed to deinitialize to run deallocation actions (and reset
- /// permissions where possible).
- 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(ArrayRef<ExecutorAddr> Allocations,
- OnDeinitializedFunction OnDeInitialized) = 0;
-
- using OnReleasedFunction = unique_function<void(Error)>;
-
- /// Release address space acquired through reserve()
- virtual void release(ArrayRef<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(ArrayRef<ExecutorAddr> Allocations,
- OnDeinitializedFunction OnDeInitialized) override;
-
- void release(ArrayRef<ExecutorAddr> Reservations,
- OnReleasedFunction OnRelease) override;
-
- ~InProcessMemoryMapper() override;
-
-private:
- struct Allocation {
- std::vector<shared::WrapperFunctionCall> DeinitializationActions;
- };
- using AllocationMap = DenseMap<ExecutorAddr, Allocation>;
-
- struct Reservation {
- size_t Size;
- std::vector<ExecutorAddr> Allocations;
- };
- using ReservationMap = DenseMap<void *, Reservation>;
-
- std::mutex Mutex;
- ReservationMap Reservations;
- AllocationMap Allocations;
-};
-
-} // namespace orc
-} // end namespace llvm
-
-#endif // LLVM_EXECUTIONENGINE_ORC_MEMORYMAPPER_H
diff --git a/llvm/lib/ExecutionEngine/Orc/CMakeLists.txt b/llvm/lib/ExecutionEngine/Orc/CMakeLists.txt
index 1c9b9e8a1b31e..cf8e0c85840c9 100644
--- a/llvm/lib/ExecutionEngine/Orc/CMakeLists.txt
+++ b/llvm/lib/ExecutionEngine/Orc/CMakeLists.txt
@@ -23,7 +23,6 @@ add_llvm_component_library(LLVMOrcJIT
LookupAndRecordAddrs.cpp
LLJIT.cpp
MachOPlatform.cpp
- MemoryMapper.cpp
ELFNixPlatform.cpp
Mangling.cpp
ObjectLinkingLayer.cpp
diff --git a/llvm/lib/ExecutionEngine/Orc/MemoryMapper.cpp b/llvm/lib/ExecutionEngine/Orc/MemoryMapper.cpp
deleted file mode 100644
index f00cac3e2c3e9..0000000000000
--- a/llvm/lib/ExecutionEngine/Orc/MemoryMapper.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-//===- 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()].Size = 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);
- Reservations[AI.MappingBase.toPtr<void *>()].Allocations.push_back(MinAddr);
- }
-
- OnInitialized(MinAddr);
-}
-
-void InProcessMemoryMapper::deinitialize(
- ArrayRef<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));
- }
-
- Allocations.erase(Base);
- }
- }
-
- OnDeinitialized(std::move(AllErr));
-}
-
-void InProcessMemoryMapper::release(ArrayRef<ExecutorAddr> Bases,
- OnReleasedFunction OnReleased) {
- Error Err = Error::success();
-
- for (auto Base : Bases) {
- std::vector<ExecutorAddr> AllocAddrs;
- size_t Size;
- {
- std::lock_guard<std::mutex> Lock(Mutex);
- auto &R = Reservations[Base.toPtr<void *>()];
- Size = R.Size;
- AllocAddrs.swap(R.Allocations);
- }
-
- // deinitialize sub allocations
- std::promise<Error> P;
- auto F = P.get_future();
- deinitialize(AllocAddrs, [&](Error Err) { P.set_value(std::move(Err)); });
- if (Error E = F.get()) {
- Err = joinErrors(std::move(Err), std::move(E));
- }
-
- // free the memory
- auto MB = sys::MemoryBlock(Base.toPtr<void *>(), Size);
-
- auto EC = sys::Memory::releaseMappedMemory(MB);
- if (EC) {
- Err = joinErrors(std::move(Err), errorCodeToError(EC));
- }
-
- std::lock_guard<std::mutex> Lock(Mutex);
- Reservations.erase(Base.toPtr<void *>());
- }
-
- OnReleased(std::move(Err));
-}
-
-InProcessMemoryMapper::~InProcessMemoryMapper() {
- std::vector<ExecutorAddr> ReservationAddrs;
- {
- std::lock_guard<std::mutex> Lock(Mutex);
-
- ReservationAddrs.reserve(Reservations.size());
- for (const auto &R : Reservations) {
- ReservationAddrs.push_back(ExecutorAddr::fromPtr(R.getFirst()));
- }
- }
-
- std::promise<Error> P;
- auto F = P.get_future();
- release(ReservationAddrs, [&](Error Err) { P.set_value(std::move(Err)); });
- cantFail(F.get());
-}
-
-} // namespace orc
-
-} // namespace llvm
diff --git a/llvm/unittests/ExecutionEngine/Orc/CMakeLists.txt b/llvm/unittests/ExecutionEngine/Orc/CMakeLists.txt
index dd4028e5302ca..9d45957266b8a 100644
--- a/llvm/unittests/ExecutionEngine/Orc/CMakeLists.txt
+++ b/llvm/unittests/ExecutionEngine/Orc/CMakeLists.txt
@@ -24,7 +24,6 @@ add_llvm_unittest(OrcJITTests
JITTargetMachineBuilderTest.cpp
LazyCallThroughAndReexportsTest.cpp
LookupAndRecordAddrsTest.cpp
- MemoryMapperTest.cpp
ObjectLinkingLayerTest.cpp
OrcCAPITest.cpp
OrcTestCommon.cpp
diff --git a/llvm/unittests/ExecutionEngine/Orc/MemoryMapperTest.cpp b/llvm/unittests/ExecutionEngine/Orc/MemoryMapperTest.cpp
deleted file mode 100644
index f352715429c02..0000000000000
--- a/llvm/unittests/ExecutionEngine/Orc/MemoryMapperTest.cpp
+++ /dev/null
@@ -1,203 +0,0 @@
-//===------------------------ 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> ReleaseAddrs = {Mem2->Start};
- EXPECT_THAT_ERROR(release(*Mapper, ReleaseAddrs), Succeeded());
-
- EXPECT_EQ(InitializeCounter, 3);
- EXPECT_EQ(DeinitializeCounter, 2);
- }
- }
-
- // Implicit deinitialization by the destructor
- EXPECT_EQ(InitializeCounter, 3);
- EXPECT_EQ(DeinitializeCounter, 3);
-}
-
-} // namespace
More information about the llvm-commits
mailing list