refactor: use Clonable type for pImplicitArgs

Clonable is a helper type which eases proper management of
dynamically-allocated resources. It allows to reduce the amount of
manual handling.

Related-To: NEO-16017
Signed-off-by: Maciej Bielski <maciej.bielski@intel.com>

Author: MaciejBielski

level_zero/core/source/kernel/kernel_imp.cpp

@@ -246,10 +246,9 @@ void KernelImmutableData::setIsaPerKernelAllocation(NEO::GraphicsAllocation *all
     this->isaGraphicsAllocation.reset(allocation);
 }
 
-KernelMutableState::KernelMutableState() : pImplicitArgs{nullptr}, pExtension{nullptr} {};
+KernelMutableState::KernelMutableState() : pImplicitArgs{}, pExtension{nullptr} {};
 
-KernelMutableState::KernelMutableState(const KernelMutableState &rhs) : Params{rhs} {
-    pImplicitArgs = (rhs.pImplicitArgs) ? std::make_unique<NEO::ImplicitArgs>(*rhs.pImplicitArgs) : nullptr;
+KernelMutableState::KernelMutableState(const KernelMutableState &rhs) : Params{rhs}, pImplicitArgs(rhs.pImplicitArgs) {
     pExtension = nullptr;
 
     crossThreadData = rhs.crossThreadData;
@@ -1233,8 +1232,7 @@ ze_result_t KernelImp::initialize(const ze_kernel_desc_t *desc) {
     }
 
     if (kernelDescriptor.kernelAttributes.flags.requiresImplicitArgs) {
-        privateState.pImplicitArgs = std::make_unique<NEO::ImplicitArgs>();
-        *privateState.pImplicitArgs = {};
+        privateState.pImplicitArgs = Clonable(new NEO::ImplicitArgs());
         privateState.pImplicitArgs->initializeHeader(sharedState.implicitArgsVersion);
         privateState.pImplicitArgs->setSimdWidth(kernelDescriptor.kernelAttributes.simdSize);
     }

level_zero/core/source/kernel/kernel_imp.h

@@ -206,7 +206,7 @@ struct KernelImp : Kernel {
 
     ze_result_t setSchedulingHintExp(ze_scheduling_hint_exp_desc_t *pHint) override;
 
-    NEO::ImplicitArgs *getImplicitArgs() const override { return privateState.pImplicitArgs.get(); }
+    NEO::ImplicitArgs *getImplicitArgs() const override { return privateState.pImplicitArgs.ptr.get(); }
 
     uint32_t getMaxWgCountPerTile(NEO::EngineGroupType engineGroupType) const override {
         auto value = this->sharedState->maxWgCountPerTileCcs;

level_zero/core/source/kernel/kernel_mutable_state.h

@@ -9,6 +9,7 @@
 
 #include "shared/source/helpers/vec.h"
 #include "shared/source/unified_memory/unified_memory.h"
+#include "shared/source/utilities/mem_lifetime.h"
 
 #include "level_zero/ze_api.h"
 
@@ -89,7 +90,7 @@ struct KernelMutableState : public KernelMutableStateDefaultCopyableParams {
 
     void reservePerThreadDataForWholeThreadGroup(uint32_t sizeNeeded);
 
-    std::unique_ptr<NEO::ImplicitArgs> pImplicitArgs;
+    Clonable<NEO::ImplicitArgs> pImplicitArgs;
     std::unique_ptr<KernelExt> pExtension;
     std::vector<uint8_t> crossThreadData{};
     std::vector<uint8_t> surfaceStateHeapData{};

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

@@ -13,6 +13,7 @@
 #include "shared/source/helpers/register_offsets.h"
 #include "shared/source/indirect_heap/indirect_heap.h"
 #include "shared/source/kernel/implicit_args_helper.h"
+#include "shared/source/utilities/mem_lifetime.h"
 #include "shared/test/common/cmd_parse/gen_cmd_parse.h"
 #include "shared/test/common/helpers/debug_manager_state_restore.h"
 #include "shared/test/common/helpers/unit_test_helper.h"
@@ -307,7 +308,7 @@ HWTEST_F(CommandListAppendLaunchKernel, givenNonPrintfKernelWithPrintfBufferCrea
     kernel->setModule(&module);
     kernel->descriptor.kernelAttributes.flags.usesPrintf = false;
     kernel->descriptor.kernelAttributes.flags.useStackCalls = true;
-    kernel->privateState.pImplicitArgs.reset(new ImplicitArgs());
+    kernel->privateState.pImplicitArgs = Clonable(new ImplicitArgs());
     kernel->privateState.pImplicitArgs->v0.header.structVersion = 0;
     kernel->privateState.pImplicitArgs->v0.header.structSize = ImplicitArgsV0::getSize();
     UnitTestHelper<FamilyType>::adjustKernelDescriptorForImplicitArgs(*kernel->immutableData.kernelDescriptor);
@@ -409,7 +410,7 @@ HWTEST_F(CommandListAppendLaunchKernel, givenNonPrintfKernelAndPrintfBufferForSt
     kernel->setModule(&module);
     kernel->descriptor.kernelAttributes.flags.usesPrintf = false;
     kernel->descriptor.kernelAttributes.flags.useStackCalls = true;
-    kernel->privateState.pImplicitArgs.reset(new ImplicitArgs());
+    kernel->privateState.pImplicitArgs = Clonable(new ImplicitArgs());
     kernel->privateState.pImplicitArgs->v0.header.structVersion = 0;
     kernel->privateState.pImplicitArgs->v0.header.structSize = ImplicitArgsV0::getSize();
     UnitTestHelper<FamilyType>::adjustKernelDescriptorForImplicitArgs(*kernel->immutableData.kernelDescriptor);
@@ -1236,7 +1237,7 @@ struct CommandListAppendLaunchKernelWithImplicitArgs : CommandListAppendLaunchKe
         if (FamilyType::supportsCmdSet(IGFX_XE_HP_CORE)) {
             const auto &rootDeviceEnvironment = device->getNEODevice()->getRootDeviceEnvironment();
             auto implicitArgsProgrammingSize =
-                ImplicitArgsHelper::getSizeForImplicitArgsPatching(kernel.privateState.pImplicitArgs.get(),
+                ImplicitArgsHelper::getSizeForImplicitArgsPatching(kernel.getImplicitArgs(),
                                                                    kernel.getKernelDescriptor(),
                                                                    !kernel.privateState.kernelRequiresGenerationOfLocalIdsByRuntime,
                                                                    rootDeviceEnvironment);
@@ -1257,7 +1258,7 @@ HWTEST_F(CommandListAppendLaunchKernelWithImplicitArgs, givenIndirectDispatchWit
     auto pMockModule = std::unique_ptr<Module>(new Mock<Module>(device, nullptr));
     kernel.module = pMockModule.get();
     kernel.immutableData.crossThreadDataSize = sizeof(uint64_t);
-    kernel.privateState.pImplicitArgs.reset(new ImplicitArgs());
+    kernel.privateState.pImplicitArgs = Clonable(new ImplicitArgs());
     kernel.privateState.pImplicitArgs->v0.header.structVersion = 0;
     kernel.privateState.pImplicitArgs->v0.header.structSize = ImplicitArgsV0::getSize();
     kernel.privateState.pImplicitArgs->setLocalSize(1, 1, 1);

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

@@ -10,6 +10,7 @@
 #include "shared/source/helpers/gfx_core_helper.h"
 #include "shared/source/helpers/local_id_gen.h"
 #include "shared/source/helpers/simd_helper.h"
+#include "shared/source/utilities/mem_lifetime.h"
 #include "shared/test/common/helpers/raii_gfx_core_helper.h"
 #include "shared/test/common/helpers/stream_capture.h"
 #include "shared/test/common/mocks/mock_bindless_heaps_helper.h"
@@ -78,7 +79,7 @@ TEST_F(KernelImpTest, GivenKernelMutableStateWhenAssigningToItselfThenTheCurrent
 
 void fillKernelMutableStateWithMockData(KernelMutableState &state) {
     state.unifiedMemoryControls = {true, true, true};
-    state.pImplicitArgs.reset(new ImplicitArgs{});
+    state.pImplicitArgs.ptr.reset(new ImplicitArgs{});
     state.pImplicitArgs->v0 = ImplicitArgsV0{
         .numWorkDim = 2,
         .simdWidth = 4,

shared/source/utilities/mem_lifetime.h

@@ -88,7 +88,7 @@ struct Ext : Impl::UniquePtrWrapperOps<Ext<T>> {
 };
 
 template <typename T>
-struct Clonable : Impl::UniquePtrWrapperOps<Clonable<Ext<T>>> {
+struct Clonable : Impl::UniquePtrWrapperOps<Clonable<T>> {
     Clonable(T *ptr) : ptr(ptr) {}
     Clonable() = default;
     Clonable(const Clonable &rhs) {