Revert "[SYCL] Improve mock PI plugin" (#7183)

Reverts #7129

Author: Pavel Chupin

sycl/unittests/SYCL2020/GetNativeOpenCL.cpp

@@ -86,18 +86,16 @@ TEST(GetNative, GetNativeHandle) {
   sycl::unittest::PiMock Mock;
   sycl::platform Plt = Mock.getPlatform();
 
-  Mock.redefineBefore<detail::PiApiKind::piEventGetInfo>(redefinedEventGetInfo);
-  Mock.redefineBefore<detail::PiApiKind::piContextRetain>(
-      redefinedContextRetain);
-  Mock.redefineBefore<detail::PiApiKind::piQueueRetain>(redefinedQueueRetain);
-  Mock.redefineBefore<detail::PiApiKind::piDeviceRetain>(redefinedDeviceRetain);
-  Mock.redefineBefore<detail::PiApiKind::piProgramRetain>(
-      redefinedProgramRetain);
-  Mock.redefineBefore<detail::PiApiKind::piEventRetain>(redefinedEventRetain);
-  Mock.redefineBefore<detail::PiApiKind::piMemRetain>(redefinedMemRetain);
-  Mock.redefineBefore<sycl::detail::PiApiKind::piMemBufferCreate>(
+  Mock.redefine<detail::PiApiKind::piEventGetInfo>(redefinedEventGetInfo);
+  Mock.redefine<detail::PiApiKind::piContextRetain>(redefinedContextRetain);
+  Mock.redefine<detail::PiApiKind::piQueueRetain>(redefinedQueueRetain);
+  Mock.redefine<detail::PiApiKind::piDeviceRetain>(redefinedDeviceRetain);
+  Mock.redefine<detail::PiApiKind::piProgramRetain>(redefinedProgramRetain);
+  Mock.redefine<detail::PiApiKind::piEventRetain>(redefinedEventRetain);
+  Mock.redefine<detail::PiApiKind::piMemRetain>(redefinedMemRetain);
+  Mock.redefine<sycl::detail::PiApiKind::piMemBufferCreate>(
       redefinedMemBufferCreate);
-  Mock.redefineBefore<detail::PiApiKind::piextUSMEnqueueMemset>(
+  Mock.redefine<detail::PiApiKind::piextUSMEnqueueMemset>(
       redefinedUSMEnqueueMemset);
 
   context Context(Plt);

sycl/unittests/assert/assert.cpp

@@ -175,9 +175,11 @@ static int MemoryMapCounter = MemoryMapCounterBase;
 static constexpr int PauseWaitOnIdx = KernelLaunchCounterBase + 1;
 
 // Mock redifinitions
-static pi_result redefinedKernelGetGroupInfoAfter(
-    pi_kernel kernel, pi_device device, pi_kernel_group_info param_name,
-    size_t param_value_size, void *param_value, size_t *param_value_size_ret) {
+static pi_result redefinedKernelGetGroupInfo(pi_kernel kernel, pi_device device,
+                                             pi_kernel_group_info param_name,
+                                             size_t param_value_size,
+                                             void *param_value,
+                                             size_t *param_value_size_ret) {
   if (param_name == PI_KERNEL_GROUP_INFO_COMPILE_WORK_GROUP_SIZE) {
     if (param_value_size_ret) {
       *param_value_size_ret = 3 * sizeof(size_t);
@@ -192,23 +194,25 @@ static pi_result redefinedKernelGetGroupInfoAfter(
   return PI_SUCCESS;
 }
 
-static pi_result
-redefinedEnqueueKernelLaunchAfter(pi_queue, pi_kernel, pi_uint32,
-                                  const size_t *, const size_t *,
-                                  const size_t *LocalSize, pi_uint32 NDeps,
-                                  const pi_event *Deps, pi_event *RetEvent) {
-  static pi_event UserKernelEvent = *RetEvent;
-  int Val = KernelLaunchCounter++;
+static pi_result redefinedEnqueueKernelLaunch(pi_queue, pi_kernel, pi_uint32,
+                                              const size_t *, const size_t *,
+                                              const size_t *LocalSize,
+                                              pi_uint32 N, const pi_event *Deps,
+                                              pi_event *RetEvent) {
+  int *Ret = new int[1];
+  *Ret = KernelLaunchCounter++;
   // This output here is to reduce amount of time requried to debug/reproduce a
   // failing test upon feature break
-  printf("Enqueued %i\n", Val);
+  printf("Enqueued %i\n", *Ret);
 
-  if (PauseWaitOnIdx == Val) {
+  if (PauseWaitOnIdx == *Ret) {
     // It should be copier kernel. Check if it depends on user's one.
-    EXPECT_EQ(NDeps, 1U);
-    EXPECT_EQ(Deps[0], UserKernelEvent);
+    EXPECT_EQ(N, 1U);
+    int EventIdx = reinterpret_cast<int *>(Deps[0])[0];
+    EXPECT_EQ(EventIdx, 0);
   }
 
+  *RetEvent = reinterpret_cast<pi_event>(Ret);
   return PI_SUCCESS;
 }
 
@@ -239,30 +243,56 @@ static pi_result redefinedEventsWaitNegative(pi_uint32 num_events,
   return PI_SUCCESS;
 }
 
-static pi_result redefinedEnqueueMemBufferMapAfter(
+static pi_result
+redefinedMemBufferCreate(pi_context context, pi_mem_flags flags, size_t size,
+                         void *host_ptr, pi_mem *ret_mem,
+                         const pi_mem_properties *properties = nullptr) {
+  static size_t MemAddrCounter = 1;
+  *ret_mem = (pi_mem)MemAddrCounter++;
+  return PI_SUCCESS;
+}
+
+static pi_result redefinedMemRelease(pi_mem mem) { return PI_SUCCESS; }
+
+static pi_result redefinedKernelSetArg(pi_kernel kernel, pi_uint32 arg_index,
+                                       size_t arg_size, const void *arg_value) {
+  return PI_SUCCESS;
+}
+
+static pi_result redefinedEnqueueMemBufferMap(
     pi_queue command_queue, pi_mem buffer, pi_bool blocking_map,
     pi_map_flags map_flags, size_t offset, size_t size,
     pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list,
     pi_event *RetEvent, void **RetMap) {
-  MemoryMapCounter++;
+  int *Ret = new int[1];
+  *Ret = MemoryMapCounter++;
   // This output here is to reduce amount of time requried to debug/reproduce a
   // failing test upon feature break
-  printf("Memory map %i\n", MemoryMapCounter);
+  printf("Memory map %i\n", *Ret);
+  *RetEvent = reinterpret_cast<pi_event>(Ret);
 
   *RetMap = (void *)&ExpectedToOutput;
 
   return PI_SUCCESS;
 }
 
+static pi_result redefinedExtKernelSetArgMemObj(pi_kernel kernel,
+                                                pi_uint32 arg_index,
+                                                const pi_mem *arg_value) {
+  return PI_SUCCESS;
+}
+
 static void setupMock(sycl::unittest::PiMock &Mock) {
   using namespace sycl::detail;
-  Mock.redefineAfter<PiApiKind::piKernelGetGroupInfo>(
-      redefinedKernelGetGroupInfoAfter);
-  Mock.redefineAfter<PiApiKind::piEnqueueKernelLaunch>(
-      redefinedEnqueueKernelLaunchAfter);
-  Mock.redefineAfter<PiApiKind::piEnqueueMemBufferMap>(
-      redefinedEnqueueMemBufferMapAfter);
-  Mock.redefineBefore<PiApiKind::piEventsWait>(redefinedEventsWaitPositive);
+  Mock.redefine<PiApiKind::piKernelGetGroupInfo>(redefinedKernelGetGroupInfo);
+  Mock.redefine<PiApiKind::piEnqueueKernelLaunch>(redefinedEnqueueKernelLaunch);
+  Mock.redefine<PiApiKind::piMemBufferCreate>(redefinedMemBufferCreate);
+  Mock.redefine<PiApiKind::piMemRelease>(redefinedMemRelease);
+  Mock.redefine<PiApiKind::piKernelSetArg>(redefinedKernelSetArg);
+  Mock.redefine<PiApiKind::piEnqueueMemBufferMap>(redefinedEnqueueMemBufferMap);
+  Mock.redefine<PiApiKind::piEventsWait>(redefinedEventsWaitPositive);
+  Mock.redefine<PiApiKind::piextKernelSetArgMemObj>(
+      redefinedExtKernelSetArgMemObj);
 }
 
 namespace TestInteropKernel {
@@ -287,15 +317,12 @@ static pi_result redefinedKernelGetInfo(pi_kernel Kernel,
   }
 
   if (PI_KERNEL_INFO_PROGRAM == ParamName) {
-    pi_program PIProgram = nullptr;
-    pi_result Res = mock_piProgramCreate(/*pi_context=*/0x0, /**il*/ nullptr,
-                                         /*length=*/0, &PIProgram);
-    assert(PI_SUCCESS == Res);
+    cl_program X = (cl_program)1;
 
     if (ParamValue)
-      memcpy(ParamValue, &PIProgram, sizeof(PIProgram));
+      memcpy(ParamValue, &X, sizeof(X));
     if (ParamValueSizeRet)
-      *ParamValueSizeRet = sizeof(PIProgram);
+      *ParamValueSizeRet = sizeof(X);
 
     return PI_SUCCESS;
   }
@@ -323,11 +350,13 @@ static pi_result redefinedEnqueueKernelLaunch(pi_queue, pi_kernel, pi_uint32,
                                               const size_t *LocalSize,
                                               pi_uint32 N, const pi_event *Deps,
                                               pi_event *RetEvent) {
-  int Val = KernelLaunchCounter++;
+  int *Ret = new int[1];
+  *Ret = KernelLaunchCounter++;
   // This output here is to reduce amount of time requried to debug/reproduce a
   // failing test upon feature break
-  printf("Enqueued %i\n", Val);
+  printf("Enqueued %i\n", *Ret);
 
+  *RetEvent = reinterpret_cast<pi_event>(Ret);
   return PI_SUCCESS;
 }
 
@@ -397,18 +426,21 @@ static void setupMockForInterop(sycl::unittest::PiMock &Mock,
   TestInteropKernel::Device = &Dev;
   TestInteropKernel::Context = &Ctx;
 
-  Mock.redefineAfter<PiApiKind::piKernelGetGroupInfo>(
-      redefinedKernelGetGroupInfoAfter);
-  Mock.redefineBefore<PiApiKind::piEnqueueKernelLaunch>(
+  Mock.redefine<PiApiKind::piKernelGetGroupInfo>(redefinedKernelGetGroupInfo);
+  Mock.redefine<PiApiKind::piEnqueueKernelLaunch>(
       TestInteropKernel::redefinedEnqueueKernelLaunch);
-  Mock.redefineAfter<PiApiKind::piEnqueueMemBufferMap>(
-      redefinedEnqueueMemBufferMapAfter);
-  Mock.redefineBefore<PiApiKind::piEventsWait>(redefinedEventsWaitNegative);
-  Mock.redefineBefore<PiApiKind::piKernelGetInfo>(
+  Mock.redefine<PiApiKind::piMemBufferCreate>(redefinedMemBufferCreate);
+  Mock.redefine<PiApiKind::piMemRelease>(redefinedMemRelease);
+  Mock.redefine<PiApiKind::piKernelSetArg>(redefinedKernelSetArg);
+  Mock.redefine<PiApiKind::piEnqueueMemBufferMap>(redefinedEnqueueMemBufferMap);
+  Mock.redefine<PiApiKind::piEventsWait>(redefinedEventsWaitNegative);
+  Mock.redefine<PiApiKind::piextKernelSetArgMemObj>(
+      redefinedExtKernelSetArgMemObj);
+  Mock.redefine<PiApiKind::piKernelGetInfo>(
       TestInteropKernel::redefinedKernelGetInfo);
-  Mock.redefineBefore<PiApiKind::piProgramGetInfo>(
+  Mock.redefine<PiApiKind::piProgramGetInfo>(
       TestInteropKernel::redefinedProgramGetInfo);
-  Mock.redefineBefore<PiApiKind::piProgramGetBuildInfo>(
+  Mock.redefine<PiApiKind::piProgramGetBuildInfo>(
       TestInteropKernel::redefinedProgramGetBuildInfo);
 }
 
@@ -549,15 +581,10 @@ TEST(Assert, TestInteropKernelNegative) {
 
   sycl::queue Queue{Ctx, Dev};
 
-  pi_kernel PIKernel = nullptr;
-
-  pi_result Res = mock_piKernelCreate(
-      /*pi_program=*/0x0, /*kernel_name=*/"dummy_kernel", &PIKernel);
-  assert(PI_SUCCESS == Res);
-
+  cl_kernel CLKernel = (cl_kernel)(0x01);
   // TODO use make_kernel. This requires a fix in backend.cpp to get plugin
   // from context instead of free getPlugin to alllow for mocking of its methods
-  sycl::kernel KInterop((cl_kernel)PIKernel, Ctx);
+  sycl::kernel KInterop(CLKernel, Ctx);
 
   Queue.submit([&](sycl::handler &H) { H.single_task(KInterop); });
 

sycl/unittests/buffer/BufferLocation.cpp

@@ -43,11 +43,11 @@ pi_result redefinedMemBufferCreate(pi_context, pi_mem_flags, size_t size,
   return PI_SUCCESS;
 }
 
-static pi_result redefinedDeviceGetInfoAfter(pi_device device,
-                                             pi_device_info param_name,
-                                             size_t param_value_size,
-                                             void *param_value,
-                                             size_t *param_value_size_ret) {
+static pi_result redefinedDeviceGetInfo(pi_device device,
+                                        pi_device_info param_name,
+                                        size_t param_value_size,
+                                        void *param_value,
+                                        size_t *param_value_size_ret) {
   if (param_name == PI_DEVICE_INFO_TYPE) {
     auto *Result = reinterpret_cast<_pi_device_type *>(param_value);
     *Result = PI_DEVICE_TYPE_ACC;
@@ -58,15 +58,9 @@ static pi_result redefinedDeviceGetInfoAfter(pi_device device,
   }
   if (param_name == PI_DEVICE_INFO_EXTENSIONS) {
     const std::string name = "cl_intel_mem_alloc_buffer_location";
-
-    // Increase size by one for the null terminator
-    const size_t nameSize = name.size() + 1;
-
     if (!param_value) {
-      // Choose bigger size so that both original and redefined function
-      // has enough memory for storing the extension string
-      *param_value_size_ret =
-          nameSize > *param_value_size_ret ? nameSize : *param_value_size_ret;
+      // Increase size by one for the null terminator
+      *param_value_size_ret = name.size() + 1;
     } else {
       char *dst = static_cast<char *>(param_value);
       strcpy(dst, name.data());
@@ -81,10 +75,10 @@ class BufferTest : public ::testing::Test {
 
 protected:
   void SetUp() override {
-    Mock.redefineBefore<sycl::detail::PiApiKind::piMemBufferCreate>(
+    Mock.redefine<sycl::detail::PiApiKind::piMemBufferCreate>(
         redefinedMemBufferCreate);
-    Mock.redefineAfter<sycl::detail::PiApiKind::piDeviceGetInfo>(
-        redefinedDeviceGetInfoAfter);
+    Mock.redefine<sycl::detail::PiApiKind::piDeviceGetInfo>(
+        redefinedDeviceGetInfo);
   }
 
 protected:

sycl/unittests/event/EventDestruction.cpp

@@ -33,9 +33,8 @@ class EventDestructionTest : public ::testing::Test {
 
 protected:
   void SetUp() override {
-    Mock.redefineBefore<detail::PiApiKind::piEventRelease>(
-        redefinedEventRelease);
-    Mock.redefineBefore<detail::PiApiKind::piMemBufferCreate>(
+    Mock.redefine<detail::PiApiKind::piEventRelease>(redefinedEventRelease);
+    Mock.redefine<detail::PiApiKind::piMemBufferCreate>(
         redefinedMemBufferCreate);
   }