1 //===---------------- SimpleExecutorMemoryManagerTest.cpp -----------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "llvm/ExecutionEngine/Orc/TargetProcess/SimpleExecutorMemoryManager.h"
10 #include "llvm/Testing/Support/Error.h"
11 #include "gtest/gtest.h"
12 
13 #include <limits>
14 #include <vector>
15 
16 using namespace llvm;
17 using namespace llvm::orc;
18 using namespace llvm::orc::shared;
19 using namespace llvm::orc::rt_bootstrap;
20 
21 namespace {
22 
23 orc::shared::CWrapperFunctionResult incrementWrapper(const char *ArgData,
24                                                      size_t ArgSize) {
25   return WrapperFunction<void(SPSExecutorAddr)>::handle(
26              ArgData, ArgSize, [](ExecutorAddr A) { *A.toPtr<int *>() += 1; })
27       .release();
28 }
29 
30 TEST(SimpleExecutorMemoryManagerTest, AllocFinalizeFree) {
31   SimpleExecutorMemoryManager MemMgr;
32 
33   constexpr unsigned AllocSize = 16384;
34   auto Mem = MemMgr.allocate(AllocSize);
35   EXPECT_THAT_ERROR(Mem.takeError(), Succeeded());
36 
37   std::string HW = "Hello, world!";
38 
39   int FinalizeCounter = 0;
40   auto FinalizeCounterAddrArgBuffer =
41       orc::shared::detail::serializeViaSPSToWrapperFunctionResult<
42           SPSArgList<SPSExecutorAddr>>(ExecutorAddr::fromPtr(&FinalizeCounter));
43 
44   int DeallocateCounter = 0;
45   auto DeallocateCounterAddrArgBuffer =
46       orc::shared::detail::serializeViaSPSToWrapperFunctionResult<
47           SPSArgList<SPSExecutorAddr>>(
48           ExecutorAddr::fromPtr(&DeallocateCounter));
49 
50   tpctypes::FinalizeRequest FR;
51   FR.Segments.push_back(
52       tpctypes::SegFinalizeRequest{tpctypes::WPF_Read | tpctypes::WPF_Write,
53                                    *Mem,
54                                    AllocSize,
55                                    {HW.data(), HW.size() + 1}});
56   FR.Actions.push_back(
57       {/* Finalize: */
58        {ExecutorAddr::fromPtr(incrementWrapper),
59         {ExecutorAddr::fromPtr(FinalizeCounterAddrArgBuffer.data()),
60          ExecutorAddrDiff(FinalizeCounterAddrArgBuffer.size())}},
61        /*  Deallocate: */
62        {ExecutorAddr::fromPtr(incrementWrapper),
63         {ExecutorAddr::fromPtr(DeallocateCounterAddrArgBuffer.data()),
64          ExecutorAddrDiff(DeallocateCounterAddrArgBuffer.size())}}});
65 
66   EXPECT_EQ(FinalizeCounter, 0);
67   EXPECT_EQ(DeallocateCounter, 0);
68 
69   auto FinalizeErr = MemMgr.finalize(FR);
70   EXPECT_THAT_ERROR(std::move(FinalizeErr), Succeeded());
71 
72   EXPECT_EQ(FinalizeCounter, 1);
73   EXPECT_EQ(DeallocateCounter, 0);
74 
75   EXPECT_EQ(HW, std::string(Mem->toPtr<const char *>()));
76 
77   auto DeallocateErr = MemMgr.deallocate({*Mem});
78   EXPECT_THAT_ERROR(std::move(DeallocateErr), Succeeded());
79 
80   EXPECT_EQ(FinalizeCounter, 1);
81   EXPECT_EQ(DeallocateCounter, 1);
82 }
83 
84 } // namespace
85