From: Matthew Parkinson Date: Tue, 2 Feb 2021 18:15:19 +0000 (+0000) Subject: Fix namespace for MLIR Async Runtime X-Git-Tag: llvmorg-14-init~16231 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=b7d80058ff4649d1a15ef930269458dbb17145d9;p=platform%2Fupstream%2Fllvm.git Fix namespace for MLIR Async Runtime The MLIR Async runtime uses different namespacing for the header file, and the definitions of its C API. The header file places the extern "C" functions inside namespace mlir::runtime, and the definitions are not in a namespace. This causes issues in cl.exe. It treats the declaration and definition as different, and thus does not apply dllexport to the definition, which leads to the mlir_async_runtime.dll containing no definitions, and the mlir_async_runtime.lib not being generated. This patch moves the namespace to cover the definitions, and thus generates the dll correctly on Windows with cl.exe. This was tested with Visual Studio C++ 19.28.29336. Differential Revision: https://reviews.llvm.org/D95386 --- diff --git a/mlir/include/mlir/ExecutionEngine/AsyncRuntime.h b/mlir/include/mlir/ExecutionEngine/AsyncRuntime.h index 0fe44cd..d5cede3 100644 --- a/mlir/include/mlir/ExecutionEngine/AsyncRuntime.h +++ b/mlir/include/mlir/ExecutionEngine/AsyncRuntime.h @@ -16,21 +16,10 @@ #include -#ifdef _WIN32 -#ifndef MLIR_ASYNCRUNTIME_EXPORT #ifdef mlir_async_runtime_EXPORTS // We are building this library -#define MLIR_ASYNCRUNTIME_EXPORT __declspec(dllexport) #define MLIR_ASYNCRUNTIME_DEFINE_FUNCTIONS -#else -// We are using this library -#define MLIR_ASYNCRUNTIME_EXPORT __declspec(dllimport) #endif // mlir_async_runtime_EXPORTS -#endif // MLIR_ASYNCRUNTIME_EXPORT -#else -#define MLIR_ASYNCRUNTIME_EXPORT -#define MLIR_ASYNCRUNTIME_DEFINE_FUNCTIONS -#endif // _WIN32 namespace mlir { namespace runtime { @@ -62,78 +51,67 @@ using CoroResume = void (*)(void *); // coroutine resume function using RefCountedObjPtr = void *; // Adds references to reference counted runtime object. -extern "C" MLIR_ASYNCRUNTIME_EXPORT void - mlirAsyncRuntimeAddRef(RefCountedObjPtr, int32_t); +extern "C" void mlirAsyncRuntimeAddRef(RefCountedObjPtr, int32_t); // Drops references from reference counted runtime object. -extern "C" MLIR_ASYNCRUNTIME_EXPORT void - mlirAsyncRuntimeDropRef(RefCountedObjPtr, int32_t); +extern "C" void mlirAsyncRuntimeDropRef(RefCountedObjPtr, int32_t); // Create a new `async.token` in not-ready state. -extern "C" MLIR_ASYNCRUNTIME_EXPORT AsyncToken *mlirAsyncRuntimeCreateToken(); +extern "C" AsyncToken *mlirAsyncRuntimeCreateToken(); // Create a new `async.value` in not-ready state. Size parameter specifies the // number of bytes that will be allocated for the async value storage. Storage // is owned by the `async.value` and deallocated when the async value is // destructed (reference count drops to zero). -extern "C" MLIR_ASYNCRUNTIME_EXPORT AsyncValue * - mlirAsyncRuntimeCreateValue(int32_t); +extern "C" AsyncValue *mlirAsyncRuntimeCreateValue(int32_t); // Create a new `async.group` in empty state. -extern "C" MLIR_ASYNCRUNTIME_EXPORT AsyncGroup *mlirAsyncRuntimeCreateGroup(); +extern "C" AsyncGroup *mlirAsyncRuntimeCreateGroup(); -extern "C" MLIR_ASYNCRUNTIME_EXPORT int64_t -mlirAsyncRuntimeAddTokenToGroup(AsyncToken *, AsyncGroup *); +extern "C" int64_t mlirAsyncRuntimeAddTokenToGroup(AsyncToken *, AsyncGroup *); // Switches `async.token` to ready state and runs all awaiters. -extern "C" MLIR_ASYNCRUNTIME_EXPORT void -mlirAsyncRuntimeEmplaceToken(AsyncToken *); +extern "C" void mlirAsyncRuntimeEmplaceToken(AsyncToken *); // Switches `async.value` to ready state and runs all awaiters. -extern "C" MLIR_ASYNCRUNTIME_EXPORT void -mlirAsyncRuntimeEmplaceValue(AsyncValue *); +extern "C" void mlirAsyncRuntimeEmplaceValue(AsyncValue *); // Blocks the caller thread until the token becomes ready. -extern "C" MLIR_ASYNCRUNTIME_EXPORT void -mlirAsyncRuntimeAwaitToken(AsyncToken *); +extern "C" void mlirAsyncRuntimeAwaitToken(AsyncToken *); // Blocks the caller thread until the value becomes ready. -extern "C" MLIR_ASYNCRUNTIME_EXPORT void -mlirAsyncRuntimeAwaitValue(AsyncValue *); +extern "C" void mlirAsyncRuntimeAwaitValue(AsyncValue *); // Blocks the caller thread until the elements in the group become ready. -extern "C" MLIR_ASYNCRUNTIME_EXPORT void -mlirAsyncRuntimeAwaitAllInGroup(AsyncGroup *); +extern "C" void mlirAsyncRuntimeAwaitAllInGroup(AsyncGroup *); // Returns a pointer to the storage owned by the async value. -extern "C" MLIR_ASYNCRUNTIME_EXPORT ValueStorage -mlirAsyncRuntimeGetValueStorage(AsyncValue *); +extern "C" ValueStorage mlirAsyncRuntimeGetValueStorage(AsyncValue *); // Executes the task (coro handle + resume function) in one of the threads // managed by the runtime. -extern "C" MLIR_ASYNCRUNTIME_EXPORT void mlirAsyncRuntimeExecute(CoroHandle, - CoroResume); +extern "C" void mlirAsyncRuntimeExecute(CoroHandle, CoroResume); // Executes the task (coro handle + resume function) in one of the threads // managed by the runtime after the token becomes ready. -extern "C" MLIR_ASYNCRUNTIME_EXPORT void -mlirAsyncRuntimeAwaitTokenAndExecute(AsyncToken *, CoroHandle, CoroResume); +extern "C" void mlirAsyncRuntimeAwaitTokenAndExecute(AsyncToken *, CoroHandle, + CoroResume); // Executes the task (coro handle + resume function) in one of the threads // managed by the runtime after the value becomes ready. -extern "C" MLIR_ASYNCRUNTIME_EXPORT void -mlirAsyncRuntimeAwaitValueAndExecute(AsyncValue *, CoroHandle, CoroResume); +extern "C" void mlirAsyncRuntimeAwaitValueAndExecute(AsyncValue *, CoroHandle, + CoroResume); // Executes the task (coro handle + resume function) in one of the threads // managed by the runtime after the all members of the group become ready. -extern "C" MLIR_ASYNCRUNTIME_EXPORT void +extern "C" void mlirAsyncRuntimeAwaitAllInGroupAndExecute(AsyncGroup *, CoroHandle, CoroResume); //===----------------------------------------------------------------------===// // Small async runtime support library for testing. //===----------------------------------------------------------------------===// -extern "C" MLIR_ASYNCRUNTIME_EXPORT void mlirAsyncRuntimePrintCurrentThreadId(); +extern "C" void mlirAsyncRuntimePrintCurrentThreadId(); } // namespace runtime } // namespace mlir diff --git a/mlir/lib/ExecutionEngine/AsyncRuntime.cpp b/mlir/lib/ExecutionEngine/AsyncRuntime.cpp index c5978eb..e4d41d6 100644 --- a/mlir/lib/ExecutionEngine/AsyncRuntime.cpp +++ b/mlir/lib/ExecutionEngine/AsyncRuntime.cpp @@ -182,8 +182,6 @@ struct AsyncGroup : public RefCounted { std::vector> awaiters; }; -} // namespace runtime -} // namespace mlir // Adds references to reference counted runtime object. extern "C" void mlirAsyncRuntimeAddRef(RefCountedObjPtr ptr, int32_t count) { @@ -369,8 +367,11 @@ extern "C" void mlirAsyncRuntimePrintCurrentThreadId() { //===----------------------------------------------------------------------===// // Export symbols for the MLIR runner integration. All other symbols are hidden. -#ifndef _WIN32 +#ifdef _WIN32 +#define API __declspec(dllexport) +#else #define API __attribute__((visibility("default"))) +#endif extern "C" API void __mlir_runner_init(llvm::StringMap &exportSymbols) { auto exportSymbol = [&](llvm::StringRef name, auto ptr) { @@ -416,6 +417,7 @@ extern "C" API void __mlir_runner_init(llvm::StringMap &exportSymbols) { extern "C" API void __mlir_runner_destroy() { resetDefaultAsyncRuntime(); } -#endif // _WIN32 +} // namespace runtime +} // namespace mlir #endif // MLIR_ASYNCRUNTIME_DEFINE_FUNCTIONS