Rename to olLaunchHostFunction

Author: RossBrunton

offload/liboffload/API/Queue.td

@@ -110,26 +110,26 @@ def : Function {
 }
 
 def : FptrTypedef {
-  let name = "ol_queue_callback_cb_t";
-  let desc = "Callback function for use by `olEnqueueHostCallback`.";
+  let name = "ol_host_function_cb_t";
+  let desc = "Host function for use by `olLaunchHostFunction`.";
   let params = [
-    Param<"void *", "UserData", "user specified data passed into `olEnqueueHostCallback`.", PARAM_IN>,
+    Param<"void *", "UserData", "user specified data passed into `olLaunchHostFunction`.", PARAM_IN>,
   ];
   let return = "void";
 }
 
 def : Function {
-  let name = "olEnqueueHostCallback";
+  let name = "olLaunchHostFunction";
   let desc = "Enqueue a callback function on the host.";
   let details = [
-    "The provided function will be called from the same process as the one that called `olEnqueueHostCallback`.",
+    "The provided function will be called from the same process as the one that called `olLaunchHostFunction`.",
     "The callback will not run until all previous work submitted to the queue has completed.",
     "The callback must return before any work submitted to the queue after it is started.",
     "The callback must not call any liboffload API functions or any backend specific functions (such as Cuda or HSA library functions).",
   ];
   let params = [
     Param<"ol_queue_handle_t", "Queue", "handle of the queue", PARAM_IN>,
-    Param<"ol_queue_callback_cb_t", "Callback", "the callback function to call on the host", PARAM_IN>,
+    Param<"ol_host_function_cb_t", "Callback", "the callback function to call on the host", PARAM_IN>,
     Param<"void *", "UserData", "a pointer that will be passed verbatim to the callback function", PARAM_IN_OPTIONAL>,
   ];
   let returns = [];

offload/liboffload/src/OffloadImpl.cpp

@@ -833,9 +833,9 @@ Error olGetSymbolInfoSize_impl(ol_symbol_handle_t Symbol,
   return olGetSymbolInfoImplDetail(Symbol, PropName, 0, nullptr, PropSizeRet);
 }
 
-Error olEnqueueHostCallback_impl(ol_queue_handle_t Queue,
-                                 ol_queue_callback_cb_t Callback,
-                                 void *UserData) {
+Error olLaunchHostFunction_impl(ol_queue_handle_t Queue,
+                                ol_host_function_cb_t Callback,
+                                void *UserData) {
   return Queue->Device->Device->enqueueHostCallback(Callback, UserData,
                                                     Queue->AsyncInfo);
 }

offload/unittests/OffloadAPI/CMakeLists.txt

@@ -42,7 +42,7 @@ add_offload_unittest("queue"
     queue/olGetQueueInfo.cpp
     queue/olGetQueueInfoSize.cpp
     queue/olWaitEvents.cpp
-    queue/olEnqueueHostCallback.cpp)
+    queue/olLaunchHostFunction.cpp)
 
 add_offload_unittest("symbol"
     symbol/olGetSymbol.cpp

…floadAPI/queue/olEnqueueHostCallback.cpp …ffloadAPI/queue/olLaunchHostFunction.cppoffload/unittests/OffloadAPI/queue/olEnqueueHostCallback.cpp renamed to offload/unittests/OffloadAPI/queue/olLaunchHostFunction.cpp offload/unittests/OffloadAPI/queue/olEnqueueHostCallback.cpp renamed to offload/unittests/OffloadAPI/queue/olLaunchHostFunction.cpp

@@ -1,4 +1,4 @@
-//===------- Offload API tests - olEnqueueHostCallback --------------------===//
+//===------- Offload API tests - olLaunchHostFunction ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -11,21 +11,21 @@
 #include <gtest/gtest.h>
 #include <thread>
 
-struct olEnqueueHostCallbackTest : OffloadQueueTest {};
-OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olEnqueueHostCallbackTest);
+struct olLaunchHostFunctionTest : OffloadQueueTest {};
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olLaunchHostFunctionTest);
 
-struct olEnqueueHostCallbackKernelTest : OffloadKernelTest {};
-OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olEnqueueHostCallbackKernelTest);
+struct olLaunchHostFunctionKernelTest : OffloadKernelTest {};
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olLaunchHostFunctionKernelTest);
 
-TEST_P(olEnqueueHostCallbackTest, Success) {
-  ASSERT_SUCCESS(olEnqueueHostCallback(Queue, [](void *) {}, nullptr));
+TEST_P(olLaunchHostFunctionTest, Success) {
+  ASSERT_SUCCESS(olLaunchHostFunction(Queue, [](void *) {}, nullptr));
 }
 
-TEST_P(olEnqueueHostCallbackTest, SuccessSequence) {
+TEST_P(olLaunchHostFunctionTest, SuccessSequence) {
   uint32_t Buff[16] = {1, 1};
 
   for (auto BuffPtr = &Buff[2]; BuffPtr != &Buff[16]; BuffPtr++) {
-    ASSERT_SUCCESS(olEnqueueHostCallback(
+    ASSERT_SUCCESS(olLaunchHostFunction(
         Queue,
         [](void *BuffPtr) {
           uint32_t *AsU32 = reinterpret_cast<uint32_t *>(BuffPtr);
@@ -41,7 +41,7 @@ TEST_P(olEnqueueHostCallbackTest, SuccessSequence) {
   }
 }
 
-TEST_P(olEnqueueHostCallbackKernelTest, SuccessBlocking) {
+TEST_P(olLaunchHostFunctionKernelTest, SuccessBlocking) {
   // Verify that a host kernel can block execution - A host task is created that
   // only resolves when Block is set to false.
   ol_kernel_launch_size_args_t LaunchArgs;
@@ -63,7 +63,7 @@ TEST_P(olEnqueueHostCallbackKernelTest, SuccessBlocking) {
   }
 
   volatile bool Block = true;
-  ASSERT_SUCCESS(olEnqueueHostCallback(
+  ASSERT_SUCCESS(olLaunchHostFunction(
       Queue,
       [](void *Ptr) {
         volatile bool *Block =
@@ -95,12 +95,12 @@ TEST_P(olEnqueueHostCallbackKernelTest, SuccessBlocking) {
   ASSERT_SUCCESS(olMemFree(Mem));
 }
 
-TEST_P(olEnqueueHostCallbackTest, InvalidNullCallback) {
+TEST_P(olLaunchHostFunctionTest, InvalidNullCallback) {
   ASSERT_ERROR(OL_ERRC_INVALID_NULL_POINTER,
-               olEnqueueHostCallback(Queue, nullptr, nullptr));
+               olLaunchHostFunction(Queue, nullptr, nullptr));
 }
 
-TEST_P(olEnqueueHostCallbackTest, InvalidNullQueue) {
+TEST_P(olLaunchHostFunctionTest, InvalidNullQueue) {
   ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE,
-               olEnqueueHostCallback(nullptr, [](void *) {}, nullptr));
+               olLaunchHostFunction(nullptr, [](void *) {}, nullptr));
 }