From ba86705ccaafd1fc78505f9b8dd6d1956f19ccf9 Mon Sep 17 00:00:00 2001 From: Pavel Chupin Date: Tue, 25 Oct 2022 15:10:30 -0700 Subject: [PATCH] Revert "[SYCL] Improve mock PI plugin (#7129)" This reverts commit 1f35a3908412c2698c311646480056a835463de4. --- sycl/unittests/SYCL2020/GetNativeOpenCL.cpp | 20 +- sycl/unittests/assert/assert.cpp | 123 ++++++----- sycl/unittests/buffer/BufferLocation.cpp | 26 +-- sycl/unittests/event/EventDestruction.cpp | 5 +- sycl/unittests/helpers/PiMock.hpp | 161 +------------- sycl/unittests/helpers/PiMockPlugin.hpp | 204 +++++------------- sycl/unittests/kernel-and-program/Cache.cpp | 3 +- .../kernel-and-program/DeviceInfo.cpp | 3 +- .../kernel-and-program/KernelBuildOptions.cpp | 6 +- .../kernel-and-program/KernelInfo.cpp | 46 +++- .../kernel-and-program/KernelRelease.cpp | 40 +++- .../kernel-and-program/MultipleDevsCache.cpp | 67 ++++-- .../PersistentDeviceCodeCache.cpp | 19 +- sycl/unittests/pi/PiMock.cpp | 99 +-------- sycl/unittests/pi/piInteropRetain.cpp | 2 +- sycl/unittests/program_manager/BuildLog.cpp | 3 +- .../program_manager/EliminatedArgMask.cpp | 2 +- sycl/unittests/program_manager/SubDevices.cpp | 14 +- .../program_manager/itt_annotations.cpp | 6 +- .../passing_link_and_compile_options.cpp | 18 +- sycl/unittests/queue/DeviceCheck.cpp | 21 +- sycl/unittests/queue/EventClear.cpp | 32 ++- sycl/unittests/queue/GetProfilingInfo.cpp | 8 +- sycl/unittests/queue/USM.cpp | 51 +++-- sycl/unittests/queue/Wait.cpp | 28 ++- sycl/unittests/scheduler/AllocaLinking.cpp | 24 ++- sycl/unittests/scheduler/Commands.cpp | 20 +- .../scheduler/CommandsWaitForEvents.cpp | 25 +-- .../scheduler/EnqueueWithDependsOnDeps.cpp | 5 +- sycl/unittests/scheduler/InOrderQueueDeps.cpp | 18 +- .../scheduler/InOrderQueueHostTaskDeps.cpp | 2 +- .../scheduler/NoHostUnifiedMemory.cpp | 62 ++++-- .../scheduler/PostEnqueueCleanup.cpp | 7 +- sycl/unittests/scheduler/QueueFlushing.cpp | 122 ++++++----- sycl/unittests/scheduler/Regression.cpp | 2 +- sycl/unittests/scheduler/RequiredWGSize.cpp | 4 +- sycl/unittests/stream/stream.cpp | 2 +- sycl/unittests/windows/dllmain.cpp | 2 +- 38 files changed, 578 insertions(+), 724 deletions(-) diff --git a/sycl/unittests/SYCL2020/GetNativeOpenCL.cpp b/sycl/unittests/SYCL2020/GetNativeOpenCL.cpp index e89989c8d9b0d..b3775ae277168 100644 --- a/sycl/unittests/SYCL2020/GetNativeOpenCL.cpp +++ b/sycl/unittests/SYCL2020/GetNativeOpenCL.cpp @@ -86,18 +86,16 @@ TEST(GetNative, GetNativeHandle) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore(redefinedEventGetInfo); - Mock.redefineBefore( - redefinedContextRetain); - Mock.redefineBefore(redefinedQueueRetain); - Mock.redefineBefore(redefinedDeviceRetain); - Mock.redefineBefore( - redefinedProgramRetain); - Mock.redefineBefore(redefinedEventRetain); - Mock.redefineBefore(redefinedMemRetain); - Mock.redefineBefore( + Mock.redefine(redefinedEventGetInfo); + Mock.redefine(redefinedContextRetain); + Mock.redefine(redefinedQueueRetain); + Mock.redefine(redefinedDeviceRetain); + Mock.redefine(redefinedProgramRetain); + Mock.redefine(redefinedEventRetain); + Mock.redefine(redefinedMemRetain); + Mock.redefine( redefinedMemBufferCreate); - Mock.redefineBefore( + Mock.redefine( redefinedUSMEnqueueMemset); context Context(Plt); diff --git a/sycl/unittests/assert/assert.cpp b/sycl/unittests/assert/assert.cpp index 271dd85de87b4..5a6f487daa9a3 100644 --- a/sycl/unittests/assert/assert.cpp +++ b/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(Deps[0])[0]; + EXPECT_EQ(EventIdx, 0); } + *RetEvent = reinterpret_cast(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(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( - redefinedKernelGetGroupInfoAfter); - Mock.redefineAfter( - redefinedEnqueueKernelLaunchAfter); - Mock.redefineAfter( - redefinedEnqueueMemBufferMapAfter); - Mock.redefineBefore(redefinedEventsWaitPositive); + Mock.redefine(redefinedKernelGetGroupInfo); + Mock.redefine(redefinedEnqueueKernelLaunch); + Mock.redefine(redefinedMemBufferCreate); + Mock.redefine(redefinedMemRelease); + Mock.redefine(redefinedKernelSetArg); + Mock.redefine(redefinedEnqueueMemBufferMap); + Mock.redefine(redefinedEventsWaitPositive); + Mock.redefine( + 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(Ret); return PI_SUCCESS; } @@ -397,18 +426,21 @@ static void setupMockForInterop(sycl::unittest::PiMock &Mock, TestInteropKernel::Device = &Dev; TestInteropKernel::Context = &Ctx; - Mock.redefineAfter( - redefinedKernelGetGroupInfoAfter); - Mock.redefineBefore( + Mock.redefine(redefinedKernelGetGroupInfo); + Mock.redefine( TestInteropKernel::redefinedEnqueueKernelLaunch); - Mock.redefineAfter( - redefinedEnqueueMemBufferMapAfter); - Mock.redefineBefore(redefinedEventsWaitNegative); - Mock.redefineBefore( + Mock.redefine(redefinedMemBufferCreate); + Mock.redefine(redefinedMemRelease); + Mock.redefine(redefinedKernelSetArg); + Mock.redefine(redefinedEnqueueMemBufferMap); + Mock.redefine(redefinedEventsWaitNegative); + Mock.redefine( + redefinedExtKernelSetArgMemObj); + Mock.redefine( TestInteropKernel::redefinedKernelGetInfo); - Mock.redefineBefore( + Mock.redefine( TestInteropKernel::redefinedProgramGetInfo); - Mock.redefineBefore( + Mock.redefine( 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); }); diff --git a/sycl/unittests/buffer/BufferLocation.cpp b/sycl/unittests/buffer/BufferLocation.cpp index 62ff7d55a3fb3..f9c81890cff47 100644 --- a/sycl/unittests/buffer/BufferLocation.cpp +++ b/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(param_value); strcpy(dst, name.data()); @@ -81,10 +75,10 @@ class BufferTest : public ::testing::Test { protected: void SetUp() override { - Mock.redefineBefore( + Mock.redefine( redefinedMemBufferCreate); - Mock.redefineAfter( - redefinedDeviceGetInfoAfter); + Mock.redefine( + redefinedDeviceGetInfo); } protected: diff --git a/sycl/unittests/event/EventDestruction.cpp b/sycl/unittests/event/EventDestruction.cpp index 20427b7623cf8..aa09a50f30f4c 100644 --- a/sycl/unittests/event/EventDestruction.cpp +++ b/sycl/unittests/event/EventDestruction.cpp @@ -33,9 +33,8 @@ class EventDestructionTest : public ::testing::Test { protected: void SetUp() override { - Mock.redefineBefore( - redefinedEventRelease); - Mock.redefineBefore( + Mock.redefine(redefinedEventRelease); + Mock.redefine( redefinedMemBufferCreate); } diff --git a/sycl/unittests/helpers/PiMock.hpp b/sycl/unittests/helpers/PiMock.hpp index 677e8d4414da5..d7b9359fc8dc1 100644 --- a/sycl/unittests/helpers/PiMock.hpp +++ b/sycl/unittests/helpers/PiMock.hpp @@ -51,114 +51,23 @@ namespace unittest { namespace detail = sycl::detail; namespace RT = detail::pi; -/// The macro below defines a proxy functions for each PI API call. -/// This proxy function calls all the functions registered in CallBefore* -/// function pointer array, then calls Original function, then calls functions -/// registered in CallAfter* array. +/// Overwrites the input PiPlugin's PiFunctionTable entry for the given PI API +/// with a given function pointer. /// -/// If a function from CallBefore* returns a non-PI_SUCCESS return code the -/// proxy function bails out. - -/// Number of functions that can be registered as CallBefore and CallAfter -inline constexpr size_t CallStackSize = 16; +/// \param MPlugin is a pointer to the PiPlugin instance that will be modified. +/// \param FuncPtr is a pointer to the function that will override the original. +/// function table entry #define _PI_API(api) \ - \ - inline decltype(&::api) CallBefore_##api[CallStackSize] = {nullptr}; \ - inline decltype(&::api) CallOriginal_##api = mock_##api; \ - inline decltype(&::api) CallAfter_##api[CallStackSize] = {nullptr}; \ - \ - template RetT proxy_mock_##api(ArgsT... Args) { \ - for (size_t I = 0; I < CallStackSize && CallBefore_##api[I]; ++I) { \ - /* If before function returns an error bail out */ \ - const RetT Res = CallBefore_##api[I](Args...); \ - if (Res != PI_SUCCESS) \ - return Res; \ - } \ - \ - RetT Ret = CallOriginal_##api(Args...); \ - \ - for (size_t I = 0; I < CallStackSize && CallAfter_##api[I]; ++I) \ - CallAfter_##api[I](Args...); \ - \ - return Ret; \ - } \ - \ - /* A helper function for instantiating proxy functions for a given */ \ - /* PI API signature */ \ - template \ - int ConverterT_##api(RetT_ (*FuncArg)(ArgsT_...)) { \ - [[maybe_unused]] constexpr static RetT_ (*Func)(ArgsT_...) = \ - proxy_mock_##api; \ - return 42; \ - } \ - inline int Anchor_##api = ConverterT_##api(decltype (&::api)(0x0)); \ - \ - /*Overrides a plugin PI function with a given one */ \ template \ inline void setFuncPtr(RT::PiPlugin *MPlugin, decltype(&::api) FuncPtr); \ template <> \ inline void setFuncPtr(RT::PiPlugin * MPlugin, \ decltype(&::api) FuncPtr) { \ - CallOriginal_##api = FuncPtr; \ - } \ - \ - /*Adds a function to be called before the PI function*/ \ - template \ - inline void setFuncPtrBefore(RT::PiPlugin *MPlugin, \ - decltype(&::api) FuncPtr); \ - template <> \ - inline void setFuncPtrBefore( \ - RT::PiPlugin * MPlugin, decltype(&::api) FuncPtr) { \ - /* Find free slot */ \ - size_t I = 0; \ - for (; I < CallStackSize && CallBefore_##api[I]; ++I) \ - ; \ - assert(I < CallStackSize && "Too many calls before"); \ - CallBefore_##api[I] = FuncPtr; \ - } \ - \ - /*Adds a function to be called after the PI function*/ \ - template \ - inline void setFuncPtrAfter(RT::PiPlugin *MPlugin, \ - decltype(&::api) FuncPtr); \ - template <> \ - inline void setFuncPtrAfter( \ - RT::PiPlugin * MPlugin, decltype(&::api) FuncPtr) { \ - /* Find free slot */ \ - size_t I = 0; \ - for (; I < CallStackSize && CallAfter_##api[I]; ++I) \ - ; \ - assert(I < CallStackSize && "Too many calls after"); \ - CallAfter_##api[I] = FuncPtr; \ + MPlugin->PiFunctionTable.api = FuncPtr; \ } #include #undef _PI_API -// Unregister functions set for calling before and after PI API -inline void clearRedefinedCalls() { - for (size_t I = 0; I < CallStackSize; ++I) { -#define _PI_API(api) \ - CallBefore_##api[I] = nullptr; \ - CallAfter_##api[I] = nullptr; -#include -#undef _PI_API - } -} - -#define _PI_MOCK_PLUGIN_CONCAT(A, B) A##B -#define PI_MOCK_PLUGIN_CONCAT(A, B) _PI_MOCK_PLUGIN_CONCAT(A, B) - -inline pi_plugin::FunctionPointers getProxyMockedFunctionPointers() { - return { -#define _PI_API(api) PI_MOCK_PLUGIN_CONCAT(proxy_mock_, api), -#include -#undef _PI_API - }; -} - -#undef PI_MOCK_PLUGIN_CONCAT -#undef _PI_MOCK_PLUGIN_CONCAT - /// The PiMock class manages the mock PI plugin and wraps an instance of a SYCL /// platform class created from this plugin. Additionally it allows for the /// redefinitions of functions in the PI API allowing tests to customize the @@ -177,7 +86,7 @@ inline pi_plugin::FunctionPointers getProxyMockedFunctionPointers() { /// pi_result redefinePiProgramRetain(pi_program program) { /*code*/ } /// /*...*/ /// unittest::PiMock Mock; -/// Mock.redefineBefore(redefinePiProgramRetain); +/// Mock.redefine(redefinePiProgramRetain); /// platform &MockP = Mock.getPlatform(); /// /*...*/ /// ``` @@ -221,10 +130,6 @@ class PiMock { PiMock(const PiMock &) = delete; PiMock &operator=(const PiMock &) = delete; ~PiMock() { - // Since the plugin relies on the global vars to store function pointers we - // need to reset them for the new PiMock plugin instance - // TODO: Make function pointers array for each PiMock instance? - clearRedefinedCalls(); if (!OrigFuncTable) return; @@ -243,31 +148,6 @@ class PiMock { template using SignatureT = typename std::remove_pointer>::type; - /// Adds a function to be called before a given PI API - /// - /// \param Replacement is a mock std::function instance to be - /// called instead of the given PI API. This function must - /// not have been constructed from a lambda. - template - void - redefineBefore(const std::function> &Replacement) { - FuncPtrT FuncPtr = - *Replacement.template target>(); - assert(FuncPtr && - "Function target is empty, try passing a lambda directly"); - setFuncPtrBefore(MPiPluginMockPtr, *FuncPtr); - } - - /// redefineBefore overload for function pointer/captureless lambda arguments. - /// - /// \param Replacement is a mock callable assignable to a function - /// pointer (function pointer/captureless lambda). - - template - void redefineBefore(const FunctorT &Replacement) { - // TODO: Check for matching signatures/assignability - setFuncPtrBefore(MPiPluginMockPtr, Replacement); - } /// Redefines the implementation of a given PI API to the input /// function object. /// @@ -298,31 +178,6 @@ class PiMock { setFuncPtr(MPiPluginMockPtr, Replacement); } - /// Adds a function to be called after a given PI API - /// - /// \param Replacement is a mock std::function instance to be - /// called instead of the given PI API. This function must - /// not have been constructed from a lambda. - template - void - redefineAfter(const std::function> &Replacement) { - FuncPtrT FuncPtr = - *Replacement.template target>(); - assert(FuncPtr && - "Function target is empty, try passing a lambda directly"); - setFuncPtrAfter(MPiPluginMockPtr, *FuncPtr); - } - - /// redefineAfter overload for function pointer/captureless lambda arguments. - /// - /// \param Replacement is a mock callable assignable to a function - /// pointer (function pointer/captureless lambda). - template - void redefineAfter(const FunctorT &Replacement) { - // TODO: Check for matching signatures/assignability - setFuncPtrAfter(MPiPluginMockPtr, Replacement); - } - /// Ensures that the mock plugin has been initialized and has been registered /// in the global handler. Additionally, all existing plugins will be removed /// and unloaded to avoid them being accidentally picked up by tests using @@ -343,7 +198,7 @@ class PiMock { auto RTPlugin = std::make_shared( RT::PiPlugin{"pi.ver.mock", "plugin.ver.mock", /*Targets=*/nullptr, - getProxyMockedFunctionPointers()}); + getMockedFunctionPointers()}); // FIXME: which backend to pass here? does it affect anything? MMockPluginPtr = std::make_unique(RTPlugin, backend::opencl, diff --git a/sycl/unittests/helpers/PiMockPlugin.hpp b/sycl/unittests/helpers/PiMockPlugin.hpp index 3fc618d06fdf3..4911b331f1423 100644 --- a/sycl/unittests/helpers/PiMockPlugin.hpp +++ b/sycl/unittests/helpers/PiMockPlugin.hpp @@ -11,45 +11,8 @@ // //===----------------------------------------------------------------------===// -#include - -#include #include - -// Helpers for dummy handles - -struct DummyHandleT { - DummyHandleT(size_t DataSize = 0) - : MStorage(DataSize), MData(MStorage.data()) {} - std::atomic MRefCounter = 1; - std::vector MStorage; - unsigned char *MData = nullptr; -}; - -using DummyHandlePtrT = DummyHandleT *; - -// Allocates a dummy handle of type T with support of reference counting. -// Takes optional 'Size' parameter which can be used to allocate additional -// memory. The handle has to be deallocated using 'releaseDummyHandle'. -template inline T createDummyHandle(size_t Size = 0) { - DummyHandlePtrT DummyHandlePtr = new DummyHandleT(Size); - return reinterpret_cast(DummyHandlePtr); -} - -// Decrement reference counter for the handle and deallocates it if the -// reference counter becomes zero -template inline void releaseDummyHandle(T Handle) { - auto DummyHandlePtr = reinterpret_cast(Handle); - const size_t NewValue = --DummyHandlePtr->MRefCounter; - if (NewValue == 0) - delete DummyHandlePtr; -} - -// Increment reference counter for the handle -template inline void retainDummyHandle(T Handle) { - auto DummyHandlePtr = reinterpret_cast(Handle); - ++DummyHandlePtr->MRefCounter; -} +#include // // Platform @@ -119,8 +82,6 @@ mock_piextPlatformGetNativeHandle(pi_platform platform, inline pi_result mock_piextPlatformCreateWithNativeHandle(pi_native_handle nativeHandle, pi_platform *platform) { - *platform = reinterpret_cast(nativeHandle); - retainDummyHandle(*platform); return PI_SUCCESS; } @@ -173,7 +134,7 @@ inline pi_result mock_piDeviceGetInfo(pi_device device, } case PI_DEVICE_INFO_EXTENSIONS: { if (param_value) { - assert(param_value_size >= sizeof(MockSupportedExtensions)); + assert(param_value_size == sizeof(MockSupportedExtensions)); std::memcpy(param_value, MockSupportedExtensions, sizeof(MockSupportedExtensions)); } @@ -217,8 +178,6 @@ mock_piextDeviceGetNativeHandle(pi_device device, inline pi_result mock_piextDeviceCreateWithNativeHandle( pi_native_handle nativeHandle, pi_platform platform, pi_device *device) { - *device = reinterpret_cast(nativeHandle); - retainDummyHandle(*device); return PI_SUCCESS; } @@ -246,7 +205,8 @@ inline pi_result mock_piContextCreate( void (*pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data), void *user_data, pi_context *ret_context) { - *ret_context = createDummyHandle(); + static uintptr_t NextContext = 0; + *ret_context = reinterpret_cast(++NextContext); return PI_SUCCESS; } @@ -268,13 +228,9 @@ inline pi_result mock_piContextGetInfo(pi_context context, } } -inline pi_result mock_piContextRetain(pi_context context) { - retainDummyHandle(context); - return PI_SUCCESS; -} +inline pi_result mock_piContextRetain(pi_context context) { return PI_SUCCESS; } inline pi_result mock_piContextRelease(pi_context context) { - releaseDummyHandle(context); return PI_SUCCESS; } @@ -294,8 +250,6 @@ inline pi_result mock_piextContextCreateWithNativeHandle( pi_native_handle nativeHandle, pi_uint32 numDevices, const pi_device *devices, bool pluginOwnsNativeHandle, pi_context *context) { - *context = reinterpret_cast(nativeHandle); - retainDummyHandle(*context); return PI_SUCCESS; } @@ -305,7 +259,8 @@ inline pi_result mock_piextContextCreateWithNativeHandle( inline pi_result mock_piQueueCreate(pi_context context, pi_device device, pi_queue_properties properties, pi_queue *queue) { - *queue = createDummyHandle(); + static uintptr_t NextQueue = 0; + *queue = reinterpret_cast(++NextQueue); return PI_SUCCESS; } @@ -327,12 +282,10 @@ inline pi_result mock_piQueueGetInfo(pi_queue command_queue, } inline pi_result mock_piQueueRetain(pi_queue command_queue) { - retainDummyHandle(command_queue); return PI_SUCCESS; } inline pi_result mock_piQueueRelease(pi_queue command_queue) { - releaseDummyHandle(command_queue); return PI_SUCCESS; } @@ -353,8 +306,6 @@ mock_piextQueueGetNativeHandle(pi_queue queue, pi_native_handle *nativeHandle) { inline pi_result mock_piextQueueCreateWithNativeHandle( pi_native_handle nativeHandle, pi_context context, pi_device device, bool pluginOwnsNativeHandle, pi_queue *queue) { - *queue = reinterpret_cast(nativeHandle); - retainDummyHandle(*queue); return PI_SUCCESS; } @@ -365,7 +316,8 @@ inline pi_result mock_piMemBufferCreate(pi_context context, pi_mem_flags flags, size_t size, void *host_ptr, pi_mem *ret_mem, const pi_mem_properties *properties = nullptr) { - *ret_mem = createDummyHandle(size); + static uintptr_t NextMem = 0; + *ret_mem = reinterpret_cast(++NextMem); return PI_SUCCESS; } @@ -373,9 +325,8 @@ inline pi_result mock_piMemImageCreate(pi_context context, pi_mem_flags flags, const pi_image_format *image_format, const pi_image_desc *image_desc, void *host_ptr, pi_mem *ret_mem) { - assert(false && - "TODO: mock_piMemImageCreate handle allocation size correctly"); - *ret_mem = createDummyHandle(/*size=*/1024 * 16); + static uintptr_t NextMem = 0; + *ret_mem = reinterpret_cast(++NextMem); return PI_SUCCESS; } @@ -392,31 +343,14 @@ inline pi_result mock_piMemImageGetInfo(pi_mem image, pi_image_info param_name, return PI_SUCCESS; } -inline pi_result mock_piMemRetain(pi_mem mem) { - retainDummyHandle(mem); - return PI_SUCCESS; -} +inline pi_result mock_piMemRetain(pi_mem mem) { return PI_SUCCESS; } -inline pi_result mock_piMemRelease(pi_mem mem) { - releaseDummyHandle(mem); - return PI_SUCCESS; -} +inline pi_result mock_piMemRelease(pi_mem mem) { return PI_SUCCESS; } inline pi_result mock_piMemBufferPartition(pi_mem buffer, pi_mem_flags flags, pi_buffer_create_type buffer_create_type, void *buffer_create_info, pi_mem *ret_mem) { - // Create a sub buf without memory as we will reuse parent's one - *ret_mem = createDummyHandle(/*size=*/0); - - auto parentDummyHandle = reinterpret_cast(buffer); - auto childDummyHandle = reinterpret_cast(*ret_mem); - - auto region = reinterpret_cast(buffer_create_info); - - // Point the sub buf to the original buf memory - childDummyHandle->MData = parentDummyHandle->MData + region->origin; - return PI_SUCCESS; } @@ -430,8 +364,6 @@ inline pi_result mock_piextMemCreateWithNativeHandle(pi_native_handle nativeHandle, pi_context context, bool ownNativeHandle, pi_mem *mem) { - *mem = reinterpret_cast(nativeHandle); - retainDummyHandle(*mem); return PI_SUCCESS; } @@ -441,7 +373,8 @@ mock_piextMemCreateWithNativeHandle(pi_native_handle nativeHandle, inline pi_result mock_piProgramCreate(pi_context context, const void *il, size_t length, pi_program *res_program) { - *res_program = createDummyHandle(); + static uintptr_t NextProgram = 0; + *res_program = reinterpret_cast(++NextProgram); return PI_SUCCESS; } @@ -450,7 +383,8 @@ inline pi_result mock_piclProgramCreateWithSource(pi_context context, const char **strings, const size_t *lengths, pi_program *ret_program) { - *ret_program = createDummyHandle(); + static uintptr_t NextProgram = 100; + *ret_program = reinterpret_cast(++NextProgram); return PI_SUCCESS; } @@ -459,7 +393,8 @@ inline pi_result mock_piProgramCreateWithBinary( const size_t *lengths, const unsigned char **binaries, size_t num_metadata_entries, const pi_device_binary_property *metadata, pi_int32 *binary_status, pi_program *ret_program) { - *ret_program = createDummyHandle(); + static uintptr_t NextProgram = 200; + *ret_program = reinterpret_cast(++NextProgram); return PI_SUCCESS; } @@ -486,7 +421,7 @@ inline pi_result mock_piProgramGetInfo(pi_program program, } case PI_PROGRAM_INFO_BINARIES: { if (param_value) - **static_cast(param_value) = 1; + *static_cast(param_value) = 1; if (param_value_size_ret) *param_value_size_ret = sizeof(unsigned char); return PI_SUCCESS; @@ -508,7 +443,8 @@ mock_piProgramLink(pi_context context, pi_uint32 num_devices, const pi_program *input_programs, void (*pfn_notify)(pi_program program, void *user_data), void *user_data, pi_program *ret_program) { - *ret_program = createDummyHandle(); + static uintptr_t NextProgram = 300; + *ret_program = reinterpret_cast(++NextProgram); return PI_SUCCESS; } @@ -534,13 +470,9 @@ inline pi_result mock_piProgramGetBuildInfo( return PI_SUCCESS; } -inline pi_result mock_piProgramRetain(pi_program program) { - retainDummyHandle(program); - return PI_SUCCESS; -} +inline pi_result mock_piProgramRetain(pi_program program) { return PI_SUCCESS; } inline pi_result mock_piProgramRelease(pi_program program) { - releaseDummyHandle(program); return PI_SUCCESS; } @@ -561,8 +493,6 @@ mock_piextProgramGetNativeHandle(pi_program program, inline pi_result mock_piextProgramCreateWithNativeHandle( pi_native_handle nativeHandle, pi_context context, bool pluginOwnsNativeHandle, pi_program *program) { - *program = reinterpret_cast(nativeHandle); - retainDummyHandle(*program); return PI_SUCCESS; } @@ -573,7 +503,8 @@ inline pi_result mock_piextProgramCreateWithNativeHandle( inline pi_result mock_piKernelCreate(pi_program program, const char *kernel_name, pi_kernel *ret_kernel) { - *ret_kernel = createDummyHandle(); + static uintptr_t NextKernel = 0; + *ret_kernel = reinterpret_cast(++NextKernel); return PI_SUCCESS; } @@ -620,15 +551,9 @@ inline pi_result mock_piKernelGetSubGroupInfo( return PI_SUCCESS; } -inline pi_result mock_piKernelRetain(pi_kernel kernel) { - retainDummyHandle(kernel); - return PI_SUCCESS; -} +inline pi_result mock_piKernelRetain(pi_kernel kernel) { return PI_SUCCESS; } -inline pi_result mock_piKernelRelease(pi_kernel kernel) { - releaseDummyHandle(kernel); - return PI_SUCCESS; -} +inline pi_result mock_piKernelRelease(pi_kernel kernel) { return PI_SUCCESS; } inline pi_result mock_piextKernelSetArgPointer(pi_kernel kernel, pi_uint32 arg_index, @@ -647,9 +572,6 @@ inline pi_result mock_piKernelSetExecInfo(pi_kernel kernel, inline pi_result mock_piextKernelCreateWithNativeHandle( pi_native_handle nativeHandle, pi_context context, pi_program program, bool pluginOwnsNativeHandle, pi_kernel *kernel) { - - *kernel = reinterpret_cast(nativeHandle); - retainDummyHandle(*kernel); return PI_SUCCESS; } @@ -664,7 +586,8 @@ mock_piextKernelGetNativeHandle(pi_kernel kernel, // Events // inline pi_result mock_piEventCreate(pi_context context, pi_event *ret_event) { - *ret_event = createDummyHandle(); + static uintptr_t NextEvent = 0; + *ret_event = reinterpret_cast(++NextEvent); return PI_SUCCESS; } @@ -711,15 +634,9 @@ inline pi_result mock_piEventSetStatus(pi_event event, return PI_SUCCESS; } -inline pi_result mock_piEventRetain(pi_event event) { - retainDummyHandle(event); - return PI_SUCCESS; -} +inline pi_result mock_piEventRetain(pi_event event) { return PI_SUCCESS; } -inline pi_result mock_piEventRelease(pi_event event) { - releaseDummyHandle(event); - return PI_SUCCESS; -} +inline pi_result mock_piEventRelease(pi_event event) { return PI_SUCCESS; } inline pi_result mock_piextEventGetNativeHandle(pi_event event, pi_native_handle *nativeHandle) { @@ -731,8 +648,6 @@ inline pi_result mock_piextEventCreateWithNativeHandle(pi_native_handle nativeHandle, pi_context context, bool ownNativeHandle, pi_event *event) { - *event = reinterpret_cast(nativeHandle); - retainDummyHandle(*event); return PI_SUCCESS; } @@ -743,7 +658,8 @@ inline pi_result mock_piSamplerCreate(pi_context context, const pi_sampler_properties *sampler_properties, pi_sampler *result_sampler) { - *result_sampler = createDummyHandle(); + static uintptr_t NextSampler = 0; + *result_sampler = reinterpret_cast(++NextSampler); return PI_SUCCESS; } @@ -755,13 +671,9 @@ inline pi_result mock_piSamplerGetInfo(pi_sampler sampler, return PI_SUCCESS; } -inline pi_result mock_piSamplerRetain(pi_sampler sampler) { - retainDummyHandle(sampler); - return PI_SUCCESS; -} +inline pi_result mock_piSamplerRetain(pi_sampler sampler) { return PI_SUCCESS; } inline pi_result mock_piSamplerRelease(pi_sampler sampler) { - releaseDummyHandle(sampler); return PI_SUCCESS; } @@ -773,7 +685,8 @@ inline pi_result mock_piEnqueueKernelLaunch( const size_t *global_work_offset, const size_t *global_work_size, const size_t *local_work_size, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event) { - *event = createDummyHandle(); + static uintptr_t NextEvent = 1000; + *event = reinterpret_cast(++NextEvent); return PI_SUCCESS; } @@ -782,7 +695,6 @@ inline pi_result mock_piEnqueueNativeKernel( pi_uint32 num_mem_objects, const pi_mem *mem_list, const void **args_mem_loc, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } @@ -790,14 +702,12 @@ inline pi_result mock_piEnqueueEventsWait(pi_queue command_queue, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } inline pi_result mock_piEnqueueEventsWaitWithBarrier( pi_queue command_queue, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } @@ -806,7 +716,6 @@ mock_piEnqueueMemBufferRead(pi_queue queue, pi_mem buffer, pi_bool blocking_read, size_t offset, size_t size, void *ptr, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } @@ -817,7 +726,6 @@ inline pi_result mock_piEnqueueMemBufferReadRect( size_t buffer_slice_pitch, size_t host_row_pitch, size_t host_slice_pitch, void *ptr, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } @@ -826,7 +734,6 @@ mock_piEnqueueMemBufferWrite(pi_queue command_queue, pi_mem buffer, pi_bool blocking_write, size_t offset, size_t size, const void *ptr, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } @@ -837,7 +744,6 @@ inline pi_result mock_piEnqueueMemBufferWriteRect( size_t buffer_slice_pitch, size_t host_row_pitch, size_t host_slice_pitch, const void *ptr, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } @@ -847,7 +753,6 @@ mock_piEnqueueMemBufferCopy(pi_queue command_queue, pi_mem src_buffer, size_t dst_offset, size_t size, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } @@ -858,7 +763,6 @@ inline pi_result mock_piEnqueueMemBufferCopyRect( size_t dst_row_pitch, size_t dst_slice_pitch, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } @@ -869,7 +773,6 @@ inline pi_result mock_piEnqueueMemBufferFill(pi_queue command_queue, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } @@ -878,7 +781,6 @@ inline pi_result mock_piEnqueueMemImageRead( pi_image_offset origin, pi_image_region region, size_t row_pitch, size_t slice_pitch, void *ptr, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } @@ -889,7 +791,6 @@ mock_piEnqueueMemImageWrite(pi_queue command_queue, pi_mem image, size_t input_slice_pitch, const void *ptr, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } @@ -899,7 +800,6 @@ mock_piEnqueueMemImageCopy(pi_queue command_queue, pi_mem src_image, pi_image_offset dst_origin, pi_image_region region, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } @@ -909,7 +809,6 @@ mock_piEnqueueMemImageFill(pi_queue command_queue, pi_mem image, const size_t *region, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } @@ -920,10 +819,6 @@ inline pi_result mock_piEnqueueMemBufferMap(pi_queue command_queue, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event, void **ret_map) { - *event = createDummyHandle(); - - auto parentDummyHandle = reinterpret_cast(buffer); - *ret_map = (void *)(parentDummyHandle->MData); return PI_SUCCESS; } @@ -932,7 +827,6 @@ inline pi_result mock_piEnqueueMemUnmap(pi_queue command_queue, pi_mem memobj, pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } @@ -954,8 +848,7 @@ inline pi_result mock_piextKernelSetArgSampler(pi_kernel kernel, inline pi_result mock_piextUSMHostAlloc(void **result_ptr, pi_context context, pi_usm_mem_properties *properties, size_t size, pi_uint32 alignment) { - assert(alignment < 16 && "TODO: mock_piextUSMHostAlloc handle alignment"); - *result_ptr = createDummyHandle(size); + *result_ptr = (void *)0x1; return PI_SUCCESS; } @@ -963,8 +856,7 @@ inline pi_result mock_piextUSMDeviceAlloc(void **result_ptr, pi_context context, pi_device device, pi_usm_mem_properties *properties, size_t size, pi_uint32 alignment) { - assert(alignment < 16 && "TODO: mock_piextUSMHostAlloc handle alignment"); - *result_ptr = createDummyHandle(size); + *result_ptr = (void *)0x1; return PI_SUCCESS; } @@ -972,8 +864,7 @@ inline pi_result mock_piextUSMSharedAlloc(void **result_ptr, pi_context context, pi_device device, pi_usm_mem_properties *properties, size_t size, pi_uint32 alignment) { - assert(alignment < 16 && "TODO: mock_piextUSMHostAlloc handle alignment"); - *result_ptr = createDummyHandle(size); + *result_ptr = (void *)0x1; return PI_SUCCESS; } @@ -986,7 +877,6 @@ inline pi_result mock_piextUSMEnqueueMemset(pi_queue queue, void *ptr, pi_uint32 num_events_in_waitlist, const pi_event *events_waitlist, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } @@ -996,7 +886,6 @@ inline pi_result mock_piextUSMEnqueueMemcpy(pi_queue queue, pi_bool blocking, pi_uint32 num_events_in_waitlist, const pi_event *events_waitlist, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } @@ -1006,7 +895,6 @@ inline pi_result mock_piextUSMEnqueuePrefetch(pi_queue queue, const void *ptr, pi_uint32 num_events_in_waitlist, const pi_event *events_waitlist, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } @@ -1014,7 +902,6 @@ inline pi_result mock_piextUSMEnqueueMemAdvise(pi_queue queue, const void *ptr, size_t length, pi_mem_advice advice, pi_event *event) { - *event = createDummyHandle(); return PI_SUCCESS; } @@ -1034,3 +921,16 @@ inline pi_result mock_piTearDown(void *PluginParameter) { return PI_SUCCESS; } inline pi_result mock_piPluginGetLastError(char **message) { return PI_SUCCESS; } + +#define _PI_MOCK_PLUGIN_CONCAT(A, B) A##B +#define PI_MOCK_PLUGIN_CONCAT(A, B) _PI_MOCK_PLUGIN_CONCAT(A, B) + +inline pi_plugin::FunctionPointers getMockedFunctionPointers() { + return { +#define _PI_API(api) PI_MOCK_PLUGIN_CONCAT(mock_, api), +#include + }; +} + +#undef PI_MOCK_PLUGIN_CONCAT +#undef _PI_MOCK_PLUGIN_CONCAT diff --git a/sycl/unittests/kernel-and-program/Cache.cpp b/sycl/unittests/kernel-and-program/Cache.cpp index 423918bd0048c..b7066c1412955 100644 --- a/sycl/unittests/kernel-and-program/Cache.cpp +++ b/sycl/unittests/kernel-and-program/Cache.cpp @@ -110,8 +110,7 @@ class KernelAndProgramCacheTest : public ::testing::Test { protected: void SetUp() override { - Mock.redefineBefore( - redefinedKernelGetInfo); + Mock.redefine(redefinedKernelGetInfo); } protected: diff --git a/sycl/unittests/kernel-and-program/DeviceInfo.cpp b/sycl/unittests/kernel-and-program/DeviceInfo.cpp index 43d94d989843f..f713614984bff 100644 --- a/sycl/unittests/kernel-and-program/DeviceInfo.cpp +++ b/sycl/unittests/kernel-and-program/DeviceInfo.cpp @@ -54,8 +54,7 @@ class DeviceInfoTest : public ::testing::Test { protected: void SetUp() override { - Mock.redefineBefore( - redefinedDeviceGetInfo); + Mock.redefine(redefinedDeviceGetInfo); } protected: diff --git a/sycl/unittests/kernel-and-program/KernelBuildOptions.cpp b/sycl/unittests/kernel-and-program/KernelBuildOptions.cpp index f67ffed3f81f1..161c5046cecc5 100644 --- a/sycl/unittests/kernel-and-program/KernelBuildOptions.cpp +++ b/sycl/unittests/kernel-and-program/KernelBuildOptions.cpp @@ -79,9 +79,9 @@ static pi_result redefinedProgramLink(pi_context, pi_uint32, const pi_device *, static void setupCommonMockAPIs(sycl::unittest::PiMock &Mock) { using namespace sycl::detail; - Mock.redefineBefore(redefinedProgramCompile); - Mock.redefineBefore(redefinedProgramLink); - Mock.redefineBefore(redefinedProgramBuild); + Mock.redefine(redefinedProgramCompile); + Mock.redefine(redefinedProgramLink); + Mock.redefine(redefinedProgramBuild); } static sycl::unittest::PiImage generateDefaultImage() { diff --git a/sycl/unittests/kernel-and-program/KernelInfo.cpp b/sycl/unittests/kernel-and-program/KernelInfo.cpp index 98bb1f0e0f667..34f965fbe4887 100644 --- a/sycl/unittests/kernel-and-program/KernelInfo.cpp +++ b/sycl/unittests/kernel-and-program/KernelInfo.cpp @@ -38,6 +38,32 @@ static pi_result redefinedKernelGetGroupInfo(pi_kernel kernel, pi_device device, return PI_SUCCESS; } +static pi_result redefinedProgramCreateWithSource(pi_context context, + pi_uint32 count, + const char **strings, + const size_t *lengths, + pi_program *ret_program) { + return PI_SUCCESS; +} + +static pi_result +redefinedProgramBuild(pi_program program, pi_uint32 num_devices, + const pi_device *device_list, const char *options, + void (*pfn_notify)(pi_program program, void *user_data), + void *user_data) { + return PI_SUCCESS; +} + +static pi_result redefinedKernelCreate(pi_program program, + const char *kernel_name, + pi_kernel *ret_kernel) { + return PI_SUCCESS; +} + +static pi_result redefinedKernelRetain(pi_kernel kernel) { return PI_SUCCESS; } + +static pi_result redefinedKernelRelease(pi_kernel kernel) { return PI_SUCCESS; } + static pi_result redefinedKernelGetInfo(pi_kernel kernel, pi_kernel_info param_name, size_t param_value_size, @@ -52,16 +78,30 @@ static pi_result redefinedKernelGetInfo(pi_kernel kernel, return PI_SUCCESS; } +static pi_result redefinedKernelSetExecInfo(pi_kernel kernel, + pi_kernel_exec_info param_name, + size_t param_value_size, + const void *param_value) { + return PI_SUCCESS; +} + class KernelInfoTest : public ::testing::Test { public: KernelInfoTest() : Mock{}, Plt{Mock.getPlatform()} {} protected: void SetUp() override { - Mock.redefineBefore( + Mock.redefine( redefinedKernelGetGroupInfo); - Mock.redefineBefore( - redefinedKernelGetInfo); + Mock.redefine( + redefinedProgramCreateWithSource); + Mock.redefine(redefinedProgramBuild); + Mock.redefine(redefinedKernelCreate); + Mock.redefine(redefinedKernelRetain); + Mock.redefine(redefinedKernelRelease); + Mock.redefine(redefinedKernelGetInfo); + Mock.redefine( + redefinedKernelSetExecInfo); } protected: diff --git a/sycl/unittests/kernel-and-program/KernelRelease.cpp b/sycl/unittests/kernel-and-program/KernelRelease.cpp index b6f616c34461e..9fab6f97d9a8e 100644 --- a/sycl/unittests/kernel-and-program/KernelRelease.cpp +++ b/sycl/unittests/kernel-and-program/KernelRelease.cpp @@ -29,6 +29,22 @@ struct TestCtx { static std::unique_ptr TestContext; +static pi_result redefinedProgramCreateWithSource(pi_context context, + pi_uint32 count, + const char **strings, + const size_t *lengths, + pi_program *ret_program) { + return PI_SUCCESS; +} + +static pi_result +redefinedProgramBuild(pi_program program, pi_uint32 num_devices, + const pi_device *device_list, const char *options, + void (*pfn_notify)(pi_program program, void *user_data), + void *user_data) { + return PI_SUCCESS; +} + static pi_result redefinedKernelCreate(pi_program program, const char *kernel_name, pi_kernel *ret_kernel) { @@ -60,14 +76,24 @@ static pi_result redefinedKernelGetInfo(pi_kernel kernel, return PI_SUCCESS; } +static pi_result redefinedKernelSetExecInfo(pi_kernel kernel, + pi_kernel_exec_info param_name, + size_t param_value_size, + const void *param_value) { + return PI_SUCCESS; +} + TEST(KernelReleaseTest, DISABLED_GetKernelRelease) { sycl::unittest::PiMock Mock; - Mock.redefineBefore(redefinedKernelCreate); - Mock.redefineBefore(redefinedKernelRetain); - Mock.redefineBefore( - redefinedKernelRelease); - Mock.redefineBefore( - redefinedKernelGetInfo); + Mock.redefine( + redefinedProgramCreateWithSource); + Mock.redefine(redefinedProgramBuild); + Mock.redefine(redefinedKernelCreate); + Mock.redefine(redefinedKernelRetain); + Mock.redefine(redefinedKernelRelease); + Mock.redefine(redefinedKernelGetInfo); + Mock.redefine( + redefinedKernelSetExecInfo); context Ctx{Mock.getPlatform().get_devices()[0]}; TestContext.reset(new TestCtx(Ctx)); @@ -79,4 +105,4 @@ TEST(KernelReleaseTest, DISABLED_GetKernelRelease) { ASSERT_EQ(TestContext->KernelReferenceCount, 0) << "Reference count not equal to 0 after kernel destruction"; -} +} \ No newline at end of file diff --git a/sycl/unittests/kernel-and-program/MultipleDevsCache.cpp b/sycl/unittests/kernel-and-program/MultipleDevsCache.cpp index 27e235c4ae3b1..c443d34bcc36e 100644 --- a/sycl/unittests/kernel-and-program/MultipleDevsCache.cpp +++ b/sycl/unittests/kernel-and-program/MultipleDevsCache.cpp @@ -21,11 +21,24 @@ using namespace sycl; -static pi_result redefinedDevicesGetAfter(pi_platform platform, - pi_device_type device_type, - pi_uint32 num_entries, - pi_device *devices, - pi_uint32 *num_devices) { +static pi_result redefinedContextCreate( + const pi_context_properties *properties, pi_uint32 num_devices, + const pi_device *devices, + void (*pfn_notify)(const char *errinfo, const void *private_info, size_t cb, + void *user_data), + void *user_data, pi_context *ret_context) { + *ret_context = reinterpret_cast(123); + return PI_SUCCESS; +} + +static pi_result redefinedContextRelease(pi_context context) { + return PI_SUCCESS; +} + +static pi_result redefinedDevicesGet(pi_platform platform, + pi_device_type device_type, + pi_uint32 num_entries, pi_device *devices, + pi_uint32 *num_devices) { if (num_devices) { *num_devices = static_cast(2); return PI_SUCCESS; @@ -54,6 +67,31 @@ static pi_result redefinedDeviceGetInfo(pi_device device, return PI_SUCCESS; } +static pi_result redefinedDeviceRetain(pi_device device) { return PI_SUCCESS; } + +static pi_result redefinedDeviceRelease(pi_device device) { return PI_SUCCESS; } + +static pi_result redefinedQueueCreate(pi_context context, pi_device device, + pi_queue_properties properties, + pi_queue *queue) { + *queue = reinterpret_cast(1234); + return PI_SUCCESS; +} + +static pi_result redefinedQueueRelease(pi_queue command_queue) { + return PI_SUCCESS; +} + +static size_t ProgramNum = 12345; +static pi_result redefinedProgramCreate(pi_context context, const void *il, + size_t length, + pi_program *res_program) { + size_t CurrentProgram = ProgramNum; + *res_program = reinterpret_cast(CurrentProgram); + ++ProgramNum; + return PI_SUCCESS; +} + static int RetainCounter = 0; static pi_result redefinedProgramRetain(pi_program program) { ++RetainCounter; @@ -72,14 +110,17 @@ class MultipleDeviceCacheTest : public ::testing::Test { protected: void SetUp() override { - Mock.redefineAfter( - redefinedDevicesGetAfter); - Mock.redefineBefore( - redefinedDeviceGetInfo); - Mock.redefineBefore( - redefinedProgramRetain); - Mock.redefineBefore( - redefinedKernelRelease); + Mock.redefine(redefinedDevicesGet); + Mock.redefine(redefinedDeviceGetInfo); + Mock.redefine(redefinedDeviceRetain); + Mock.redefine(redefinedDeviceRelease); + Mock.redefine(redefinedContextCreate); + Mock.redefine(redefinedContextRelease); + Mock.redefine(redefinedQueueCreate); + Mock.redefine(redefinedQueueRelease); + Mock.redefine(redefinedProgramRetain); + Mock.redefine(redefinedProgramCreate); + Mock.redefine(redefinedKernelRelease); } protected: diff --git a/sycl/unittests/kernel-and-program/PersistentDeviceCodeCache.cpp b/sycl/unittests/kernel-and-program/PersistentDeviceCodeCache.cpp index be50f0a84bafd..93de59da61b32 100644 --- a/sycl/unittests/kernel-and-program/PersistentDeviceCodeCache.cpp +++ b/sycl/unittests/kernel-and-program/PersistentDeviceCodeCache.cpp @@ -52,11 +52,11 @@ std::vector> Progs = { static unsigned char DeviceCodeID = 2; -static pi_result redefinedProgramGetInfoAfter(pi_program program, - pi_program_info param_name, - size_t param_value_size, - void *param_value, - size_t *param_value_size_ret) { +static pi_result redefinedProgramGetInfo(pi_program program, + pi_program_info param_name, + size_t param_value_size, + void *param_value, + size_t *param_value_size_ret) { if (param_name == PI_PROGRAM_INFO_NUM_DEVICES) { auto value = reinterpret_cast(param_value); *value = Progs[DeviceCodeID].size(); @@ -70,11 +70,9 @@ static pi_result redefinedProgramGetInfoAfter(pi_program program, if (param_name == PI_PROGRAM_INFO_BINARIES) { auto value = reinterpret_cast(param_value); - for (size_t i = 0; i < Progs[DeviceCodeID].size(); ++i) { - for (int j = 0; j < Progs[DeviceCodeID][i]; ++j) { + for (size_t i = 0; i < Progs[DeviceCodeID].size(); ++i) + for (int j = 0; j < Progs[DeviceCodeID][i]; ++j) value[i][j] = i; - } - } } return PI_SUCCESS; @@ -171,8 +169,7 @@ class PersistentDeviceCodeCache RootSYCLCacheDir = SYCLCacheDir; Dev = Plt.get_devices()[0]; - Mock.redefineAfter( - redefinedProgramGetInfoAfter); + Mock.redefine(redefinedProgramGetInfo); } /* Helper function for concurent cache item read/write from diffrent number diff --git a/sycl/unittests/pi/PiMock.cpp b/sycl/unittests/pi/PiMock.cpp index 97342a6922552..6fb725e7d4466 100644 --- a/sycl/unittests/pi/PiMock.cpp +++ b/sycl/unittests/pi/PiMock.cpp @@ -14,42 +14,14 @@ using namespace sycl; -static bool GpiProgramBuildRedefineCalled = false; -static bool GpiKernelCreateRedefineCalled = false; -static bool GpiProgramRetainCalled = false; -static bool GpiContextCreateRedefineCalledAfter = false; -static bool GpiQueueCreateRedefineCalledBefore = false; - -pi_result piQueueCreateRedefineBefore(pi_context context, pi_device device, - pi_queue_properties properties, - pi_queue *queue) { - // The context should have been set by the original function - GpiQueueCreateRedefineCalledBefore = *queue == nullptr; - // Returning an error should stop calls to all redefined functions - return PI_ERROR_INVALID_OPERATION; -} - -pi_result piContextCreateRedefineAfter( - const pi_context_properties *properties, pi_uint32 num_devices, - const pi_device *devices, - void (*pfn_notify)(const char *errinfo, const void *private_info, size_t cb, - void *user_data), - void *user_data, pi_context *ret_context) { - // The context should have been set by the original function - GpiContextCreateRedefineCalledAfter = *ret_context != nullptr; - return PI_SUCCESS; -} - pi_result piProgramBuildRedefine(pi_program, pi_uint32, const pi_device *, const char *, void (*)(pi_program, void *), void *) { - GpiProgramBuildRedefineCalled = true; - return PI_SUCCESS; + return PI_ERROR_INVALID_BINARY; } pi_result piKernelCreateRedefine(pi_program, const char *, pi_kernel *) { - GpiKernelCreateRedefineCalled = true; - return PI_SUCCESS; + return PI_ERROR_INVALID_DEVICE; } TEST(PiMockTest, ConstructFromQueue) { @@ -98,73 +70,24 @@ TEST(PiMockTest, RedefineAPI) { // Pass a function pointer Mock.redefine(piProgramBuildRedefine); - Table.piProgramBuild(/*pi_program*/ nullptr, /*num_devices=*/0, - /*device_list = */ nullptr, - /*options=*/nullptr, /*pfn_notify=*/nullptr, - /*user_data=*/nullptr); - - EXPECT_TRUE(GpiProgramBuildRedefineCalled) + EXPECT_EQ(Table.piProgramBuild, &piProgramBuildRedefine) << "Function redefinition didn't propagate to the mock plugin"; // Pass a std::function Mock.redefine({piKernelCreateRedefine}); - - Table.piKernelCreate(/*pi_program=*/nullptr, /*kernel_name=*/nullptr, - /*pi_kernel=*/nullptr); - EXPECT_TRUE(GpiKernelCreateRedefineCalled) + EXPECT_EQ(Table.piKernelCreate, &piKernelCreateRedefine) << "Function redefinition didn't propagate to the mock plugin"; // Pass a captureless lambda + auto *OldFuncPtr = Table.piProgramRetain; auto Lambda = [](pi_program) -> pi_result { - GpiProgramRetainCalled = true; - return PI_SUCCESS; + return PI_ERROR_INVALID_PROGRAM; }; + EXPECT_FALSE(OldFuncPtr == Lambda) + << "Lambda is the same as the existing function."; Mock.redefine(Lambda); - Table.piProgramRetain(/*pi_program=*/nullptr); - - EXPECT_TRUE(GpiProgramRetainCalled) + EXPECT_FALSE(Table.piProgramRetain == OldFuncPtr) << "Passing a lambda didn't change the function table entry"; -} - -TEST(PiMockTest, RedefineAfterAPI) { - sycl::unittest::PiMock Mock; - - const auto &MockPiPlugin = - detail::getSyclObjImpl(Mock.getPlatform())->getPlugin().getPiPlugin(); - const auto &Table = MockPiPlugin.PiFunctionTable; - - // Pass a function pointer - Mock.redefineAfter( - piContextCreateRedefineAfter); - - pi_context PIContext = nullptr; - Table.piContextCreate( - /*pi_context_properties=*/nullptr, /*num_devices=*/0, - /*devices=*/nullptr, /*pfn_notify=*/nullptr, - /*user_data=*/nullptr, &PIContext); - - EXPECT_TRUE(GpiContextCreateRedefineCalledAfter) - << "The additional function is not called after the original one"; -} - -TEST(PiMockTest, RedefineBeforeAPI) { - sycl::unittest::PiMock Mock; - - const auto &MockPiPlugin = - detail::getSyclObjImpl(Mock.getPlatform())->getPlugin().getPiPlugin(); - const auto &Table = MockPiPlugin.PiFunctionTable; - - // Pass a function pointer - Mock.redefineBefore( - piQueueCreateRedefineBefore); - - pi_queue Queue = nullptr; - Table.piQueueCreate(/*pi_context=*/nullptr, /*pi_device=*/nullptr, - /*pi_queue_properties=*/0, &Queue); - - EXPECT_TRUE(GpiQueueCreateRedefineCalledBefore) - << "The additional function is not called before the original one"; - - EXPECT_TRUE(nullptr == Queue) << "Queue is expected to be non-initialized as " - "the original function should not be called"; + ASSERT_FALSE(Table.piProgramRetain == nullptr) + << "Passing a lambda set the table entry to a null pointer"; } diff --git a/sycl/unittests/pi/piInteropRetain.cpp b/sycl/unittests/pi/piInteropRetain.cpp index b76007328c336..4ac58bd4d125f 100644 --- a/sycl/unittests/pi/piInteropRetain.cpp +++ b/sycl/unittests/pi/piInteropRetain.cpp @@ -30,7 +30,7 @@ TEST(PiInteropTest, CheckRetain) { // The queue construction should not call to piQueueRetain. Instead // piQueueCreate should return the "retained" queue. - Mock.redefineBefore(redefinedQueueRetain); + Mock.redefine(redefinedQueueRetain); queue Q{Ctx, default_selector()}; EXPECT_TRUE(QueueRetainCalled == 0); diff --git a/sycl/unittests/program_manager/BuildLog.cpp b/sycl/unittests/program_manager/BuildLog.cpp index a1829d4c06e4d..30a5b3b90be24 100644 --- a/sycl/unittests/program_manager/BuildLog.cpp +++ b/sycl/unittests/program_manager/BuildLog.cpp @@ -49,8 +49,7 @@ static pi_result redefinedProgramGetBuildInfo( static void setupCommonTestAPIs(sycl::unittest::PiMock &Mock) { using namespace sycl::detail; - Mock.redefineBefore( - redefinedProgramGetBuildInfo); + Mock.redefine(redefinedProgramGetBuildInfo); } TEST(BuildLog, OutputNothingOnLevel1) { diff --git a/sycl/unittests/program_manager/EliminatedArgMask.cpp b/sycl/unittests/program_manager/EliminatedArgMask.cpp index d71902b5f2a40..97f0ff70665c9 100644 --- a/sycl/unittests/program_manager/EliminatedArgMask.cpp +++ b/sycl/unittests/program_manager/EliminatedArgMask.cpp @@ -194,7 +194,7 @@ sycl::detail::ProgramManager::KernelArgMask getKernelArgMaskFromBundle( TEST(EliminatedArgMask, KernelBundleWith2Kernels) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore( + Mock.redefine( redefinedProgramCreateEAM); const sycl::device Dev = Plt.get_devices()[0]; diff --git a/sycl/unittests/program_manager/SubDevices.cpp b/sycl/unittests/program_manager/SubDevices.cpp index b71156f05d71d..da6ebf0a4426a 100644 --- a/sycl/unittests/program_manager/SubDevices.cpp +++ b/sycl/unittests/program_manager/SubDevices.cpp @@ -99,17 +99,15 @@ TEST(SubDevices, DISABLED_BuildProgramForSubdevices) { // Setup Mock APIs sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore( + Mock.redefine( redefinedDeviceGetInfo); - Mock.redefineBefore( + Mock.redefine( redefinedDevicePartition); - Mock.redefineBefore( - redefinedDeviceRetain); - Mock.redefineBefore( + Mock.redefine(redefinedDeviceRetain); + Mock.redefine( redefinedDeviceRelease); - Mock.redefineBefore( - redefinedProgramBuild); - Mock.redefineBefore( + Mock.redefine(redefinedProgramBuild); + Mock.redefine( redefinedContextCreate); // Create 2 sub-devices and use first platform device as a root device diff --git a/sycl/unittests/program_manager/itt_annotations.cpp b/sycl/unittests/program_manager/itt_annotations.cpp index 444b2aaacdaf6..1d127160493e5 100644 --- a/sycl/unittests/program_manager/itt_annotations.cpp +++ b/sycl/unittests/program_manager/itt_annotations.cpp @@ -64,8 +64,7 @@ TEST(ITTNotify, UseKernelBundle) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore< - sycl::detail::PiApiKind::piextProgramSetSpecializationConstant>( + Mock.redefine( redefinedProgramSetSpecializationConstant); const sycl::device Dev = Plt.get_devices()[0]; @@ -92,8 +91,7 @@ TEST(ITTNotify, VarNotSet) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore< - sycl::detail::PiApiKind::piextProgramSetSpecializationConstant>( + Mock.redefine( redefinedProgramSetSpecializationConstant); const sycl::device Dev = Plt.get_devices()[0]; diff --git a/sycl/unittests/program_manager/passing_link_and_compile_options.cpp b/sycl/unittests/program_manager/passing_link_and_compile_options.cpp index 95f2cf4ba5ca3..e9dffcc97fb73 100644 --- a/sycl/unittests/program_manager/passing_link_and_compile_options.cpp +++ b/sycl/unittests/program_manager/passing_link_and_compile_options.cpp @@ -146,10 +146,9 @@ inline pi_result redefinedProgramBuild( TEST(Link_Compile_Options, compile_link_Options_Test_empty_options) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore( + Mock.redefine( redefinedProgramCompile); - Mock.redefineBefore( - redefinedProgramLink); + Mock.redefine(redefinedProgramLink); const sycl::device Dev = Plt.get_devices()[0]; current_link_options.clear(); current_compile_options.clear(); @@ -173,10 +172,9 @@ TEST(Link_Compile_Options, compile_link_Options_Test_empty_options) { TEST(Link_Compile_Options, compile_link_Options_Test_filled_options) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore( + Mock.redefine( redefinedProgramCompile); - Mock.redefineBefore( - redefinedProgramLink); + Mock.redefine(redefinedProgramLink); const sycl::device Dev = Plt.get_devices()[0]; current_link_options.clear(); current_compile_options.clear(); @@ -208,12 +206,10 @@ TEST(Link_Compile_Options, compile_link_Options_Test_filled_options) { TEST(Link_Compile_Options, check_sycl_build) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore( + Mock.redefine( redefinedProgramCompile); - Mock.redefineBefore( - redefinedProgramLink); - Mock.redefineBefore( - redefinedProgramBuild); + Mock.redefine(redefinedProgramLink); + Mock.redefine(redefinedProgramBuild); const sycl::device Dev = Plt.get_devices()[0]; current_link_options.clear(); current_compile_options.clear(); diff --git a/sycl/unittests/queue/DeviceCheck.cpp b/sycl/unittests/queue/DeviceCheck.cpp index 92fa103d18c4e..c66472459cadf 100644 --- a/sycl/unittests/queue/DeviceCheck.cpp +++ b/sycl/unittests/queue/DeviceCheck.cpp @@ -103,19 +103,14 @@ TEST(QueueDeviceCheck, CheckDeviceRestriction) { context DefaultCtx = Plt.ext_oneapi_get_default_context(); device Dev = DefaultCtx.get_devices()[0]; - Mock.redefineBefore( - redefinedContextCreate); - Mock.redefineBefore( - redefinedContextRelease); - Mock.redefineBefore( - redefinedDeviceGetInfo); - Mock.redefineBefore( - redefinedDevicePartition); - Mock.redefineBefore( - redefinedDeviceRelease); - Mock.redefineBefore(redefinedDeviceRetain); - Mock.redefineBefore(redefinedQueueCreate); - Mock.redefineBefore(redefinedQueueRelease); + Mock.redefine(redefinedContextCreate); + Mock.redefine(redefinedContextRelease); + Mock.redefine(redefinedDeviceGetInfo); + Mock.redefine(redefinedDevicePartition); + Mock.redefine(redefinedDeviceRelease); + Mock.redefine(redefinedDeviceRetain); + Mock.redefine(redefinedQueueCreate); + Mock.redefine(redefinedQueueRelease); // Device is a member of the context. { diff --git a/sycl/unittests/queue/EventClear.cpp b/sycl/unittests/queue/EventClear.cpp index 043616100518e..f8e9af152add8 100644 --- a/sycl/unittests/queue/EventClear.cpp +++ b/sycl/unittests/queue/EventClear.cpp @@ -36,15 +36,27 @@ pi_result redefinedQueueCreate(pi_context context, pi_device device, return PI_SUCCESS; } +pi_result redefinedQueueRelease(pi_queue Queue) { return PI_SUCCESS; } + +pi_result redefinedUSMEnqueueMemset(pi_queue queue, void *ptr, pi_int32 value, + size_t count, + pi_uint32 num_events_in_waitlist, + const pi_event *events_waitlist, + pi_event *event) { + // Provide a dummy non-nullptr value + *event = reinterpret_cast(1); + return PI_SUCCESS; +} + pi_result redefinedEventsWait(pi_uint32 num_events, const pi_event *event_list) { ++TestContext->NEventsWaitedFor; return PI_SUCCESS; } -pi_result redefinedEventGetInfoAfter(pi_event event, pi_event_info param_name, - size_t param_value_size, void *param_value, - size_t *param_value_size_ret) { +pi_result redefinedEventGetInfo(pi_event event, pi_event_info param_name, + size_t param_value_size, void *param_value, + size_t *param_value_size_ret) { EXPECT_EQ(param_name, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS) << "Unexpected event info requested"; // Report first half of events as complete. @@ -71,12 +83,14 @@ pi_result redefinedEventRelease(pi_event event) { } void preparePiMock(unittest::PiMock &Mock) { - Mock.redefineBefore(redefinedQueueCreate); - Mock.redefineBefore(redefinedEventsWait); - Mock.redefineAfter( - redefinedEventGetInfoAfter); - Mock.redefineBefore(redefinedEventRetain); - Mock.redefineBefore(redefinedEventRelease); + Mock.redefine(redefinedQueueCreate); + Mock.redefine(redefinedQueueRelease); + Mock.redefine( + redefinedUSMEnqueueMemset); + Mock.redefine(redefinedEventsWait); + Mock.redefine(redefinedEventGetInfo); + Mock.redefine(redefinedEventRetain); + Mock.redefine(redefinedEventRelease); } // Check that the USM events are cleared from the queue upon call to wait(), diff --git a/sycl/unittests/queue/GetProfilingInfo.cpp b/sycl/unittests/queue/GetProfilingInfo.cpp index f410811e63445..2af4be9323f4a 100644 --- a/sycl/unittests/queue/GetProfilingInfo.cpp +++ b/sycl/unittests/queue/GetProfilingInfo.cpp @@ -71,7 +71,7 @@ redefinedPiEventGetProfilingInfo(pi_event event, pi_profiling_info param_name, TEST(GetProfilingInfo, normal_pass_without_exception) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore( + Mock.redefine( redefinedPiEventGetProfilingInfo); const sycl::device Dev = Plt.get_devices()[0]; sycl::context Ctx{Dev}; @@ -109,7 +109,7 @@ TEST(GetProfilingInfo, normal_pass_without_exception) { TEST(GetProfilingInfo, command_exception_check) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore( + Mock.redefine( redefinedPiEventGetProfilingInfo); const sycl::device Dev = Plt.get_devices()[0]; @@ -212,7 +212,7 @@ TEST(GetProfilingInfo, exception_check_no_queue) { TEST(GetProfilingInfo, check_if_now_dead_queue_property_set) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore( + Mock.redefine( redefinedPiEventGetProfilingInfo); const sycl::device Dev = Plt.get_devices()[0]; sycl::context Ctx{Dev}; @@ -253,7 +253,7 @@ TEST(GetProfilingInfo, check_if_now_dead_queue_property_set) { TEST(GetProfilingInfo, check_if_now_dead_queue_property_not_set) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore( + Mock.redefine( redefinedPiEventGetProfilingInfo); const sycl::device Dev = Plt.get_devices()[0]; sycl::context Ctx{Dev}; diff --git a/sycl/unittests/queue/USM.cpp b/sycl/unittests/queue/USM.cpp index 30cdd2b37393e..0fe7015832be3 100644 --- a/sycl/unittests/queue/USM.cpp +++ b/sycl/unittests/queue/USM.cpp @@ -21,38 +21,41 @@ struct { } TestContext; // Dummy event values for bookkeeping -pi_event WAIT = nullptr; -pi_event MEMCPY = nullptr; -pi_event MEMSET = nullptr; +pi_event WAIT = reinterpret_cast(1); +pi_event MEMCPY = reinterpret_cast(2); +pi_event MEMSET = reinterpret_cast(3); template auto getVal(T obj) { return detail::getSyclObjImpl(obj)->getHandleRef(); } -pi_result redefinedEnqueueEventsWaitAfter(pi_queue, pi_uint32 NumDeps, - const pi_event *Deps, - pi_event *Event) { +pi_result redefinedEnqueueEventsWait(pi_queue, pi_uint32 NumDeps, + const pi_event *Deps, pi_event *Event) { EXPECT_EQ(NumDeps, TestContext.Deps.size()); for (size_t i = 0; i < NumDeps; ++i) { EXPECT_EQ(Deps[i], getVal(TestContext.Deps[i])); } - WAIT = *Event; + *Event = WAIT; return PI_SUCCESS; } -pi_result redefinedUSMEnqueueMemcpyAfter(pi_queue, pi_bool, void *, - const void *, size_t, pi_uint32, - const pi_event *, pi_event *Event) { - // Set MEMCPY to the event produced by the original USMEnqueueMemcpy - MEMCPY = *Event; +pi_result redefinedUSMEnqueueMemcpy(pi_queue, pi_bool, void *, const void *, + size_t, pi_uint32, const pi_event *, + pi_event *Event) { + *Event = MEMCPY; return PI_SUCCESS; } -pi_result redefinedUSMEnqueueMemsetAfter(pi_queue, void *, pi_int32, size_t, - pi_uint32, const pi_event *, - pi_event *Event) { - // Set MEMSET to the event produced by the original USMEnqueueMemcpy - MEMSET = *Event; +pi_result redefinedUSMEnqueueMemset(pi_queue, void *, pi_int32, size_t, + pi_uint32, const pi_event *, + pi_event *Event) { + *Event = MEMSET; + return PI_SUCCESS; +} + +pi_result redefinedEventRelease(pi_event) { return PI_SUCCESS; } +pi_result redefinedEventsWait(pi_uint32 /* num_events */, + const pi_event * /* event_list */) { return PI_SUCCESS; } @@ -60,12 +63,14 @@ pi_result redefinedUSMEnqueueMemsetAfter(pi_queue, void *, pi_int32, size_t, TEST(USM, NoOpPreservesDependencyChain) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineAfter( - redefinedEnqueueEventsWaitAfter); - Mock.redefineAfter( - redefinedUSMEnqueueMemcpyAfter); - Mock.redefineAfter( - redefinedUSMEnqueueMemsetAfter); + Mock.redefine( + redefinedEnqueueEventsWait); + Mock.redefine( + redefinedUSMEnqueueMemcpy); + Mock.redefine( + redefinedUSMEnqueueMemset); + Mock.redefine(redefinedEventRelease); + Mock.redefine(redefinedEventsWait); context Ctx{Plt.get_devices()[0]}; queue Q{Ctx, default_selector()}; diff --git a/sycl/unittests/queue/Wait.cpp b/sycl/unittests/queue/Wait.cpp index e32e2c8ad2a33..e1b8eac1c3ee8 100644 --- a/sycl/unittests/queue/Wait.cpp +++ b/sycl/unittests/queue/Wait.cpp @@ -36,12 +36,16 @@ pi_result redefinedQueueCreate(pi_context context, pi_device device, return PI_SUCCESS; } +pi_result redefinedQueueRelease(pi_queue Queue) { return PI_SUCCESS; } + pi_result redefinedUSMEnqueueMemset(pi_queue Queue, void *Ptr, pi_int32 Value, size_t Count, pi_uint32 Num_events_in_waitlist, const pi_event *Events_waitlist, pi_event *Event) { + // Provide a dummy non-nullptr value TestContext.EventReferenceCount = 1; + *Event = reinterpret_cast(1); return PI_SUCCESS; } pi_result redefinedEnqueueMemBufferFill(pi_queue Queue, pi_mem Buffer, @@ -50,7 +54,9 @@ pi_result redefinedEnqueueMemBufferFill(pi_queue Queue, pi_mem Buffer, pi_uint32 NumEventsInWaitList, const pi_event *EventWaitList, pi_event *Event) { + // Provide a dummy non-nullptr value TestContext.EventReferenceCount = 1; + *Event = reinterpret_cast(1); return PI_SUCCESS; } @@ -64,6 +70,12 @@ pi_result redefinedEventsWait(pi_uint32 num_events, return PI_SUCCESS; } +pi_result redefinedEventGetInfo(pi_event event, pi_event_info param_name, + size_t param_value_size, void *param_value, + size_t *param_value_size_ret) { + return PI_SUCCESS; +} + pi_result redefinedEventRetain(pi_event event) { ++TestContext.EventReferenceCount; return PI_SUCCESS; @@ -77,15 +89,17 @@ pi_result redefinedEventRelease(pi_event event) { TEST(QueueWait, QueueWaitTest) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore(redefinedQueueCreate); - Mock.redefineBefore(redefinedQueueFinish); - Mock.redefineBefore( + Mock.redefine(redefinedQueueCreate); + Mock.redefine(redefinedQueueRelease); + Mock.redefine(redefinedQueueFinish); + Mock.redefine( redefinedUSMEnqueueMemset); - Mock.redefineBefore(redefinedEventsWait); - Mock.redefineBefore( + Mock.redefine(redefinedEventsWait); + Mock.redefine( redefinedEnqueueMemBufferFill); - Mock.redefineBefore(redefinedEventRetain); - Mock.redefineBefore(redefinedEventRelease); + Mock.redefine(redefinedEventGetInfo); + Mock.redefine(redefinedEventRetain); + Mock.redefine(redefinedEventRelease); context Ctx{Plt.get_devices()[0]}; queue Q{Ctx, default_selector()}; diff --git a/sycl/unittests/scheduler/AllocaLinking.cpp b/sycl/unittests/scheduler/AllocaLinking.cpp index 57f909c270d08..c30f49dee53fd 100644 --- a/sycl/unittests/scheduler/AllocaLinking.cpp +++ b/sycl/unittests/scheduler/AllocaLinking.cpp @@ -17,11 +17,10 @@ using namespace sycl; static bool HostUnifiedMemory = false; -static pi_result redefinedDeviceGetInfoAfter(pi_device Device, - pi_device_info ParamName, - size_t ParamValueSize, - void *ParamValue, - size_t *ParamValueSizeRet) { +static pi_result redefinedDeviceGetInfo(pi_device Device, + pi_device_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { if (ParamName == PI_DEVICE_INFO_HOST_UNIFIED_MEMORY) { auto *Result = reinterpret_cast(ParamValue); *Result = HostUnifiedMemory; @@ -32,6 +31,16 @@ static pi_result redefinedDeviceGetInfoAfter(pi_device Device, return PI_SUCCESS; } +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) { + *ret_mem = nullptr; + return PI_SUCCESS; +} + +static pi_result redefinedMemRelease(pi_mem mem) { return PI_SUCCESS; } + TEST_F(SchedulerTest, AllocaLinking) { // This host device constructor should be placed before Mock.redefine // because it overrides the real implementation of get_device_info @@ -43,8 +52,9 @@ TEST_F(SchedulerTest, AllocaLinking) { sycl::unittest::PiMock Mock; sycl::queue Q{Mock.getPlatform().get_devices()[0]}; - Mock.redefineAfter( - redefinedDeviceGetInfoAfter); + Mock.redefine(redefinedDeviceGetInfo); + Mock.redefine(redefinedMemBufferCreate); + Mock.redefine(redefinedMemRelease); sycl::detail::QueueImplPtr QImpl = detail::getSyclObjImpl(Q); MockScheduler MS; diff --git a/sycl/unittests/scheduler/Commands.cpp b/sycl/unittests/scheduler/Commands.cpp index 96bcdad734968..d31a78e5c7cf5 100644 --- a/sycl/unittests/scheduler/Commands.cpp +++ b/sycl/unittests/scheduler/Commands.cpp @@ -34,6 +34,10 @@ pi_result redefinePiEventGetInfo(pi_event, pi_event_info, size_t, return PI_SUCCESS; } +pi_result redefinePiEventRetain(pi_event) { return PI_SUCCESS; } + +pi_result redefinePiEventRelease(pi_event) { return PI_SUCCESS; } + // // This test checks a handling of empty events in WaitWithBarrier command. // Original reproducer for l0 plugin led to segfault(nullptr dereference): @@ -49,7 +53,7 @@ TEST_F(SchedulerTest, WaitEmptyEventWithBarrier) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore( + Mock.redefine( redefinePiEnqueueEventsWaitWithBarrier); queue Queue{Plt.get_devices()[0]}; @@ -58,17 +62,13 @@ TEST_F(SchedulerTest, WaitEmptyEventWithBarrier) { queue_global_context = detail::getSyclObjImpl(Queue.get_context())->getHandleRef(); - Mock.redefineBefore( - redefinePiEventGetInfo); + Mock.redefine(redefinePiEventGetInfo); + Mock.redefine(redefinePiEventRetain); + Mock.redefine(redefinePiEventRelease); auto EmptyEvent = std::make_shared(); - - pi_event PIEvent = nullptr; - pi_result Res = mock_piEventCreate(/*context = */ (pi_context)0x1, &PIEvent); - assert(PI_SUCCESS == Res); - - auto Event = - std::make_shared(PIEvent, Queue.get_context()); + auto Event = std::make_shared( + reinterpret_cast(0x01), Queue.get_context()); using EventList = std::vector; std::vector InputEventWaitLists = { diff --git a/sycl/unittests/scheduler/CommandsWaitForEvents.cpp b/sycl/unittests/scheduler/CommandsWaitForEvents.cpp index 5808ebc9e7fc4..603b4e785aa9b 100644 --- a/sycl/unittests/scheduler/CommandsWaitForEvents.cpp +++ b/sycl/unittests/scheduler/CommandsWaitForEvents.cpp @@ -8,11 +8,8 @@ #include "SchedulerTest.hpp" #include "SchedulerTestUtils.hpp" -#include #include -#include - using namespace sycl; struct TestCtx { @@ -22,23 +19,15 @@ struct TestCtx { std::shared_ptr Ctx1; std::shared_ptr Ctx2; - pi_event EventCtx1 = nullptr; - - pi_event EventCtx2 = nullptr; + pi_event EventCtx1 = reinterpret_cast(0x01); + pi_event EventCtx2 = reinterpret_cast(0x02); bool EventCtx1WasWaited = false; bool EventCtx2WasWaited = false; TestCtx(queue &Queue1, queue &Queue2) : Q1(Queue1), Q2(Queue2), Ctx1{detail::getSyclObjImpl(Q1.get_context())}, - Ctx2{detail::getSyclObjImpl(Q2.get_context())} { - - pi_result Res = mock_piEventCreate((pi_context)0x0, &EventCtx1); - assert(PI_SUCCESS == Res); - - Res = mock_piEventCreate((pi_context)0x0, &EventCtx2); - assert(PI_SUCCESS == Res); - } + Ctx2{detail::getSyclObjImpl(Q2.get_context())} {} }; std::unique_ptr TestContext; @@ -59,6 +48,8 @@ pi_result waitFunc(pi_uint32 N, const pi_event *List) { return PI_SUCCESS; } +pi_result retainReleaseFunc(pi_event) { return PI_SUCCESS; } + pi_result getEventInfoFunc(pi_event Event, pi_event_info PName, size_t PVSize, void *PV, size_t *PVSizeRet) { EXPECT_EQ(PName, PI_EVENT_INFO_CONTEXT) << "Unknown param name"; @@ -77,8 +68,10 @@ TEST_F(SchedulerTest, CommandsWaitForEvents) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore(waitFunc); - Mock.redefineBefore(getEventInfoFunc); + Mock.redefine(waitFunc); + Mock.redefine(retainReleaseFunc); + Mock.redefine(retainReleaseFunc); + Mock.redefine(getEventInfoFunc); context Ctx1{Plt.get_devices()[0]}; queue Q1{Ctx1, default_selector_v}; diff --git a/sycl/unittests/scheduler/EnqueueWithDependsOnDeps.cpp b/sycl/unittests/scheduler/EnqueueWithDependsOnDeps.cpp index 43b677290a2d9..29db4edc8c759 100644 --- a/sycl/unittests/scheduler/EnqueueWithDependsOnDeps.cpp +++ b/sycl/unittests/scheduler/EnqueueWithDependsOnDeps.cpp @@ -303,9 +303,8 @@ TEST_F(SchedulerTest, InOrderEnqueueNoMemObjDoubleKernelDepHost) { if (!CheckTestExecutionRequirements(Plt)) return; - Mock.redefineBefore( - redefinedEventsWaitCustom); - Mock.redefineBefore( + Mock.redefine(redefinedEventsWaitCustom); + Mock.redefine( redefinedEnqueueKernelLaunchCustom); { diff --git a/sycl/unittests/scheduler/InOrderQueueDeps.cpp b/sycl/unittests/scheduler/InOrderQueueDeps.cpp index be5e8d874da17..fb1c22c6e6575 100644 --- a/sycl/unittests/scheduler/InOrderQueueDeps.cpp +++ b/sycl/unittests/scheduler/InOrderQueueDeps.cpp @@ -79,19 +79,17 @@ pi_result redefinedEventRelease(pi_event event) { return PI_SUCCESS; } TEST_F(SchedulerTest, InOrderQueueDeps) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore( - redefinedMemBufferCreate); - Mock.redefineBefore(redefinedMemRelease); - Mock.redefineBefore( + Mock.redefine(redefinedMemBufferCreate); + Mock.redefine(redefinedMemRelease); + Mock.redefine( redefinedEnqueueMemBufferReadRect); - Mock.redefineBefore( + Mock.redefine( redefinedEnqueueMemBufferWriteRect); - Mock.redefineBefore( + Mock.redefine( redefinedEnqueueMemBufferMap); - Mock.redefineBefore( - redefinedEnqueueMemUnmap); - Mock.redefineBefore(redefinedEventsWait); - Mock.redefineBefore(redefinedEventRelease); + Mock.redefine(redefinedEnqueueMemUnmap); + Mock.redefine(redefinedEventsWait); + Mock.redefine(redefinedEventRelease); context Ctx{Plt.get_devices()[0]}; queue InOrderQueue{Ctx, default_selector_v, property::queue::in_order()}; diff --git a/sycl/unittests/scheduler/InOrderQueueHostTaskDeps.cpp b/sycl/unittests/scheduler/InOrderQueueHostTaskDeps.cpp index 020a956537ddd..276d521cadb29 100644 --- a/sycl/unittests/scheduler/InOrderQueueHostTaskDeps.cpp +++ b/sycl/unittests/scheduler/InOrderQueueHostTaskDeps.cpp @@ -34,7 +34,7 @@ inline pi_result redefinedEventsWait(pi_uint32 num_events, TEST_F(SchedulerTest, InOrderQueueHostTaskDeps) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore(redefinedEventsWait); + Mock.redefine(redefinedEventsWait); context Ctx{Plt}; queue InOrderQueue{Ctx, default_selector_v, property::queue::in_order()}; diff --git a/sycl/unittests/scheduler/NoHostUnifiedMemory.cpp b/sycl/unittests/scheduler/NoHostUnifiedMemory.cpp index 93cd9287dc66b..49ac8db448de5 100644 --- a/sycl/unittests/scheduler/NoHostUnifiedMemory.cpp +++ b/sycl/unittests/scheduler/NoHostUnifiedMemory.cpp @@ -18,11 +18,10 @@ using namespace sycl; -static pi_result redefinedDeviceGetInfoAfter(pi_device Device, - pi_device_info ParamName, - size_t ParamValueSize, - void *ParamValue, - size_t *ParamValueSizeRet) { +static pi_result redefinedDeviceGetInfo(pi_device Device, + pi_device_info ParamName, + size_t ParamValueSize, void *ParamValue, + size_t *ParamValueSizeRet) { if (ParamName == PI_DEVICE_INFO_HOST_UNIFIED_MEMORY) { auto *Result = reinterpret_cast(ParamValue); *Result = false; @@ -41,11 +40,33 @@ redefinedMemBufferCreate(pi_context context, pi_mem_flags flags, size_t size, return PI_SUCCESS; } +static pi_result redefinedEnqueueMemBufferReadRect( + pi_queue command_queue, pi_mem buffer, pi_bool blocking_read, + pi_buff_rect_offset buffer_offset, pi_buff_rect_offset host_offset, + pi_buff_rect_region region, size_t buffer_row_pitch, + size_t buffer_slice_pitch, size_t host_row_pitch, size_t host_slice_pitch, + void *ptr, pi_uint32 num_events_in_wait_list, + const pi_event *event_wait_list, pi_event *event) { + return PI_SUCCESS; +} + +static pi_result redefinedEnqueueMemBufferWriteRect( + pi_queue command_queue, pi_mem buffer, pi_bool blocking_write, + pi_buff_rect_offset buffer_offset, pi_buff_rect_offset host_offset, + pi_buff_rect_region region, size_t buffer_row_pitch, + size_t buffer_slice_pitch, size_t host_row_pitch, size_t host_slice_pitch, + const void *ptr, pi_uint32 num_events_in_wait_list, + const pi_event *event_wait_list, pi_event *event) { + return PI_SUCCESS; +} + +static pi_result redefinedMemRetain(pi_mem mem) { return PI_SUCCESS; } +static pi_result redefinedMemRelease(pi_mem mem) { return PI_SUCCESS; } + static pi_context InteropPiContext = nullptr; -static pi_result redefinedMemGetInfoAfter(pi_mem mem, pi_mem_info param_name, - size_t param_value_size, - void *param_value, - size_t *param_value_size_ret) { +static pi_result redefinedMemGetInfo(pi_mem mem, pi_mem_info param_name, + size_t param_value_size, void *param_value, + size_t *param_value_size_ret) { auto *Result = reinterpret_cast(param_value); *Result = InteropPiContext; return PI_SUCCESS; @@ -69,12 +90,16 @@ redefinedMemCreateWithNativeHandle(pi_native_handle native_handle, TEST_F(SchedulerTest, NoHostUnifiedMemory) { unittest::PiMock Mock; queue Q{Mock.getPlatform().get_devices()[0]}; - Mock.redefineAfter( - redefinedDeviceGetInfoAfter); - Mock.redefineBefore( - redefinedMemBufferCreate); - Mock.redefineAfter(redefinedMemGetInfoAfter); - Mock.redefineBefore( + Mock.redefine(redefinedDeviceGetInfo); + Mock.redefine(redefinedMemBufferCreate); + Mock.redefine( + redefinedEnqueueMemBufferReadRect); + Mock.redefine( + redefinedEnqueueMemBufferWriteRect); + Mock.redefine(redefinedMemRetain); + Mock.redefine(redefinedMemRelease); + Mock.redefine(redefinedMemGetInfo); + Mock.redefine( redefinedMemCreateWithNativeHandle); sycl::detail::QueueImplPtr QImpl = detail::getSyclObjImpl(Q); @@ -188,12 +213,7 @@ TEST_F(SchedulerTest, NoHostUnifiedMemory) { } // Check that interoperability memory objects are initialized. { - pi_mem MockInteropBuffer = nullptr; - pi_result PIRes = mock_piMemBufferCreate( - /*pi_context=*/0x0, /*pi_mem_flags=*/PI_MEM_FLAGS_ACCESS_RW, /*size=*/1, - /*host_ptr=*/nullptr, &MockInteropBuffer); - assert(PI_SUCCESS == PIRes); - + cl_mem MockInteropBuffer = reinterpret_cast(1); context InteropContext = Q.get_context(); InteropPiContext = detail::getSyclObjImpl(InteropContext)->getHandleRef(); auto BufI = std::make_shared( diff --git a/sycl/unittests/scheduler/PostEnqueueCleanup.cpp b/sycl/unittests/scheduler/PostEnqueueCleanup.cpp index c0c1869ad318b..73b52c0214345 100644 --- a/sycl/unittests/scheduler/PostEnqueueCleanup.cpp +++ b/sycl/unittests/scheduler/PostEnqueueCleanup.cpp @@ -205,11 +205,10 @@ TEST_F(SchedulerTest, PostEnqueueCleanup) { detail::SYCLConfig::reset}; sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore( + Mock.redefine( redefinedEnqueueMemBufferMap); - Mock.redefineBefore( - redefinedEnqueueMemUnmap); - Mock.redefineBefore( + Mock.redefine(redefinedEnqueueMemUnmap); + Mock.redefine( redefinedEnqueueMemBufferFill); context Ctx{Plt}; diff --git a/sycl/unittests/scheduler/QueueFlushing.cpp b/sycl/unittests/scheduler/QueueFlushing.cpp index a09bbaa06a372..d40e9f5f6e3f6 100644 --- a/sycl/unittests/scheduler/QueueFlushing.cpp +++ b/sycl/unittests/scheduler/QueueFlushing.cpp @@ -26,11 +26,10 @@ static pi_result redefinedQueueFlush(pi_queue Queue) { return PI_SUCCESS; } -static pi_result redefinedEventGetInfoAfter(pi_event event, - pi_event_info param_name, - size_t param_value_size, - void *param_value, - size_t *param_value_size_ret) { +static pi_result redefinedEventGetInfo(pi_event event, pi_event_info param_name, + size_t param_value_size, + void *param_value, + size_t *param_value_size_ret) { EXPECT_NE(event, nullptr); if (param_name == PI_EVENT_INFO_COMMAND_EXECUTION_STATUS) { auto *Status = reinterpret_cast(param_value); @@ -40,6 +39,55 @@ static pi_result redefinedEventGetInfoAfter(pi_event event, return PI_SUCCESS; } +static pi_result redefinedEnqueueMemBufferReadRect( + pi_queue command_queue, pi_mem buffer, pi_bool blocking_read, + pi_buff_rect_offset buffer_offset, pi_buff_rect_offset host_offset, + pi_buff_rect_region region, size_t buffer_row_pitch, + size_t buffer_slice_pitch, size_t host_row_pitch, size_t host_slice_pitch, + void *ptr, pi_uint32 num_events_in_wait_list, + const pi_event *event_wait_list, pi_event *event) { + *event = reinterpret_cast(new int{}); + return PI_SUCCESS; +} + +static pi_result redefinedEnqueueMemBufferWriteRect( + pi_queue command_queue, pi_mem buffer, pi_bool blocking_write, + pi_buff_rect_offset buffer_offset, pi_buff_rect_offset host_offset, + pi_buff_rect_region region, size_t buffer_row_pitch, + size_t buffer_slice_pitch, size_t host_row_pitch, size_t host_slice_pitch, + const void *ptr, pi_uint32 num_events_in_wait_list, + const pi_event *event_wait_list, pi_event *event) { + *event = reinterpret_cast(new int{}); + 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 *event, void **ret_map) { + *event = reinterpret_cast(new int{}); + return PI_SUCCESS; +} + +static pi_result redefinedEnqueueMemUnmap(pi_queue command_queue, pi_mem memobj, + void *mapped_ptr, + pi_uint32 num_events_in_wait_list, + const pi_event *event_wait_list, + pi_event *event) { + *event = reinterpret_cast(new int{}); + return PI_SUCCESS; +} + +static pi_result redefinedEnqueueMemBufferFill( + pi_queue command_queue, pi_mem buffer, const void *pattern, + size_t pattern_size, size_t offset, size_t size, + pi_uint32 num_events_in_wait_list, const pi_event *event_wait_list, + pi_event *event) { + *event = reinterpret_cast(new int{}); + return PI_SUCCESS; +} + static void resetTestCtx() { EventStatus = PI_EVENT_QUEUED; QueueFlushed = false; @@ -51,12 +99,7 @@ static void addDepAndEnqueue(detail::Command *Cmd, detail::Requirement &MockReq) { MockCommand DepCmd(DepQueue); std::vector ToCleanUp; - - pi_event PIEvent = nullptr; - pi_result CallRet = mock_piEventCreate(/*pi_context=*/0x0, &PIEvent); - assert(PI_SUCCESS == CallRet); - - DepCmd.getEvent()->getHandleRef() = PIEvent; + DepCmd.getEvent()->getHandleRef() = reinterpret_cast(new int{}); (void)Cmd->addDep(detail::DepDesc{&DepCmd, &MockReq, nullptr}, ToCleanUp); detail::EnqueueResultT Res; @@ -85,9 +128,17 @@ static void testEventStatusCheck(detail::Command *Cmd, TEST_F(SchedulerTest, QueueFlushing) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore(redefinedQueueFlush); - Mock.redefineAfter( - redefinedEventGetInfoAfter); + Mock.redefine(redefinedQueueFlush); + Mock.redefine(redefinedEventGetInfo); + Mock.redefine( + redefinedEnqueueMemBufferReadRect); + Mock.redefine( + redefinedEnqueueMemBufferWriteRect); + Mock.redefine( + redefinedEnqueueMemBufferMap); + Mock.redefine(redefinedEnqueueMemUnmap); + Mock.redefine( + redefinedEnqueueMemBufferFill); context Ctx{Plt}; queue QueueA{Ctx, default_selector_v}; @@ -99,15 +150,7 @@ TEST_F(SchedulerTest, QueueFlushing) { int val; buffer Buf(&val, range<1>(1)); detail::Requirement MockReq = getMockRequirement(Buf); - - pi_mem PIBuf = nullptr; - pi_result Ret = mock_piMemBufferCreate(/*pi_context=*/0x0, - PI_MEM_FLAGS_ACCESS_RW, /*size=*/1, - /*host_ptr=*/nullptr, &PIBuf); - assert(Ret == PI_SUCCESS); - detail::AllocaCommand AllocaCmd = detail::AllocaCommand(QueueImplA, MockReq); - AllocaCmd.MMemAllocation = PIBuf; void *MockHostPtr; detail::EnqueueResultT Res; std::vector ToCleanUp; @@ -159,12 +202,7 @@ TEST_F(SchedulerTest, QueueFlushing) { access::mode::read_write}; detail::EventImplPtr DepEvent{new detail::event_impl(QueueImplB)}; DepEvent->setContextImpl(QueueImplB->getContextImplPtr()); - - pi_event PIEvent = nullptr; - pi_result CallRet = mock_piEventCreate(/*pi_context=*/0x0, &PIEvent); - assert(PI_SUCCESS == CallRet); - - DepEvent->getHandleRef() = PIEvent; + DepEvent->getHandleRef() = reinterpret_cast(new int{}); (void)Cmd.addDep(DepEvent, ToCleanUp); MockScheduler::enqueueCommand(&Cmd, Res, detail::NON_BLOCKING); EXPECT_TRUE(QueueFlushed); @@ -181,12 +219,7 @@ TEST_F(SchedulerTest, QueueFlushing) { detail::QueueImplPtr TempQueueImpl = detail::getSyclObjImpl(TempQueue); DepEvent.reset(new detail::event_impl(TempQueueImpl)); DepEvent->setContextImpl(TempQueueImpl->getContextImplPtr()); - - pi_event PIEvent = nullptr; - pi_result CallRet = mock_piEventCreate(/*pi_context=*/0x0, &PIEvent); - assert(PI_SUCCESS == CallRet); - - DepEvent->getHandleRef() = PIEvent; + DepEvent->getHandleRef() = reinterpret_cast(new int{}); } (void)Cmd.addDep(DepEvent, ToCleanUp); MockScheduler::enqueueCommand(&Cmd, Res, detail::NON_BLOCKING); @@ -207,20 +240,10 @@ TEST_F(SchedulerTest, QueueFlushing) { detail::MapMemObject Cmd = {&AllocaCmd, MockReq, &MockHostPtr, QueueImplA, access::mode::read_write}; MockCommand DepCmdA(QueueImplB); - - pi_event PIEvent = nullptr; - pi_result CallRet = mock_piEventCreate(/*pi_context=*/0x0, &PIEvent); - assert(PI_SUCCESS == CallRet); - - DepCmdA.getEvent()->getHandleRef() = PIEvent; + DepCmdA.getEvent()->getHandleRef() = reinterpret_cast(new int{}); (void)Cmd.addDep(detail::DepDesc{&DepCmdA, &MockReq, nullptr}, ToCleanUp); MockCommand DepCmdB(QueueImplB); - - PIEvent = nullptr; - CallRet = mock_piEventCreate(/*pi_context=*/0x0, &PIEvent); - assert(PI_SUCCESS == CallRet); - - DepCmdB.getEvent()->getHandleRef() = PIEvent; + DepCmdB.getEvent()->getHandleRef() = reinterpret_cast(new int{}); (void)Cmd.addDep(detail::DepDesc{&DepCmdB, &MockReq, nullptr}, ToCleanUp); // The check is performed in redefinedQueueFlush MockScheduler::enqueueCommand(&Cmd, Res, detail::NON_BLOCKING); @@ -232,12 +255,7 @@ TEST_F(SchedulerTest, QueueFlushing) { detail::MapMemObject CmdA{&AllocaCmd, MockReq, &MockHostPtr, QueueImplA, access::mode::read_write}; MockCommand DepCmd(QueueImplB); - - pi_event PIEvent = nullptr; - pi_result CallRet = mock_piEventCreate(/*pi_context=*/0x0, &PIEvent); - assert(PI_SUCCESS == CallRet); - - DepCmd.getEvent()->getHandleRef() = PIEvent; + DepCmd.getEvent()->getHandleRef() = reinterpret_cast(new int{}); (void)CmdA.addDep(detail::DepDesc{&DepCmd, &MockReq, nullptr}, ToCleanUp); MockScheduler::enqueueCommand(&CmdA, Res, detail::NON_BLOCKING); diff --git a/sycl/unittests/scheduler/Regression.cpp b/sycl/unittests/scheduler/Regression.cpp index 52ba6d385eb03..c1c36ca94f077 100644 --- a/sycl/unittests/scheduler/Regression.cpp +++ b/sycl/unittests/scheduler/Regression.cpp @@ -57,7 +57,7 @@ static pi_result redefinedEnqueueNativeKernel( TEST_F(SchedulerTest, CheckArgsBlobInPiEnqueueNativeKernelIsValid) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore( + Mock.redefine( redefinedEnqueueNativeKernel); auto Kernel = []() { std::cout << "Blablabla"; }; diff --git a/sycl/unittests/scheduler/RequiredWGSize.cpp b/sycl/unittests/scheduler/RequiredWGSize.cpp index 29b9f8fc2b8ac..4206a16af9f38 100644 --- a/sycl/unittests/scheduler/RequiredWGSize.cpp +++ b/sycl/unittests/scheduler/RequiredWGSize.cpp @@ -66,9 +66,9 @@ static void reset() { static void performChecks() { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore( + Mock.redefine( redefinedEnqueueKernelLaunch); - Mock.redefineBefore( + Mock.redefine( redefinedKernelGetGroupInfo); const sycl::device Dev = Plt.get_devices()[0]; diff --git a/sycl/unittests/stream/stream.cpp b/sycl/unittests/stream/stream.cpp index 36afde6e06750..82d1b3a85bb5d 100644 --- a/sycl/unittests/stream/stream.cpp +++ b/sycl/unittests/stream/stream.cpp @@ -31,7 +31,7 @@ redefinedMemBufferCreate(pi_context context, pi_mem_flags flags, size_t size, TEST(Stream, TestStreamConstructorExceptionNoAllocation) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore( + Mock.redefine( redefinedMemBufferCreate); const sycl::device Dev = Plt.get_devices()[0]; diff --git a/sycl/unittests/windows/dllmain.cpp b/sycl/unittests/windows/dllmain.cpp index 5a2ebc5e6a421..6c51ff32eac71 100644 --- a/sycl/unittests/windows/dllmain.cpp +++ b/sycl/unittests/windows/dllmain.cpp @@ -38,7 +38,7 @@ TEST(Windows, DllMainCall) { #ifdef _WIN32 sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefineBefore(redefinedTearDown); + Mock.redefine(redefinedTearDown); // Teardown calls are only expected on sycl.dll library unload, not when // process gets terminated.