[mlir][async] Mark exported symbols of runtime lib as visible.

[ingomueller-net]

Summary

The async runtime library explicitly registers the symbols it exports
with the loading mechanism of the execution engine. This even works even
though these symbols were marked as hidden in the library. However, if
used outside the execution engine, such as with lli --dlopen or if AOT
compiled, these hidden symbols would not be found. This patch thus marks
all symbols that are part of the API as visible.

[ingomueller-net]

This is still part of my effort of making the handling of various runtime libraries consistent, see https://reviews.llvm.org/D153250.

[mehdi_amini]

AOT compiled, these hidden symbols would not be found.

Just a nit but AOT compiled and statically linked: there wouldn't be any problem here.

mlir/include/mlir/ExecutionEngine/AsyncRuntime.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_EXECUTIONENGINE_ASYNCRUNTIME_H_
 #define MLIR_EXECUTIONENGINE_ASYNCRUNTIME_H_
 
 #include <cstddef>
 #include <stdint.h>
 
+#ifdef _WIN32
+#ifndef MLIR_ASYNC_RUNTIME_EXPORT
 #ifdef mlir_async_runtime_EXPORTS
 // We are building this library
-#define MLIR_ASYNCRUNTIME_DEFINE_FUNCTIONS
+#define MLIR_ASYNC_RUNTIME_EXPORT __declspec(dllexport)
+#else
+// We are using this library
+#define MLIR_ASYNC_RUNTIME_EXPORT __declspec(dllimport)
 #endif // mlir_async_runtime_EXPORTS
+#endif // MLIR_ASYNC_RUNTIME_EXPORT
+#else
+// Non-windows: use visibility attributes.
+#define MLIR_ASYNC_RUNTIME_EXPORT __attribute__((visibility("default")))
+#endif // _WIN32
 
 namespace mlir {
 namespace runtime {
 
 //===----------------------------------------------------------------------===//
 // Async runtime API.
 //===----------------------------------------------------------------------===//
 

 using CoroHandle = void *;           // coroutine handle
 using CoroResume = void (*)(void *); // coroutine resume function
 
 // Async runtime uses reference counting to manage the lifetime of async values
 // (values of async types like tokens, values and groups).
 using RefCountedObjPtr = void *;
 
 // Adds references to reference counted runtime object.
-extern "C" void mlirAsyncRuntimeAddRef(RefCountedObjPtr, int64_t);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT void
+    mlirAsyncRuntimeAddRef(RefCountedObjPtr, int64_t);
 
 // Drops references from reference counted runtime object.
-extern "C" void mlirAsyncRuntimeDropRef(RefCountedObjPtr, int64_t);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT void
+    mlirAsyncRuntimeDropRef(RefCountedObjPtr, int64_t);
 
 // Create a new `async.token` in not-ready state.
-extern "C" AsyncToken *mlirAsyncRuntimeCreateToken();
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT 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" AsyncValue *mlirAsyncRuntimeCreateValue(int64_t);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT AsyncValue *
+    mlirAsyncRuntimeCreateValue(int64_t);
 
 // Create a new `async.group` in empty state.
-extern "C" AsyncGroup *mlirAsyncRuntimeCreateGroup(int64_t size);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT AsyncGroup *
+mlirAsyncRuntimeCreateGroup(int64_t size);
 
-extern "C" int64_t mlirAsyncRuntimeAddTokenToGroup(AsyncToken *, AsyncGroup *);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT int64_t
+mlirAsyncRuntimeAddTokenToGroup(AsyncToken *, AsyncGroup *);
 
 // Switches `async.token` to ready state and runs all awaiters.
-extern "C" void mlirAsyncRuntimeEmplaceToken(AsyncToken *);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT void
+mlirAsyncRuntimeEmplaceToken(AsyncToken *);
 
 // Switches `async.value` to ready state and runs all awaiters.
-extern "C" void mlirAsyncRuntimeEmplaceValue(AsyncValue *);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT void
+mlirAsyncRuntimeEmplaceValue(AsyncValue *);
 
 // Switches `async.token` to error state and runs all awaiters.
-extern "C" void mlirAsyncRuntimeSetTokenError(AsyncToken *);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT void
+mlirAsyncRuntimeSetTokenError(AsyncToken *);
 
 // Switches `async.value` to error state and runs all awaiters.
-extern "C" void mlirAsyncRuntimeSetValueError(AsyncValue *);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT void
+mlirAsyncRuntimeSetValueError(AsyncValue *);
 
 // Returns true if token is in the error state.
-extern "C" bool mlirAsyncRuntimeIsTokenError(AsyncToken *);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT bool
+mlirAsyncRuntimeIsTokenError(AsyncToken *);
 
 // Returns true if value is in the error state.
-extern "C" bool mlirAsyncRuntimeIsValueError(AsyncValue *);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT bool
+mlirAsyncRuntimeIsValueError(AsyncValue *);
 
 // Returns true if group is in the error state (any of the tokens or values
 // added to the group are in the error state).
-extern "C" bool mlirAsyncRuntimeIsGroupError(AsyncGroup *);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT bool
+mlirAsyncRuntimeIsGroupError(AsyncGroup *);
 
 // Blocks the caller thread until the token becomes ready.
-extern "C" void mlirAsyncRuntimeAwaitToken(AsyncToken *);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT void
+mlirAsyncRuntimeAwaitToken(AsyncToken *);
 
 // Blocks the caller thread until the value becomes ready.
-extern "C" void mlirAsyncRuntimeAwaitValue(AsyncValue *);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT void
+mlirAsyncRuntimeAwaitValue(AsyncValue *);
 
 // Blocks the caller thread until the elements in the group become ready.
-extern "C" void mlirAsyncRuntimeAwaitAllInGroup(AsyncGroup *);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT void
+mlirAsyncRuntimeAwaitAllInGroup(AsyncGroup *);
 
 // Returns a pointer to the storage owned by the async value.
-extern "C" ValueStorage mlirAsyncRuntimeGetValueStorage(AsyncValue *);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT ValueStorage
+mlirAsyncRuntimeGetValueStorage(AsyncValue *);
 
 // Executes the task (coro handle + resume function) in one of the threads
 // managed by the runtime.
-extern "C" void mlirAsyncRuntimeExecute(CoroHandle, CoroResume);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT 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" void mlirAsyncRuntimeAwaitTokenAndExecute(AsyncToken *, CoroHandle,
-                                                     CoroResume);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT 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" void mlirAsyncRuntimeAwaitValueAndExecute(AsyncValue *, CoroHandle,
-                                                     CoroResume);
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT 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" void
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT void
 mlirAsyncRuntimeAwaitAllInGroupAndExecute(AsyncGroup *, CoroHandle, CoroResume);
 
 // Returns the current number of available worker threads in the threadpool.
