9c456e5eb7
SimpleRemoteMemoryMapper is a MemoryMapper implementation that manages remote memory via EPC-calls to reserve, initialize, deinitialize, and release operations. It is compatible with the SimpleExecutorMemoryManager backend, and its introduction allows MapperJITLinkMemoryManager to use this backend. It is also intended to be compatible with the orc_rt::SimpleNativeMemoryMap backend.
105 lines
3.8 KiB
C++
105 lines
3.8 KiB
C++
//===---- SimpleRemoteMemoryMapper.cpp - Remote 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/SimpleRemoteMemoryMapper.h"
|
|
|
|
#include "llvm/ExecutionEngine/JITLink/JITLink.h"
|
|
#include "llvm/ExecutionEngine/Orc/Shared/OrcRTBridge.h"
|
|
|
|
namespace llvm::orc {
|
|
|
|
SimpleRemoteMemoryMapper::SimpleRemoteMemoryMapper(ExecutorProcessControl &EPC,
|
|
SymbolAddrs SAs)
|
|
: EPC(EPC), SAs(SAs) {}
|
|
|
|
void SimpleRemoteMemoryMapper::reserve(size_t NumBytes,
|
|
OnReservedFunction OnReserved) {
|
|
EPC.callSPSWrapperAsync<rt::SPSSimpleRemoteMemoryMapReserveSignature>(
|
|
SAs.Reserve,
|
|
[NumBytes, OnReserved = std::move(OnReserved)](
|
|
Error SerializationErr, Expected<ExecutorAddr> Result) mutable {
|
|
if (SerializationErr) {
|
|
cantFail(Result.takeError());
|
|
return OnReserved(std::move(SerializationErr));
|
|
}
|
|
|
|
if (Result)
|
|
OnReserved(ExecutorAddrRange(*Result, NumBytes));
|
|
else
|
|
OnReserved(Result.takeError());
|
|
},
|
|
SAs.Instance, static_cast<uint64_t>(NumBytes));
|
|
}
|
|
|
|
char *SimpleRemoteMemoryMapper::prepare(jitlink::LinkGraph &G,
|
|
ExecutorAddr Addr, size_t ContentSize) {
|
|
return G.allocateBuffer(ContentSize).data();
|
|
}
|
|
|
|
void SimpleRemoteMemoryMapper::initialize(MemoryMapper::AllocInfo &AI,
|
|
OnInitializedFunction OnInitialized) {
|
|
|
|
tpctypes::FinalizeRequest FR;
|
|
|
|
std::swap(FR.Actions, AI.Actions);
|
|
FR.Segments.reserve(AI.Segments.size());
|
|
|
|
for (auto Seg : AI.Segments)
|
|
FR.Segments.push_back({Seg.AG, AI.MappingBase + Seg.Offset,
|
|
Seg.ContentSize + Seg.ZeroFillSize,
|
|
ArrayRef<char>(Seg.WorkingMem, Seg.ContentSize)});
|
|
|
|
EPC.callSPSWrapperAsync<rt::SPSSimpleRemoteMemoryMapInitializeSignature>(
|
|
SAs.Initialize,
|
|
[OnInitialized = std::move(OnInitialized)](
|
|
Error SerializationErr, Expected<ExecutorAddr> Result) mutable {
|
|
if (SerializationErr) {
|
|
cantFail(Result.takeError());
|
|
return OnInitialized(std::move(SerializationErr));
|
|
}
|
|
|
|
OnInitialized(std::move(Result));
|
|
},
|
|
SAs.Instance, std::move(FR));
|
|
}
|
|
|
|
void SimpleRemoteMemoryMapper::deinitialize(
|
|
ArrayRef<ExecutorAddr> Allocations,
|
|
MemoryMapper::OnDeinitializedFunction OnDeinitialized) {
|
|
EPC.callSPSWrapperAsync<rt::SPSSimpleRemoteMemoryMapDeinitializeSignature>(
|
|
SAs.Deinitialize,
|
|
[OnDeinitialized = std::move(OnDeinitialized)](Error SerializationErr,
|
|
Error Result) mutable {
|
|
if (SerializationErr) {
|
|
cantFail(std::move(Result));
|
|
return OnDeinitialized(std::move(SerializationErr));
|
|
}
|
|
|
|
OnDeinitialized(std::move(Result));
|
|
},
|
|
SAs.Instance, Allocations);
|
|
}
|
|
|
|
void SimpleRemoteMemoryMapper::release(ArrayRef<ExecutorAddr> Bases,
|
|
OnReleasedFunction OnReleased) {
|
|
EPC.callSPSWrapperAsync<rt::SPSSimpleRemoteMemoryMapReleaseSignature>(
|
|
SAs.Release,
|
|
[OnReleased = std::move(OnReleased)](Error SerializationErr,
|
|
Error Result) mutable {
|
|
if (SerializationErr) {
|
|
cantFail(std::move(Result));
|
|
return OnReleased(std::move(SerializationErr));
|
|
}
|
|
|
|
return OnReleased(std::move(Result));
|
|
},
|
|
SAs.Instance, Bases);
|
|
}
|
|
|
|
} // namespace llvm::orc
|