fix: serialize printf kernel accesses using device-wise locks

Related-To: LOCI-4114

Signed-off-by: Lu, Wenbin <wenbin.lu@intel.com>

level_zero/core/source/cmdlist/cmdlist.cpp

@@ -22,6 +22,7 @@
 #include "level_zero/core/source/driver/driver_handle_imp.h"
 #include "level_zero/core/source/event/event.h"
 #include "level_zero/core/source/kernel/kernel.h"
+#include "level_zero/core/source/kernel/kernel_imp.h"
 
 namespace L0 {
 
@@ -38,11 +39,12 @@ CommandList::~CommandList() {
 }
 
 void CommandList::storePrintfKernel(Kernel *kernel) {
-    auto it = std::find(this->printfKernelContainer.begin(), this->printfKernelContainer.end(),
-                        kernel);
+    auto it = std::find_if(this->printfKernelContainer.begin(), this->printfKernelContainer.end(),
+                           [&kernel](const auto &printfKernel) { return printfKernel.lock().get() == kernel; });
 
     if (it == this->printfKernelContainer.end()) {
-        this->printfKernelContainer.push_back(kernel);
+        auto module = static_cast<const ModuleImp *>(&static_cast<KernelImp *>(kernel)->getParentModule());
+        this->printfKernelContainer.push_back(module->getPrintfKernelWeakPtr(kernel->toHandle()));
     }
 }
 

level_zero/core/source/cmdlist/cmdlist.h

@@ -226,7 +226,7 @@ struct CommandList : _ze_command_list_handle_t {
         return indirectAllocationsAllowed;
     }
 
-    std::vector<Kernel *> &getPrintfKernelContainer() {
+    std::vector<std::weak_ptr<Kernel>> &getPrintfKernelContainer() {
         return this->printfKernelContainer;
     }
 
@@ -357,7 +357,7 @@ struct CommandList : _ze_command_list_handle_t {
     std::map<const void *, NEO::GraphicsAllocation *> hostPtrMap;
     std::vector<NEO::GraphicsAllocation *> ownedPrivateAllocations;
     std::vector<NEO::GraphicsAllocation *> patternAllocations;
-    std::vector<Kernel *> printfKernelContainer;
+    std::vector<std::weak_ptr<Kernel>> printfKernelContainer;
 
     NEO::CommandContainer commandContainer;
 

level_zero/core/source/cmdlist/cmdlist_hw.inl

@@ -388,7 +388,10 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelIndirect(ze_
     if (hEvent) {
         event = Event::fromHandle(hEvent);
         if (Kernel::fromHandle(kernelHandle)->getPrintfBufferAllocation() != nullptr) {
-            event->setKernelForPrintf(Kernel::fromHandle(kernelHandle));
+            Kernel *kernel = Kernel::fromHandle(kernelHandle);
+            auto module = static_cast<const ModuleImp *>(&static_cast<KernelImp *>(kernel)->getParentModule());
+            event->setKernelForPrintf(module->getPrintfKernelWeakPtr(kernelHandle));
+            event->setKernelWithPrintfDeviceMutex(kernel->getDevicePrintfKernelMutex());
         }
         launchParams.isHostSignalScopeEvent = event->isSignalScope(ZE_EVENT_SCOPE_FLAG_HOST);
     }

level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl

@@ -385,7 +385,7 @@ inline ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::executeCommand
 
     this->cmdQImmediate->setTaskCount(completionStamp.taskCount);
 
-    if (this->isSyncModeQueue || this->printfKernelContainer.size() > 0u) {
+    if (this->isSyncModeQueue) {
         status = hostSynchronize(std::numeric_limits<uint64_t>::max(), completionStamp.taskCount, true);
     }
 
@@ -1242,7 +1242,10 @@ template <GFXCORE_FAMILY gfxCoreFamily>
 void CommandListCoreFamilyImmediate<gfxCoreFamily>::printKernelsPrintfOutput(bool hangDetected) {
     size_t size = this->printfKernelContainer.size();
     for (size_t i = 0; i < size; i++) {
-        this->printfKernelContainer[i]->printPrintfOutput(hangDetected);
+        std::lock_guard<std::mutex> lock(static_cast<DeviceImp *>(this->device)->printfKernelMutex);
+        if (!this->printfKernelContainer[i].expired()) {
+            this->printfKernelContainer[i].lock()->printPrintfOutput(hangDetected);
+        }
     }
     this->printfKernelContainer.clear();
 }

level_zero/core/source/cmdlist/cmdlist_hw_skl_to_tgllp.inl

@@ -240,7 +240,9 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(K
     }
 
     if (event != nullptr && kernel->getPrintfBufferAllocation() != nullptr) {
-        event->setKernelForPrintf(kernel);
+        auto module = static_cast<const ModuleImp *>(&static_cast<KernelImp *>(kernel)->getParentModule());
+        event->setKernelForPrintf(module->getPrintfKernelWeakPtr(kernel->toHandle()));
+        event->setKernelWithPrintfDeviceMutex(kernel->getDevicePrintfKernelMutex());
     }
 
     if (this->inOrderExecutionEnabled && !launchParams.isKernelSplitOperation) {

level_zero/core/source/cmdlist/cmdlist_hw_xehp_and_later.inl

@@ -24,7 +24,9 @@
 #include "shared/source/xe_hp_core/hw_info.h"
 
 #include "level_zero/core/source/cmdlist/cmdlist_hw.h"
+#include "level_zero/core/source/device/device.h"
 #include "level_zero/core/source/driver/driver_handle_imp.h"
+#include "level_zero/core/source/event/event.h"
 #include "level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h"
 #include "level_zero/core/source/kernel/kernel_imp.h"
 #include "level_zero/core/source/module/module.h"
@@ -171,7 +173,9 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(K
     Event *compactEvent = nullptr;
     if (event) {
         if (kernel->getPrintfBufferAllocation() != nullptr) {
-            event->setKernelForPrintf(kernel);
+            auto module = static_cast<const ModuleImp *>(&static_cast<KernelImp *>(kernel)->getParentModule());
+            event->setKernelForPrintf(module->getPrintfKernelWeakPtr(kernel->toHandle()));
+            event->setKernelWithPrintfDeviceMutex(kernel->getDevicePrintfKernelMutex());
         }
         isHostSignalScopeEvent = event->isSignalScope(ZE_EVENT_SCOPE_FLAG_HOST);
         if (compactL3FlushEvent(getDcFlushRequired(event->isSignalScope()))) {

level_zero/core/source/cmdqueue/cmdqueue.cpp

@@ -189,7 +189,10 @@ ze_result_t CommandQueueImp::synchronizeByPollingForTaskCount(uint64_t timeout)
 void CommandQueueImp::printKernelsPrintfOutput(bool hangDetected) {
     size_t size = this->printfKernelContainer.size();
     for (size_t i = 0; i < size; i++) {
-        this->printfKernelContainer[i]->printPrintfOutput(hangDetected);
+        std::lock_guard<std::mutex> lock(static_cast<DeviceImp *>(this->getDevice())->printfKernelMutex);
+        if (!this->printfKernelContainer[i].expired()) {
+            this->printfKernelContainer[i].lock()->printPrintfOutput(hangDetected);
+        }
     }
     this->printfKernelContainer.clear();
 }

level_zero/core/source/cmdqueue/cmdqueue_imp.h

@@ -137,7 +137,7 @@ struct CommandQueueImp : public CommandQueue {
     NEO::LinearStream firstCmdListStream{};
     NEO::HeapContainer heapContainer;
     ze_command_queue_desc_t desc;
-    std::vector<Kernel *> printfKernelContainer;
+    std::vector<std::weak_ptr<Kernel>> printfKernelContainer;
 
     Device *device = nullptr;
     NEO::CommandStreamReceiver *csr = nullptr;

level_zero/core/source/device/device_imp.h

@@ -131,6 +131,8 @@ struct DeviceImp : public Device {
     ze_pci_speed_ext_t pciMaxSpeed = {-1, -1, -1};
     Device *rootDevice = nullptr;
 
+    std::mutex printfKernelMutex;
+
     BcsSplit bcsSplit;
 
     bool resourcesReleased = false;

level_zero/core/source/event/event.h

@@ -18,6 +18,7 @@
 #include <chrono>
 #include <limits>
 #include <memory>
+#include <mutex>
 #include <vector>
 
 struct _ze_event_handle_t {};
@@ -196,12 +197,24 @@ struct Event : _ze_event_handle_t {
     uint32_t getMaxKernelCount() const {
         return maxKernelCount;
     }
-    void setKernelForPrintf(Kernel *inputKernelPtr) {
-        kernelWithPrintf = inputKernelPtr;
+    void setKernelForPrintf(std::weak_ptr<Kernel> inputKernelWeakPtr) {
+        kernelWithPrintf = inputKernelWeakPtr;
     }
-    Kernel *getKernelForPrintf() {
+    std::weak_ptr<Kernel> getKernelForPrintf() {
         return kernelWithPrintf;
     }
+    void resetKernelForPrintf() {
+        kernelWithPrintf.reset();
+    }
+    void setKernelWithPrintfDeviceMutex(std::mutex *mutexPtr) {
+        kernelWithPrintfDeviceMutex = mutexPtr;
+    }
+    std::mutex *getKernelWithPrintfDeviceMutex() {
+        return kernelWithPrintfDeviceMutex;
+    }
+    void resetKernelWithPrintfDeviceMutex() {
+        kernelWithPrintfDeviceMutex = nullptr;
+    }
 
     bool isSignalScope() const {
         return !!signalScope;
@@ -262,7 +275,8 @@ struct Event : _ze_event_handle_t {
     void *hostAddress = nullptr;
     Device *device = nullptr;
     EventPool *eventPool = nullptr;
-    Kernel *kernelWithPrintf = nullptr;
+    std::weak_ptr<Kernel> kernelWithPrintf = std::weak_ptr<Kernel>();
+    std::mutex *kernelWithPrintfDeviceMutex = nullptr;
     NEO::GraphicsAllocation *inOrderExecDataAllocation = nullptr;
     CommandQueue *latestUsedCmdQueue = nullptr;
 

level_zero/core/source/event/event_impl.inl

@@ -14,6 +14,7 @@
 #include "shared/source/memory_manager/memory_operations_handler.h"
 #include "shared/source/os_interface/os_time.h"
 
+#include "level_zero/core/source/device/device.h"
 #include "level_zero/core/source/event/event_imp.h"
 #include "level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h"
 #include "level_zero/core/source/kernel/kernel.h"
@@ -406,9 +407,13 @@ ze_result_t EventImp<TagSizeT>::hostSynchronize(uint64_t timeout) {
             ret = queryStatus();
         }
         if (ret == ZE_RESULT_SUCCESS) {
-            if (this->getKernelForPrintf() != nullptr) {
-                static_cast<Kernel *>(this->getKernelForPrintf())->printPrintfOutput(true);
-                this->setKernelForPrintf(nullptr);
+            if (this->getKernelWithPrintfDeviceMutex() != nullptr) {
+                std::lock_guard<std::mutex> lock(*this->getKernelWithPrintfDeviceMutex());
+                if (!this->getKernelForPrintf().expired()) {
+                    this->getKernelForPrintf().lock()->printPrintfOutput(true);
+                }
+                this->resetKernelForPrintf();
+                this->resetKernelWithPrintfDeviceMutex();
             }
             if (device->getNEODevice()->getRootDeviceEnvironment().assertHandler.get()) {
                 device->getNEODevice()->getRootDeviceEnvironment().assertHandler->printAssertAndAbort();

level_zero/core/source/kernel/kernel.h

@@ -141,6 +141,7 @@ struct Kernel : _ze_kernel_handle_t, virtual NEO::DispatchKernelEncoderI {
     virtual UnifiedMemoryControls getUnifiedMemoryControls() const = 0;
     virtual bool hasIndirectAllocationsAllowed() const = 0;
 
+    virtual std::mutex *getDevicePrintfKernelMutex() = 0;
     virtual NEO::GraphicsAllocation *getPrintfBufferAllocation() = 0;
     virtual void printPrintfOutput(bool hangDetected) = 0;
 

level_zero/core/source/kernel/kernel_imp.cpp

@@ -1086,11 +1086,11 @@ void KernelImp::createPrintfBuffer() {
         if (pImplicitArgs) {
             pImplicitArgs->printfBufferPtr = printfBuffer->getGpuAddress();
         }
+        this->devicePrintfKernelMutex = &(static_cast<DeviceImp *>(this->module->getDevice())->printfKernelMutex);
     }
 }
 
 void KernelImp::printPrintfOutput(bool hangDetected) {
-    std::lock_guard<std::mutex> lock(this->printfLock);
     PrintfHandler::printOutput(kernelImmData, this->printfBuffer, module->getDevice(), hangDetected);
 }
 

level_zero/core/source/kernel/kernel_imp.h

@@ -14,6 +14,8 @@
 #include "shared/source/unified_memory/unified_memory.h"
 
 #include "level_zero/core/source/kernel/kernel.h"
+#include "level_zero/core/source/module/module.h"
+#include "level_zero/core/source/module/module_imp.h"
 
 #include <memory>
 #include <mutex>
@@ -38,8 +40,12 @@ struct KernelImp : Kernel {
     ~KernelImp() override;
 
     ze_result_t destroy() override {
-        delete this;
-        return ZE_RESULT_SUCCESS;
+        if (this->devicePrintfKernelMutex == nullptr) {
+            delete this;
+            return ZE_RESULT_SUCCESS;
+        } else {
+            return static_cast<ModuleImp *>(this->module)->destroyPrintfKernel(this);
+        }
     }
 
     ze_result_t getBaseAddress(uint64_t *baseAddress) override;
@@ -99,6 +105,7 @@ struct KernelImp : Kernel {
     uint32_t getNumThreadsPerThreadGroup() const override { return numThreadsPerThreadGroup; }
     uint32_t getThreadExecutionMask() const override { return threadExecutionMask; }
 
+    std::mutex *getDevicePrintfKernelMutex() override { return this->devicePrintfKernelMutex; }
     NEO::GraphicsAllocation *getPrintfBufferAllocation() override { return this->printfBuffer; }
     void printPrintfOutput(bool hangDetected) override;
 
@@ -199,6 +206,7 @@ struct KernelImp : Kernel {
     std::vector<KernelImp::KernelArgHandler> kernelArgHandlers;
     std::vector<NEO::GraphicsAllocation *> residencyContainer;
 
+    std::mutex *devicePrintfKernelMutex = nullptr;
     NEO::GraphicsAllocation *printfBuffer = nullptr;
 
     uint32_t groupSize[3] = {0u, 0u, 0u};
@@ -238,7 +246,6 @@ struct KernelImp : Kernel {
     std::unique_ptr<NEO::ImplicitArgs> pImplicitArgs;
 
     std::unique_ptr<KernelExt> pExtension;
-    std::mutex printfLock;
 
     struct SuggestGroupSizeCacheEntry {
         Vec3<size_t> groupSize;

level_zero/core/source/module/module_imp.cpp

@@ -39,6 +39,7 @@
 #include "shared/source/program/program_initialization.h"
 
 #include "level_zero/core/source/device/device.h"
+#include "level_zero/core/source/device/device_imp.h"
 #include "level_zero/core/source/driver/driver_handle.h"
 #include "level_zero/core/source/driver/driver_handle_imp.h"
 #include "level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h"
@@ -499,6 +500,12 @@ ModuleImp::ModuleImp(Device *device, ModuleBuildLog *moduleBuildLog, ModuleType
 }
 
 ModuleImp::~ModuleImp() {
+    for (auto &kernel : printfKernelContainer) {
+        if (kernel.get() != nullptr) {
+            destroyPrintfKernel(kernel->toHandle());
+        }
+    }
+    printfKernelContainer.clear();
     kernelImmDatas.clear();
 }
 
@@ -813,6 +820,9 @@ ze_result_t ModuleImp::createKernel(const ze_kernel_desc_t *desc,
 
     if (res == ZE_RESULT_SUCCESS) {
         *kernelHandle = kernel->toHandle();
+        if (kernel->getPrintfBufferAllocation() != nullptr) {
+            this->printfKernelContainer.push_back(std::shared_ptr<Kernel>(kernel));
+        }
     } else {
         driverHandle->clearErrorDescription();
     }
@@ -831,6 +841,29 @@ ze_result_t ModuleImp::createKernel(const ze_kernel_desc_t *desc,
     return res;
 }
 
+std::weak_ptr<Kernel> ModuleImp::getPrintfKernelWeakPtr(ze_kernel_handle_t kernelHandle) const {
+    std::lock_guard<std::mutex> lock(static_cast<DeviceImp *>(device)->printfKernelMutex);
+    Kernel *kernel = Kernel::fromHandle(kernelHandle);
+    auto it = std::find_if(this->printfKernelContainer.begin(), this->printfKernelContainer.end(), [&kernel](const auto &kernelSharedPtr) { return kernelSharedPtr.get() == kernel; });
+    if (it == this->printfKernelContainer.end()) {
+        return std::weak_ptr<Kernel>{};
+    } else {
+        return std::weak_ptr<Kernel>{*it};
+    }
+}
+
+ze_result_t ModuleImp::destroyPrintfKernel(ze_kernel_handle_t kernelHandle) {
+    std::lock_guard<std::mutex> lock(static_cast<DeviceImp *>(device)->printfKernelMutex);
+    Kernel *kernel = Kernel::fromHandle(kernelHandle);
+    auto it = std::find_if(this->printfKernelContainer.begin(), this->printfKernelContainer.end(),
+                           [&kernel](const auto &kernelPtr) { return kernelPtr.get() == kernel; });
+    if (it == this->printfKernelContainer.end()) {
+        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+    it->reset();
+    return ZE_RESULT_SUCCESS;
+}
+
 ze_result_t ModuleImp::getNativeBinary(size_t *pSize, uint8_t *pModuleNativeBinary) {
     auto genBinary = this->translationUnit->packedDeviceBinary.get();
 

level_zero/core/source/module/module_imp.h

@@ -11,6 +11,7 @@
 #include "shared/source/compiler_interface/linker.h"
 #include "shared/source/program/program_info.h"
 
+#include "level_zero/core/source/kernel/kernel.h"
 #include "level_zero/core/source/module/module.h"
 
 #include "igfxfmid.h"
@@ -152,6 +153,10 @@ struct ModuleImp : public Module {
         return this->translationUnit.get();
     }
 
+    std::vector<std::shared_ptr<Kernel>> &getPrintfKernelContainer() { return this->printfKernelContainer; }
+    std::weak_ptr<Kernel> getPrintfKernelWeakPtr(ze_kernel_handle_t kernelHandle) const;
+    ze_result_t destroyPrintfKernel(ze_kernel_handle_t kernelHandle);
+
   protected:
     ze_result_t initializeTranslationUnit(const ze_module_desc_t *desc, NEO::Device *neoDevice);
     ze_result_t checkIfBuildShouldBeFailed(NEO::Device *neoDevice);
@@ -172,6 +177,7 @@ struct ModuleImp : public Module {
     std::unique_ptr<ModuleTranslationUnit> translationUnit;
     ModuleBuildLog *moduleBuildLog = nullptr;
     NEO::GraphicsAllocation *exportedFunctionsSurface = nullptr;
+    std::vector<std::shared_ptr<Kernel>> printfKernelContainer;
     std::vector<std::unique_ptr<KernelImmutableData>> kernelImmDatas;
     NEO::Linker::RelocatedSymbolsMap symbols;
 

level_zero/core/test/unit_tests/fixtures/module_fixture.cpp

@@ -178,7 +178,7 @@ std::unique_ptr<WhiteBox<::L0::KernelImp>> ModuleFixture::createKernelWithName(s
 }
 
 void ModuleFixture::tearDown() {
-    kernel.reset(nullptr);
+    kernel.reset();
     module.reset(nullptr);
     DeviceFixture::tearDown();
 }
@@ -219,7 +219,7 @@ void MultiDeviceModuleFixture::createKernel(uint32_t rootDeviceIndex) {
 }
 
 void MultiDeviceModuleFixture::tearDown() {
-    kernel.reset(nullptr);
+    kernel.reset();
     for (auto &module : modules) {
         module.reset(nullptr);
     }

level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_1.cpp

@@ -219,36 +219,43 @@ HWTEST2_F(CommandListAppendLaunchKernel, givenNotEnoughSpaceInCommandStreamWhenA
 }
 
 HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfUsedWhenAppendedToCommandListThenKernelIsStored) {
-    createKernel();
     ze_result_t returnValue;
     std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
     ze_group_count_t groupCount{1, 1, 1};
 
-    EXPECT_TRUE(kernel->kernelImmData->getDescriptor().kernelAttributes.flags.usesPrintf);
+    auto kernel = new Mock<KernelImp>();
+    kernel->module = module.get();
+    kernel->descriptor.kernelAttributes.flags.usesPrintf = true;
+    kernel->createPrintfBuffer();
+    static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer().push_back(std::shared_ptr<Kernel>{kernel});
+
     CmdListKernelLaunchParams launchParams = {};
-    auto result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false));
 
     EXPECT_EQ(1u, commandList->getPrintfKernelContainer().size());
-    EXPECT_EQ(kernel.get(), commandList->getPrintfKernelContainer()[0]);
+    std::shared_ptr<Kernel> kernelSharedPtr = commandList->getPrintfKernelContainer()[0].lock();
+    EXPECT_EQ(kernel, kernelSharedPtr.get());
 }
 
 HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfUsedWhenAppendedToCommandListMultipleTimesThenKernelIsStoredOnce) {
-    createKernel();
     ze_result_t returnValue;
     std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
     ze_group_count_t groupCount{1, 1, 1};
 
-    EXPECT_TRUE(kernel->kernelImmData->getDescriptor().kernelAttributes.flags.usesPrintf);
+    auto kernel = new Mock<KernelImp>();
+    kernel->module = module.get();
+    kernel->descriptor.kernelAttributes.flags.usesPrintf = true;
+    kernel->createPrintfBuffer();
+    static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer().push_back(std::shared_ptr<Kernel>{kernel});
+
     CmdListKernelLaunchParams launchParams = {};
-    auto result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false));
 
     EXPECT_EQ(1u, commandList->getPrintfKernelContainer().size());
-    EXPECT_EQ(kernel.get(), commandList->getPrintfKernelContainer()[0]);
+    std::shared_ptr<Kernel> kernelSharedPtr = commandList->getPrintfKernelContainer()[0].lock();
+    EXPECT_EQ(kernel, kernelSharedPtr.get());
 
-    result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false));
     EXPECT_EQ(1u, commandList->getPrintfKernelContainer().size());
 }
 
@@ -262,25 +269,27 @@ HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfWhenAppendedToSynch
 
     std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &queueDesc, false, NEO::EngineGroupType::RenderCompute, returnValue));
 
-    Mock<KernelImp> kernel;
-    kernel.descriptor.kernelAttributes.flags.usesPrintf = true;
+    auto kernel = new Mock<KernelImp>();
+    kernel->module = module.get();
+    kernel->descriptor.kernelAttributes.flags.usesPrintf = true;
+    kernel->createPrintfBuffer();
+    static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer().push_back(std::shared_ptr<Kernel>{kernel});
 
+    EXPECT_EQ(0u, kernel->printPrintfOutputCalledTimes);
     ze_group_count_t groupCount{1, 1, 1};
     CmdListKernelLaunchParams launchParams = {};
-    auto result = commandList->appendLaunchKernel(kernel.toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(1u, kernel.printPrintfOutputCalledTimes);
-    EXPECT_FALSE(kernel.hangDetectedPassedToPrintfOutput);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false));
+    EXPECT_EQ(1u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_FALSE(kernel->hangDetectedPassedToPrintfOutput);
     EXPECT_EQ(0u, commandList->getPrintfKernelContainer().size());
 
-    result = commandList->appendLaunchKernel(kernel.toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(2u, kernel.printPrintfOutputCalledTimes);
-    EXPECT_FALSE(kernel.hangDetectedPassedToPrintfOutput);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false));
+    EXPECT_EQ(2u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_FALSE(kernel->hangDetectedPassedToPrintfOutput);
     EXPECT_EQ(0u, commandList->getPrintfKernelContainer().size());
 }
 
-HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfWhenAppendedToAsynchronousImmCommandListThenPrintfBufferIsPrinted) {
+HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfWhenAppendedToAsynchronousImmCommandListThenPrintfBufferIsNotPrintedUntilHostSync) {
     DebugManagerStateRestore dbgRestorer;
     DebugManager.flags.EnableFlushTaskSubmission.set(1);
 
@@ -290,21 +299,26 @@ HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfWhenAppendedToAsync
 
     std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &queueDesc, false, NEO::EngineGroupType::RenderCompute, returnValue));
 
-    Mock<KernelImp> kernel;
-    kernel.descriptor.kernelAttributes.flags.usesPrintf = true;
+    auto kernel = new Mock<KernelImp>();
+    kernel->module = module.get();
+    kernel->descriptor.kernelAttributes.flags.usesPrintf = true;
+    kernel->createPrintfBuffer();
+    static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer().push_back(std::shared_ptr<Kernel>{kernel});
 
     ze_group_count_t groupCount{1, 1, 1};
     CmdListKernelLaunchParams launchParams = {};
-    auto result = commandList->appendLaunchKernel(kernel.toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(1u, kernel.printPrintfOutputCalledTimes);
-    EXPECT_FALSE(kernel.hangDetectedPassedToPrintfOutput);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false));
+    EXPECT_EQ(0u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->hostSynchronize(std::numeric_limits<uint64_t>::max()));
+    EXPECT_EQ(1u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_FALSE(kernel->hangDetectedPassedToPrintfOutput);
     EXPECT_EQ(0u, commandList->getPrintfKernelContainer().size());
 
-    result = commandList->appendLaunchKernel(kernel.toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(2u, kernel.printPrintfOutputCalledTimes);
-    EXPECT_FALSE(kernel.hangDetectedPassedToPrintfOutput);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false));
+    EXPECT_EQ(1u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->hostSynchronize(std::numeric_limits<uint64_t>::max()));
+    EXPECT_EQ(2u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_FALSE(kernel->hangDetectedPassedToPrintfOutput);
     EXPECT_EQ(0u, commandList->getPrintfKernelContainer().size());
 }
 
@@ -323,22 +337,402 @@ HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfWhenAppendToSynchro
 
     std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &queueDesc, false, NEO::EngineGroupType::RenderCompute, returnValue));
 
-    Mock<KernelImp> kernel;
-    kernel.descriptor.kernelAttributes.flags.usesPrintf = true;
+    auto kernel = new Mock<KernelImp>();
+    kernel->module = module.get();
+    kernel->descriptor.kernelAttributes.flags.usesPrintf = true;
+    kernel->createPrintfBuffer();
+    static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer().push_back(std::shared_ptr<Kernel>{kernel});
+
+    EXPECT_EQ(0u, kernel->printPrintfOutputCalledTimes);
+    ze_group_count_t groupCount{1, 1, 1};
+    CmdListKernelLaunchParams launchParams = {};
+    EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false));
+    EXPECT_EQ(1u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_TRUE(kernel->hangDetectedPassedToPrintfOutput);
+    EXPECT_EQ(0u, commandList->getPrintfKernelContainer().size());
+
+    EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false));
+    EXPECT_EQ(2u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_TRUE(kernel->hangDetectedPassedToPrintfOutput);
+    EXPECT_EQ(0u, commandList->getPrintfKernelContainer().size());
+}
+
+HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfAppendedToCommandListAndDestroyKernelAfterSynchronizationThenSuccessIsReturned) {
+    ze_result_t result;
+    std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, result));
+
+    auto kernel = new Mock<KernelImp>();
+    kernel->module = module.get();
+    kernel->descriptor.kernelAttributes.flags.usesPrintf = true;
+    kernel->createPrintfBuffer();
+    static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer().push_back(std::shared_ptr<Kernel>{kernel});
 
     ze_group_count_t groupCount{1, 1, 1};
     CmdListKernelLaunchParams launchParams = {};
-    auto result = commandList->appendLaunchKernel(kernel.toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false);
-    EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, result);
-    EXPECT_EQ(1u, kernel.printPrintfOutputCalledTimes);
-    EXPECT_TRUE(kernel.hangDetectedPassedToPrintfOutput);
-    EXPECT_EQ(0u, commandList->getPrintfKernelContainer().size());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false));
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->close());
 
-    result = commandList->appendLaunchKernel(kernel.toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false);
-    EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, result);
-    EXPECT_EQ(2u, kernel.printPrintfOutputCalledTimes);
-    EXPECT_TRUE(kernel.hangDetectedPassedToPrintfOutput);
-    EXPECT_EQ(0u, commandList->getPrintfKernelContainer().size());
+    ze_command_queue_handle_t commandQueueHandle;
+    ze_command_queue_desc_t desc{};
+    desc.stype = ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC;
+    desc.pNext = nullptr;
+    desc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
+    desc.ordinal = 0u;
+    desc.index = 0u;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, device->createCommandQueue(&desc, &commandQueueHandle));
+    auto commandQueue = static_cast<L0::ult::CommandQueue *>(L0::CommandQueue::fromHandle(commandQueueHandle));
+    ASSERT_NE(commandQueue, nullptr);
+
+    auto commandListHandle = commandList->toHandle();
+    EXPECT_EQ(0u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false));
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandQueue->synchronize(std::numeric_limits<uint64_t>::max()));
+    EXPECT_EQ(1u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, kernel->destroy());
+    EXPECT_EQ(nullptr, static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer()[0].get());
+
+    commandQueue->destroy();
+}
+
+HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfAndEventAppendedToCommandListAndDestroyKernelAfterQueueSyncThenSuccessIsReturnedAndEventSyncDoesNotAccessKernel) {
+    ze_result_t result;
+    std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, result));
+
+    auto kernel = new Mock<KernelImp>();
+    kernel->module = module.get();
+    kernel->descriptor.kernelAttributes.flags.usesPrintf = true;
+    kernel->createPrintfBuffer();
+    static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer().push_back(std::shared_ptr<Kernel>{kernel});
+
+    ze_event_pool_desc_t eventPoolDesc = {};
+    eventPoolDesc.stype = ZE_STRUCTURE_TYPE_EVENT_POOL_DESC;
+    eventPoolDesc.pNext = nullptr;
+    eventPoolDesc.count = 1;
+    eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
+    auto eventPool = std::unique_ptr<::L0::EventPool>(::L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc, result));
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    ze_event_desc_t eventDesc = {};
+    eventDesc.stype = ZE_STRUCTURE_TYPE_EVENT_DESC;
+    eventDesc.pNext = nullptr;
+    eventDesc.index = 0;
+    eventDesc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
+    eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
+    auto event = std::unique_ptr<::L0::Event>(::L0::Event::create<typename FamilyType::TimestampPacketType>(eventPool.get(), &eventDesc, device));
+    auto hEventHandle = event->toHandle();
+
+    ze_group_count_t groupCount{1, 1, 1};
+    CmdListKernelLaunchParams launchParams = {};
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, hEventHandle, 0, nullptr, launchParams, false));
+    EXPECT_NE(nullptr, event->getKernelForPrintf().lock().get());
+    EXPECT_NE(nullptr, event->getKernelWithPrintfDeviceMutex());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->close());
+
+    ze_command_queue_handle_t commandQueueHandle;
+    ze_command_queue_desc_t desc{};
+    desc.stype = ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC;
+    desc.pNext = nullptr;
+    desc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
+    desc.ordinal = 0u;
+    desc.index = 0u;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, device->createCommandQueue(&desc, &commandQueueHandle));
+    auto commandQueue = static_cast<L0::ult::CommandQueue *>(L0::CommandQueue::fromHandle(commandQueueHandle));
+    ASSERT_NE(commandQueue, nullptr);
+
+    auto commandListHandle = commandList->toHandle();
+    EXPECT_EQ(0u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false));
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandQueue->synchronize(std::numeric_limits<uint64_t>::max()));
+    *reinterpret_cast<uint32_t *>(event->getHostAddress()) = Event::STATE_SIGNALED;
+    EXPECT_EQ(1u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, kernel->destroy());
+    EXPECT_EQ(nullptr, static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer()[0].get());
+    EXPECT_EQ(1u, commandList->getPrintfKernelContainer().size());
+    EXPECT_EQ(nullptr, commandList->getPrintfKernelContainer()[0].lock());
+    EXPECT_EQ(nullptr, event->getKernelForPrintf().lock().get());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, event->queryStatus());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, event->hostSynchronize(std::numeric_limits<uint64_t>::max()));
+    EXPECT_EQ(nullptr, event->getKernelWithPrintfDeviceMutex());
+
+    commandQueue->destroy();
+}
+
+HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfAndEventAppendedToCommandListAndDestroyKernelAfterEventSyncThenSuccessIsReturnedAndQueueSyncDoesNotAccessKernel) {
+    ze_result_t result;
+    std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, result));
+
+    auto kernel = new Mock<KernelImp>();
+    kernel->module = module.get();
+    kernel->descriptor.kernelAttributes.flags.usesPrintf = true;
+    kernel->createPrintfBuffer();
+    static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer().push_back(std::shared_ptr<Kernel>{kernel});
+
+    ze_event_pool_desc_t eventPoolDesc = {};
+    eventPoolDesc.stype = ZE_STRUCTURE_TYPE_EVENT_POOL_DESC;
+    eventPoolDesc.pNext = nullptr;
+    eventPoolDesc.count = 1;
+    eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
+    auto eventPool = std::unique_ptr<::L0::EventPool>(::L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc, result));
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    ze_event_desc_t eventDesc = {};
+    eventDesc.stype = ZE_STRUCTURE_TYPE_EVENT_DESC;
+    eventDesc.pNext = nullptr;
+    eventDesc.index = 0;
+    eventDesc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
+    eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
+    auto event = std::unique_ptr<::L0::Event>(::L0::Event::create<typename FamilyType::TimestampPacketType>(eventPool.get(), &eventDesc, device));
+    auto hEventHandle = event->toHandle();
+
+    ze_group_count_t groupCount{1, 1, 1};
+    CmdListKernelLaunchParams launchParams = {};
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, hEventHandle, 0, nullptr, launchParams, false));
+    EXPECT_NE(nullptr, event->getKernelForPrintf().lock().get());
+    EXPECT_NE(nullptr, event->getKernelWithPrintfDeviceMutex());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->close());
+
+    ze_command_queue_handle_t commandQueueHandle;
+    ze_command_queue_desc_t desc{};
+    desc.stype = ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC;
+    desc.pNext = nullptr;
+    desc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
+    desc.ordinal = 0u;
+    desc.index = 0u;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, device->createCommandQueue(&desc, &commandQueueHandle));
+    auto commandQueue = static_cast<L0::ult::CommandQueue *>(L0::CommandQueue::fromHandle(commandQueueHandle));
+    ASSERT_NE(commandQueue, nullptr);
+
+    auto commandListHandle = commandList->toHandle();
+    EXPECT_EQ(0u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false));
+    *reinterpret_cast<uint32_t *>(event->getHostAddress()) = Event::STATE_SIGNALED;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, event->hostSynchronize(std::numeric_limits<uint64_t>::max()));
+    EXPECT_EQ(1u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, kernel->destroy());
+    EXPECT_EQ(nullptr, static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer()[0].get());
+    EXPECT_EQ(nullptr, event->getKernelForPrintf().lock().get());
+    EXPECT_EQ(nullptr, event->getKernelWithPrintfDeviceMutex());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandQueue->synchronize(std::numeric_limits<uint64_t>::max()));
+    EXPECT_EQ(1u, commandList->getPrintfKernelContainer().size());
+    EXPECT_EQ(nullptr, commandList->getPrintfKernelContainer()[0].lock());
+
+    commandQueue->destroy();
+}
+
+HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfAppendedToImmCommandListWithFlushTaskSubmissionAndDestroyKernelAfterSynchronizationThenSuccessIsReturned) {
+    DebugManagerStateRestore restorer;
+    NEO::DebugManager.flags.EnableFlushTaskSubmission.set(1);
+
+    ze_result_t result;
+    ze_command_queue_desc_t queueDesc = {};
+    queueDesc.stype = ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC;
+    queueDesc.pNext = nullptr;
+    queueDesc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
+    queueDesc.ordinal = 0;
+    queueDesc.index = 0;
+    std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &queueDesc, false, NEO::EngineGroupType::RenderCompute, result));
+
+    auto kernel = new Mock<KernelImp>();
+    kernel->module = module.get();
+    kernel->descriptor.kernelAttributes.flags.usesPrintf = true;
+    kernel->createPrintfBuffer();
+    static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer().push_back(std::shared_ptr<Kernel>{kernel});
+
+    EXPECT_EQ(0u, kernel->printPrintfOutputCalledTimes);
+    ze_group_count_t groupCount{1, 1, 1};
+    CmdListKernelLaunchParams launchParams = {};
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false));
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->hostSynchronize(std::numeric_limits<uint64_t>::max()));
+    EXPECT_EQ(1u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, kernel->destroy());
+    EXPECT_EQ(nullptr, static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer()[0].get());
+}
+
+HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfAndEventAppendedToImmCommandListWithFlushTaskSubmissionAndDestroyKernelAfterListSyncThenSuccessIsReturnedAndEventSyncDoesNotAccessKernel) {
+    DebugManagerStateRestore restorer;
+    NEO::DebugManager.flags.EnableFlushTaskSubmission.set(1);
+
+    ze_result_t result;
+    ze_command_queue_desc_t queueDesc = {};
+    queueDesc.stype = ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC;
+    queueDesc.pNext = nullptr;
+    queueDesc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
+    queueDesc.ordinal = 0;
+    queueDesc.index = 0;
+    std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &queueDesc, false, NEO::EngineGroupType::RenderCompute, result));
+
+    auto kernel = new Mock<KernelImp>();
+    kernel->module = module.get();
+    kernel->descriptor.kernelAttributes.flags.usesPrintf = true;
+    kernel->createPrintfBuffer();
+    static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer().push_back(std::shared_ptr<Kernel>{kernel});
+
+    ze_event_pool_desc_t eventPoolDesc = {};
+    eventPoolDesc.stype = ZE_STRUCTURE_TYPE_EVENT_POOL_DESC;
+    eventPoolDesc.pNext = nullptr;
+    eventPoolDesc.count = 1;
+    eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
+    auto eventPool = std::unique_ptr<::L0::EventPool>(::L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc, result));
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    ze_event_desc_t eventDesc = {};
+    eventDesc.stype = ZE_STRUCTURE_TYPE_EVENT_DESC;
+    eventDesc.pNext = nullptr;
+    eventDesc.index = 0;
+    eventDesc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
+    eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
+    auto event = std::unique_ptr<::L0::Event>(::L0::Event::create<typename FamilyType::TimestampPacketType>(eventPool.get(), &eventDesc, device));
+    auto hEventHandle = event->toHandle();
+
+    EXPECT_EQ(0u, kernel->printPrintfOutputCalledTimes);
+    ze_group_count_t groupCount{1, 1, 1};
+    CmdListKernelLaunchParams launchParams = {};
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, hEventHandle, 0, nullptr, launchParams, false));
+    EXPECT_NE(nullptr, event->getKernelForPrintf().lock().get());
+    EXPECT_NE(nullptr, event->getKernelWithPrintfDeviceMutex());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->hostSynchronize(std::numeric_limits<uint64_t>::max()));
+    *reinterpret_cast<uint32_t *>(event->getHostAddress()) = Event::STATE_SIGNALED;
+    EXPECT_EQ(1u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, kernel->destroy());
+    EXPECT_EQ(nullptr, static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer()[0].get());
+    EXPECT_EQ(nullptr, event->getKernelForPrintf().lock().get());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, event->queryStatus());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, event->hostSynchronize(std::numeric_limits<uint64_t>::max()));
+    EXPECT_EQ(nullptr, event->getKernelWithPrintfDeviceMutex());
+}
+
+HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfAndEventAppendedToImmCommandListWithFlushTaskSubmissionAndDestroyKernelAfterEventSyncThenSuccessIsReturnedAndListSyncDoesNotAccessKernel) {
+    DebugManagerStateRestore restorer;
+    NEO::DebugManager.flags.EnableFlushTaskSubmission.set(1);
+
+    ze_result_t result;
+    ze_command_queue_desc_t queueDesc = {};
+    queueDesc.stype = ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC;
+    queueDesc.pNext = nullptr;
+    queueDesc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
+    queueDesc.ordinal = 0;
+    queueDesc.index = 0;
+    std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &queueDesc, false, NEO::EngineGroupType::RenderCompute, result));
+
+    auto kernel = new Mock<KernelImp>();
+    kernel->module = module.get();
+    kernel->descriptor.kernelAttributes.flags.usesPrintf = true;
+    kernel->createPrintfBuffer();
+    static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer().push_back(std::shared_ptr<Kernel>{kernel});
+
+    ze_event_pool_desc_t eventPoolDesc = {};
+    eventPoolDesc.stype = ZE_STRUCTURE_TYPE_EVENT_POOL_DESC;
+    eventPoolDesc.pNext = nullptr;
+    eventPoolDesc.count = 1;
+    eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
+    auto eventPool = std::unique_ptr<::L0::EventPool>(::L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc, result));
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    ze_event_desc_t eventDesc = {};
+    eventDesc.stype = ZE_STRUCTURE_TYPE_EVENT_DESC;
+    eventDesc.pNext = nullptr;
+    eventDesc.index = 0;
+    eventDesc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
+    eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
+    auto event = std::unique_ptr<::L0::Event>(::L0::Event::create<typename FamilyType::TimestampPacketType>(eventPool.get(), &eventDesc, device));
+    auto hEventHandle = event->toHandle();
+
+    EXPECT_EQ(0u, kernel->printPrintfOutputCalledTimes);
+    ze_group_count_t groupCount{1, 1, 1};
+    CmdListKernelLaunchParams launchParams = {};
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, hEventHandle, 0, nullptr, launchParams, false));
+    EXPECT_NE(nullptr, event->getKernelForPrintf().lock().get());
+    EXPECT_NE(nullptr, event->getKernelWithPrintfDeviceMutex());
+    *reinterpret_cast<uint32_t *>(event->getHostAddress()) = Event::STATE_SIGNALED;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, event->hostSynchronize(std::numeric_limits<uint64_t>::max()));
+    EXPECT_EQ(1u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, kernel->destroy());
+    EXPECT_EQ(nullptr, static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer()[0].get());
+    EXPECT_EQ(nullptr, event->getKernelForPrintf().lock().get());
+    EXPECT_EQ(nullptr, event->getKernelWithPrintfDeviceMutex());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->hostSynchronize(std::numeric_limits<uint64_t>::max()));
+}
+
+HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfAppendedToImmCommandListWithoutFlushTaskSubmissionAndDestroyKernelAfterSynchronizationThenSuccessIsReturned) {
+    DebugManagerStateRestore restorer;
+    NEO::DebugManager.flags.EnableFlushTaskSubmission.set(0);
+
+    ze_result_t result;
+    ze_command_queue_desc_t queueDesc = {};
+    queueDesc.stype = ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC;
+    queueDesc.pNext = nullptr;
+    queueDesc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
+    queueDesc.ordinal = 0;
+    queueDesc.index = 0;
+    std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &queueDesc, false, NEO::EngineGroupType::RenderCompute, result));
+
+    auto kernel = new Mock<KernelImp>();
+    kernel->module = module.get();
+    kernel->descriptor.kernelAttributes.flags.usesPrintf = true;
+    kernel->createPrintfBuffer();
+    static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer().push_back(std::shared_ptr<Kernel>{kernel});
+
+    EXPECT_EQ(0u, kernel->printPrintfOutputCalledTimes);
+    ze_group_count_t groupCount{1, 1, 1};
+    CmdListKernelLaunchParams launchParams = {};
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams, false));
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->hostSynchronize(std::numeric_limits<uint64_t>::max()));
+    EXPECT_EQ(1u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, kernel->destroy());
+    EXPECT_EQ(nullptr, static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer()[0].get());
+}
+
+HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfAndEventAppendedToImmCommandListWithoutFlushTaskSubmissionAndDestroyKernelAfterListSyncThenSuccessIsReturnedAndEventSyncDoesNotAccessKernel) {
+    DebugManagerStateRestore restorer;
+    NEO::DebugManager.flags.EnableFlushTaskSubmission.set(0);
+
+    ze_result_t result;
+    ze_command_queue_desc_t queueDesc = {};
+    queueDesc.stype = ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC;
+    queueDesc.pNext = nullptr;
+    queueDesc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
+    queueDesc.ordinal = 0;
+    queueDesc.index = 0;
+    std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &queueDesc, false, NEO::EngineGroupType::RenderCompute, result));
+
+    auto kernel = new Mock<KernelImp>();
+    kernel->module = module.get();
+    kernel->descriptor.kernelAttributes.flags.usesPrintf = true;
+    kernel->createPrintfBuffer();
+    static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer().push_back(std::shared_ptr<Kernel>{kernel});
+
+    ze_event_pool_desc_t eventPoolDesc = {};
+    eventPoolDesc.stype = ZE_STRUCTURE_TYPE_EVENT_POOL_DESC;
+    eventPoolDesc.pNext = nullptr;
+    eventPoolDesc.count = 1;
+    eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
+    auto eventPool = std::unique_ptr<::L0::EventPool>(::L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc, result));
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    ze_event_desc_t eventDesc = {};
+    eventDesc.stype = ZE_STRUCTURE_TYPE_EVENT_DESC;
+    eventDesc.pNext = nullptr;
+    eventDesc.index = 0;
+    eventDesc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
+    eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
+    auto event = std::unique_ptr<::L0::Event>(::L0::Event::create<typename FamilyType::TimestampPacketType>(eventPool.get(), &eventDesc, device));
+    auto hEventHandle = event->toHandle();
+
+    EXPECT_EQ(0u, kernel->printPrintfOutputCalledTimes);
+    ze_group_count_t groupCount{1, 1, 1};
+    CmdListKernelLaunchParams launchParams = {};
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, hEventHandle, 0, nullptr, launchParams, false));
+    EXPECT_NE(nullptr, event->getKernelForPrintf().lock().get());
+    EXPECT_NE(nullptr, event->getKernelWithPrintfDeviceMutex());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, commandList->hostSynchronize(std::numeric_limits<uint64_t>::max()));
+    *reinterpret_cast<uint32_t *>(event->getHostAddress()) = Event::STATE_SIGNALED;
+    EXPECT_EQ(1u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, kernel->destroy());
+    EXPECT_EQ(nullptr, static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer()[0].get());
+    EXPECT_EQ(nullptr, event->getKernelForPrintf().lock().get());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, event->queryStatus());
+    EXPECT_EQ(ZE_RESULT_SUCCESS, event->hostSynchronize(std::numeric_limits<uint64_t>::max()));
+    EXPECT_EQ(nullptr, event->getKernelWithPrintfDeviceMutex());
 }
 
 HWTEST_F(CommandListAppendLaunchKernel, WhenAppendingMultipleTimesThenSshIsNotDepletedButReallocated) {

level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_3.cpp

@@ -266,7 +266,8 @@ HWTEST2_F(CommandListAppendLaunchKernel, givenImmediateCommandListWhenAppendingL
 
 HWTEST2_F(CommandListAppendLaunchKernel, givenNonemptyAllocPrintfBufferKernelWhenAppendingLaunchKernelIndirectThenKernelIsStoredOnEvent, IsAtLeastSkl) {
     Mock<Module> module(this->device, nullptr);
-    Mock<::L0::KernelImp> kernel;
+    std::shared_ptr<Mock<::L0::KernelImp>> kernel{new Mock<::L0::KernelImp>()};
+    static_cast<ModuleImp *>(&module)->getPrintfKernelContainer().push_back(kernel);
 
     ze_result_t returnValue;
     std::unique_ptr<L0::CommandList> commandList(L0::CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
@@ -274,9 +275,9 @@ HWTEST2_F(CommandListAppendLaunchKernel, givenNonemptyAllocPrintfBufferKernelWhe
     eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
     eventPoolDesc.count = 1;
 
-    kernel.module = &module;
-    kernel.descriptor.kernelAttributes.flags.usesPrintf = true;
-    kernel.createPrintfBuffer();
+    kernel->module = &module;
+    kernel->descriptor.kernelAttributes.flags.usesPrintf = true;
+    kernel->createPrintfBuffer();
 
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
@@ -286,15 +287,15 @@ HWTEST2_F(CommandListAppendLaunchKernel, givenNonemptyAllocPrintfBufferKernelWhe
     auto event = std::unique_ptr<Event>(Event::create<typename FamilyType::TimestampPacketType>(eventPool.get(), &eventDesc, device));
 
     ze_group_count_t groupCount{1, 1, 1};
-    auto result = commandList->appendLaunchKernelIndirect(kernel.toHandle(), &groupCount, event->toHandle(), 0, nullptr, false);
+    auto result = commandList->appendLaunchKernelIndirect(kernel->toHandle(), &groupCount, event->toHandle(), 0, nullptr, false);
     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
 
-    ASSERT_NE(nullptr, event->getKernelForPrintf());
+    ASSERT_FALSE(event->getKernelForPrintf().expired());
 }
 
 HWTEST2_F(CommandListAppendLaunchKernel, givenEmptyAllocPrintfBufferKernelWhenAppendingLaunchKernelIndirectThenKernelIsNotStoredOnEvent, IsAtLeastSkl) {
     Mock<Module> module(this->device, nullptr);
-    Mock<::L0::KernelImp> kernel;
+    std::shared_ptr<Mock<::L0::KernelImp>> kernel{new Mock<::L0::KernelImp>()};
 
     ze_result_t returnValue;
     std::unique_ptr<L0::CommandList> commandList(L0::CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
@@ -302,8 +303,8 @@ HWTEST2_F(CommandListAppendLaunchKernel, givenEmptyAllocPrintfBufferKernelWhenAp
     eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
     eventPoolDesc.count = 1;
 
-    kernel.module = &module;
-    kernel.descriptor.kernelAttributes.flags.usesPrintf = false;
+    kernel->module = &module;
+    kernel->descriptor.kernelAttributes.flags.usesPrintf = false;
 
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
@@ -313,24 +314,25 @@ HWTEST2_F(CommandListAppendLaunchKernel, givenEmptyAllocPrintfBufferKernelWhenAp
     auto event = std::unique_ptr<Event>(Event::create<typename FamilyType::TimestampPacketType>(eventPool.get(), &eventDesc, device));
 
     ze_group_count_t groupCount{1, 1, 1};
-    auto result = commandList->appendLaunchKernelIndirect(kernel.toHandle(), &groupCount, event->toHandle(), 0, nullptr, false);
+    auto result = commandList->appendLaunchKernelIndirect(kernel->toHandle(), &groupCount, event->toHandle(), 0, nullptr, false);
     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
 
-    ASSERT_EQ(nullptr, event->getKernelForPrintf());
+    ASSERT_TRUE(event->getKernelForPrintf().expired());
 }
 
 HWTEST2_F(CommandListAppendLaunchKernel, givenNonemptyAllocPrintfBufferKernelWhenAppendingLaunchKernelWithParamThenKernelIsStoredOnEvent, IsAtLeastSkl) {
     Mock<Module> module(this->device, nullptr);
-    Mock<::L0::KernelImp> kernel;
+    std::shared_ptr<Mock<::L0::KernelImp>> kernel{new Mock<::L0::KernelImp>()};
+    static_cast<ModuleImp *>(&module)->getPrintfKernelContainer().push_back(kernel);
 
     ze_result_t returnValue;
     ze_event_pool_desc_t eventPoolDesc = {};
     eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
     eventPoolDesc.count = 1;
 
-    kernel.module = &module;
-    kernel.descriptor.kernelAttributes.flags.usesPrintf = true;
-    kernel.createPrintfBuffer();
+    kernel->module = &module;
+    kernel->descriptor.kernelAttributes.flags.usesPrintf = true;
+    kernel->createPrintfBuffer();
 
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
@@ -346,23 +348,23 @@ HWTEST2_F(CommandListAppendLaunchKernel, givenNonemptyAllocPrintfBufferKernelWhe
     auto pCommandList = std::make_unique<WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>>>();
     pCommandList->initialize(device, NEO::EngineGroupType::Compute, 0u);
 
-    auto result = pCommandList->appendLaunchKernelWithParams(&kernel, &groupCount, event.get(), launchParams);
+    auto result = pCommandList->appendLaunchKernelWithParams(kernel.get(), &groupCount, event.get(), launchParams);
     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
 
-    ASSERT_NE(nullptr, event->getKernelForPrintf());
+    ASSERT_FALSE(event->getKernelForPrintf().expired());
 }
 
 HWTEST2_F(CommandListAppendLaunchKernel, givenEmptyAllocPrintfBufferKernelWhenAppendingLaunchKernelWithParamThenKernelIsNotStoredOnEvent, IsAtLeastSkl) {
     Mock<Module> module(this->device, nullptr);
-    Mock<::L0::KernelImp> kernel;
+    std::shared_ptr<Mock<::L0::KernelImp>> kernel{new Mock<::L0::KernelImp>()};
 
     ze_result_t returnValue;
     ze_event_pool_desc_t eventPoolDesc = {};
     eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
     eventPoolDesc.count = 1;
 
-    kernel.module = &module;
-    kernel.descriptor.kernelAttributes.flags.usesPrintf = false;
+    kernel->module = &module;
+    kernel->descriptor.kernelAttributes.flags.usesPrintf = false;
 
     ze_event_desc_t eventDesc = {};
     eventDesc.index = 0;
@@ -378,10 +380,10 @@ HWTEST2_F(CommandListAppendLaunchKernel, givenEmptyAllocPrintfBufferKernelWhenAp
     auto pCommandList = std::make_unique<WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>>>();
     pCommandList->initialize(device, NEO::EngineGroupType::Compute, 0u);
 
-    auto result = pCommandList->appendLaunchKernelWithParams(&kernel, &groupCount, event.get(), launchParams);
+    auto result = pCommandList->appendLaunchKernelWithParams(kernel.get(), &groupCount, event.get(), launchParams);
     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
 
-    ASSERT_EQ(nullptr, event->getKernelForPrintf());
+    ASSERT_TRUE(event->getKernelForPrintf().expired());
 }
 
 HWTEST2_F(CommandListAppendLaunchKernel, givenImmediateCommandListWhenAppendingLaunchKernelIndirectThenKernelIsExecutedOnImmediateCmdQ, IsAtLeastSkl) {

level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_1.cpp

@@ -81,16 +81,17 @@ TEST_F(CommandQueueCreate, whenSynchronizeByPollingTaskCountThenCallsPrintOutput
                                                           false,
                                                           returnValue));
 
-    Mock<KernelImp> kernel1, kernel2;
+    std::shared_ptr<Mock<KernelImp>> kernel1{new Mock<KernelImp>()};
+    std::shared_ptr<Mock<KernelImp>> kernel2{new Mock<KernelImp>()};
 
-    commandQueue->printfKernelContainer.push_back(&kernel1);
-    commandQueue->printfKernelContainer.push_back(&kernel2);
+    commandQueue->printfKernelContainer.push_back(std::weak_ptr<Kernel>{kernel1});
+    commandQueue->printfKernelContainer.push_back(std::weak_ptr<Kernel>{kernel2});
 
     commandQueue->synchronizeByPollingForTaskCount(0u);
 
     EXPECT_EQ(0u, commandQueue->printfKernelContainer.size());
-    EXPECT_EQ(1u, kernel1.printPrintfOutputCalledTimes);
-    EXPECT_EQ(1u, kernel2.printPrintfOutputCalledTimes);
+    EXPECT_EQ(1u, kernel1->printPrintfOutputCalledTimes);
+    EXPECT_EQ(1u, kernel2->printPrintfOutputCalledTimes);
 
     commandQueue->destroy();
 }
@@ -107,20 +108,20 @@ HWTEST_F(CommandQueueCreate, givenPrintfKernelAndDetectedHangWhenSynchronizingBy
                                                           false,
                                                           returnValue));
 
-    Mock<KernelImp> kernel1;
+    std::shared_ptr<Mock<KernelImp>> kernel1{new Mock<KernelImp>()};
     TaskCountType currentTaskCount = 33u;
     auto &csr = neoDevice->getUltCommandStreamReceiver<FamilyType>();
     csr.callBaseWaitForCompletionWithTimeout = false;
     csr.latestWaitForCompletionWithTimeoutTaskCount = currentTaskCount;
     csr.returnWaitForCompletionWithTimeout = WaitStatus::GpuHang;
 
-    commandQueue->printfKernelContainer.push_back(&kernel1);
+    commandQueue->printfKernelContainer.push_back(std::weak_ptr<Kernel>{kernel1});
 
     commandQueue->synchronizeByPollingForTaskCount(0u);
 
     EXPECT_EQ(0u, commandQueue->printfKernelContainer.size());
-    EXPECT_EQ(1u, kernel1.printPrintfOutputCalledTimes);
-    EXPECT_TRUE(kernel1.hangDetectedPassedToPrintfOutput);
+    EXPECT_EQ(1u, kernel1->printPrintfOutputCalledTimes);
+    EXPECT_TRUE(kernel1->hangDetectedPassedToPrintfOutput);
 
     commandQueue->destroy();
 }
@@ -140,18 +141,18 @@ HWTEST_F(CommandQueueCreate, givenPrintfKernelAndDetectedHangWhenSynchronizingTh
                                                           false,
                                                           returnValue));
 
-    Mock<KernelImp> kernel1;
+    std::shared_ptr<Mock<KernelImp>> kernel1{new Mock<KernelImp>()};
     TaskCountType currentTaskCount = 33u;
     auto &csr = neoDevice->getUltCommandStreamReceiver<FamilyType>();
     csr.latestWaitForCompletionWithTimeoutTaskCount = currentTaskCount;
     csr.waitForTaskCountWithKmdNotifyFallbackReturnValue = WaitStatus::GpuHang;
 
-    commandQueue->printfKernelContainer.push_back(&kernel1);
+    commandQueue->printfKernelContainer.push_back(std::weak_ptr<Kernel>{kernel1});
     commandQueue->synchronize(std::numeric_limits<uint64_t>::max());
 
     EXPECT_EQ(0u, commandQueue->printfKernelContainer.size());
-    EXPECT_EQ(1u, kernel1.printPrintfOutputCalledTimes);
-    EXPECT_TRUE(kernel1.hangDetectedPassedToPrintfOutput);
+    EXPECT_EQ(1u, kernel1->printPrintfOutputCalledTimes);
+    EXPECT_TRUE(kernel1->hangDetectedPassedToPrintfOutput);
 
     commandQueue->destroy();
 }
@@ -325,7 +326,7 @@ HWTEST_F(CommandQueueCreate, given100CmdListsWhenExecutingThenCommandStreamIsNot
                                                           returnValue));
     ASSERT_NE(nullptr, commandQueue);
 
-    Mock<KernelImp> kernel;
+    Mock<::L0::KernelImp> kernel;
     kernel.immutableData.device = device;
 
     auto commandList = std::unique_ptr<CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
@@ -378,7 +379,7 @@ HWTEST2_F(CommandQueueCreate, givenLogicalStateHelperWhenExecutingThenMergeState
     auto ultCsr = static_cast<UltCommandStreamReceiver<FamilyType> *>(commandQueue->getCsr());
     ultCsr->logicalStateHelper.reset(mockCsrLogicalStateHelper);
 
-    Mock<KernelImp> kernel;
+    Mock<::L0::KernelImp> kernel;
     kernel.immutableData.device = device;
 
     auto commandList = std::unique_ptr<L0::ult::CommandList>(whiteboxCast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
@@ -417,7 +418,7 @@ HWTEST2_F(CommandQueueCreate, givenLogicalStateHelperAndImmediateCmdListWhenExec
     auto ultCsr = static_cast<UltCommandStreamReceiver<FamilyType> *>(commandQueue->getCsr());
     ultCsr->logicalStateHelper.reset(mockCsrLogicalStateHelper);
 
-    Mock<KernelImp> kernel;
+    Mock<::L0::KernelImp> kernel;
     kernel.immutableData.device = device;
 
     auto commandList = std::unique_ptr<L0::ult::CommandList>(whiteboxCast(CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::RenderCompute, returnValue)));
@@ -442,7 +443,7 @@ HWTEST2_F(CommandQueueCreate, givenOutOfHostMemoryErrorFromSubmitBatchBufferWhen
     commandQueue->initialize(false, false, false);
     commandQueue->submitBatchBufferReturnValue = NEO::SubmissionStatus::OUT_OF_HOST_MEMORY;
 
-    Mock<KernelImp> kernel;
+    Mock<::L0::KernelImp> kernel;
     kernel.immutableData.device = device;
 
     ze_result_t returnValue;
@@ -466,7 +467,7 @@ HWTEST2_F(CommandQueueCreate, givenGpuHangInReservingLinearStreamWhenExecutingCo
     MockCommandQueueHw<gfxCoreFamily> commandQueue(device, neoDevice->getDefaultEngine().commandStreamReceiver, &desc);
     commandQueue.reserveLinearStreamSizeReturnValue = NEO::WaitStatus::GpuHang;
 
-    Mock<KernelImp> kernel;
+    Mock<::L0::KernelImp> kernel;
     kernel.immutableData.device = device;
 
     ze_result_t returnValue;

level_zero/core/test/unit_tests/sources/event/test_event.cpp

@@ -3569,31 +3569,36 @@ TEST_F(EventTests, GivenResetAllPacketsFalseWhenResetPacketsThenKernelCountAndPa
 TEST_F(EventTests, givenCallToEventQueryStatusWithKernelPointerReturnsCounter) {
     auto event = std::make_unique<MockEventCompletion<uint32_t>>(eventPool.get(), 1u, device);
     Mock<Module> mockModule(this->device, nullptr);
-    Mock<KernelImp> mockKernel;
-    mockKernel.descriptor.kernelAttributes.flags.usesPrintf = true;
-    mockKernel.module = &mockModule;
+    std::shared_ptr<Mock<KernelImp>> mockKernel{new Mock<KernelImp>()};
+    mockKernel->descriptor.kernelAttributes.flags.usesPrintf = true;
+    mockKernel->module = &mockModule;
 
-    event->setKernelForPrintf(&mockKernel);
-    EXPECT_NE(nullptr, event->getKernelForPrintf());
+    std::mutex mockDevicePrintfKernelMutex;
+    event->setKernelForPrintf(std::weak_ptr<Kernel>{mockKernel});
+    event->setKernelWithPrintfDeviceMutex(&mockDevicePrintfKernelMutex);
+    EXPECT_FALSE(event->getKernelForPrintf().expired());
+    EXPECT_NE(nullptr, event->getKernelWithPrintfDeviceMutex());
 
     constexpr uint64_t timeout = std::numeric_limits<std::uint64_t>::max();
     event->hostSynchronize(timeout);
-    EXPECT_EQ(1u, mockKernel.printPrintfOutputCalledTimes);
+    EXPECT_EQ(1u, mockKernel->printPrintfOutputCalledTimes);
 }
 
 TEST_F(EventTests, givenCallToEventQueryStatusWithNullKernelPointerReturnsCounter) {
     auto event = std::make_unique<MockEventCompletion<uint32_t>>(eventPool.get(), 1u, device);
     Mock<Module> mockModule(this->device, nullptr);
-    Mock<KernelImp> mockKernel;
-    mockKernel.descriptor.kernelAttributes.flags.usesPrintf = true;
-    mockKernel.module = &mockModule;
+    std::shared_ptr<Mock<KernelImp>> mockKernel{new Mock<KernelImp>()};
+    mockKernel->descriptor.kernelAttributes.flags.usesPrintf = true;
+    mockKernel->module = &mockModule;
 
-    event->setKernelForPrintf(nullptr);
-    EXPECT_EQ(nullptr, event->getKernelForPrintf());
+    event->resetKernelForPrintf();
+    event->resetKernelWithPrintfDeviceMutex();
+    EXPECT_TRUE(event->getKernelForPrintf().expired());
+    EXPECT_EQ(nullptr, event->getKernelWithPrintfDeviceMutex());
 
     constexpr uint64_t timeout = std::numeric_limits<std::uint64_t>::max();
     event->hostSynchronize(timeout);
-    EXPECT_EQ(0u, mockKernel.printPrintfOutputCalledTimes);
+    EXPECT_EQ(0u, mockKernel->printPrintfOutputCalledTimes);
 }
 
 TEST_F(EventSynchronizeTest, whenEventSetCsrThenCorrectCsrSet) {

level_zero/core/test/unit_tests/sources/fence/test_fence.cpp

@@ -364,13 +364,13 @@ HWTEST_F(FenceTest, givenPrintfKernelWhenSynchronizingFenceThenPrintPrintfOutput
                                                           false,
                                                           false,
                                                           returnValue));
-    Mock<KernelImp> kernel;
+    std::shared_ptr<Mock<KernelImp>> kernel{new Mock<KernelImp>()};
     TaskCountType currentTaskCount = 33u;
     auto &csr = neoDevice->getUltCommandStreamReceiver<FamilyType>();
     csr.returnWaitForCompletionWithTimeout = WaitStatus::Ready;
     csr.latestWaitForCompletionWithTimeoutTaskCount = currentTaskCount;
     *csr.tagAddress = currentTaskCount;
-    commandQueue->printfKernelContainer.push_back(&kernel);
+    commandQueue->printfKernelContainer.push_back(std::weak_ptr<Kernel>{kernel});
 
     ze_fence_desc_t fenceDesc = {ZE_STRUCTURE_TYPE_FENCE_DESC,
                                  nullptr,
@@ -382,8 +382,8 @@ HWTEST_F(FenceTest, givenPrintfKernelWhenSynchronizingFenceThenPrintPrintfOutput
     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
 
     EXPECT_EQ(0u, commandQueue->printfKernelContainer.size());
-    EXPECT_EQ(1u, kernel.printPrintfOutputCalledTimes);
-    EXPECT_FALSE(kernel.hangDetectedPassedToPrintfOutput);
+    EXPECT_EQ(1u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_FALSE(kernel->hangDetectedPassedToPrintfOutput);
 
     delete fence;
 
@@ -407,14 +407,14 @@ HWTEST_F(FenceTest, givenPrintfKernelAndDetectedHangWhenSynchronizingFenceThenPr
                                                           false,
                                                           returnValue));
 
-    Mock<KernelImp> kernel;
+    std::shared_ptr<Mock<KernelImp>> kernel{new Mock<KernelImp>()};
     TaskCountType currentTaskCount = 33u;
     auto &csr = neoDevice->getUltCommandStreamReceiver<FamilyType>();
     csr.latestWaitForCompletionWithTimeoutTaskCount = currentTaskCount;
     csr.returnWaitForCompletionWithTimeout = WaitStatus::GpuHang;
     *csr.tagAddress = 0;
     csr.gpuHangCheckPeriod = 0us;
-    commandQueue->printfKernelContainer.push_back(&kernel);
+    commandQueue->printfKernelContainer.push_back(std::weak_ptr<Kernel>{kernel});
 
     ze_fence_desc_t fenceDesc = {ZE_STRUCTURE_TYPE_FENCE_DESC,
                                  nullptr,
@@ -426,8 +426,8 @@ HWTEST_F(FenceTest, givenPrintfKernelAndDetectedHangWhenSynchronizingFenceThenPr
     EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, result);
 
     EXPECT_EQ(0u, commandQueue->printfKernelContainer.size());
-    EXPECT_EQ(1u, kernel.printPrintfOutputCalledTimes);
-    EXPECT_TRUE(kernel.hangDetectedPassedToPrintfOutput);
+    EXPECT_EQ(1u, kernel->printPrintfOutputCalledTimes);
+    EXPECT_TRUE(kernel->hangDetectedPassedToPrintfOutput);
 
     delete fence;
     commandQueue->destroy();
@@ -444,14 +444,14 @@ HWTEST_F(FenceTest, givenPrintfKernelNotCompletedWhenSynchronizingFenceWithZeroT
                                                           false,
                                                           false,
                                                           returnValue));
-    Mock<KernelImp> kernel;
+    std::shared_ptr<Mock<KernelImp>> kernel{new Mock<KernelImp>()};
     TaskCountType currentTaskCount = 33u;
     auto &csr = neoDevice->getUltCommandStreamReceiver<FamilyType>();
     csr.returnWaitForCompletionWithTimeout = WaitStatus::Ready;
     csr.latestWaitForCompletionWithTimeoutTaskCount = currentTaskCount;
     *csr.tagAddress = currentTaskCount - 1;
 
-    commandQueue->printfKernelContainer.push_back(&kernel);
+    commandQueue->printfKernelContainer.push_back(std::weak_ptr<Kernel>{kernel});
 
     ze_fence_desc_t fenceDesc = {ZE_STRUCTURE_TYPE_FENCE_DESC,
                                  nullptr,
@@ -463,7 +463,7 @@ HWTEST_F(FenceTest, givenPrintfKernelNotCompletedWhenSynchronizingFenceWithZeroT
     EXPECT_EQ(ZE_RESULT_NOT_READY, result);
 
     EXPECT_EQ(1u, commandQueue->printfKernelContainer.size());
-    EXPECT_EQ(0u, kernel.printPrintfOutputCalledTimes);
+    EXPECT_EQ(0u, kernel->printPrintfOutputCalledTimes);
 
     delete fence;
     commandQueue->destroy();

level_zero/core/test/unit_tests/sources/kernel/test_kernel.cpp

@@ -2838,6 +2838,40 @@ TEST_F(KernelPrintHandlerTest, whenPrintPrintfOutputIsCalledThenPrintfBufferIsUs
     EXPECT_EQ(buffer, MyPrintfHandler::getPrintfSurfaceInitialDataSize());
 }
 
+using PrintfKernelOwnershipTest = Test<ModuleFixture>;
+
+TEST_F(PrintfKernelOwnershipTest, givenKernelWithPrintfThenTheModuleStoresItCorrectly) {
+    ze_kernel_handle_t kernelHandle;
+    ze_kernel_desc_t kernelDesc = {};
+    kernelDesc.pKernelName = kernelName.c_str();
+    EXPECT_EQ(ZE_RESULT_SUCCESS, module->createKernel(&kernelDesc, &kernelHandle));
+
+    auto kernel = static_cast<Mock<KernelImp> *>(L0::Kernel::fromHandle(kernelHandle));
+    EXPECT_NE(nullptr, kernel->getPrintfBufferAllocation());
+    EXPECT_NE(nullptr, kernel->getDevicePrintfKernelMutex());
+    EXPECT_EQ(1u, static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer().size());
+    EXPECT_EQ(kernel, static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer()[0].get());
+}
+
+TEST_F(PrintfKernelOwnershipTest, givenKernelWithPrintfDestroyedFirstThenModuleDestructionReturnsTheCorrectStatus) {
+    ze_kernel_handle_t kernelHandle;
+    ze_kernel_desc_t kernelDesc = {};
+    kernelDesc.pKernelName = kernelName.c_str();
+    EXPECT_EQ(ZE_RESULT_SUCCESS, module->createKernel(&kernelDesc, &kernelHandle));
+
+    auto kernel = static_cast<Mock<KernelImp> *>(L0::Kernel::fromHandle(kernelHandle));
+    EXPECT_NE(nullptr, kernel->getPrintfBufferAllocation());
+    EXPECT_NE(nullptr, kernel->getDevicePrintfKernelMutex());
+    EXPECT_EQ(1u, static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer().size());
+    EXPECT_EQ(kernel, static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer()[0].get());
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, kernel->destroy());
+
+    EXPECT_EQ(1u, static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer().size());
+    EXPECT_EQ(nullptr, static_cast<ModuleImp *>(module.get())->getPrintfKernelContainer()[0].get());
+    EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, static_cast<ModuleImp *>(module.get())->destroyPrintfKernel(kernelHandle));
+}
+
 using PrintfTest = Test<DeviceFixture>;
 
 TEST_F(PrintfTest, givenKernelWithPrintfThenPrintfBufferIsCreated) {