-extern "C" int64_t mlirAsyncRuntimGetNumWorkerThreads();
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT int64_t
+mlirAsyncRuntimGetNumWorkerThreads();
 
 //===----------------------------------------------------------------------===//
 // Small async runtime support library for testing.
 //===----------------------------------------------------------------------===//
 
-extern "C" void mlirAsyncRuntimePrintCurrentThreadId();
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT void
+mlirAsyncRuntimePrintCurrentThreadId();
 
 } // namespace runtime
 } // namespace mlir
 
 #endif // MLIR_EXECUTIONENGINE_ASYNCRUNTIME_H_

mlir/lib/ExecutionEngine/AsyncRuntime.cpp

 //===- AsyncRuntime.cpp - Async runtime reference implementation ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements basic Async runtime API for supporting Async dialect
 // to LLVM dialect lowering.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/ExecutionEngine/AsyncRuntime.h"
 
-#ifdef MLIR_ASYNCRUNTIME_DEFINE_FUNCTIONS
-
 #include <atomic>
 #include <cassert>
 #include <condition_variable>
 #include <functional>
 #include <iostream>
 #include <mutex>
 #include <thread>
 #include <vector>
extern "C" void mlirAsyncRuntimePrintCurrentThreadId() {
   static thread_local std::thread::id thisId = std::this_thread::get_id();
   std::cout << "Current thread id: " << thisId << std::endl;
 }
 
 //===----------------------------------------------------------------------===//
 // MLIR ExecutionEngine dynamic library integration.
 //===----------------------------------------------------------------------===//
 
-// Export symbols for the MLIR ExecutionEngine integration. All other symbols
-// are hidden.
-#ifdef _WIN32
-#define API __declspec(dllexport)
-#else
-#define API __attribute__((visibility("default")))
-#endif
-
 // Visual Studio had a bug that fails to compile nested generic lambdas
 // inside an `extern "C"` function.
 //   https://developercommunity.visualstudio.com/content/problem/475494/clexe-error-with-lambda-inside-function-templates.html
 // The bug is fixed in VS2019 16.1. Separating the declaration and definition is
 // a work around for older versions of Visual Studio.
 // NOLINTNEXTLINE(*-identifier-naming): externally called.
-extern "C" API void
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT void
 __mlir_execution_engine_init(llvm::StringMap<void *> &exportSymbols);
 
 // NOLINTNEXTLINE(*-identifier-naming): externally called.
 void __mlir_execution_engine_init(llvm::StringMap<void *> &exportSymbols) {
   auto exportSymbol = [&](llvm::StringRef name, auto ptr) {
     assert(exportSymbols.count(name) == 0 && "symbol already exists");
     exportSymbols[name] = reinterpret_cast<void *>(ptr);
   };
exportSymbol("mlirAsyncRuntimeAwaitAllInGroupAndExecute",
                &mlir::runtime::mlirAsyncRuntimeAwaitAllInGroupAndExecute);
   exportSymbol("mlirAsyncRuntimGetNumWorkerThreads",
                &mlir::runtime::mlirAsyncRuntimGetNumWorkerThreads);
   exportSymbol("mlirAsyncRuntimePrintCurrentThreadId",
                &mlir::runtime::mlirAsyncRuntimePrintCurrentThreadId);
 }
 
 // NOLINTNEXTLINE(*-identifier-naming): externally called.
-extern "C" API void __mlir_execution_engine_destroy() {
+extern "C" MLIR_ASYNC_RUNTIME_EXPORT void __mlir_execution_engine_destroy() {
   resetDefaultAsyncRuntime();
 }
 
 } // namespace runtime
 } // namespace mlir
-
-#endif // MLIR_ASYNCRUNTIME_DEFINE_FUNCTIONS