1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
//===---------------- SimpleExecutorMemoryManagerTest.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/TargetProcess/SimpleExecutorMemoryManager.h"
#include "llvm/Testing/Support/Error.h"
#include "gtest/gtest.h"
#include <limits>
#include <vector>
using namespace llvm;
using namespace llvm::orc;
using namespace llvm::orc::shared;
using namespace llvm::orc::rt_bootstrap;
namespace {
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(SimpleExecutorMemoryManagerTest, AllocFinalizeFree) {
SimpleExecutorMemoryManager MemMgr;
constexpr unsigned AllocSize = 16384;
auto Mem = MemMgr.allocate(AllocSize);
EXPECT_THAT_ERROR(Mem.takeError(), Succeeded());
std::string HW = "Hello, world!";
int FinalizeCounter = 0;
int DeallocateCounter = 0;
tpctypes::FinalizeRequest FR;
FR.Segments.push_back(
tpctypes::SegFinalizeRequest{MemProt::Read | MemProt::Write,
*Mem,
AllocSize,
{HW.data(), HW.size() + 1}});
FR.Actions.push_back(
{/* Finalize: */
cantFail(WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddr>>(
ExecutorAddr::fromPtr(incrementWrapper),
ExecutorAddr::fromPtr(&FinalizeCounter))),
/* Deallocate: */
cantFail(WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddr>>(
ExecutorAddr::fromPtr(incrementWrapper),
ExecutorAddr::fromPtr(&DeallocateCounter)))});
EXPECT_EQ(FinalizeCounter, 0);
EXPECT_EQ(DeallocateCounter, 0);
auto FinalizeErr = MemMgr.finalize(FR);
EXPECT_THAT_ERROR(std::move(FinalizeErr), Succeeded());
EXPECT_EQ(FinalizeCounter, 1);
EXPECT_EQ(DeallocateCounter, 0);
EXPECT_EQ(HW, std::string(Mem->toPtr<const char *>()));
auto DeallocateErr = MemMgr.deallocate({*Mem});
EXPECT_THAT_ERROR(std::move(DeallocateErr), Succeeded());
EXPECT_EQ(FinalizeCounter, 1);
EXPECT_EQ(DeallocateCounter, 1);
}
} // namespace
|
