[MemoryMapper] use thread-local variant for thread-local tests

Clarify this code does not have access to a TaskDispatcher, and thus is
not permitted use of threads, by using a more efficient single-threaded
monostate variant, instead of making it appear that this test could
potentially be a cause of thread-safety concerns (notably deadlock).

Author: vtjnash

llvm/unittests/ExecutionEngine/Orc/MemoryMapperTest.cpp

@@ -12,40 +12,46 @@
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
+#include <variant>
+
 using namespace llvm;
 using namespace llvm::orc;
 using namespace llvm::orc::shared;
 
 namespace {
 
 Expected<ExecutorAddrRange> reserve(MemoryMapper &M, size_t NumBytes) {
-  std::promise<MSVCPExpected<ExecutorAddrRange>> P;
-  auto F = P.get_future();
-  M.reserve(NumBytes, [&](auto R) { P.set_value(std::move(R)); });
-  return F.get();
+  std::variant<std::monostate, Expected<ExecutorAddrRange>> Result;
+  M.reserve(NumBytes, [&](auto R) { Result = std::move(R); });
+  assert(!std::holds_alternative<std::monostate>(Result) &&
+         "MemoryMapper operations should complete synchronously in tests");
+  return std::move(std::get<Expected<ExecutorAddrRange>>(Result));
 }
 
 Expected<ExecutorAddr> initialize(MemoryMapper &M,
                                   MemoryMapper::AllocInfo &AI) {
-  std::promise<MSVCPExpected<ExecutorAddr>> P;
-  auto F = P.get_future();
-  M.initialize(AI, [&](auto R) { P.set_value(std::move(R)); });
-  return F.get();
+  std::variant<std::monostate, Expected<ExecutorAddr>> Result;
+  M.initialize(AI, [&](auto R) { Result = std::move(R); });
+  assert(!std::holds_alternative<std::monostate>(Result) &&
+         "MemoryMapper operations should complete synchronously in tests");
+  return std::move(std::get<Expected<ExecutorAddr>>(Result));
 }
 
 Error deinitialize(MemoryMapper &M,
                    const std::vector<ExecutorAddr> &Allocations) {
-  std::promise<MSVCPError> P;
-  auto F = P.get_future();
-  M.deinitialize(Allocations, [&](auto R) { P.set_value(std::move(R)); });
-  return F.get();
+  std::variant<std::monostate, Error> Result;
+  M.deinitialize(Allocations, [&](auto R) { Result = std::move(R); });
+  assert(!std::holds_alternative<std::monostate>(Result) &&
+         "MemoryMapper operations should complete synchronously in tests");
+  return std::move(std::get<Error>(Result));
 }
 
 Error release(MemoryMapper &M, const std::vector<ExecutorAddr> &Reservations) {
-  std::promise<MSVCPError> P;
-  auto F = P.get_future();
-  M.release(Reservations, [&](auto R) { P.set_value(std::move(R)); });
-  return F.get();
+  std::variant<std::monostate, Error> Result;
+  M.release(Reservations, [&](auto R) { Result = std::move(R); });
+  assert(!std::holds_alternative<std::monostate>(Result) &&
+         "MemoryMapper operations should complete synchronously in tests");
+  return std::move(std::get<Error>(Result));
 }
 
 // A basic function to be used as both initializer/deinitializer

llvm/unittests/ExecutionEngine/Orc/WrapperFunctionUtilsTest.cpp

@@ -11,7 +11,7 @@
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
-#include <future>
+#include <variant>
 
 using namespace llvm;
 using namespace llvm::orc;
@@ -114,29 +114,29 @@ static void voidNoopAsync(unique_function<void(SPSEmpty)> SendResult) {
 
 static WrapperFunctionResult voidNoopAsyncWrapper(const char *ArgData,
                                                   size_t ArgSize) {
-  std::promise<WrapperFunctionResult> RP;
-  auto RF = RP.get_future();
+  std::variant<std::monostate, WrapperFunctionResult> Result;
 
   WrapperFunction<void()>::handleAsync(
-      ArgData, ArgSize,
-      [&](WrapperFunctionResult R) { RP.set_value(std::move(R)); },
+      ArgData, ArgSize, [&](WrapperFunctionResult R) { Result = std::move(R); },
       voidNoopAsync);
 
-  return RF.get();
+  assert(!std::holds_alternative<std::monostate>(Result) &&
+         "handleAsync should complete synchronously in tests");
+  return std::move(std::get<WrapperFunctionResult>(Result));
 }
 
 static WrapperFunctionResult addAsyncWrapper(const char *ArgData,
                                              size_t ArgSize) {
-  std::promise<WrapperFunctionResult> RP;
-  auto RF = RP.get_future();
+  std::variant<std::monostate, WrapperFunctionResult> Result;
 
   WrapperFunction<int32_t(int32_t, int32_t)>::handleAsync(
-      ArgData, ArgSize,
-      [&](WrapperFunctionResult R) { RP.set_value(std::move(R)); },
+      ArgData, ArgSize, [&](WrapperFunctionResult R) { Result = std::move(R); },
       [](unique_function<void(int32_t)> SendResult, int32_t X, int32_t Y) {
         SendResult(X + Y);
       });
-  return RF.get();
+  assert(!std::holds_alternative<std::monostate>(Result) &&
+         "handleAsync should complete synchronously in tests");
+  return std::move(std::get<WrapperFunctionResult>(Result));
 }
 
 TEST(WrapperFunctionUtilsTest, WrapperFunctionCallAndHandleAsyncVoid) {