diff --git a/sycl/unittests/SYCL2020/GetNativeOpenCL.cpp b/sycl/unittests/SYCL2020/GetNativeOpenCL.cpp index b3775ae277168..e89989c8d9b0d 100644 --- a/sycl/unittests/SYCL2020/GetNativeOpenCL.cpp +++ b/sycl/unittests/SYCL2020/GetNativeOpenCL.cpp @@ -86,16 +86,18 @@ TEST(GetNative, GetNativeHandle) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefine(redefinedEventGetInfo); - Mock.redefine(redefinedContextRetain); - Mock.redefine(redefinedQueueRetain); - Mock.redefine(redefinedDeviceRetain); - Mock.redefine(redefinedProgramRetain); - Mock.redefine(redefinedEventRetain); - Mock.redefine(redefinedMemRetain); - Mock.redefine( + Mock.redefineBefore(redefinedEventGetInfo); + Mock.redefineBefore( + redefinedContextRetain); + Mock.redefineBefore(redefinedQueueRetain); + Mock.redefineBefore(redefinedDeviceRetain); + Mock.redefineBefore( + redefinedProgramRetain); + Mock.redefineBefore(redefinedEventRetain); + Mock.redefineBefore(redefinedMemRetain); + Mock.redefineBefore( redefinedMemBufferCreate); - Mock.redefine( + Mock.redefineBefore( redefinedUSMEnqueueMemset); context Context(Plt); diff --git a/sycl/unittests/assert/assert.cpp b/sycl/unittests/assert/assert.cpp index 5a6f487daa9a3..271dd85de87b4 100644 --- a/sycl/unittests/assert/assert.cpp +++ b/sycl/unittests/assert/assert.cpp @@ -175,11 +175,9 @@ static int MemoryMapCounter = MemoryMapCounterBase; static constexpr int PauseWaitOnIdx = KernelLaunchCounterBase + 1; // Mock redifinitions -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) { +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) { if (param_name == PI_KERNEL_GROUP_INFO_COMPILE_WORK_GROUP_SIZE) { if (param_value_size_ret) { *param_value_size_ret = 3 * sizeof(size_t); @@ -194,25 +192,23 @@ static pi_result redefinedKernelGetGroupInfo(pi_kernel kernel, pi_device device, return PI_SUCCESS; } -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++; +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++; // This output here is to reduce amount of time requried to debug/reproduce a // failing test upon feature break - printf("Enqueued %i\n", *Ret); + printf("Enqueued %i\n", Val); - if (PauseWaitOnIdx == *Ret) { + if (PauseWaitOnIdx == Val) { // It should be copier kernel. Check if it depends on user's one. - EXPECT_EQ(N, 1U); - int EventIdx = reinterpret_cast(Deps[0])[0]; - EXPECT_EQ(EventIdx, 0); + EXPECT_EQ(NDeps, 1U); + EXPECT_EQ(Deps[0], UserKernelEvent); } - *RetEvent = reinterpret_cast(Ret); return PI_SUCCESS; } @@ -243,56 +239,30 @@ static pi_result redefinedEventsWaitNegative(pi_uint32 num_events, 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) { - 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( +static pi_result redefinedEnqueueMemBufferMapAfter( 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) { - int *Ret = new int[1]; - *Ret = MemoryMapCounter++; + 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", *Ret); - *RetEvent = reinterpret_cast(Ret); + printf("Memory map %i\n", MemoryMapCounter); *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.redefine(redefinedKernelGetGroupInfo); - Mock.redefine(redefinedEnqueueKernelLaunch); - Mock.redefine(redefinedMemBufferCreate); - Mock.redefine(redefinedMemRelease); - Mock.redefine(redefinedKernelSetArg); - Mock.redefine(redefinedEnqueueMemBufferMap); - Mock.redefine(redefinedEventsWaitPositive); - Mock.redefine( - redefinedExtKernelSetArgMemObj); + Mock.redefineAfter( + redefinedKernelGetGroupInfoAfter); + Mock.redefineAfter( + redefinedEnqueueKernelLaunchAfter); + Mock.redefineAfter( + redefinedEnqueueMemBufferMapAfter); + Mock.redefineBefore(redefinedEventsWaitPositive); } namespace TestInteropKernel { @@ -317,12 +287,15 @@ static pi_result redefinedKernelGetInfo(pi_kernel Kernel, } if (PI_KERNEL_INFO_PROGRAM == ParamName) { - cl_program X = (cl_program)1; + pi_program PIProgram = nullptr; + pi_result Res = mock_piProgramCreate(/*pi_context=*/0x0, /**il*/ nullptr, + /*length=*/0, &PIProgram); + assert(PI_SUCCESS == Res); if (ParamValue) - memcpy(ParamValue, &X, sizeof(X)); + memcpy(ParamValue, &PIProgram, sizeof(PIProgram)); if (ParamValueSizeRet) - *ParamValueSizeRet = sizeof(X); + *ParamValueSizeRet = sizeof(PIProgram); return PI_SUCCESS; } @@ -350,13 +323,11 @@ 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 *Ret = new int[1]; - *Ret = KernelLaunchCounter++; + int Val = KernelLaunchCounter++; // This output here is to reduce amount of time requried to debug/reproduce a // failing test upon feature break - printf("Enqueued %i\n", *Ret); + printf("Enqueued %i\n", Val); - *RetEvent = reinterpret_cast(Ret); return PI_SUCCESS; } @@ -426,21 +397,18 @@ static void setupMockForInterop(sycl::unittest::PiMock &Mock, TestInteropKernel::Device = &Dev; TestInteropKernel::Context = &Ctx; - Mock.redefine(redefinedKernelGetGroupInfo); - Mock.redefine( + Mock.redefineAfter( + redefinedKernelGetGroupInfoAfter); + Mock.redefineBefore( TestInteropKernel::redefinedEnqueueKernelLaunch); - Mock.redefine(redefinedMemBufferCreate); - Mock.redefine(redefinedMemRelease); - Mock.redefine(redefinedKernelSetArg); - Mock.redefine(redefinedEnqueueMemBufferMap); - Mock.redefine(redefinedEventsWaitNegative); - Mock.redefine( - redefinedExtKernelSetArgMemObj); - Mock.redefine( + Mock.redefineAfter( + redefinedEnqueueMemBufferMapAfter); + Mock.redefineBefore(redefinedEventsWaitNegative); + Mock.redefineBefore( TestInteropKernel::redefinedKernelGetInfo); - Mock.redefine( + Mock.redefineBefore( TestInteropKernel::redefinedProgramGetInfo); - Mock.redefine( + Mock.redefineBefore( TestInteropKernel::redefinedProgramGetBuildInfo); } @@ -581,10 +549,15 @@ TEST(Assert, TestInteropKernelNegative) { sycl::queue Queue{Ctx, Dev}; - cl_kernel CLKernel = (cl_kernel)(0x01); + pi_kernel PIKernel = nullptr; + + pi_result Res = mock_piKernelCreate( + /*pi_program=*/0x0, /*kernel_name=*/"dummy_kernel", &PIKernel); + assert(PI_SUCCESS == Res); + // 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(CLKernel, Ctx); + sycl::kernel KInterop((cl_kernel)PIKernel, 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 f9c81890cff47..62ff7d55a3fb3 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 redefinedDeviceGetInfo(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 redefinedDeviceGetInfoAfter(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,9 +58,15 @@ static pi_result redefinedDeviceGetInfo(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) { - // Increase size by one for the null terminator - *param_value_size_ret = name.size() + 1; + // 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; } else { char *dst = static_cast(param_value); strcpy(dst, name.data()); @@ -75,10 +81,10 @@ class BufferTest : public ::testing::Test { protected: void SetUp() override { - Mock.redefine( + Mock.redefineBefore( redefinedMemBufferCreate); - Mock.redefine( - redefinedDeviceGetInfo); + Mock.redefineAfter( + redefinedDeviceGetInfoAfter); } protected: diff --git a/sycl/unittests/event/EventDestruction.cpp b/sycl/unittests/event/EventDestruction.cpp index aa09a50f30f4c..20427b7623cf8 100644 --- a/sycl/unittests/event/EventDestruction.cpp +++ b/sycl/unittests/event/EventDestruction.cpp @@ -33,8 +33,9 @@ class EventDestructionTest : public ::testing::Test { protected: void SetUp() override { - Mock.redefine(redefinedEventRelease); - Mock.redefine( + Mock.redefineBefore( + redefinedEventRelease); + Mock.redefineBefore( redefinedMemBufferCreate); } diff --git a/sycl/unittests/helpers/PiMock.hpp b/sycl/unittests/helpers/PiMock.hpp index d7b9359fc8dc1..677e8d4414da5 100644 --- a/sycl/unittests/helpers/PiMock.hpp +++ b/sycl/unittests/helpers/PiMock.hpp @@ -51,23 +51,114 @@ namespace unittest { namespace detail = sycl::detail; namespace RT = detail::pi; -/// Overwrites the input PiPlugin's PiFunctionTable entry for the given PI API -/// with a given function pointer. +/// 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. /// -/// \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 +/// 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; #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) { \ - MPlugin->PiFunctionTable.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; \ } #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 @@ -86,7 +177,7 @@ namespace RT = detail::pi; /// pi_result redefinePiProgramRetain(pi_program program) { /*code*/ } /// /*...*/ /// unittest::PiMock Mock; -/// Mock.redefine(redefinePiProgramRetain); +/// Mock.redefineBefore(redefinePiProgramRetain); /// platform &MockP = Mock.getPlatform(); /// /*...*/ /// ``` @@ -130,6 +221,10 @@ 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; @@ -148,6 +243,31 @@ 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. /// @@ -178,6 +298,31 @@ 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 @@ -198,7 +343,7 @@ class PiMock { auto RTPlugin = std::make_shared( RT::PiPlugin{"pi.ver.mock", "plugin.ver.mock", /*Targets=*/nullptr, - getMockedFunctionPointers()}); + getProxyMockedFunctionPointers()}); // 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 4911b331f1423..3fc618d06fdf3 100644 --- a/sycl/unittests/helpers/PiMockPlugin.hpp +++ b/sycl/unittests/helpers/PiMockPlugin.hpp @@ -11,9 +11,46 @@ // //===----------------------------------------------------------------------===// -#include #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; +} + // // Platform // @@ -82,6 +119,8 @@ 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; } @@ -134,7 +173,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)); } @@ -178,6 +217,8 @@ 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; } @@ -205,8 +246,7 @@ 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) { - static uintptr_t NextContext = 0; - *ret_context = reinterpret_cast(++NextContext); + *ret_context = createDummyHandle(); return PI_SUCCESS; } @@ -228,9 +268,13 @@ inline pi_result mock_piContextGetInfo(pi_context context, } } -inline pi_result mock_piContextRetain(pi_context context) { return PI_SUCCESS; } +inline pi_result mock_piContextRetain(pi_context context) { + retainDummyHandle(context); + return PI_SUCCESS; +} inline pi_result mock_piContextRelease(pi_context context) { + releaseDummyHandle(context); return PI_SUCCESS; } @@ -250,6 +294,8 @@ 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; } @@ -259,8 +305,7 @@ inline pi_result mock_piextContextCreateWithNativeHandle( inline pi_result mock_piQueueCreate(pi_context context, pi_device device, pi_queue_properties properties, pi_queue *queue) { - static uintptr_t NextQueue = 0; - *queue = reinterpret_cast(++NextQueue); + *queue = createDummyHandle(); return PI_SUCCESS; } @@ -282,10 +327,12 @@ 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; } @@ -306,6 +353,8 @@ 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; } @@ -316,8 +365,7 @@ 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) { - static uintptr_t NextMem = 0; - *ret_mem = reinterpret_cast(++NextMem); + *ret_mem = createDummyHandle(size); return PI_SUCCESS; } @@ -325,8 +373,9 @@ 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) { - static uintptr_t NextMem = 0; - *ret_mem = reinterpret_cast(++NextMem); + assert(false && + "TODO: mock_piMemImageCreate handle allocation size correctly"); + *ret_mem = createDummyHandle(/*size=*/1024 * 16); return PI_SUCCESS; } @@ -343,14 +392,31 @@ inline pi_result mock_piMemImageGetInfo(pi_mem image, pi_image_info param_name, return PI_SUCCESS; } -inline pi_result mock_piMemRetain(pi_mem mem) { return PI_SUCCESS; } +inline pi_result mock_piMemRetain(pi_mem mem) { + retainDummyHandle(mem); + return PI_SUCCESS; +} -inline pi_result mock_piMemRelease(pi_mem mem) { return PI_SUCCESS; } +inline pi_result mock_piMemRelease(pi_mem mem) { + releaseDummyHandle(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; } @@ -364,6 +430,8 @@ 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; } @@ -373,8 +441,7 @@ mock_piextMemCreateWithNativeHandle(pi_native_handle nativeHandle, inline pi_result mock_piProgramCreate(pi_context context, const void *il, size_t length, pi_program *res_program) { - static uintptr_t NextProgram = 0; - *res_program = reinterpret_cast(++NextProgram); + *res_program = createDummyHandle(); return PI_SUCCESS; } @@ -383,8 +450,7 @@ inline pi_result mock_piclProgramCreateWithSource(pi_context context, const char **strings, const size_t *lengths, pi_program *ret_program) { - static uintptr_t NextProgram = 100; - *ret_program = reinterpret_cast(++NextProgram); + *ret_program = createDummyHandle(); return PI_SUCCESS; } @@ -393,8 +459,7 @@ 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) { - static uintptr_t NextProgram = 200; - *ret_program = reinterpret_cast(++NextProgram); + *ret_program = createDummyHandle(); return PI_SUCCESS; } @@ -421,7 +486,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; @@ -443,8 +508,7 @@ 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) { - static uintptr_t NextProgram = 300; - *ret_program = reinterpret_cast(++NextProgram); + *ret_program = createDummyHandle(); return PI_SUCCESS; } @@ -470,9 +534,13 @@ inline pi_result mock_piProgramGetBuildInfo( return PI_SUCCESS; } -inline pi_result mock_piProgramRetain(pi_program program) { return PI_SUCCESS; } +inline pi_result mock_piProgramRetain(pi_program program) { + retainDummyHandle(program); + return PI_SUCCESS; +} inline pi_result mock_piProgramRelease(pi_program program) { + releaseDummyHandle(program); return PI_SUCCESS; } @@ -493,6 +561,8 @@ 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; } @@ -503,8 +573,7 @@ inline pi_result mock_piextProgramCreateWithNativeHandle( inline pi_result mock_piKernelCreate(pi_program program, const char *kernel_name, pi_kernel *ret_kernel) { - static uintptr_t NextKernel = 0; - *ret_kernel = reinterpret_cast(++NextKernel); + *ret_kernel = createDummyHandle(); return PI_SUCCESS; } @@ -551,9 +620,15 @@ inline pi_result mock_piKernelGetSubGroupInfo( return PI_SUCCESS; } -inline pi_result mock_piKernelRetain(pi_kernel kernel) { return PI_SUCCESS; } +inline pi_result mock_piKernelRetain(pi_kernel kernel) { + retainDummyHandle(kernel); + return PI_SUCCESS; +} -inline pi_result mock_piKernelRelease(pi_kernel kernel) { return PI_SUCCESS; } +inline pi_result mock_piKernelRelease(pi_kernel kernel) { + releaseDummyHandle(kernel); + return PI_SUCCESS; +} inline pi_result mock_piextKernelSetArgPointer(pi_kernel kernel, pi_uint32 arg_index, @@ -572,6 +647,9 @@ 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; } @@ -586,8 +664,7 @@ mock_piextKernelGetNativeHandle(pi_kernel kernel, // Events // inline pi_result mock_piEventCreate(pi_context context, pi_event *ret_event) { - static uintptr_t NextEvent = 0; - *ret_event = reinterpret_cast(++NextEvent); + *ret_event = createDummyHandle(); return PI_SUCCESS; } @@ -634,9 +711,15 @@ inline pi_result mock_piEventSetStatus(pi_event event, return PI_SUCCESS; } -inline pi_result mock_piEventRetain(pi_event event) { return PI_SUCCESS; } +inline pi_result mock_piEventRetain(pi_event event) { + retainDummyHandle(event); + return PI_SUCCESS; +} -inline pi_result mock_piEventRelease(pi_event event) { return PI_SUCCESS; } +inline pi_result mock_piEventRelease(pi_event event) { + releaseDummyHandle(event); + return PI_SUCCESS; +} inline pi_result mock_piextEventGetNativeHandle(pi_event event, pi_native_handle *nativeHandle) { @@ -648,6 +731,8 @@ 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; } @@ -658,8 +743,7 @@ inline pi_result mock_piSamplerCreate(pi_context context, const pi_sampler_properties *sampler_properties, pi_sampler *result_sampler) { - static uintptr_t NextSampler = 0; - *result_sampler = reinterpret_cast(++NextSampler); + *result_sampler = createDummyHandle(); return PI_SUCCESS; } @@ -671,9 +755,13 @@ inline pi_result mock_piSamplerGetInfo(pi_sampler sampler, return PI_SUCCESS; } -inline pi_result mock_piSamplerRetain(pi_sampler sampler) { return PI_SUCCESS; } +inline pi_result mock_piSamplerRetain(pi_sampler sampler) { + retainDummyHandle(sampler); + return PI_SUCCESS; +} inline pi_result mock_piSamplerRelease(pi_sampler sampler) { + releaseDummyHandle(sampler); return PI_SUCCESS; } @@ -685,8 +773,7 @@ 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) { - static uintptr_t NextEvent = 1000; - *event = reinterpret_cast(++NextEvent); + *event = createDummyHandle(); return PI_SUCCESS; } @@ -695,6 +782,7 @@ 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; } @@ -702,12 +790,14 @@ 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; } @@ -716,6 +806,7 @@ 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; } @@ -726,6 +817,7 @@ 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; } @@ -734,6 +826,7 @@ 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; } @@ -744,6 +837,7 @@ 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; } @@ -753,6 +847,7 @@ 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; } @@ -763,6 +858,7 @@ 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; } @@ -773,6 +869,7 @@ 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; } @@ -781,6 +878,7 @@ 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; } @@ -791,6 +889,7 @@ 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; } @@ -800,6 +899,7 @@ 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; } @@ -809,6 +909,7 @@ 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; } @@ -819,6 +920,10 @@ 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; } @@ -827,6 +932,7 @@ 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; } @@ -848,7 +954,8 @@ 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) { - *result_ptr = (void *)0x1; + assert(alignment < 16 && "TODO: mock_piextUSMHostAlloc handle alignment"); + *result_ptr = createDummyHandle(size); return PI_SUCCESS; } @@ -856,7 +963,8 @@ 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) { - *result_ptr = (void *)0x1; + assert(alignment < 16 && "TODO: mock_piextUSMHostAlloc handle alignment"); + *result_ptr = createDummyHandle(size); return PI_SUCCESS; } @@ -864,7 +972,8 @@ 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) { - *result_ptr = (void *)0x1; + assert(alignment < 16 && "TODO: mock_piextUSMHostAlloc handle alignment"); + *result_ptr = createDummyHandle(size); return PI_SUCCESS; } @@ -877,6 +986,7 @@ 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; } @@ -886,6 +996,7 @@ 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; } @@ -895,6 +1006,7 @@ 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; } @@ -902,6 +1014,7 @@ 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; } @@ -921,16 +1034,3 @@ 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 b7066c1412955..423918bd0048c 100644 --- a/sycl/unittests/kernel-and-program/Cache.cpp +++ b/sycl/unittests/kernel-and-program/Cache.cpp @@ -110,7 +110,8 @@ class KernelAndProgramCacheTest : public ::testing::Test { protected: void SetUp() override { - Mock.redefine(redefinedKernelGetInfo); + Mock.redefineBefore( + redefinedKernelGetInfo); } protected: diff --git a/sycl/unittests/kernel-and-program/DeviceInfo.cpp b/sycl/unittests/kernel-and-program/DeviceInfo.cpp index f713614984bff..43d94d989843f 100644 --- a/sycl/unittests/kernel-and-program/DeviceInfo.cpp +++ b/sycl/unittests/kernel-and-program/DeviceInfo.cpp @@ -54,7 +54,8 @@ class DeviceInfoTest : public ::testing::Test { protected: void SetUp() override { - Mock.redefine(redefinedDeviceGetInfo); + Mock.redefineBefore( + redefinedDeviceGetInfo); } protected: diff --git a/sycl/unittests/kernel-and-program/KernelBuildOptions.cpp b/sycl/unittests/kernel-and-program/KernelBuildOptions.cpp index 161c5046cecc5..f67ffed3f81f1 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.redefine(redefinedProgramCompile); - Mock.redefine(redefinedProgramLink); - Mock.redefine(redefinedProgramBuild); + Mock.redefineBefore(redefinedProgramCompile); + Mock.redefineBefore(redefinedProgramLink); + Mock.redefineBefore(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 34f965fbe4887..98bb1f0e0f667 100644 --- a/sycl/unittests/kernel-and-program/KernelInfo.cpp +++ b/sycl/unittests/kernel-and-program/KernelInfo.cpp @@ -38,32 +38,6 @@ 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, @@ -78,30 +52,16 @@ 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.redefine( + Mock.redefineBefore( redefinedKernelGetGroupInfo); - Mock.redefine( - redefinedProgramCreateWithSource); - Mock.redefine(redefinedProgramBuild); - Mock.redefine(redefinedKernelCreate); - Mock.redefine(redefinedKernelRetain); - Mock.redefine(redefinedKernelRelease); - Mock.redefine(redefinedKernelGetInfo); - Mock.redefine( - redefinedKernelSetExecInfo); + Mock.redefineBefore( + redefinedKernelGetInfo); } protected: diff --git a/sycl/unittests/kernel-and-program/KernelRelease.cpp b/sycl/unittests/kernel-and-program/KernelRelease.cpp index 9fab6f97d9a8e..b6f616c34461e 100644 --- a/sycl/unittests/kernel-and-program/KernelRelease.cpp +++ b/sycl/unittests/kernel-and-program/KernelRelease.cpp @@ -29,22 +29,6 @@ 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) { @@ -76,24 +60,14 @@ 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.redefine( - redefinedProgramCreateWithSource); - Mock.redefine(redefinedProgramBuild); - Mock.redefine(redefinedKernelCreate); - Mock.redefine(redefinedKernelRetain); - Mock.redefine(redefinedKernelRelease); - Mock.redefine(redefinedKernelGetInfo); - Mock.redefine( - redefinedKernelSetExecInfo); + Mock.redefineBefore(redefinedKernelCreate); + Mock.redefineBefore(redefinedKernelRetain); + Mock.redefineBefore( + redefinedKernelRelease); + Mock.redefineBefore( + redefinedKernelGetInfo); context Ctx{Mock.getPlatform().get_devices()[0]}; TestContext.reset(new TestCtx(Ctx)); @@ -105,4 +79,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 c443d34bcc36e..27e235c4ae3b1 100644 --- a/sycl/unittests/kernel-and-program/MultipleDevsCache.cpp +++ b/sycl/unittests/kernel-and-program/MultipleDevsCache.cpp @@ -21,24 +21,11 @@ using namespace sycl; -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) { +static pi_result redefinedDevicesGetAfter(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; @@ -67,31 +54,6 @@ 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; @@ -110,17 +72,14 @@ class MultipleDeviceCacheTest : public ::testing::Test { protected: void SetUp() override { - 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); + Mock.redefineAfter( + redefinedDevicesGetAfter); + Mock.redefineBefore( + redefinedDeviceGetInfo); + Mock.redefineBefore( + redefinedProgramRetain); + Mock.redefineBefore( + redefinedKernelRelease); } protected: diff --git a/sycl/unittests/kernel-and-program/PersistentDeviceCodeCache.cpp b/sycl/unittests/kernel-and-program/PersistentDeviceCodeCache.cpp index 93de59da61b32..be50f0a84bafd 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 redefinedProgramGetInfo(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 redefinedProgramGetInfoAfter(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,9 +70,11 @@ static pi_result redefinedProgramGetInfo(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; @@ -169,7 +171,8 @@ class PersistentDeviceCodeCache RootSYCLCacheDir = SYCLCacheDir; Dev = Plt.get_devices()[0]; - Mock.redefine(redefinedProgramGetInfo); + Mock.redefineAfter( + redefinedProgramGetInfoAfter); } /* 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 6fb725e7d4466..97342a6922552 100644 --- a/sycl/unittests/pi/PiMock.cpp +++ b/sycl/unittests/pi/PiMock.cpp @@ -14,14 +14,42 @@ 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 *) { - return PI_ERROR_INVALID_BINARY; + GpiProgramBuildRedefineCalled = true; + return PI_SUCCESS; } pi_result piKernelCreateRedefine(pi_program, const char *, pi_kernel *) { - return PI_ERROR_INVALID_DEVICE; + GpiKernelCreateRedefineCalled = true; + return PI_SUCCESS; } TEST(PiMockTest, ConstructFromQueue) { @@ -70,24 +98,73 @@ TEST(PiMockTest, RedefineAPI) { // Pass a function pointer Mock.redefine(piProgramBuildRedefine); - EXPECT_EQ(Table.piProgramBuild, &piProgramBuildRedefine) + Table.piProgramBuild(/*pi_program*/ nullptr, /*num_devices=*/0, + /*device_list = */ nullptr, + /*options=*/nullptr, /*pfn_notify=*/nullptr, + /*user_data=*/nullptr); + + EXPECT_TRUE(GpiProgramBuildRedefineCalled) << "Function redefinition didn't propagate to the mock plugin"; // Pass a std::function Mock.redefine({piKernelCreateRedefine}); - EXPECT_EQ(Table.piKernelCreate, &piKernelCreateRedefine) + + Table.piKernelCreate(/*pi_program=*/nullptr, /*kernel_name=*/nullptr, + /*pi_kernel=*/nullptr); + EXPECT_TRUE(GpiKernelCreateRedefineCalled) << "Function redefinition didn't propagate to the mock plugin"; // Pass a captureless lambda - auto *OldFuncPtr = Table.piProgramRetain; auto Lambda = [](pi_program) -> pi_result { - return PI_ERROR_INVALID_PROGRAM; + GpiProgramRetainCalled = true; + return PI_SUCCESS; }; - EXPECT_FALSE(OldFuncPtr == Lambda) - << "Lambda is the same as the existing function."; Mock.redefine(Lambda); - EXPECT_FALSE(Table.piProgramRetain == OldFuncPtr) + Table.piProgramRetain(/*pi_program=*/nullptr); + + EXPECT_TRUE(GpiProgramRetainCalled) << "Passing a lambda didn't change the function table entry"; - ASSERT_FALSE(Table.piProgramRetain == nullptr) - << "Passing a lambda set the table entry to a null pointer"; +} + +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"; } diff --git a/sycl/unittests/pi/piInteropRetain.cpp b/sycl/unittests/pi/piInteropRetain.cpp index 4ac58bd4d125f..b76007328c336 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.redefine(redefinedQueueRetain); + Mock.redefineBefore(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 30a5b3b90be24..a1829d4c06e4d 100644 --- a/sycl/unittests/program_manager/BuildLog.cpp +++ b/sycl/unittests/program_manager/BuildLog.cpp @@ -49,7 +49,8 @@ static pi_result redefinedProgramGetBuildInfo( static void setupCommonTestAPIs(sycl::unittest::PiMock &Mock) { using namespace sycl::detail; - Mock.redefine(redefinedProgramGetBuildInfo); + Mock.redefineBefore( + redefinedProgramGetBuildInfo); } TEST(BuildLog, OutputNothingOnLevel1) { diff --git a/sycl/unittests/program_manager/EliminatedArgMask.cpp b/sycl/unittests/program_manager/EliminatedArgMask.cpp index 97f0ff70665c9..d71902b5f2a40 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.redefine( + Mock.redefineBefore( 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 da6ebf0a4426a..b71156f05d71d 100644 --- a/sycl/unittests/program_manager/SubDevices.cpp +++ b/sycl/unittests/program_manager/SubDevices.cpp @@ -99,15 +99,17 @@ TEST(SubDevices, DISABLED_BuildProgramForSubdevices) { // Setup Mock APIs sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefine( + Mock.redefineBefore( redefinedDeviceGetInfo); - Mock.redefine( + Mock.redefineBefore( redefinedDevicePartition); - Mock.redefine(redefinedDeviceRetain); - Mock.redefine( + Mock.redefineBefore( + redefinedDeviceRetain); + Mock.redefineBefore( redefinedDeviceRelease); - Mock.redefine(redefinedProgramBuild); - Mock.redefine( + Mock.redefineBefore( + redefinedProgramBuild); + Mock.redefineBefore( 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 1d127160493e5..444b2aaacdaf6 100644 --- a/sycl/unittests/program_manager/itt_annotations.cpp +++ b/sycl/unittests/program_manager/itt_annotations.cpp @@ -64,7 +64,8 @@ TEST(ITTNotify, UseKernelBundle) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefine( + Mock.redefineBefore< + sycl::detail::PiApiKind::piextProgramSetSpecializationConstant>( redefinedProgramSetSpecializationConstant); const sycl::device Dev = Plt.get_devices()[0]; @@ -91,7 +92,8 @@ TEST(ITTNotify, VarNotSet) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefine( + Mock.redefineBefore< + sycl::detail::PiApiKind::piextProgramSetSpecializationConstant>( 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 e9dffcc97fb73..95f2cf4ba5ca3 100644 --- a/sycl/unittests/program_manager/passing_link_and_compile_options.cpp +++ b/sycl/unittests/program_manager/passing_link_and_compile_options.cpp @@ -146,9 +146,10 @@ inline pi_result redefinedProgramBuild( TEST(Link_Compile_Options, compile_link_Options_Test_empty_options) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefine( + Mock.redefineBefore( redefinedProgramCompile); - Mock.redefine(redefinedProgramLink); + Mock.redefineBefore( + redefinedProgramLink); const sycl::device Dev = Plt.get_devices()[0]; current_link_options.clear(); current_compile_options.clear(); @@ -172,9 +173,10 @@ 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.redefine( + Mock.redefineBefore( redefinedProgramCompile); - Mock.redefine(redefinedProgramLink); + Mock.redefineBefore( + redefinedProgramLink); const sycl::device Dev = Plt.get_devices()[0]; current_link_options.clear(); current_compile_options.clear(); @@ -206,10 +208,12 @@ 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.redefine( + Mock.redefineBefore( redefinedProgramCompile); - Mock.redefine(redefinedProgramLink); - Mock.redefine(redefinedProgramBuild); + Mock.redefineBefore( + redefinedProgramLink); + Mock.redefineBefore( + 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 c66472459cadf..92fa103d18c4e 100644 --- a/sycl/unittests/queue/DeviceCheck.cpp +++ b/sycl/unittests/queue/DeviceCheck.cpp @@ -103,14 +103,19 @@ TEST(QueueDeviceCheck, CheckDeviceRestriction) { context DefaultCtx = Plt.ext_oneapi_get_default_context(); device Dev = DefaultCtx.get_devices()[0]; - Mock.redefine(redefinedContextCreate); - Mock.redefine(redefinedContextRelease); - Mock.redefine(redefinedDeviceGetInfo); - Mock.redefine(redefinedDevicePartition); - Mock.redefine(redefinedDeviceRelease); - Mock.redefine(redefinedDeviceRetain); - Mock.redefine(redefinedQueueCreate); - Mock.redefine(redefinedQueueRelease); + Mock.redefineBefore( + redefinedContextCreate); + Mock.redefineBefore( + redefinedContextRelease); + Mock.redefineBefore( + redefinedDeviceGetInfo); + Mock.redefineBefore( + redefinedDevicePartition); + Mock.redefineBefore( + redefinedDeviceRelease); + Mock.redefineBefore(redefinedDeviceRetain); + Mock.redefineBefore(redefinedQueueCreate); + Mock.redefineBefore(redefinedQueueRelease); // Device is a member of the context. { diff --git a/sycl/unittests/queue/EventClear.cpp b/sycl/unittests/queue/EventClear.cpp index f8e9af152add8..043616100518e 100644 --- a/sycl/unittests/queue/EventClear.cpp +++ b/sycl/unittests/queue/EventClear.cpp @@ -36,27 +36,15 @@ 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 redefinedEventGetInfo(pi_event event, pi_event_info param_name, - size_t param_value_size, void *param_value, - size_t *param_value_size_ret) { +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) { EXPECT_EQ(param_name, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS) << "Unexpected event info requested"; // Report first half of events as complete. @@ -83,14 +71,12 @@ pi_result redefinedEventRelease(pi_event event) { } void preparePiMock(unittest::PiMock &Mock) { - Mock.redefine(redefinedQueueCreate); - Mock.redefine(redefinedQueueRelease); - Mock.redefine( - redefinedUSMEnqueueMemset); - Mock.redefine(redefinedEventsWait); - Mock.redefine(redefinedEventGetInfo); - Mock.redefine(redefinedEventRetain); - Mock.redefine(redefinedEventRelease); + Mock.redefineBefore(redefinedQueueCreate); + Mock.redefineBefore(redefinedEventsWait); + Mock.redefineAfter( + redefinedEventGetInfoAfter); + Mock.redefineBefore(redefinedEventRetain); + Mock.redefineBefore(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 2af4be9323f4a..f410811e63445 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.redefine( + Mock.redefineBefore( 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.redefine( + Mock.redefineBefore( 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.redefine( + Mock.redefineBefore( 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.redefine( + Mock.redefineBefore( 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 0fe7015832be3..30cdd2b37393e 100644 --- a/sycl/unittests/queue/USM.cpp +++ b/sycl/unittests/queue/USM.cpp @@ -21,41 +21,38 @@ struct { } TestContext; // Dummy event values for bookkeeping -pi_event WAIT = reinterpret_cast(1); -pi_event MEMCPY = reinterpret_cast(2); -pi_event MEMSET = reinterpret_cast(3); +pi_event WAIT = nullptr; +pi_event MEMCPY = nullptr; +pi_event MEMSET = nullptr; template auto getVal(T obj) { return detail::getSyclObjImpl(obj)->getHandleRef(); } -pi_result redefinedEnqueueEventsWait(pi_queue, pi_uint32 NumDeps, - const pi_event *Deps, pi_event *Event) { +pi_result redefinedEnqueueEventsWaitAfter(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])); } - *Event = WAIT; + WAIT = *Event; return PI_SUCCESS; } -pi_result redefinedUSMEnqueueMemcpy(pi_queue, pi_bool, void *, const void *, - size_t, pi_uint32, const pi_event *, - pi_event *Event) { - *Event = MEMCPY; +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; return PI_SUCCESS; } -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 */) { +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; return PI_SUCCESS; } @@ -63,14 +60,12 @@ pi_result redefinedEventsWait(pi_uint32 /* num_events */, TEST(USM, NoOpPreservesDependencyChain) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefine( - redefinedEnqueueEventsWait); - Mock.redefine( - redefinedUSMEnqueueMemcpy); - Mock.redefine( - redefinedUSMEnqueueMemset); - Mock.redefine(redefinedEventRelease); - Mock.redefine(redefinedEventsWait); + Mock.redefineAfter( + redefinedEnqueueEventsWaitAfter); + Mock.redefineAfter( + redefinedUSMEnqueueMemcpyAfter); + Mock.redefineAfter( + redefinedUSMEnqueueMemsetAfter); 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 e1b8eac1c3ee8..e32e2c8ad2a33 100644 --- a/sycl/unittests/queue/Wait.cpp +++ b/sycl/unittests/queue/Wait.cpp @@ -36,16 +36,12 @@ 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, @@ -54,9 +50,7 @@ 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; } @@ -70,12 +64,6 @@ 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; @@ -89,17 +77,15 @@ pi_result redefinedEventRelease(pi_event event) { TEST(QueueWait, QueueWaitTest) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefine(redefinedQueueCreate); - Mock.redefine(redefinedQueueRelease); - Mock.redefine(redefinedQueueFinish); - Mock.redefine( + Mock.redefineBefore(redefinedQueueCreate); + Mock.redefineBefore(redefinedQueueFinish); + Mock.redefineBefore( redefinedUSMEnqueueMemset); - Mock.redefine(redefinedEventsWait); - Mock.redefine( + Mock.redefineBefore(redefinedEventsWait); + Mock.redefineBefore( redefinedEnqueueMemBufferFill); - Mock.redefine(redefinedEventGetInfo); - Mock.redefine(redefinedEventRetain); - Mock.redefine(redefinedEventRelease); + Mock.redefineBefore(redefinedEventRetain); + Mock.redefineBefore(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 c30f49dee53fd..57f909c270d08 100644 --- a/sycl/unittests/scheduler/AllocaLinking.cpp +++ b/sycl/unittests/scheduler/AllocaLinking.cpp @@ -17,10 +17,11 @@ using namespace sycl; static bool HostUnifiedMemory = false; -static pi_result redefinedDeviceGetInfo(pi_device Device, - pi_device_info ParamName, - size_t ParamValueSize, void *ParamValue, - size_t *ParamValueSizeRet) { +static pi_result redefinedDeviceGetInfoAfter(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; @@ -31,16 +32,6 @@ static pi_result redefinedDeviceGetInfo(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 @@ -52,9 +43,8 @@ TEST_F(SchedulerTest, AllocaLinking) { sycl::unittest::PiMock Mock; sycl::queue Q{Mock.getPlatform().get_devices()[0]}; - Mock.redefine(redefinedDeviceGetInfo); - Mock.redefine(redefinedMemBufferCreate); - Mock.redefine(redefinedMemRelease); + Mock.redefineAfter( + redefinedDeviceGetInfoAfter); sycl::detail::QueueImplPtr QImpl = detail::getSyclObjImpl(Q); MockScheduler MS; diff --git a/sycl/unittests/scheduler/Commands.cpp b/sycl/unittests/scheduler/Commands.cpp index d31a78e5c7cf5..96bcdad734968 100644 --- a/sycl/unittests/scheduler/Commands.cpp +++ b/sycl/unittests/scheduler/Commands.cpp @@ -34,10 +34,6 @@ 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): @@ -53,7 +49,7 @@ TEST_F(SchedulerTest, WaitEmptyEventWithBarrier) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefine( + Mock.redefineBefore( redefinePiEnqueueEventsWaitWithBarrier); queue Queue{Plt.get_devices()[0]}; @@ -62,13 +58,17 @@ TEST_F(SchedulerTest, WaitEmptyEventWithBarrier) { queue_global_context = detail::getSyclObjImpl(Queue.get_context())->getHandleRef(); - Mock.redefine(redefinePiEventGetInfo); - Mock.redefine(redefinePiEventRetain); - Mock.redefine(redefinePiEventRelease); + Mock.redefineBefore( + redefinePiEventGetInfo); auto EmptyEvent = std::make_shared(); - auto Event = std::make_shared( - reinterpret_cast(0x01), Queue.get_context()); + + 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()); using EventList = std::vector; std::vector InputEventWaitLists = { diff --git a/sycl/unittests/scheduler/CommandsWaitForEvents.cpp b/sycl/unittests/scheduler/CommandsWaitForEvents.cpp index 603b4e785aa9b..5808ebc9e7fc4 100644 --- a/sycl/unittests/scheduler/CommandsWaitForEvents.cpp +++ b/sycl/unittests/scheduler/CommandsWaitForEvents.cpp @@ -8,8 +8,11 @@ #include "SchedulerTest.hpp" #include "SchedulerTestUtils.hpp" +#include #include +#include + using namespace sycl; struct TestCtx { @@ -19,15 +22,23 @@ struct TestCtx { std::shared_ptr Ctx1; std::shared_ptr Ctx2; - pi_event EventCtx1 = reinterpret_cast(0x01); - pi_event EventCtx2 = reinterpret_cast(0x02); + pi_event EventCtx1 = nullptr; + + pi_event EventCtx2 = nullptr; 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())} {} + 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); + } }; std::unique_ptr TestContext; @@ -48,8 +59,6 @@ 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"; @@ -68,10 +77,8 @@ TEST_F(SchedulerTest, CommandsWaitForEvents) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefine(waitFunc); - Mock.redefine(retainReleaseFunc); - Mock.redefine(retainReleaseFunc); - Mock.redefine(getEventInfoFunc); + Mock.redefineBefore(waitFunc); + Mock.redefineBefore(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 29db4edc8c759..43b677290a2d9 100644 --- a/sycl/unittests/scheduler/EnqueueWithDependsOnDeps.cpp +++ b/sycl/unittests/scheduler/EnqueueWithDependsOnDeps.cpp @@ -303,8 +303,9 @@ TEST_F(SchedulerTest, InOrderEnqueueNoMemObjDoubleKernelDepHost) { if (!CheckTestExecutionRequirements(Plt)) return; - Mock.redefine(redefinedEventsWaitCustom); - Mock.redefine( + Mock.redefineBefore( + redefinedEventsWaitCustom); + Mock.redefineBefore( redefinedEnqueueKernelLaunchCustom); { diff --git a/sycl/unittests/scheduler/InOrderQueueDeps.cpp b/sycl/unittests/scheduler/InOrderQueueDeps.cpp index fb1c22c6e6575..be5e8d874da17 100644 --- a/sycl/unittests/scheduler/InOrderQueueDeps.cpp +++ b/sycl/unittests/scheduler/InOrderQueueDeps.cpp @@ -79,17 +79,19 @@ pi_result redefinedEventRelease(pi_event event) { return PI_SUCCESS; } TEST_F(SchedulerTest, InOrderQueueDeps) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefine(redefinedMemBufferCreate); - Mock.redefine(redefinedMemRelease); - Mock.redefine( + Mock.redefineBefore( + redefinedMemBufferCreate); + Mock.redefineBefore(redefinedMemRelease); + Mock.redefineBefore( redefinedEnqueueMemBufferReadRect); - Mock.redefine( + Mock.redefineBefore( redefinedEnqueueMemBufferWriteRect); - Mock.redefine( + Mock.redefineBefore( redefinedEnqueueMemBufferMap); - Mock.redefine(redefinedEnqueueMemUnmap); - Mock.redefine(redefinedEventsWait); - Mock.redefine(redefinedEventRelease); + Mock.redefineBefore( + redefinedEnqueueMemUnmap); + Mock.redefineBefore(redefinedEventsWait); + Mock.redefineBefore(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 276d521cadb29..020a956537ddd 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.redefine(redefinedEventsWait); + Mock.redefineBefore(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 49ac8db448de5..93cd9287dc66b 100644 --- a/sycl/unittests/scheduler/NoHostUnifiedMemory.cpp +++ b/sycl/unittests/scheduler/NoHostUnifiedMemory.cpp @@ -18,10 +18,11 @@ using namespace sycl; -static pi_result redefinedDeviceGetInfo(pi_device Device, - pi_device_info ParamName, - size_t ParamValueSize, void *ParamValue, - size_t *ParamValueSizeRet) { +static pi_result redefinedDeviceGetInfoAfter(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; @@ -40,33 +41,11 @@ 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 redefinedMemGetInfo(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 redefinedMemGetInfoAfter(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; @@ -90,16 +69,12 @@ redefinedMemCreateWithNativeHandle(pi_native_handle native_handle, TEST_F(SchedulerTest, NoHostUnifiedMemory) { unittest::PiMock Mock; queue Q{Mock.getPlatform().get_devices()[0]}; - Mock.redefine(redefinedDeviceGetInfo); - Mock.redefine(redefinedMemBufferCreate); - Mock.redefine( - redefinedEnqueueMemBufferReadRect); - Mock.redefine( - redefinedEnqueueMemBufferWriteRect); - Mock.redefine(redefinedMemRetain); - Mock.redefine(redefinedMemRelease); - Mock.redefine(redefinedMemGetInfo); - Mock.redefine( + Mock.redefineAfter( + redefinedDeviceGetInfoAfter); + Mock.redefineBefore( + redefinedMemBufferCreate); + Mock.redefineAfter(redefinedMemGetInfoAfter); + Mock.redefineBefore( redefinedMemCreateWithNativeHandle); sycl::detail::QueueImplPtr QImpl = detail::getSyclObjImpl(Q); @@ -213,7 +188,12 @@ TEST_F(SchedulerTest, NoHostUnifiedMemory) { } // Check that interoperability memory objects are initialized. { - cl_mem MockInteropBuffer = reinterpret_cast(1); + 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); + 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 73b52c0214345..c0c1869ad318b 100644 --- a/sycl/unittests/scheduler/PostEnqueueCleanup.cpp +++ b/sycl/unittests/scheduler/PostEnqueueCleanup.cpp @@ -205,10 +205,11 @@ TEST_F(SchedulerTest, PostEnqueueCleanup) { detail::SYCLConfig::reset}; sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefine( + Mock.redefineBefore( redefinedEnqueueMemBufferMap); - Mock.redefine(redefinedEnqueueMemUnmap); - Mock.redefine( + Mock.redefineBefore( + redefinedEnqueueMemUnmap); + Mock.redefineBefore( redefinedEnqueueMemBufferFill); context Ctx{Plt}; diff --git a/sycl/unittests/scheduler/QueueFlushing.cpp b/sycl/unittests/scheduler/QueueFlushing.cpp index d40e9f5f6e3f6..a09bbaa06a372 100644 --- a/sycl/unittests/scheduler/QueueFlushing.cpp +++ b/sycl/unittests/scheduler/QueueFlushing.cpp @@ -26,10 +26,11 @@ static pi_result redefinedQueueFlush(pi_queue Queue) { return PI_SUCCESS; } -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) { +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) { EXPECT_NE(event, nullptr); if (param_name == PI_EVENT_INFO_COMMAND_EXECUTION_STATUS) { auto *Status = reinterpret_cast(param_value); @@ -39,55 +40,6 @@ static pi_result redefinedEventGetInfo(pi_event event, pi_event_info param_name, 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; @@ -99,7 +51,12 @@ static void addDepAndEnqueue(detail::Command *Cmd, detail::Requirement &MockReq) { MockCommand DepCmd(DepQueue); std::vector ToCleanUp; - DepCmd.getEvent()->getHandleRef() = reinterpret_cast(new int{}); + + pi_event PIEvent = nullptr; + pi_result CallRet = mock_piEventCreate(/*pi_context=*/0x0, &PIEvent); + assert(PI_SUCCESS == CallRet); + + DepCmd.getEvent()->getHandleRef() = PIEvent; (void)Cmd->addDep(detail::DepDesc{&DepCmd, &MockReq, nullptr}, ToCleanUp); detail::EnqueueResultT Res; @@ -128,17 +85,9 @@ static void testEventStatusCheck(detail::Command *Cmd, TEST_F(SchedulerTest, QueueFlushing) { sycl::unittest::PiMock Mock; sycl::platform Plt = Mock.getPlatform(); - Mock.redefine(redefinedQueueFlush); - Mock.redefine(redefinedEventGetInfo); - Mock.redefine( - redefinedEnqueueMemBufferReadRect); - Mock.redefine( - redefinedEnqueueMemBufferWriteRect); - Mock.redefine( - redefinedEnqueueMemBufferMap); - Mock.redefine(redefinedEnqueueMemUnmap); - Mock.redefine( - redefinedEnqueueMemBufferFill); + Mock.redefineBefore(redefinedQueueFlush); + Mock.redefineAfter( + redefinedEventGetInfoAfter); context Ctx{Plt}; queue QueueA{Ctx, default_selector_v}; @@ -150,7 +99,15 @@ 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; @@ -202,7 +159,12 @@ TEST_F(SchedulerTest, QueueFlushing) { access::mode::read_write}; detail::EventImplPtr DepEvent{new detail::event_impl(QueueImplB)}; DepEvent->setContextImpl(QueueImplB->getContextImplPtr()); - DepEvent->getHandleRef() = reinterpret_cast(new int{}); + + pi_event PIEvent = nullptr; + pi_result CallRet = mock_piEventCreate(/*pi_context=*/0x0, &PIEvent); + assert(PI_SUCCESS == CallRet); + + DepEvent->getHandleRef() = PIEvent; (void)Cmd.addDep(DepEvent, ToCleanUp); MockScheduler::enqueueCommand(&Cmd, Res, detail::NON_BLOCKING); EXPECT_TRUE(QueueFlushed); @@ -219,7 +181,12 @@ TEST_F(SchedulerTest, QueueFlushing) { detail::QueueImplPtr TempQueueImpl = detail::getSyclObjImpl(TempQueue); DepEvent.reset(new detail::event_impl(TempQueueImpl)); DepEvent->setContextImpl(TempQueueImpl->getContextImplPtr()); - DepEvent->getHandleRef() = reinterpret_cast(new int{}); + + pi_event PIEvent = nullptr; + pi_result CallRet = mock_piEventCreate(/*pi_context=*/0x0, &PIEvent); + assert(PI_SUCCESS == CallRet); + + DepEvent->getHandleRef() = PIEvent; } (void)Cmd.addDep(DepEvent, ToCleanUp); MockScheduler::enqueueCommand(&Cmd, Res, detail::NON_BLOCKING); @@ -240,10 +207,20 @@ TEST_F(SchedulerTest, QueueFlushing) { detail::MapMemObject Cmd = {&AllocaCmd, MockReq, &MockHostPtr, QueueImplA, access::mode::read_write}; MockCommand DepCmdA(QueueImplB); - DepCmdA.getEvent()->getHandleRef() = reinterpret_cast(new int{}); + + pi_event PIEvent = nullptr; + pi_result CallRet = mock_piEventCreate(/*pi_context=*/0x0, &PIEvent); + assert(PI_SUCCESS == CallRet); + + DepCmdA.getEvent()->getHandleRef() = PIEvent; (void)Cmd.addDep(detail::DepDesc{&DepCmdA, &MockReq, nullptr}, ToCleanUp); MockCommand DepCmdB(QueueImplB); - DepCmdB.getEvent()->getHandleRef() = reinterpret_cast(new int{}); + + PIEvent = nullptr; + CallRet = mock_piEventCreate(/*pi_context=*/0x0, &PIEvent); + assert(PI_SUCCESS == CallRet); + + DepCmdB.getEvent()->getHandleRef() = PIEvent; (void)Cmd.addDep(detail::DepDesc{&DepCmdB, &MockReq, nullptr}, ToCleanUp); // The check is performed in redefinedQueueFlush MockScheduler::enqueueCommand(&Cmd, Res, detail::NON_BLOCKING); @@ -255,7 +232,12 @@ TEST_F(SchedulerTest, QueueFlushing) { detail::MapMemObject CmdA{&AllocaCmd, MockReq, &MockHostPtr, QueueImplA, access::mode::read_write}; MockCommand DepCmd(QueueImplB); - DepCmd.getEvent()->getHandleRef() = reinterpret_cast(new int{}); + + pi_event PIEvent = nullptr; + pi_result CallRet = mock_piEventCreate(/*pi_context=*/0x0, &PIEvent); + assert(PI_SUCCESS == CallRet); + + DepCmd.getEvent()->getHandleRef() = PIEvent; (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 c1c36ca94f077..52ba6d385eb03 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.redefine( + Mock.redefineBefore( redefinedEnqueueNativeKernel); auto Kernel = []() { std::cout << "Blablabla"; }; diff --git a/sycl/unittests/scheduler/RequiredWGSize.cpp b/sycl/unittests/scheduler/RequiredWGSize.cpp index 4206a16af9f38..29b9f8fc2b8ac 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.redefine( + Mock.redefineBefore( redefinedEnqueueKernelLaunch); - Mock.redefine( + Mock.redefineBefore( redefinedKernelGetGroupInfo); const sycl::device Dev = Plt.get_devices()[0]; diff --git a/sycl/unittests/stream/stream.cpp b/sycl/unittests/stream/stream.cpp index 82d1b3a85bb5d..36afde6e06750 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.redefine( + Mock.redefineBefore( redefinedMemBufferCreate); const sycl::device Dev = Plt.get_devices()[0]; diff --git a/sycl/unittests/windows/dllmain.cpp b/sycl/unittests/windows/dllmain.cpp index 6c51ff32eac71..5a2ebc5e6a421 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.redefine(redefinedTearDown); + Mock.redefineBefore(redefinedTearDown); // Teardown calls are only expected on sycl.dll library unload, not when // process gets terminated.