[llvm] e7efd37 - Revert "Re-apply [ORC] Unify task dispatch across ExecutionSession and..."
Lang Hames via llvm-commits
llvm-commits at lists.llvm.org
Mon Apr 22 17:53:46 PDT 2024
Author: Lang Hames
Date: 2024-04-22T16:53:34-08:00
New Revision: e7efd37c2296f329fb0fd687dd0cfb846d47480f
URL: https://github.com/llvm/llvm-project/commit/e7efd37c2296f329fb0fd687dd0cfb846d47480f
DIFF: https://github.com/llvm/llvm-project/commit/e7efd37c2296f329fb0fd687dd0cfb846d47480f.diff
LOG: Revert "Re-apply [ORC] Unify task dispatch across ExecutionSession and..."
This reverts commit 1effa19de24 while I investigate the test failure at
https://lab.llvm.org/buildbot/#/builders/285/builds/888.
Added:
Modified:
llvm/include/llvm/ExecutionEngine/Orc/Core.h
llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h
llvm/include/llvm/ExecutionEngine/Orc/TaskDispatch.h
llvm/lib/ExecutionEngine/Orc/ExecutorProcessControl.cpp
llvm/lib/ExecutionEngine/Orc/LLJIT.cpp
llvm/lib/ExecutionEngine/Orc/TaskDispatch.cpp
llvm/tools/llvm-jitlink/llvm-jitlink.cpp
llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.cpp
llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h
llvm/unittests/ExecutionEngine/Orc/TaskDispatchTest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/Core.h b/llvm/include/llvm/ExecutionEngine/Orc/Core.h
index bac923aba02afd..7121b3fe762748 100644
--- a/llvm/include/llvm/ExecutionEngine/Orc/Core.h
+++ b/llvm/include/llvm/ExecutionEngine/Orc/Core.h
@@ -1443,6 +1443,9 @@ class ExecutionSession {
/// Send a result to the remote.
using SendResultFunction = unique_function<void(shared::WrapperFunctionResult)>;
+ /// For dispatching ORC tasks (typically materialization tasks).
+ using DispatchTaskFunction = unique_function<void(std::unique_ptr<Task> T)>;
+
/// An asynchronous wrapper-function callable from the executor via
/// jit-dispatch.
using JITDispatchHandlerFunction = unique_function<void(
@@ -1565,6 +1568,12 @@ class ExecutionSession {
/// Unhandled errors can be sent here to log them.
void reportError(Error Err) { ReportError(std::move(Err)); }
+ /// Set the task dispatch function.
+ ExecutionSession &setDispatchTask(DispatchTaskFunction DispatchTask) {
+ this->DispatchTask = std::move(DispatchTask);
+ return *this;
+ }
+
/// Search the given JITDylibs to find the flags associated with each of the
/// given symbols.
void lookupFlags(LookupKind K, JITDylibSearchOrder SearchOrder,
@@ -1639,7 +1648,7 @@ class ExecutionSession {
void dispatchTask(std::unique_ptr<Task> T) {
assert(T && "T must be non-null");
DEBUG_WITH_TYPE("orc", dumpDispatchInfo(*T));
- EPC->getDispatcher().dispatch(std::move(T));
+ DispatchTask(std::move(T));
}
/// Run a wrapper function in the executor.
@@ -1753,6 +1762,8 @@ class ExecutionSession {
logAllUnhandledErrors(std::move(Err), errs(), "JIT session error: ");
}
+ static void runOnCurrentThread(std::unique_ptr<Task> T) { T->run(); }
+
void dispatchOutstandingMUs();
static std::unique_ptr<MaterializationResponsibility>
@@ -1858,6 +1869,7 @@ class ExecutionSession {
std::unique_ptr<ExecutorProcessControl> EPC;
std::unique_ptr<Platform> P;
ErrorReporter ReportError = logErrorsToStdErr;
+ DispatchTaskFunction DispatchTask = runOnCurrentThread;
std::vector<ResourceManager *> ResourceManagers;
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h b/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h
index 3a71ddc88ce956..810a38f4a6acb8 100644
--- a/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h
+++ b/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h
@@ -254,6 +254,7 @@ class LLJIT {
DataLayout DL;
Triple TT;
+ std::unique_ptr<DefaultThreadPool> CompileThreads;
std::unique_ptr<ObjectLayer> ObjLinkingLayer;
std::unique_ptr<ObjectTransformLayer> ObjTransformLayer;
@@ -324,7 +325,6 @@ class LLJITBuilderState {
PlatformSetupFunction SetUpPlatform;
NotifyCreatedFunction NotifyCreated;
unsigned NumCompileThreads = 0;
- std::optional<bool> SupportConcurrentCompilation;
/// Called prior to JIT class construcion to fix up defaults.
Error prepareForConstruction();
@@ -333,7 +333,7 @@ class LLJITBuilderState {
template <typename JITType, typename SetterImpl, typename State>
class LLJITBuilderSetters {
public:
- /// Set an ExecutorProcessControl for this instance.
+ /// Set a ExecutorProcessControl for this instance.
/// This should not be called if ExecutionSession has already been set.
SetterImpl &
setExecutorProcessControl(std::unique_ptr<ExecutorProcessControl> EPC) {
@@ -462,26 +462,19 @@ class LLJITBuilderSetters {
///
/// If this method is not called, behavior will be as if it were called with
/// a zero argument.
- ///
- /// This setting should not be used if a custom ExecutionSession or
- /// ExecutorProcessControl object is set: in those cases a custom
- /// TaskDispatcher should be used instead.
SetterImpl &setNumCompileThreads(unsigned NumCompileThreads) {
impl().NumCompileThreads = NumCompileThreads;
return impl();
}
- /// If set, this forces LLJIT concurrent compilation support to be either on
- /// or off. This controls the selection of compile function (concurrent vs
- /// single threaded) and whether or not sub-modules are cloned to new
- /// contexts for lazy emission.
+ /// Set an ExecutorProcessControl object.
///
- /// If not explicitly set then concurrency support will be turned on if
- /// NumCompileThreads is set to a non-zero value, or if a custom
- /// ExecutionSession or ExecutorProcessControl instance is provided.
- SetterImpl &setSupportConcurrentCompilation(
- std::optional<bool> SupportConcurrentCompilation) {
- impl().SupportConcurrentCompilation = SupportConcurrentCompilation;
+ /// If the platform uses ObjectLinkingLayer by default and no
+ /// ObjectLinkingLayerCreator has been set then the ExecutorProcessControl
+ /// object will be used to supply the memory manager for the
+ /// ObjectLinkingLayer.
+ SetterImpl &setExecutorProcessControl(ExecutorProcessControl &EPC) {
+ impl().EPC = &EPC;
return impl();
}
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/TaskDispatch.h b/llvm/include/llvm/ExecutionEngine/Orc/TaskDispatch.h
index 8c65677aae25a4..8c287f9fec0e89 100644
--- a/llvm/include/llvm/ExecutionEngine/Orc/TaskDispatch.h
+++ b/llvm/include/llvm/ExecutionEngine/Orc/TaskDispatch.h
@@ -23,7 +23,6 @@
#if LLVM_ENABLE_THREADS
#include <condition_variable>
-#include <deque>
#include <mutex>
#include <thread>
#endif
@@ -115,9 +114,6 @@ class InPlaceTaskDispatcher : public TaskDispatcher {
class DynamicThreadPoolTaskDispatcher : public TaskDispatcher {
public:
- DynamicThreadPoolTaskDispatcher(
- std::optional<size_t> MaxMaterializationThreads)
- : MaxMaterializationThreads(MaxMaterializationThreads) {}
void dispatch(std::unique_ptr<Task> T) override;
void shutdown() override;
private:
@@ -125,10 +121,6 @@ class DynamicThreadPoolTaskDispatcher : public TaskDispatcher {
bool Running = true;
size_t Outstanding = 0;
std::condition_variable OutstandingCV;
-
- std::optional<size_t> MaxMaterializationThreads;
- size_t NumMaterializationThreads = 0;
- std::deque<std::unique_ptr<Task>> MaterializationTaskQueue;
};
#endif // LLVM_ENABLE_THREADS
diff --git a/llvm/lib/ExecutionEngine/Orc/ExecutorProcessControl.cpp b/llvm/lib/ExecutionEngine/Orc/ExecutorProcessControl.cpp
index 4081bc80f4c859..efafca949e61ef 100644
--- a/llvm/lib/ExecutionEngine/Orc/ExecutorProcessControl.cpp
+++ b/llvm/lib/ExecutionEngine/Orc/ExecutorProcessControl.cpp
@@ -63,7 +63,7 @@ SelfExecutorProcessControl::Create(
if (!D) {
#if LLVM_ENABLE_THREADS
- D = std::make_unique<DynamicThreadPoolTaskDispatcher>(std::nullopt);
+ D = std::make_unique<DynamicThreadPoolTaskDispatcher>();
#else
D = std::make_unique<InPlaceTaskDispatcher>();
#endif
diff --git a/llvm/lib/ExecutionEngine/Orc/LLJIT.cpp b/llvm/lib/ExecutionEngine/Orc/LLJIT.cpp
index 53f13a68c7b8b3..79adda5b7bc034 100644
--- a/llvm/lib/ExecutionEngine/Orc/LLJIT.cpp
+++ b/llvm/lib/ExecutionEngine/Orc/LLJIT.cpp
@@ -667,37 +667,6 @@ Error LLJITBuilderState::prepareForConstruction() {
return JTMBOrErr.takeError();
}
- if ((ES || EPC) && NumCompileThreads)
- return make_error<StringError>(
- "NumCompileThreads cannot be used with a custom ExecutionSession or "
- "ExecutorProcessControl",
- inconvertibleErrorCode());
-
-#if !LLVM_ENABLE_THREADS
- if (NumCompileThreads)
- return make_error<StringError>(
- "LLJIT num-compile-threads is " + Twine(NumCompileThreads) +
- " but LLVM was compiled with LLVM_ENABLE_THREADS=Off",
- inconvertibleErrorCode());
-#endif // !LLVM_ENABLE_THREADS
-
- bool ConcurrentCompilationSettingDefaulted = !SupportConcurrentCompilation;
- if (!SupportConcurrentCompilation) {
-#if LLVM_ENABLE_THREADS
- SupportConcurrentCompilation = NumCompileThreads || ES || EPC;
-#else
- SupportConcurrentCompilation = false;
-#endif // LLVM_ENABLE_THREADS
- } else {
-#if !LLVM_ENABLE_THREADS
- if (*SupportConcurrentCompilation)
- return make_error<StringError>(
- "LLJIT concurrent compilation support requested, but LLVM was built "
- "with LLVM_ENABLE_THREADS=Off",
- inconvertibleErrorCode());
-#endif // !LLVM_ENABLE_THREADS
- }
-
LLVM_DEBUG({
dbgs() << " JITTargetMachineBuilder is "
<< JITTargetMachineBuilderPrinter(*JTMB, " ")
@@ -715,13 +684,11 @@ Error LLJITBuilderState::prepareForConstruction() {
<< (CreateCompileFunction ? "Yes" : "No") << "\n"
<< " Custom platform-setup function: "
<< (SetUpPlatform ? "Yes" : "No") << "\n"
- << " Support concurrent compilation: "
- << (*SupportConcurrentCompilation ? "Yes" : "No");
- if (ConcurrentCompilationSettingDefaulted)
- dbgs() << " (defaulted based on ES / EPC)\n";
+ << " Number of compile threads: " << NumCompileThreads;
+ if (!NumCompileThreads)
+ dbgs() << " (code will be compiled on the execution thread)\n";
else
dbgs() << "\n";
- dbgs() << " Number of compile threads: " << NumCompileThreads << "\n";
});
// Create DL if not specified.
@@ -738,19 +705,7 @@ Error LLJITBuilderState::prepareForConstruction() {
dbgs() << "ExecutorProcessControl not specified, "
"Creating SelfExecutorProcessControl instance\n";
});
-
- std::unique_ptr<TaskDispatcher> D = nullptr;
-#if LLVM_ENABLE_THREADS
- if (*SupportConcurrentCompilation) {
- std::optional<size_t> NumThreads = std ::nullopt;
- if (NumCompileThreads)
- NumThreads = NumCompileThreads;
- D = std::make_unique<DynamicThreadPoolTaskDispatcher>(NumThreads);
- } else
- D = std::make_unique<InPlaceTaskDispatcher>();
-#endif // LLVM_ENABLE_THREADS
- if (auto EPCOrErr =
- SelfExecutorProcessControl::Create(nullptr, std::move(D), nullptr))
+ if (auto EPCOrErr = SelfExecutorProcessControl::Create())
EPC = std::move(*EPCOrErr);
else
return EPCOrErr.takeError();
@@ -835,6 +790,8 @@ Error LLJITBuilderState::prepareForConstruction() {
}
LLJIT::~LLJIT() {
+ if (CompileThreads)
+ CompileThreads->wait();
if (auto Err = ES->endSession())
ES->reportError(std::move(Err));
}
@@ -959,8 +916,9 @@ LLJIT::createCompileFunction(LLJITBuilderState &S,
if (S.CreateCompileFunction)
return S.CreateCompileFunction(std::move(JTMB));
- // If using a custom EPC then use a ConcurrentIRCompiler by default.
- if (*S.SupportConcurrentCompilation)
+ // Otherwise default to creating a SimpleCompiler, or ConcurrentIRCompiler,
+ // depending on the number of threads requested.
+ if (S.NumCompileThreads > 0)
return std::make_unique<ConcurrentIRCompiler>(std::move(JTMB));
auto TM = JTMB.createTargetMachine();
@@ -1012,8 +970,21 @@ LLJIT::LLJIT(LLJITBuilderState &S, Error &Err)
std::make_unique<IRTransformLayer>(*ES, *TransformLayer);
}
- if (*S.SupportConcurrentCompilation)
+ if (S.NumCompileThreads > 0) {
InitHelperTransformLayer->setCloneToNewContextOnEmit(true);
+ CompileThreads = std::make_unique<DefaultThreadPool>(
+ hardware_concurrency(S.NumCompileThreads));
+ ES->setDispatchTask([this](std::unique_ptr<Task> T) {
+ // FIXME: We should be able to use move-capture here, but ThreadPool's
+ // AsyncTaskTys are std::functions rather than unique_functions
+ // (because MSVC's std::packaged_tasks don't support move-only types).
+ // Fix this when all the above gets sorted out.
+ CompileThreads->async([UnownedT = T.release()]() mutable {
+ std::unique_ptr<Task> T(UnownedT);
+ T->run();
+ });
+ });
+ }
if (S.SetupProcessSymbolsJITDylib) {
if (auto ProcSymsJD = S.SetupProcessSymbolsJITDylib(*this)) {
@@ -1269,7 +1240,7 @@ LLLazyJIT::LLLazyJIT(LLLazyJITBuilderState &S, Error &Err) : LLJIT(S, Err) {
CODLayer = std::make_unique<CompileOnDemandLayer>(
*ES, *InitHelperTransformLayer, *LCTMgr, std::move(ISMBuilder));
- if (*S.SupportConcurrentCompilation)
+ if (S.NumCompileThreads > 0)
CODLayer->setCloneToNewContextOnEmit(true);
}
diff --git a/llvm/lib/ExecutionEngine/Orc/TaskDispatch.cpp b/llvm/lib/ExecutionEngine/Orc/TaskDispatch.cpp
index 4ac2a42091858e..11a99986f2ee92 100644
--- a/llvm/lib/ExecutionEngine/Orc/TaskDispatch.cpp
+++ b/llvm/lib/ExecutionEngine/Orc/TaskDispatch.cpp
@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "llvm/ExecutionEngine/Orc/TaskDispatch.h"
-#include "llvm/ExecutionEngine/Orc/Core.h"
namespace llvm {
namespace orc {
@@ -25,52 +24,16 @@ void InPlaceTaskDispatcher::shutdown() {}
#if LLVM_ENABLE_THREADS
void DynamicThreadPoolTaskDispatcher::dispatch(std::unique_ptr<Task> T) {
- bool IsMaterializationTask = isa<MaterializationTask>(*T);
-
{
std::lock_guard<std::mutex> Lock(DispatchMutex);
-
- if (IsMaterializationTask) {
-
- // If this is a materialization task and there are too many running
- // already then queue this one up and return early.
- if (MaxMaterializationThreads &&
- NumMaterializationThreads == *MaxMaterializationThreads) {
- MaterializationTaskQueue.push_back(std::move(T));
- return;
- }
-
- // Otherwise record that we have a materialization task running.
- ++NumMaterializationThreads;
- }
-
++Outstanding;
}
- std::thread([this, T = std::move(T), IsMaterializationTask]() mutable {
- while (true) {
-
- // Run the task.
- T->run();
-
- std::lock_guard<std::mutex> Lock(DispatchMutex);
- if (!MaterializationTaskQueue.empty()) {
- // If there are any materialization tasks running then steal that work.
- T = std::move(MaterializationTaskQueue.front());
- MaterializationTaskQueue.pop_front();
- if (!IsMaterializationTask) {
- ++NumMaterializationThreads;
- IsMaterializationTask = true;
- }
- } else {
- // Otherwise decrement work counters.
- if (IsMaterializationTask)
- --NumMaterializationThreads;
- --Outstanding;
- OutstandingCV.notify_all();
- return;
- }
- }
+ std::thread([this, T = std::move(T)]() mutable {
+ T->run();
+ std::lock_guard<std::mutex> Lock(DispatchMutex);
+ --Outstanding;
+ OutstandingCV.notify_all();
}).detach();
}
diff --git a/llvm/tools/llvm-jitlink/llvm-jitlink.cpp b/llvm/tools/llvm-jitlink/llvm-jitlink.cpp
index bff05b9ca4bebc..09b2a5900eb0b7 100644
--- a/llvm/tools/llvm-jitlink/llvm-jitlink.cpp
+++ b/llvm/tools/llvm-jitlink/llvm-jitlink.cpp
@@ -807,8 +807,8 @@ static Expected<std::unique_ptr<ExecutorProcessControl>> launchExecutor() {
S.CreateMemoryManager = createSharedMemoryManager;
return SimpleRemoteEPC::Create<FDSimpleRemoteEPCTransport>(
- std::make_unique<DynamicThreadPoolTaskDispatcher>(std::nullopt),
- std::move(S), FromExecutor[ReadEnd], ToExecutor[WriteEnd]);
+ std::make_unique<DynamicThreadPoolTaskDispatcher>(), std::move(S),
+ FromExecutor[ReadEnd], ToExecutor[WriteEnd]);
#endif
}
@@ -897,7 +897,7 @@ static Expected<std::unique_ptr<ExecutorProcessControl>> connectToExecutor() {
S.CreateMemoryManager = createSharedMemoryManager;
return SimpleRemoteEPC::Create<FDSimpleRemoteEPCTransport>(
- std::make_unique<DynamicThreadPoolTaskDispatcher>(std::nullopt),
+ std::make_unique<DynamicThreadPoolTaskDispatcher>(),
std::move(S), *SockFD, *SockFD);
#endif
}
diff --git a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
index 3b24e29e1ed386..5e2b5f35bcf471 100644
--- a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
@@ -1005,11 +1005,11 @@ TEST_F(CoreAPIsStandardTest, RedefineBoundWeakSymbol) {
TEST_F(CoreAPIsStandardTest, DefineMaterializingSymbol) {
bool ExpectNoMoreMaterialization = false;
- DispatchOverride = [&](std::unique_ptr<Task> T) {
+ ES.setDispatchTask([&](std::unique_ptr<Task> T) {
if (ExpectNoMoreMaterialization && isa<MaterializationTask>(*T))
ADD_FAILURE() << "Unexpected materialization";
T->run();
- };
+ });
auto MU = std::make_unique<SimpleMaterializationUnit>(
SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
@@ -1403,7 +1403,7 @@ TEST_F(CoreAPIsStandardTest, TestLookupWithThreadedMaterialization) {
std::mutex WorkThreadsMutex;
std::vector<std::thread> WorkThreads;
- DispatchOverride = [&](std::unique_ptr<Task> T) {
+ ES.setDispatchTask([&](std::unique_ptr<Task> T) {
std::promise<void> WaitP;
std::lock_guard<std::mutex> Lock(WorkThreadsMutex);
WorkThreads.push_back(
@@ -1412,7 +1412,7 @@ TEST_F(CoreAPIsStandardTest, TestLookupWithThreadedMaterialization) {
T->run();
}));
WaitP.set_value();
- };
+ });
cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
diff --git a/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.cpp b/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.cpp
index 307f14dfe24d03..bc87df1fe8c6a9 100644
--- a/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.cpp
@@ -22,18 +22,3 @@ ModuleBuilder::ModuleBuilder(LLVMContext &Context, StringRef Triple,
if (Triple != "")
M->setTargetTriple(Triple);
}
-
-void llvm::orc::CoreAPIsBasedStandardTest::OverridableDispatcher::dispatch(
- std::unique_ptr<Task> T) {
- if (Parent.DispatchOverride)
- Parent.DispatchOverride(std::move(T));
- else
- InPlaceTaskDispatcher::dispatch(std::move(T));
-}
-
-std::unique_ptr<llvm::orc::ExecutorProcessControl>
-llvm::orc::CoreAPIsBasedStandardTest::makeEPC(
- std::shared_ptr<SymbolStringPool> SSP) {
- return std::make_unique<UnsupportedExecutorProcessControl>(
- std::move(SSP), std::make_unique<OverridableDispatcher>(*this));
-}
diff --git a/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h b/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h
index 0981f4b8132bd0..ce7da76c9653a3 100644
--- a/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h
+++ b/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h
@@ -52,20 +52,8 @@ class CoreAPIsBasedStandardTest : public testing::Test {
}
protected:
- class OverridableDispatcher : public InPlaceTaskDispatcher {
- public:
- OverridableDispatcher(CoreAPIsBasedStandardTest &Parent) : Parent(Parent) {}
- void dispatch(std::unique_ptr<Task> T) override;
-
- private:
- CoreAPIsBasedStandardTest &Parent;
- };
-
- std::unique_ptr<llvm::orc::ExecutorProcessControl>
- makeEPC(std::shared_ptr<SymbolStringPool> SSP);
-
std::shared_ptr<SymbolStringPool> SSP = std::make_shared<SymbolStringPool>();
- ExecutionSession ES{makeEPC(SSP)};
+ ExecutionSession ES{std::make_unique<UnsupportedExecutorProcessControl>(SSP)};
JITDylib &JD = ES.createBareJITDylib("JD");
SymbolStringPtr Foo = ES.intern("foo");
SymbolStringPtr Bar = ES.intern("bar");
@@ -79,7 +67,6 @@ class CoreAPIsBasedStandardTest : public testing::Test {
ExecutorSymbolDef BarSym{BarAddr, JITSymbolFlags::Exported};
ExecutorSymbolDef BazSym{BazAddr, JITSymbolFlags::Exported};
ExecutorSymbolDef QuxSym{QuxAddr, JITSymbolFlags::Exported};
- unique_function<void(std::unique_ptr<Task>)> DispatchOverride;
};
} // end namespace orc
diff --git a/llvm/unittests/ExecutionEngine/Orc/TaskDispatchTest.cpp b/llvm/unittests/ExecutionEngine/Orc/TaskDispatchTest.cpp
index 6af0d60cf8ae6a..83d386c631dddb 100644
--- a/llvm/unittests/ExecutionEngine/Orc/TaskDispatchTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/TaskDispatchTest.cpp
@@ -24,7 +24,7 @@ TEST(InPlaceTaskDispatchTest, GenericNamedTask) {
#if LLVM_ENABLE_THREADS
TEST(DynamicThreadPoolDispatchTest, GenericNamedTask) {
- auto D = std::make_unique<DynamicThreadPoolTaskDispatcher>(std::nullopt);
+ auto D = std::make_unique<DynamicThreadPoolTaskDispatcher>();
std::promise<bool> P;
auto F = P.get_future();
D->dispatch(makeGenericNamedTask(
More information about the llvm-commits
mailing list