From 23eff82d0ab04d1fbf8e4bfa323eb826a0ea1ca0 Mon Sep 17 00:00:00 2001 From: Mateusz Jablonski Date: Thu, 29 Sep 2022 16:36:48 +0200 Subject: [PATCH] OCL: optimize creating printf buffer Dont create printf buffer when kernel doesnt require it Related-To: HSD-18023825570 Signed-off-by: Mateusz Jablonski --- opencl/source/command_queue/enqueue_common.h | 2 +- opencl/source/program/printf_handler.cpp | 42 +++++++------------ opencl/source/program/printf_handler.h | 16 +++---- .../enqueue_command_without_kernel_tests.cpp | 2 +- ...and_without_kernel_tests_dg2_and_later.cpp | 2 +- .../command_queue/enqueue_kernel_2_tests.cpp | 16 +++---- ...and_stream_receiver_flush_task_3_tests.cpp | 2 +- opencl/test/unit_test/event/event_tests.cpp | 6 +-- .../memory_manager/memory_manager_tests.cpp | 13 ++---- .../unit_test/mocks/mock_printf_handler.h | 15 +++++-- .../program/printf_handler_tests.cpp | 39 ++++++----------- 11 files changed, 66 insertions(+), 89 deletions(-) diff --git a/opencl/source/command_queue/enqueue_common.h b/opencl/source/command_queue/enqueue_common.h index 154429f1b8..d4671ff801 100644 --- a/opencl/source/command_queue/enqueue_common.h +++ b/opencl/source/command_queue/enqueue_common.h @@ -408,7 +408,7 @@ void CommandQueueHw::processDispatchForKernels(const MultiDispatchInf TagNodeBase *hwPerfCounter = nullptr; getClFileLogger().dumpKernelArgs(&multiDispatchInfo); - printfHandler.reset(PrintfHandler::create(multiDispatchInfo, *device)); + printfHandler.reset(PrintfHandler::create(multiDispatchInfo, device->getDevice())); if (printfHandler) { printfHandler->prepareDispatch(multiDispatchInfo); } diff --git a/opencl/source/program/printf_handler.cpp b/opencl/source/program/printf_handler.cpp index 70508dc5e6..c8c160f1a9 100644 --- a/opencl/source/program/printf_handler.cpp +++ b/opencl/source/program/printf_handler.cpp @@ -7,6 +7,7 @@ #include "printf_handler.h" +#include "shared/source/device/device.h" #include "shared/source/helpers/aligned_memory.h" #include "shared/source/helpers/blit_commands_helper.h" #include "shared/source/helpers/hw_helper.h" @@ -15,15 +16,13 @@ #include "shared/source/os_interface/hw_info_config.h" #include "shared/source/program/print_formatter.h" -#include "opencl/source/cl_device/cl_device.h" -#include "opencl/source/context/context.h" #include "opencl/source/helpers/dispatch_info.h" #include "opencl/source/kernel/kernel.h" #include "opencl/source/mem_obj/buffer.h" namespace NEO { -PrintfHandler::PrintfHandler(ClDevice &deviceArg) : device(deviceArg) { +PrintfHandler::PrintfHandler(Device &deviceArg) : device(deviceArg) { printfSurfaceInitialDataSizePtr = std::make_unique(); *printfSurfaceInitialDataSizePtr = sizeof(uint32_t); } @@ -32,21 +31,15 @@ PrintfHandler::~PrintfHandler() { device.getMemoryManager()->freeGraphicsMemory(printfSurface); } -PrintfHandler *PrintfHandler::create(const MultiDispatchInfo &multiDispatchInfo, ClDevice &device) { +PrintfHandler *PrintfHandler::create(const MultiDispatchInfo &multiDispatchInfo, Device &device) { if (multiDispatchInfo.usesStatelessPrintfSurface()) { return new PrintfHandler(device); } - auto mainKernel = multiDispatchInfo.peekMainKernel(); - if (mainKernel != nullptr) { - if (mainKernel->getImplicitArgs()) { - return new PrintfHandler(device); - } - } return nullptr; } void PrintfHandler::prepareDispatch(const MultiDispatchInfo &multiDispatchInfo) { - auto printfSurfaceSize = device.getSharedDeviceInfo().printfBufferSize; + auto printfSurfaceSize = device.getDeviceInfo().printfBufferSize; if (printfSurfaceSize == 0) { return; } @@ -58,22 +51,19 @@ void PrintfHandler::prepareDispatch(const MultiDispatchInfo &multiDispatchInfo) const auto &hwInfoConfig = *HwInfoConfig::get(hwInfo.platform.eProductFamily); MemoryTransferHelper::transferMemoryToAllocation(hwInfoConfig.isBlitCopyRequiredForLocalMemory(hwInfo, *printfSurface), - device.getDevice(), printfSurface, 0, printfSurfaceInitialDataSizePtr.get(), + device, printfSurface, 0, printfSurfaceInitialDataSizePtr.get(), sizeof(*printfSurfaceInitialDataSizePtr.get())); - if (kernel->getKernelInfo().kernelDescriptor.kernelAttributes.flags.usesPrintf) { - - const auto &printfSurfaceArg = kernel->getKernelInfo().kernelDescriptor.payloadMappings.implicitArgs.printfSurfaceAddress; - auto printfPatchAddress = ptrOffset(reinterpret_cast(kernel->getCrossThreadData()), printfSurfaceArg.stateless); - patchWithRequiredSize(printfPatchAddress, printfSurfaceArg.pointerSize, (uintptr_t)printfSurface->getGpuAddressToPatch()); - if (isValidOffset(printfSurfaceArg.bindful)) { - auto surfaceState = ptrOffset(reinterpret_cast(kernel->getSurfaceStateHeap()), printfSurfaceArg.bindful); - void *addressToPatch = printfSurface->getUnderlyingBuffer(); - size_t sizeToPatch = printfSurface->getUnderlyingBufferSize(); - Buffer::setSurfaceState(&device.getDevice(), surfaceState, false, false, sizeToPatch, addressToPatch, 0, printfSurface, 0, 0, - kernel->getKernelInfo().kernelDescriptor.kernelAttributes.flags.useGlobalAtomics, - kernel->areMultipleSubDevicesInContext()); - } + const auto &printfSurfaceArg = kernel->getKernelInfo().kernelDescriptor.payloadMappings.implicitArgs.printfSurfaceAddress; + auto printfPatchAddress = ptrOffset(reinterpret_cast(kernel->getCrossThreadData()), printfSurfaceArg.stateless); + patchWithRequiredSize(printfPatchAddress, printfSurfaceArg.pointerSize, (uintptr_t)printfSurface->getGpuAddressToPatch()); + if (isValidOffset(printfSurfaceArg.bindful)) { + auto surfaceState = ptrOffset(reinterpret_cast(kernel->getSurfaceStateHeap()), printfSurfaceArg.bindful); + void *addressToPatch = printfSurface->getUnderlyingBuffer(); + size_t sizeToPatch = printfSurface->getUnderlyingBufferSize(); + Buffer::setSurfaceState(&device, surfaceState, false, false, sizeToPatch, addressToPatch, 0, printfSurface, 0, 0, + kernel->getKernelInfo().kernelDescriptor.kernelAttributes.flags.useGlobalAtomics, + kernel->areMultipleSubDevicesInContext()); } auto pImplicitArgs = kernel->getImplicitArgs(); if (pImplicitArgs) { @@ -107,7 +97,7 @@ bool PrintfHandler::printEnqueueOutput() { printfSurface->getGpuAddress(), 0, 0, 0, Vec3(printfOutputSize, 0, 0), 0, 0, 0, 0)); - const auto newTaskCount = bcsEngine.commandStreamReceiver->flushBcsTask(blitPropertiesContainer, true, false, device.getDevice()); + const auto newTaskCount = bcsEngine.commandStreamReceiver->flushBcsTask(blitPropertiesContainer, true, false, device); if (!newTaskCount) { return false; } diff --git a/opencl/source/program/printf_handler.h b/opencl/source/program/printf_handler.h index 822b8b5185..2d1cefbfb0 100644 --- a/opencl/source/program/printf_handler.h +++ b/opencl/source/program/printf_handler.h @@ -7,18 +7,20 @@ #pragma once -#include "shared/source/command_stream/command_stream_receiver.h" - -#include "opencl/source/kernel/kernel.h" +#include +#include namespace NEO { -class ClDevice; +class CommandStreamReceiver; +class Kernel; +class GraphicsAllocation; +class Device; struct MultiDispatchInfo; class PrintfHandler { public: - static PrintfHandler *create(const MultiDispatchInfo &multiDispatchInfo, ClDevice &deviceArg); + static PrintfHandler *create(const MultiDispatchInfo &multiDispatchInfo, Device &deviceArg); MOCKABLE_VIRTUAL ~PrintfHandler(); @@ -31,10 +33,10 @@ class PrintfHandler { } protected: - PrintfHandler(ClDevice &device); + PrintfHandler(Device &device); std::unique_ptr printfSurfaceInitialDataSizePtr; - ClDevice &device; + Device &device; Kernel *kernel = nullptr; GraphicsAllocation *printfSurface = nullptr; }; diff --git a/opencl/test/unit_test/command_queue/enqueue_command_without_kernel_tests.cpp b/opencl/test/unit_test/command_queue/enqueue_command_without_kernel_tests.cpp index 2a23ca22e6..dea22d1bf8 100644 --- a/opencl/test/unit_test/command_queue/enqueue_command_without_kernel_tests.cpp +++ b/opencl/test/unit_test/command_queue/enqueue_command_without_kernel_tests.cpp @@ -435,7 +435,7 @@ HWTEST_F(DispatchFlagsTests, givenMockKernelWhenSettingAdditionalKernelExecInfoT auto pKernel = mockKernelWithInternals.mockKernel; MockMultiDispatchInfo multiDispatchInfo(device.get(), pKernel); - std::unique_ptr printfHandler(PrintfHandler::create(multiDispatchInfo, *device.get())); + std::unique_ptr printfHandler(PrintfHandler::create(multiDispatchInfo, device->getDevice())); IndirectHeap *dsh = nullptr, *ioh = nullptr, *ssh = nullptr; mockCmdQ->allocateHeapMemory(IndirectHeap::Type::DYNAMIC_STATE, 4096u, dsh); mockCmdQ->allocateHeapMemory(IndirectHeap::Type::INDIRECT_OBJECT, 4096u, ioh); diff --git a/opencl/test/unit_test/command_queue/enqueue_command_without_kernel_tests_dg2_and_later.cpp b/opencl/test/unit_test/command_queue/enqueue_command_without_kernel_tests_dg2_and_later.cpp index 918d36e283..07d5dc7321 100644 --- a/opencl/test/unit_test/command_queue/enqueue_command_without_kernel_tests_dg2_and_later.cpp +++ b/opencl/test/unit_test/command_queue/enqueue_command_without_kernel_tests_dg2_and_later.cpp @@ -44,7 +44,7 @@ HWTEST2_F(DispatchFlagsTests, whenSubmittingKernelWithAdditionalKernelExecInfoTh auto pKernel = mockKernelWithInternals.mockKernel; MockMultiDispatchInfo multiDispatchInfo(device.get(), pKernel); - std::unique_ptr printfHandler(PrintfHandler::create(multiDispatchInfo, *device.get())); + std::unique_ptr printfHandler(PrintfHandler::create(multiDispatchInfo, device->getDevice())); IndirectHeap *dsh = nullptr, *ioh = nullptr, *ssh = nullptr; mockCmdQ->allocateHeapMemory(IndirectHeap::Type::DYNAMIC_STATE, 4096u, dsh); mockCmdQ->allocateHeapMemory(IndirectHeap::Type::INDIRECT_OBJECT, 4096u, ioh); diff --git a/opencl/test/unit_test/command_queue/enqueue_kernel_2_tests.cpp b/opencl/test/unit_test/command_queue/enqueue_kernel_2_tests.cpp index 91e6a50e38..f79ca3779e 100644 --- a/opencl/test/unit_test/command_queue/enqueue_kernel_2_tests.cpp +++ b/opencl/test/unit_test/command_queue/enqueue_kernel_2_tests.cpp @@ -630,13 +630,11 @@ HWTEST_P(EnqueueKernelPrintfTest, GivenKernelWithPrintfBlockedByEventWhenEventUn MockKernelWithInternals mockKernel(*pClDevice); std::string testString = "test"; mockKernel.kernelInfo.addToPrintfStringsMap(0, testString); - mockKernel.kernelInfo.kernelDescriptor.kernelAttributes.flags.usesPrintf = false; + mockKernel.kernelInfo.kernelDescriptor.kernelAttributes.flags.usesPrintf = true; mockKernel.kernelInfo.kernelDescriptor.kernelAttributes.flags.usesStringMapForPrintf = true; mockKernel.kernelInfo.kernelDescriptor.kernelAttributes.binaryFormat = DeviceBinaryFormat::Patchtokens; - UnitTestHelper::adjustKernelDescriptorForImplicitArgs(mockKernel.kernelInfo.kernelDescriptor); - mockKernel.mockKernel->pImplicitArgs = std::make_unique(); - *mockKernel.mockKernel->pImplicitArgs = {}; - + mockKernel.kernelInfo.setBufferAddressingMode(KernelDescriptor::Stateless); + mockKernel.kernelInfo.setPrintfSurface(sizeof(uintptr_t), 8); cl_uint workDim = 1; size_t globalWorkOffset[3] = {0, 0, 0}; @@ -671,7 +669,7 @@ HWTEST_P(EnqueueKernelPrintfTest, GivenKernelWithPrintfBlockedByEventWhenEventUn EXPECT_STREQ("test", output.c_str()); } -HWTEST_P(EnqueueKernelPrintfTest, GivenKernelWithPrintfWithStringMapDisbaledAndImplicitArgsBlockedByEventWhenEventUnblockedThenOutputPrinted) { +HWTEST_P(EnqueueKernelPrintfTest, GivenKernelWithPrintfWithStringMapDisbaledAndImplicitArgsBlockedByEventWhenEventUnblockedThenNoOutputPrinted) { auto userEvent = makeReleaseable(context); MockKernelWithInternals mockKernel(*pClDevice); @@ -705,9 +703,7 @@ HWTEST_P(EnqueueKernelPrintfTest, GivenKernelWithPrintfWithStringMapDisbaledAndI auto pOutEvent = castToObject(outEvent); - auto printfAllocation = reinterpret_cast(static_cast(pOutEvent->peekCommand())->peekPrintfHandler()->getSurface()->getUnderlyingBuffer()); - printfAllocation[0] = 8; - printfAllocation[1] = 0; + EXPECT_EQ(nullptr, static_cast(pOutEvent->peekCommand())->peekPrintfHandler()); pOutEvent->release(); @@ -715,7 +711,7 @@ HWTEST_P(EnqueueKernelPrintfTest, GivenKernelWithPrintfWithStringMapDisbaledAndI userEvent->setStatus(CL_COMPLETE); std::string output = testing::internal::GetCapturedStdout(); - EXPECT_STREQ("test", output.c_str()); + EXPECT_STREQ("", output.c_str()); } INSTANTIATE_TEST_CASE_P(EnqueueKernel, diff --git a/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_3_tests.cpp b/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_3_tests.cpp index c0909fe3cc..c9bda44d26 100644 --- a/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_3_tests.cpp +++ b/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_3_tests.cpp @@ -1138,7 +1138,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenGpuHangOnPrintEnqueueOutputWh const auto blockedQueue{false}; const auto cleanTemporaryAllocationsList{false}; - MockPrintfHandler printfHandler(*pClDevice); + MockPrintfHandler printfHandler(*pDevice); const auto waitStatus = commandQueue.waitForAllEngines(blockedQueue, &printfHandler, cleanTemporaryAllocationsList); EXPECT_EQ(WaitStatus::GpuHang, waitStatus); diff --git a/opencl/test/unit_test/event/event_tests.cpp b/opencl/test/unit_test/event/event_tests.cpp index ef9e6fa011..02d4d540b3 100644 --- a/opencl/test/unit_test/event/event_tests.cpp +++ b/opencl/test/unit_test/event/event_tests.cpp @@ -567,7 +567,7 @@ TEST_F(InternalsEventTest, givenBlockedKernelWithPrintfWhenSubmittedThenPrintOut pKernel->setCrossThreadData(&crossThread, sizeof(uint64_t) * 8); MockMultiDispatchInfo multiDispatchInfo(pClDevice, pKernel); - std::unique_ptr printfHandler(PrintfHandler::create(multiDispatchInfo, *pClDevice)); + std::unique_ptr printfHandler(PrintfHandler::create(multiDispatchInfo, *pDevice)); printfHandler->prepareDispatch(multiDispatchInfo); auto surface = printfHandler->getSurface(); @@ -619,7 +619,7 @@ TEST_F(InternalsEventTest, givenGpuHangOnCmdQueueWaitFunctionAndBlockedKernelWit pKernel->setCrossThreadData(&crossThread, sizeof(uint64_t) * 8); MockMultiDispatchInfo multiDispatchInfo(pClDevice, pKernel); - std::unique_ptr printfHandler(PrintfHandler::create(multiDispatchInfo, *pClDevice)); + std::unique_ptr printfHandler(PrintfHandler::create(multiDispatchInfo, *pDevice)); printfHandler.get()->prepareDispatch(multiDispatchInfo); auto surface = printfHandler.get()->getSurface(); @@ -668,7 +668,7 @@ TEST_F(InternalsEventTest, givenGpuHangOnPrintingEnqueueOutputAndBlockedKernelWi pKernel->setCrossThreadData(&crossThread, sizeof(uint64_t) * 8); MockMultiDispatchInfo multiDispatchInfo(pClDevice, pKernel); - std::unique_ptr printfHandler(new MockPrintfHandler(*pClDevice)); + std::unique_ptr printfHandler(new MockPrintfHandler(*pDevice)); printfHandler.get()->prepareDispatch(multiDispatchInfo); auto surface = printfHandler.get()->getSurface(); diff --git a/opencl/test/unit_test/memory_manager/memory_manager_tests.cpp b/opencl/test/unit_test/memory_manager/memory_manager_tests.cpp index 0859dcf60f..23571cf158 100644 --- a/opencl/test/unit_test/memory_manager/memory_manager_tests.cpp +++ b/opencl/test/unit_test/memory_manager/memory_manager_tests.cpp @@ -514,13 +514,6 @@ TEST_F(MemoryAllocatorTest, givenAllocationWithoutFragmentsWhenCallingFreeGraphi EXPECT_EQ(1u, memoryManager->handleFenceCompletionCalled); } -class MockPrintfHandler : public PrintfHandler { - public: - static MockPrintfHandler *create(const MultiDispatchInfo &multiDispatchInfo, ClDevice &deviceArg) { - return (MockPrintfHandler *)PrintfHandler::create(multiDispatchInfo, deviceArg); - } -}; - TEST_F(MemoryAllocatorTest, givenStatelessKernelWithPrintfWhenPrintfSurfaceIsCreatedThenPrintfSurfaceIsPatchedWithBaseAddressOffset) { auto device = std::make_unique(MockDevice::createWithNewExecutionEnvironment(defaultHwInfo.get())); MockKernelWithInternals kernel(*device); @@ -529,7 +522,7 @@ TEST_F(MemoryAllocatorTest, givenStatelessKernelWithPrintfWhenPrintfSurfaceIsCre kernel.kernelInfo.setBufferAddressingMode(KernelDescriptor::Stateless); kernel.kernelInfo.setPrintfSurface(sizeof(uintptr_t), 8); - auto printfHandler = MockPrintfHandler::create(multiDispatchInfo, *device.get()); + auto printfHandler = PrintfHandler::create(multiDispatchInfo, device->getDevice()); printfHandler->prepareDispatch(multiDispatchInfo); @@ -552,7 +545,7 @@ HWTEST_F(MemoryAllocatorTest, givenStatefulKernelWithPrintfWhenPrintfSurfaceIsCr kernel.kernelInfo.setPrintfSurface(sizeof(uintptr_t), 8, 16); - auto printfHandler = MockPrintfHandler::create(multiDispatchInfo, *device.get()); + auto printfHandler = PrintfHandler::create(multiDispatchInfo, device->getDevice()); printfHandler->prepareDispatch(multiDispatchInfo); @@ -586,7 +579,7 @@ TEST_F(MemoryAllocatorTest, given32BitDeviceWhenPrintfSurfaceIsCreatedThen32BitA MockMultiDispatchInfo multiDispatchInfo(device.get(), kernel.mockKernel); - auto printfHandler = MockPrintfHandler::create(multiDispatchInfo, *device.get()); + auto printfHandler = PrintfHandler::create(multiDispatchInfo, device->getDevice()); printfHandler->prepareDispatch(multiDispatchInfo); uint32_t *ptr32Bit = (uint32_t *)kernel.mockKernel->mockCrossThreadData.data(); diff --git a/opencl/test/unit_test/mocks/mock_printf_handler.h b/opencl/test/unit_test/mocks/mock_printf_handler.h index 79b6dd3e2a..cd0ebb686b 100644 --- a/opencl/test/unit_test/mocks/mock_printf_handler.h +++ b/opencl/test/unit_test/mocks/mock_printf_handler.h @@ -13,10 +13,19 @@ using namespace NEO; class MockPrintfHandler : public PrintfHandler { public: - MockPrintfHandler(ClDevice &device) : PrintfHandler{device} {} + using PrintfHandler::PrintfHandler; + using PrintfHandler::printfSurface; + using PrintfHandler::printfSurfaceInitialDataSizePtr; + MockPrintfHandler(Device &device) : PrintfHandler{device} {} ~MockPrintfHandler() override = default; bool printEnqueueOutput() override { - return false; + if (callBasePrintEnqueueOutput) { + return PrintfHandler::printEnqueueOutput(); + } + return printEnqueueOutputReturnValue; } -}; \ No newline at end of file + + bool callBasePrintEnqueueOutput = false; + bool printEnqueueOutputReturnValue = false; +}; diff --git a/opencl/test/unit_test/program/printf_handler_tests.cpp b/opencl/test/unit_test/program/printf_handler_tests.cpp index 6bae2d7f99..33c2b36c56 100644 --- a/opencl/test/unit_test/program/printf_handler_tests.cpp +++ b/opencl/test/unit_test/program/printf_handler_tests.cpp @@ -22,6 +22,7 @@ #include "opencl/test/unit_test/mocks/mock_context.h" #include "opencl/test/unit_test/mocks/mock_kernel.h" #include "opencl/test/unit_test/mocks/mock_mdi.h" +#include "opencl/test/unit_test/mocks/mock_printf_handler.h" #include "opencl/test/unit_test/mocks/mock_program.h" using namespace NEO; @@ -29,14 +30,7 @@ using namespace NEO; using PrintfHandlerTests = ::testing::Test; TEST_F(PrintfHandlerTests, givenPrintfHandlerWhenBeingConstructedThenStorePrintfSurfaceInitialDataSize) { - auto device = std::make_unique(MockDevice::createWithNewExecutionEnvironment(nullptr)); - - struct MockPrintfHandler : public PrintfHandler { - using PrintfHandler::PrintfHandler; - using PrintfHandler::printfSurfaceInitialDataSizePtr; - - MockPrintfHandler(ClDevice &device) : PrintfHandler(device) {} - }; + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); MockPrintfHandler printfHandler(*device); @@ -55,7 +49,7 @@ TEST_F(PrintfHandlerTests, givenNotPreparedPrintfHandlerWhenGetSurfaceIsCalledTh MockKernel *pKernel = new MockKernel(pProgram, *pKernelInfo, *device); MockMultiDispatchInfo multiDispatchInfo(device, pKernel); - PrintfHandler *printfHandler = PrintfHandler::create(multiDispatchInfo, *device); + PrintfHandler *printfHandler = PrintfHandler::create(multiDispatchInfo, device->getDevice()); EXPECT_EQ(nullptr, printfHandler->getSurface()); @@ -80,7 +74,7 @@ TEST_F(PrintfHandlerTests, givenPreparedPrintfHandlerWithUndefinedSshOffsetWhenG pKernel->setCrossThreadData(&crossThread, sizeof(uint64_t) * 8); MockMultiDispatchInfo multiDispatchInfo(device, pKernel); - PrintfHandler *printfHandler = PrintfHandler::create(multiDispatchInfo, *device); + PrintfHandler *printfHandler = PrintfHandler::create(multiDispatchInfo, device->getDevice()); printfHandler->prepareDispatch(multiDispatchInfo); EXPECT_NE(nullptr, printfHandler->getSurface()); @@ -108,7 +102,7 @@ TEST_F(PrintfHandlerTests, givenKernelWithImplicitArgsWhenPreparingPrintfHandler kernel.initialize(); MockMultiDispatchInfo multiDispatchInfo(device.get(), &kernel); - auto printfHandler = std::unique_ptr(PrintfHandler::create(multiDispatchInfo, *device)); + auto printfHandler = std::unique_ptr(PrintfHandler::create(multiDispatchInfo, device->getDevice())); printfHandler->prepareDispatch(multiDispatchInfo); auto printfSurface = printfHandler->getSurface(); @@ -143,7 +137,7 @@ HWTEST_F(PrintfHandlerTests, givenEnabledStatelessCompressionWhenPrintEnqueueOut kernel->setCrossThreadData(&crossThread, sizeof(uint64_t) * 8); MockMultiDispatchInfo multiDispatchInfo(device.get(), kernel.get()); - std::unique_ptr printfHandler(PrintfHandler::create(multiDispatchInfo, *device)); + std::unique_ptr printfHandler(PrintfHandler::create(multiDispatchInfo, device->getDevice())); printfHandler->prepareDispatch(multiDispatchInfo); EXPECT_NE(nullptr, printfHandler->getSurface()); @@ -182,7 +176,7 @@ HWTEST_F(PrintfHandlerTests, givenGpuHangOnFlushBcsStreamAndEnabledStatelessComp kernel->setCrossThreadData(&crossThread, sizeof(uint64_t) * 8); MockMultiDispatchInfo multiDispatchInfo(device.get(), kernel.get()); - std::unique_ptr printfHandler(PrintfHandler::create(multiDispatchInfo, *device)); + std::unique_ptr printfHandler(PrintfHandler::create(multiDispatchInfo, device->getDevice())); printfHandler->prepareDispatch(multiDispatchInfo); EXPECT_NE(nullptr, printfHandler->getSurface()); @@ -201,14 +195,6 @@ HWTEST_F(PrintfHandlerTests, givenDisallowedLocalMemoryCpuAccessWhenPrintEnqueue hwInfo.capabilityTable.blitterOperationsSupported = true; REQUIRE_BLITTER_OR_SKIP(&hwInfo); - class MockPrintfHandler : public PrintfHandler { - public: - using PrintfHandler::PrintfHandler; - using PrintfHandler::printfSurface; - - MockPrintfHandler(ClDevice &device) : PrintfHandler(device) {} - }; - DebugManagerStateRestore restore; DebugManager.flags.ForceLocalMemoryAccessMode.set(static_cast(LocalMemoryAccessMode::CpuAccessDisallowed)); DebugManager.flags.EnableLocalMemory.set(1); @@ -226,8 +212,9 @@ HWTEST_F(PrintfHandlerTests, givenDisallowedLocalMemoryCpuAccessWhenPrintEnqueue kernel->setCrossThreadData(&crossThread, sizeof(uint64_t) * 8); MockMultiDispatchInfo multiDispatchInfo(device.get(), kernel.get()); - auto printfHandler = std::make_unique(*device); + auto printfHandler = std::make_unique(device->getDevice()); + printfHandler->callBasePrintEnqueueOutput = true; printfHandler->prepareDispatch(multiDispatchInfo); EXPECT_NE(nullptr, printfHandler->getSurface()); @@ -321,7 +308,7 @@ TEST_F(PrintfHandlerTests, givenMultiDispatchInfoWithMultipleKernelsWhenCreating multiDispatchInfo.push(mainDispatchInfo); multiDispatchInfo.push(dispatchInfo2); - std::unique_ptr printfHandler(PrintfHandler::create(multiDispatchInfo, *device)); + std::unique_ptr printfHandler(PrintfHandler::create(multiDispatchInfo, device->getDevice())); ASSERT_NE(nullptr, printfHandler.get()); printfHandler->prepareDispatch(multiDispatchInfo); @@ -335,7 +322,7 @@ TEST_F(PrintfHandlerTests, GivenEmptyMultiDispatchInfoWhenCreatingPrintfHandlerT multiDispatchInfo.dispatchInfos.resize(0); EXPECT_EQ(nullptr, multiDispatchInfo.peekMainKernel()); - auto printfHandler = PrintfHandler::create(multiDispatchInfo, device); + auto printfHandler = PrintfHandler::create(multiDispatchInfo, device.getDevice()); EXPECT_EQ(nullptr, printfHandler); } @@ -378,7 +365,7 @@ TEST_F(PrintfHandlerTests, GivenAllocationInLocalMemoryWhichRequiresBlitterWhenP kernel->setCrossThreadData(&crossThread, sizeof(uint64_t) * 8); MockMultiDispatchInfo multiDispatchInfo(pClDevice.get(), kernel.get()); - std::unique_ptr printfHandler(PrintfHandler::create(multiDispatchInfo, *pClDevice)); + std::unique_ptr printfHandler(PrintfHandler::create(multiDispatchInfo, pClDevice->getDevice())); printfHandler->prepareDispatch(multiDispatchInfo); if (printfHandler->getSurface()->isAllocatedInLocalMemoryPool() && @@ -403,7 +390,7 @@ TEST_F(PrintfHandlerMultiRootDeviceTests, GivenPrintfSurfaceThenItHasCorrectRoot kernel->setCrossThreadData(&crossThread, sizeof(uint64_t) * 8); MockMultiDispatchInfo multiDispatchInfo(device1, kernel.get()); - std::unique_ptr printfHandler(PrintfHandler::create(multiDispatchInfo, *device1)); + std::unique_ptr printfHandler(PrintfHandler::create(multiDispatchInfo, device1->getDevice())); printfHandler->prepareDispatch(multiDispatchInfo); auto surface = printfHandler->getSurface();