diff --git a/opencl/source/kernel/kernel.cpp b/opencl/source/kernel/kernel.cpp
index 7d33e556ae..5217e96302 100644
--- a/opencl/source/kernel/kernel.cpp
+++ b/opencl/source/kernel/kernel.cpp
@@ -64,17 +64,17 @@ class Surface;
 
 uint32_t Kernel::dummyPatchLocation = 0xbaddf00d;
 
-Kernel::Kernel(Program *programArg, const KernelInfo &kernelInfoArg, const ClDevice &deviceArg, bool schedulerKernel)
+Kernel::Kernel(Program *programArg, const KernelInfo &kernelInfoArg, bool schedulerKernel)
     : slmTotalSize(kernelInfoArg.workloadInfo.slmStaticSize),
       isParentKernel((kernelInfoArg.patchInfo.executionEnvironment != nullptr) ? (kernelInfoArg.patchInfo.executionEnvironment->HasDeviceEnqueue != 0) : false),
       isSchedulerKernel(schedulerKernel),
       program(programArg),
-      device(deviceArg),
+      deviceVector(programArg->getDevices()),
       kernelInfo(kernelInfoArg) {
     program->retain();
     imageTransformer.reset(new ImageTransformer);
 
-    maxKernelWorkGroupSize = static_cast<uint32_t>(device.getSharedDeviceInfo().maxWorkGroupSize);
+    maxKernelWorkGroupSize = static_cast<uint32_t>(deviceVector[0]->getSharedDeviceInfo().maxWorkGroupSize);
 }
 
 Kernel::~Kernel() {
@@ -166,7 +166,7 @@ cl_int Kernel::initialize() {
         const auto &patchInfo = kernelInfo.patchInfo;
 
         reconfigureKernel();
-        auto &hwInfo = device.getHardwareInfo();
+        auto &hwInfo = getDevice().getHardwareInfo();
         auto &hwHelper = HwHelper::get(hwInfo.platform.eRenderCoreFamily);
         auto maxSimdSize = getKernelInfo().getMaxSimdSize();
 
@@ -240,15 +240,16 @@ cl_int Kernel::initialize() {
         // patch crossthread data and ssh with inline surfaces, if necessary
         auto perHwThreadPrivateMemorySize = PatchTokenBinary::getPerHwThreadPrivateSurfaceSize(patchInfo.pAllocateStatelessPrivateSurface, getKernelInfo().getMaxSimdSize());
 
+        auto rootDeviceIndex = getDevice().getRootDeviceIndex();
         if (perHwThreadPrivateMemorySize) {
-            privateSurfaceSize = KernelHelper::getPrivateSurfaceSize(perHwThreadPrivateMemorySize, device.getSharedDeviceInfo().computeUnitsUsedForScratch);
+            privateSurfaceSize = KernelHelper::getPrivateSurfaceSize(perHwThreadPrivateMemorySize, getDevice().getSharedDeviceInfo().computeUnitsUsedForScratch);
 
             DEBUG_BREAK_IF(privateSurfaceSize == 0);
             if (privateSurfaceSize > std::numeric_limits<uint32_t>::max()) {
                 retVal = CL_OUT_OF_RESOURCES;
                 break;
             }
-            privateSurface = device.getMemoryManager()->allocateGraphicsMemoryWithProperties({device.getRootDeviceIndex(), static_cast<size_t>(privateSurfaceSize), GraphicsAllocation::AllocationType::PRIVATE_SURFACE, device.getDeviceBitfield()});
+            privateSurface = getDevice().getMemoryManager()->allocateGraphicsMemoryWithProperties({rootDeviceIndex, static_cast<size_t>(privateSurfaceSize), GraphicsAllocation::AllocationType::PRIVATE_SURFACE, getDevice().getDeviceBitfield()});
             if (privateSurface == nullptr) {
                 retVal = CL_OUT_OF_RESOURCES;
                 break;
@@ -256,7 +257,6 @@ cl_int Kernel::initialize() {
             const auto &patch = patchInfo.pAllocateStatelessPrivateSurface;
             patchWithImplicitSurface(reinterpret_cast<void *>(privateSurface->getGpuAddressToPatch()), *privateSurface, *patch);
         }
-        auto rootDeviceIndex = device.getRootDeviceIndex();
         if (patchInfo.pAllocateStatelessConstantMemorySurfaceWithInitialization) {
             DEBUG_BREAK_IF(program->getConstantSurface(rootDeviceIndex) == nullptr);
             uintptr_t constMemory = isBuiltIn ? (uintptr_t)program->getConstantSurface(rootDeviceIndex)->getUnderlyingBuffer() : (uintptr_t)program->getConstantSurface(rootDeviceIndex)->getGpuAddressToPatch();
@@ -357,7 +357,7 @@ cl_int Kernel::initialize() {
         }
 
         if (isParentKernel) {
-            program->allocateBlockPrivateSurfaces(device);
+            program->allocateBlockPrivateSurfaces(getDevice());
         }
 
         if (program->isKernelDebugEnabled() && getKernelInfo().patchInfo.pAllocateSystemThreadSurface) {
@@ -631,7 +631,7 @@ cl_int Kernel::getSubGroupInfo(cl_kernel_sub_group_info paramName,
     if ((paramName == CL_KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT) ||
         (paramName == CL_KERNEL_MAX_NUM_SUB_GROUPS) ||
         (paramName == CL_KERNEL_COMPILE_NUM_SUB_GROUPS)) {
-        if (device.areOcl21FeaturesEnabled() == false) {
+        if (getDevice().areOcl21FeaturesEnabled() == false) {
             return CL_INVALID_OPERATION;
         }
     }
@@ -646,7 +646,7 @@ cl_int Kernel::getSubGroupInfo(cl_kernel_sub_group_info paramName,
         }
         numDimensions = inputValueSize / sizeof(size_t);
         if (numDimensions == 0 ||
-            numDimensions > static_cast<size_t>(device.getDeviceInfo().maxWorkItemDimensions)) {
+            numDimensions > static_cast<size_t>(getDevice().getDeviceInfo().maxWorkItemDimensions)) {
             return CL_INVALID_VALUE;
         }
     }
@@ -660,7 +660,7 @@ cl_int Kernel::getSubGroupInfo(cl_kernel_sub_group_info paramName,
         }
         numDimensions = paramValueSize / sizeof(size_t);
         if (numDimensions == 0 ||
-            numDimensions > static_cast<size_t>(device.getDeviceInfo().maxWorkItemDimensions)) {
+            numDimensions > static_cast<size_t>(getDevice().getDeviceInfo().maxWorkItemDimensions)) {
             return CL_INVALID_VALUE;
         }
     }
@@ -735,7 +735,7 @@ void Kernel::substituteKernelHeap(void *newKernelHeap, size_t newKernelHeapSize)
     auto &heapInfo = pKernelInfo->heapInfo;
     heapInfo.KernelHeapSize = static_cast<uint32_t>(newKernelHeapSize);
     pKernelInfo->isKernelHeapSubstituted = true;
-    auto memoryManager = device.getMemoryManager();
+    auto memoryManager = getDevice().getMemoryManager();
 
     auto currentAllocationSize = pKernelInfo->kernelAllocation->getUnderlyingBufferSize();
     bool status = false;
@@ -744,7 +744,7 @@ void Kernel::substituteKernelHeap(void *newKernelHeap, size_t newKernelHeapSize)
     } else {
         memoryManager->checkGpuUsageAndDestroyGraphicsAllocations(pKernelInfo->kernelAllocation);
         pKernelInfo->kernelAllocation = nullptr;
-        status = pKernelInfo->createKernelAllocation(device.getDevice());
+        status = pKernelInfo->createKernelAllocation(getDevice().getDevice());
     }
     UNRECOVERABLE_IF(!status);
 }
@@ -1053,7 +1053,7 @@ inline void Kernel::makeArgsResident(CommandStreamReceiver &commandStreamReceive
         if (kernelArguments[argIndex].object) {
             if (kernelArguments[argIndex].type == SVM_ALLOC_OBJ) {
                 auto pSVMAlloc = (GraphicsAllocation *)kernelArguments[argIndex].object;
-                auto pageFaultManager = device.getMemoryManager()->getPageFaultManager();
+                auto pageFaultManager = getDevice().getMemoryManager()->getPageFaultManager();
                 if (pageFaultManager &&
                     this->isUnifiedMemorySyncRequired) {
                     pageFaultManager->moveAllocationToGpuDomain(reinterpret_cast<void *>(pSVMAlloc->getGpuAddress()));
@@ -1076,7 +1076,7 @@ inline void Kernel::makeArgsResident(CommandStreamReceiver &commandStreamReceive
 }
 
 void Kernel::makeResident(CommandStreamReceiver &commandStreamReceiver) {
-    auto rootDeviceIndex = device.getRootDeviceIndex();
+    auto rootDeviceIndex = getDevice().getRootDeviceIndex();
     if (privateSurface) {
         commandStreamReceiver.makeResident(*privateSurface);
     }
@@ -1126,7 +1126,7 @@ void Kernel::makeResident(CommandStreamReceiver &commandStreamReceiver) {
 }
 
 void Kernel::getResidency(std::vector<Surface *> &dst) {
-    auto rootDeviceIndex = device.getRootDeviceIndex();
+    auto rootDeviceIndex = getDevice().getRootDeviceIndex();
     if (privateSurface) {
         GeneralSurface *surface = new GeneralSurface(privateSurface);
         dst.push_back(surface);
@@ -1632,7 +1632,7 @@ void Kernel::unsetArg(uint32_t argIndex) {
 
 void Kernel::createReflectionSurface() {
     if (this->isParentKernel && kernelReflectionSurface == nullptr) {
-        auto &hwInfo = device.getHardwareInfo();
+        auto &hwInfo = getDevice().getHardwareInfo();
         auto &hwHelper = HwHelper::get(hwInfo.platform.eRenderCoreFamily);
         BlockKernelManager *blockManager = program->getBlockKernelManager();
         uint32_t blockCount = static_cast<uint32_t>(blockManager->getCount());
@@ -1678,7 +1678,7 @@ void Kernel::createReflectionSurface() {
         kernelReflectionSize += blockCount * alignUp(maxConstantBufferSize, sizeof(void *));
         kernelReflectionSize += parentImageCount * sizeof(IGIL_ImageParamters);
         kernelReflectionSize += parentSamplerCount * sizeof(IGIL_ParentSamplerParams);
-        kernelReflectionSurface = device.getMemoryManager()->allocateGraphicsMemoryWithProperties({device.getRootDeviceIndex(), kernelReflectionSize, GraphicsAllocation::AllocationType::DEVICE_QUEUE_BUFFER, device.getDeviceBitfield()});
+        kernelReflectionSurface = getDevice().getMemoryManager()->allocateGraphicsMemoryWithProperties({getDevice().getRootDeviceIndex(), kernelReflectionSize, GraphicsAllocation::AllocationType::DEVICE_QUEUE_BUFFER, getDevice().getDeviceBitfield()});
 
         for (uint32_t i = 0; i < blockCount; i++) {
             const KernelInfo *pBlockInfo = blockManager->getBlockKernelInfo(i);
@@ -1689,12 +1689,12 @@ void Kernel::createReflectionSurface() {
                                                                                   maxConstantBufferSize,
                                                                                   parentSamplerCount,
                                                                                   *pBlockInfo,
-                                                                                  device.getHardwareInfo());
+                                                                                  getDevice().getHardwareInfo());
 
             uint32_t offset = static_cast<uint32_t>(offsetof(IGIL_KernelDataHeader, m_data) + sizeof(IGIL_KernelAddressData) * i);
 
             uint32_t samplerHeapOffset = static_cast<uint32_t>(alignUp(kernelDataOffset + sizeof(IGIL_KernelData) + curbeParamsForBlocks[i].size() * sizeof(IGIL_KernelCurbeParams), sizeof(void *)));
-            uint32_t samplerHeapSize = static_cast<uint32_t>(alignUp(pBlockInfo->getSamplerStateArraySize(device.getHardwareInfo()), Sampler::samplerStateArrayAlignment) + pBlockInfo->getBorderColorStateSize());
+            uint32_t samplerHeapSize = static_cast<uint32_t>(alignUp(pBlockInfo->getSamplerStateArraySize(getDevice().getHardwareInfo()), Sampler::samplerStateArrayAlignment) + pBlockInfo->getBorderColorStateSize());
             uint32_t constantBufferOffset = alignUp(samplerHeapOffset + samplerHeapSize, sizeof(void *));
 
             uint32_t samplerParamsOffset = 0;
@@ -1721,7 +1721,7 @@ void Kernel::createReflectionSurface() {
                                                           sshTokenOffsetsFromKernelData[i] + kernelDataOffset,
                                                           btOffset,
                                                           *pBlockInfo,
-                                                          device.getHardwareInfo());
+                                                          getDevice().getHardwareInfo());
 
             if (samplerHeapSize > 0) {
                 void *pDst = ptrOffset(kernelReflectionSurface->getUnderlyingBuffer(), samplerHeapOffset);
@@ -1752,7 +1752,7 @@ void Kernel::createReflectionSurface() {
 
     if (DebugManager.flags.ForceDispatchScheduler.get()) {
         if (this->isSchedulerKernel && kernelReflectionSurface == nullptr) {
-            kernelReflectionSurface = device.getMemoryManager()->allocateGraphicsMemoryWithProperties({device.getRootDeviceIndex(), MemoryConstants::pageSize, GraphicsAllocation::AllocationType::DEVICE_QUEUE_BUFFER, device.getDeviceBitfield()});
+            kernelReflectionSurface = getDevice().getMemoryManager()->allocateGraphicsMemoryWithProperties({getDevice().getRootDeviceIndex(), MemoryConstants::pageSize, GraphicsAllocation::AllocationType::DEVICE_QUEUE_BUFFER, getDevice().getDeviceBitfield()});
         }
     }
 }
@@ -1792,7 +1792,7 @@ size_t Kernel::getInstructionHeapSizeForExecutionModel() const {
 }
 
 void Kernel::patchBlocksCurbeWithConstantValues() {
-    auto rootDeviceIndex = device.getRootDeviceIndex();
+    auto rootDeviceIndex = getDevice().getRootDeviceIndex();
     BlockKernelManager *blockManager = program->getBlockKernelManager();
     uint32_t blockCount = static_cast<uint32_t>(blockManager->getCount());
 
@@ -2201,7 +2201,7 @@ void Kernel::provideInitializationHints() {
     }
     if (patchInfo.mediavfestate) {
         auto scratchSize = patchInfo.mediavfestate->PerThreadScratchSpace;
-        scratchSize *= device.getSharedDeviceInfo().computeUnitsUsedForScratch * getKernelInfo().getMaxSimdSize();
+        scratchSize *= getDevice().getSharedDeviceInfo().computeUnitsUsedForScratch * getKernelInfo().getMaxSimdSize();
         if (scratchSize > 0) {
             context->providePerformanceHint(CL_CONTEXT_DIAGNOSTICS_LEVEL_BAD_INTEL, REGISTER_PRESSURE_TOO_HIGH,
                                             kernelInfo.kernelDescriptor.kernelMetadata.kernelName.c_str(), scratchSize);
@@ -2331,8 +2331,8 @@ void Kernel::resolveArgs() {
 }
 
 bool Kernel::canTransformImages() const {
-    return device.getHardwareInfo().platform.eRenderCoreFamily >= IGFX_GEN9_CORE &&
-           device.getHardwareInfo().platform.eRenderCoreFamily <= IGFX_GEN11LP_CORE;
+    return getDevice().getHardwareInfo().platform.eRenderCoreFamily >= IGFX_GEN9_CORE &&
+           getDevice().getHardwareInfo().platform.eRenderCoreFamily <= IGFX_GEN11LP_CORE;
 }
 
 void Kernel::fillWithBuffersForAuxTranslation(MemObjsForAuxTranslation &memObjsForAuxTranslation) {
@@ -2354,7 +2354,7 @@ void Kernel::fillWithBuffersForAuxTranslation(MemObjsForAuxTranslation &memObjsF
 }
 
 void Kernel::getAllocationsForCacheFlush(CacheFlushAllocationsVec &out) const {
-    if (false == HwHelper::cacheFlushAfterWalkerSupported(device.getHardwareInfo())) {
+    if (false == HwHelper::cacheFlushAfterWalkerSupported(getDevice().getHardwareInfo())) {
         return;
     }
     for (GraphicsAllocation *alloc : this->kernelArgRequiresCacheFlush) {
@@ -2365,7 +2365,7 @@ void Kernel::getAllocationsForCacheFlush(CacheFlushAllocationsVec &out) const {
         out.push_back(alloc);
     }
 
-    auto global = getProgram()->getGlobalSurface(device.getRootDeviceIndex());
+    auto global = getProgram()->getGlobalSurface(getDevice().getRootDeviceIndex());
     if (global != nullptr) {
         out.push_back(global);
     }
diff --git a/opencl/source/kernel/kernel.h b/opencl/source/kernel/kernel.h
index 53178a0798..53abc38496 100644
--- a/opencl/source/kernel/kernel.h
+++ b/opencl/source/kernel/kernel.h
@@ -80,9 +80,7 @@ class Kernel : public BaseObject<_cl_kernel> {
         cl_int retVal;
         kernel_t *pKernel = nullptr;
 
-        auto clDevice = program->getDevices()[0];
-
-        pKernel = new kernel_t(program, kernelInfo, *clDevice);
+        pKernel = new kernel_t(program, kernelInfo);
         retVal = pKernel->initialize();
 
         if (retVal != CL_SUCCESS) {
@@ -191,7 +189,7 @@ class Kernel : public BaseObject<_cl_kernel> {
     }
 
     const ClDevice &getDevice() const {
-        return device;
+        return *deviceVector[0];
     }
 
     Context &getContext() const {
@@ -501,7 +499,7 @@ class Kernel : public BaseObject<_cl_kernel> {
     void patchWithImplicitSurface(void *ptrToPatchInCrossThreadData, GraphicsAllocation &allocation, const PatchTokenT &patch);
 
     void getParentObjectCounts(ObjectCounts &objectCount);
-    Kernel(Program *programArg, const KernelInfo &kernelInfoArg, const ClDevice &deviceArg, bool schedulerKernel = false);
+    Kernel(Program *programArg, const KernelInfo &kernelInfoArg, bool schedulerKernel = false);
     void provideInitializationHints();
 
     void patchBlocksCurbeWithConstantValues();
@@ -514,7 +512,7 @@ class Kernel : public BaseObject<_cl_kernel> {
     bool allocationForCacheFlush(GraphicsAllocation *argAllocation) const;
     Program *program;
     Context *context = nullptr;
-    const ClDevice &device;
+    const ClDeviceVector &deviceVector;
     const KernelInfo &kernelInfo;
 
     std::vector<SimpleKernelArgInfo> kernelArguments;
diff --git a/opencl/source/scheduler/scheduler_kernel.cpp b/opencl/source/scheduler/scheduler_kernel.cpp
index b0f4ff5bf8..2a19dd5ea7 100644
--- a/opencl/source/scheduler/scheduler_kernel.cpp
+++ b/opencl/source/scheduler/scheduler_kernel.cpp
@@ -43,8 +43,8 @@ void SchedulerKernel::setArgs(GraphicsAllocation *queue,
             " \nkrs=", reflectionSurface->getUnderlyingBuffer(), " \nstorage=", queueStorageBuffer->getUnderlyingBuffer(), "\nssh=", ssh->getUnderlyingBuffer());
 }
 void SchedulerKernel::computeGws() {
-    auto &devInfo = device.getDeviceInfo();
-    auto &hwInfo = device.getHardwareInfo();
+    auto &devInfo = getDevice().getDeviceInfo();
+    auto &hwInfo = getDevice().getHardwareInfo();
     auto &helper = HwHelper::get(hwInfo.platform.eRenderCoreFamily);
 
     size_t hWThreadsPerSubSlice = devInfo.maxComputUnits / hwInfo.gtSystemInfo.SubSliceCount;
@@ -53,7 +53,7 @@ void SchedulerKernel::computeGws() {
     wkgsPerSubSlice = std::min(wkgsPerSubSlice, helper.getMaxBarrierRegisterPerSlice());
     gws = wkgsPerSubSlice * hwInfo.gtSystemInfo.SubSliceCount * PARALLEL_SCHEDULER_HWTHREADS_IN_HW_GROUP20 * PARALLEL_SCHEDULER_COMPILATION_SIZE_20;
 
-    if (device.isSimulation()) {
+    if (getDevice().isSimulation()) {
         gws = PARALLEL_SCHEDULER_HWTHREADS_IN_HW_GROUP20 * PARALLEL_SCHEDULER_COMPILATION_SIZE_20;
     }
     if (DebugManager.flags.SchedulerGWS.get() != 0) {
diff --git a/opencl/source/scheduler/scheduler_kernel.h b/opencl/source/scheduler/scheduler_kernel.h
index 028136fd8f..e5a373cb3e 100644
--- a/opencl/source/scheduler/scheduler_kernel.h
+++ b/opencl/source/scheduler/scheduler_kernel.h
@@ -55,13 +55,13 @@ class SchedulerKernel : public Kernel {
     static BuiltinCode loadSchedulerKernel(Device *device);
 
   protected:
-    SchedulerKernel(Program *programArg, const KernelInfo &kernelInfoArg, const ClDevice &deviceArg) : Kernel(programArg, kernelInfoArg, deviceArg, true), gws(0) {
+    SchedulerKernel(Program *programArg, const KernelInfo &kernelInfoArg) : Kernel(programArg, kernelInfoArg, true) {
         computeGws();
     };
 
     void computeGws();
 
-    size_t gws;
+    size_t gws = 0u;
 };
 
 } // namespace NEO
diff --git a/opencl/test/unit_test/accelerators/media_image_arg_tests.cpp b/opencl/test/unit_test/accelerators/media_image_arg_tests.cpp
index b261f4e132..83971ffe2a 100644
--- a/opencl/test/unit_test/accelerators/media_image_arg_tests.cpp
+++ b/opencl/test/unit_test/accelerators/media_image_arg_tests.cpp
@@ -47,7 +47,7 @@ class MediaImageSetArgTest : public ClDeviceFixture,
         pKernelInfo->kernelArgInfo[1].isImage = true;
         pKernelInfo->kernelArgInfo[0].isImage = true;
 
-        pKernel = new MockKernel(program.get(), *pKernelInfo, *pClDevice);
+        pKernel = new MockKernel(program.get(), *pKernelInfo);
         ASSERT_NE(nullptr, pKernel);
         ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
 
diff --git a/opencl/test/unit_test/api/cl_api_tests.cpp b/opencl/test/unit_test/api/cl_api_tests.cpp
index f40571de83..ffac800901 100644
--- a/opencl/test/unit_test/api/cl_api_tests.cpp
+++ b/opencl/test/unit_test/api/cl_api_tests.cpp
@@ -35,7 +35,7 @@ void api_fixture_using_aligned_memory_manager::SetUp() {
     program = new MockProgram(ctxPtr, false, toClDeviceVector(*device));
     Program *prgPtr = reinterpret_cast<Program *>(program);
 
-    kernel = new MockKernel(prgPtr, program->mockKernelInfo, *device);
+    kernel = new MockKernel(prgPtr, program->mockKernelInfo);
     ASSERT_NE(nullptr, kernel);
 }
 
diff --git a/opencl/test/unit_test/api/cl_api_tests.h b/opencl/test/unit_test/api/cl_api_tests.h
index 221f2827fd..066ab1eea8 100644
--- a/opencl/test/unit_test/api/cl_api_tests.h
+++ b/opencl/test/unit_test/api/cl_api_tests.h
@@ -17,6 +17,7 @@
 #include "opencl/source/execution_environment/cl_execution_environment.h"
 #include "opencl/source/tracing/tracing_api.h"
 #include "opencl/test/unit_test/helpers/ult_limits.h"
+#include "opencl/test/unit_test/mocks/mock_cl_device.h"
 #include "opencl/test/unit_test/mocks/mock_command_queue.h"
 #include "opencl/test/unit_test/mocks/mock_kernel.h"
 #include "test.h"
@@ -25,8 +26,6 @@
 
 namespace NEO {
 
-class MockClDevice;
-
 template <uint32_t rootDeviceIndex = 1u>
 struct ApiFixture {
 
@@ -34,12 +33,12 @@ struct ApiFixture {
         DebugManager.flags.CreateMultipleRootDevices.set(numRootDevices);
         executionEnvironment = new ClExecutionEnvironment();
         prepareDeviceEnvironments(*executionEnvironment);
-        Device *rootDevice = MockDevice::createWithExecutionEnvironment<MockDevice>(defaultHwInfo.get(), executionEnvironment, rootDeviceIndex);
+        auto rootDevice = MockDevice::createWithExecutionEnvironment<MockDevice>(defaultHwInfo.get(), executionEnvironment, rootDeviceIndex);
         if (rootDeviceIndex != 0u) {
             rootDeviceEnvironmentBackup.swap(executionEnvironment->rootDeviceEnvironments[0]);
         }
 
-        pDevice = new ClDevice(*rootDevice, nullptr);
+        pDevice = new MockClDevice(rootDevice);
         ASSERT_NE(nullptr, pDevice);
 
         testedClDevice = pDevice;
@@ -50,7 +49,7 @@ struct ApiFixture {
 
         pProgram = new MockProgram(pContext, false, toClDeviceVector(*pDevice));
 
-        pKernel = new MockKernel(pProgram, pProgram->mockKernelInfo, *pDevice);
+        pKernel = new MockKernel(pProgram, pProgram->mockKernelInfo);
         ASSERT_NE(nullptr, pKernel);
     }
 
@@ -75,7 +74,7 @@ struct ApiFixture {
     constexpr static uint32_t numRootDevices = maxRootDeviceCount;
     constexpr static uint32_t testedRootDeviceIndex = rootDeviceIndex;
     cl_device_id testedClDevice = nullptr;
-    ClDevice *pDevice = nullptr;
+    MockClDevice *pDevice = nullptr;
     ClExecutionEnvironment *executionEnvironment = nullptr;
     std::unique_ptr<RootDeviceEnvironment> rootDeviceEnvironmentBackup;
 };
diff --git a/opencl/test/unit_test/api/cl_set_kernel_arg_svm_pointer_tests.inl b/opencl/test/unit_test/api/cl_set_kernel_arg_svm_pointer_tests.inl
index a76c1021c3..85fff6c273 100644
--- a/opencl/test/unit_test/api/cl_set_kernel_arg_svm_pointer_tests.inl
+++ b/opencl/test/unit_test/api/cl_set_kernel_arg_svm_pointer_tests.inl
@@ -16,11 +16,10 @@
 
 using namespace NEO;
 
-class KernelArgSvmFixture : public ApiFixture<>, public ClDeviceFixture {
+class KernelArgSvmFixture : public ApiFixture<> {
   protected:
     void SetUp() override {
         ApiFixture::SetUp();
-        ClDeviceFixture::SetUp();
         REQUIRE_SVM_OR_SKIP(defaultHwInfo);
 
         // define kernel info
@@ -40,7 +39,7 @@ class KernelArgSvmFixture : public ApiFixture<>, public ClDeviceFixture {
         pKernelInfo->kernelArgInfo[0].kernelArgPatchInfoVector[0].size = (uint32_t)sizeof(void *);
         pKernelInfo->kernelArgInfo[0].metadata.addressQualifier = KernelArgMetadata::AddrGlobal;
 
-        pMockKernel = new MockKernel(pProgram, *pKernelInfo, *this->pClDevice);
+        pMockKernel = new MockKernel(pProgram, *pKernelInfo);
         ASSERT_EQ(CL_SUCCESS, pMockKernel->initialize());
         pMockKernel->setCrossThreadData(pCrossThreadData, sizeof(pCrossThreadData));
     }
@@ -50,7 +49,6 @@ class KernelArgSvmFixture : public ApiFixture<>, public ClDeviceFixture {
             delete pMockKernel;
         }
 
-        ClDeviceFixture::TearDown();
         ApiFixture::TearDown();
     }
 
@@ -84,11 +82,10 @@ TEST_F(clSetKernelArgSVMPointerTests, GivenInvalidArgIndexWhenSettingKernelArgTh
 }
 
 TEST_F(clSetKernelArgSVMPointerTests, GivenDeviceNotSupportingSvmWhenSettingKernelArgSVMPointerThenInvalidOperationErrorIsReturned) {
-    auto hwInfo = *defaultHwInfo;
-    hwInfo.capabilityTable.ftrSvm = false;
-    auto pDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo, 0));
+    auto hwInfo = executionEnvironment->rootDeviceEnvironments[ApiFixture::testedRootDeviceIndex]->getMutableHardwareInfo();
+    hwInfo->capabilityTable.ftrSvm = false;
 
-    auto pMockKernel = std::make_unique<MockKernel>(pProgram, *pKernelInfo, *pDevice);
+    auto pMockKernel = std::make_unique<MockKernel>(pProgram, *pKernelInfo);
     auto retVal = clSetKernelArgSVMPointer(
         pMockKernel.get(), // cl_kernel kernel
         (cl_uint)-1,       // cl_uint arg_index
@@ -109,8 +106,8 @@ TEST_F(clSetKernelArgSVMPointerTests, GivenLocalAddressAndNullArgValueWhenSettin
 }
 
 TEST_F(clSetKernelArgSVMPointerTests, GivenInvalidArgValueWhenSettingKernelArgThenInvalidArgValueErrorIsReturned) {
-    pClDevice->deviceInfo.sharedSystemMemCapabilities = 0u;
-    pClDevice->sharedDeviceInfo.sharedSystemAllocationsSupport = false;
+    pDevice->deviceInfo.sharedSystemMemCapabilities = 0u;
+    pDevice->sharedDeviceInfo.sharedSystemAllocationsSupport = false;
     void *ptrHost = malloc(256);
     EXPECT_NE(nullptr, ptrHost);
 
@@ -125,7 +122,7 @@ TEST_F(clSetKernelArgSVMPointerTests, GivenInvalidArgValueWhenSettingKernelArgTh
 }
 
 TEST_F(clSetKernelArgSVMPointerTests, GivenSvmAndNullArgValueWhenSettingKernelArgThenSuccessIsReturned) {
-    const ClDeviceInfo &devInfo = pClDevice->getDeviceInfo();
+    const ClDeviceInfo &devInfo = pDevice->getDeviceInfo();
     if (devInfo.svmCapabilities != 0) {
         auto retVal = clSetKernelArgSVMPointer(
             pMockKernel, // cl_kernel kernel
@@ -137,7 +134,7 @@ TEST_F(clSetKernelArgSVMPointerTests, GivenSvmAndNullArgValueWhenSettingKernelAr
 }
 
 TEST_F(clSetKernelArgSVMPointerTests, GivenSvmAndValidArgValueWhenSettingKernelArgThenSuccessIsReturned) {
-    const ClDeviceInfo &devInfo = pClDevice->getDeviceInfo();
+    const ClDeviceInfo &devInfo = pDevice->getDeviceInfo();
     if (devInfo.svmCapabilities != 0) {
         void *ptrSvm = clSVMAlloc(pContext, CL_MEM_READ_WRITE, 256, 4);
         EXPECT_NE(nullptr, ptrSvm);
@@ -154,7 +151,7 @@ TEST_F(clSetKernelArgSVMPointerTests, GivenSvmAndValidArgValueWhenSettingKernelA
 }
 
 TEST_F(clSetKernelArgSVMPointerTests, GivenSvmAndConstantAddressWhenSettingKernelArgThenSuccessIsReturned) {
-    const ClDeviceInfo &devInfo = pClDevice->getDeviceInfo();
+    const ClDeviceInfo &devInfo = pDevice->getDeviceInfo();
     if (devInfo.svmCapabilities != 0) {
         void *ptrSvm = clSVMAlloc(pContext, CL_MEM_READ_WRITE, 256, 4);
         EXPECT_NE(nullptr, ptrSvm);
@@ -173,7 +170,7 @@ TEST_F(clSetKernelArgSVMPointerTests, GivenSvmAndConstantAddressWhenSettingKerne
 }
 
 TEST_F(clSetKernelArgSVMPointerTests, GivenSvmAndPointerWithOffsetWhenSettingKernelArgThenSuccessIsReturned) {
-    const ClDeviceInfo &devInfo = pClDevice->getDeviceInfo();
+    const ClDeviceInfo &devInfo = pDevice->getDeviceInfo();
     if (devInfo.svmCapabilities != 0) {
         void *ptrSvm = clSVMAlloc(pContext, CL_MEM_READ_WRITE, 256, 4);
         size_t offset = 256 / 2;
@@ -191,9 +188,9 @@ TEST_F(clSetKernelArgSVMPointerTests, GivenSvmAndPointerWithOffsetWhenSettingKer
 }
 
 TEST_F(clSetKernelArgSVMPointerTests, GivenSvmAndPointerWithInvalidOffsetWhenSettingKernelArgThenInvalidArgValueErrorIsReturned) {
-    pClDevice->deviceInfo.sharedSystemMemCapabilities = 0u;
-    pClDevice->sharedDeviceInfo.sharedSystemAllocationsSupport = false;
-    const ClDeviceInfo &devInfo = pClDevice->getDeviceInfo();
+    pDevice->deviceInfo.sharedSystemMemCapabilities = 0u;
+    pDevice->sharedDeviceInfo.sharedSystemAllocationsSupport = false;
+    const ClDeviceInfo &devInfo = pDevice->getDeviceInfo();
     if (devInfo.svmCapabilities != 0) {
         void *ptrSvm = clSVMAlloc(pContext, CL_MEM_READ_WRITE, 256, 4);
         auto svmData = pContext->getSVMAllocsManager()->getSVMAlloc(ptrSvm);
diff --git a/opencl/test/unit_test/api/cl_set_kernel_exec_info_tests.inl b/opencl/test/unit_test/api/cl_set_kernel_exec_info_tests.inl
index 0b8b1de047..ff7f7ed2c2 100644
--- a/opencl/test/unit_test/api/cl_set_kernel_exec_info_tests.inl
+++ b/opencl/test/unit_test/api/cl_set_kernel_exec_info_tests.inl
@@ -21,7 +21,7 @@ class KernelExecInfoFixture : public ApiFixture<> {
 
         pKernelInfo = std::make_unique<KernelInfo>();
 
-        pMockKernel = new MockKernel(pProgram, *pKernelInfo, *pDevice);
+        pMockKernel = new MockKernel(pProgram, *pKernelInfo);
         ASSERT_EQ(CL_SUCCESS, pMockKernel->initialize());
         svmCapabilities = pDevice->getDeviceInfo().svmCapabilities;
         if (svmCapabilities != 0) {
@@ -64,11 +64,10 @@ TEST_F(clSetKernelExecInfoTests, GivenNullKernelWhenSettingAdditionalKernelInfoT
 }
 
 TEST_F(clSetKernelArgSVMPointerTests, GivenDeviceNotSupportingSvmWhenSettingKernelExecInfoThenInvalidOperationErrorIsReturned) {
-    auto hwInfo = *defaultHwInfo;
-    hwInfo.capabilityTable.ftrSvm = false;
-    auto pDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo, 0));
+    auto hwInfo = executionEnvironment->rootDeviceEnvironments[ApiFixture::testedRootDeviceIndex]->getMutableHardwareInfo();
+    hwInfo->capabilityTable.ftrSvm = false;
 
-    auto pMockKernel = std::make_unique<MockKernel>(pProgram, *pKernelInfo, *pDevice);
+    auto pMockKernel = std::make_unique<MockKernel>(pProgram, *pKernelInfo);
     auto retVal = clSetKernelExecInfo(
         pMockKernel.get(),            // cl_kernel kernel
         CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
diff --git a/opencl/test/unit_test/command_queue/dispatch_walker_tests.cpp b/opencl/test/unit_test/command_queue/dispatch_walker_tests.cpp
index e4dbaaafa5..ea52a3d544 100644
--- a/opencl/test/unit_test/command_queue/dispatch_walker_tests.cpp
+++ b/opencl/test/unit_test/command_queue/dispatch_walker_tests.cpp
@@ -147,7 +147,7 @@ HWTEST_F(DispatchWalkerTest, givenSimd1WhenSetGpgpuWalkerThreadDataThenSimdInWal
 }
 
 HWTEST_F(DispatchWalkerTest, WhenDispatchingWalkerThenCommandStreamMemoryIsntChanged) {
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     auto &commandStream = pCmdQ->getCS(4096);
@@ -194,7 +194,7 @@ HWTEST_F(DispatchWalkerTest, GivenNoLocalIdsWhenDispatchingWalkerThenWalkerIsDis
     threadPayload.LocalIDZPresent = 0;
     threadPayload.UnusedPerThreadConstantPresent = 1;
 
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     auto &commandStream = pCmdQ->getCS(4096);
@@ -236,7 +236,7 @@ HWTEST_F(DispatchWalkerTest, GivenNoLocalIdsWhenDispatchingWalkerThenWalkerIsDis
 }
 
 HWTEST_F(DispatchWalkerTest, GivenDefaultLwsAlgorithmWhenDispatchingWalkerThenDimensionsAreCorrect) {
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     kernelInfo.workloadInfo.workDimOffset = 0;
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
@@ -267,7 +267,7 @@ HWTEST_F(DispatchWalkerTest, GivenSquaredLwsAlgorithmWhenDispatchingWalkerThenDi
     DebugManagerStateRestore dbgRestore;
     DebugManager.flags.EnableComputeWorkSizeND.set(false);
     DebugManager.flags.EnableComputeWorkSizeSquared.set(true);
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     kernelInfo.workloadInfo.workDimOffset = 0;
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
@@ -295,7 +295,7 @@ HWTEST_F(DispatchWalkerTest, GivenSquaredLwsAlgorithmWhenDispatchingWalkerThenDi
 HWTEST_F(DispatchWalkerTest, GivenNdLwsAlgorithmWhenDispatchingWalkerThenDimensionsAreCorrect) {
     DebugManagerStateRestore dbgRestore;
     DebugManager.flags.EnableComputeWorkSizeND.set(true);
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     kernelInfo.workloadInfo.workDimOffset = 0;
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
@@ -324,7 +324,7 @@ HWTEST_F(DispatchWalkerTest, GivenOldLwsAlgorithmWhenDispatchingWalkerThenDimens
     DebugManagerStateRestore dbgRestore;
     DebugManager.flags.EnableComputeWorkSizeND.set(false);
     DebugManager.flags.EnableComputeWorkSizeSquared.set(false);
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     kernelInfo.workloadInfo.workDimOffset = 0;
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
@@ -350,7 +350,7 @@ HWTEST_F(DispatchWalkerTest, GivenOldLwsAlgorithmWhenDispatchingWalkerThenDimens
 }
 
 HWTEST_F(DispatchWalkerTest, GivenNumWorkGroupsWhenDispatchingWalkerThenNumWorkGroupsIsCorrectlySet) {
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     kernelInfo.workloadInfo.numWorkGroupsOffset[0] = 0;
     kernelInfo.workloadInfo.numWorkGroupsOffset[1] = 4;
     kernelInfo.workloadInfo.numWorkGroupsOffset[2] = 8;
@@ -383,7 +383,7 @@ HWTEST_F(DispatchWalkerTest, GivenNumWorkGroupsWhenDispatchingWalkerThenNumWorkG
 HWTEST_F(DispatchWalkerTest, GivenNoLocalWorkSizeAndDefaultAlgorithmWhenDispatchingWalkerThenLwsIsCorrect) {
     DebugManagerStateRestore dbgRestore;
     DebugManager.flags.EnableComputeWorkSizeND.set(false);
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     kernelInfo.workloadInfo.localWorkSizeOffsets[0] = 0;
     kernelInfo.workloadInfo.localWorkSizeOffsets[1] = 4;
     kernelInfo.workloadInfo.localWorkSizeOffsets[2] = 8;
@@ -413,7 +413,7 @@ HWTEST_F(DispatchWalkerTest, GivenNoLocalWorkSizeAndDefaultAlgorithmWhenDispatch
 HWTEST_F(DispatchWalkerTest, GivenNoLocalWorkSizeAndNdOnWhenDispatchingWalkerThenLwsIsCorrect) {
     DebugManagerStateRestore dbgRestore;
     DebugManager.flags.EnableComputeWorkSizeND.set(true);
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     kernelInfo.workloadInfo.localWorkSizeOffsets[0] = 0;
     kernelInfo.workloadInfo.localWorkSizeOffsets[1] = 4;
     kernelInfo.workloadInfo.localWorkSizeOffsets[2] = 8;
@@ -444,7 +444,7 @@ HWTEST_F(DispatchWalkerTest, GivenNoLocalWorkSizeAndSquaredAlgorithmWhenDispatch
     DebugManagerStateRestore dbgRestore;
     DebugManager.flags.EnableComputeWorkSizeSquared.set(true);
     DebugManager.flags.EnableComputeWorkSizeND.set(false);
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     kernelInfo.workloadInfo.localWorkSizeOffsets[0] = 0;
     kernelInfo.workloadInfo.localWorkSizeOffsets[1] = 4;
     kernelInfo.workloadInfo.localWorkSizeOffsets[2] = 8;
@@ -475,7 +475,7 @@ HWTEST_F(DispatchWalkerTest, GivenNoLocalWorkSizeAndSquaredAlgorithmOffAndNdOffW
     DebugManagerStateRestore dbgRestore;
     DebugManager.flags.EnableComputeWorkSizeSquared.set(false);
     DebugManager.flags.EnableComputeWorkSizeND.set(false);
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     kernelInfo.workloadInfo.localWorkSizeOffsets[0] = 0;
     kernelInfo.workloadInfo.localWorkSizeOffsets[1] = 4;
     kernelInfo.workloadInfo.localWorkSizeOffsets[2] = 8;
@@ -503,7 +503,7 @@ HWTEST_F(DispatchWalkerTest, GivenNoLocalWorkSizeAndSquaredAlgorithmOffAndNdOffW
 }
 
 HWTEST_F(DispatchWalkerTest, GivenNoLocalWorkSizeWhenDispatchingWalkerThenLwsIsCorrect) {
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     kernelInfo.workloadInfo.localWorkSizeOffsets[0] = 0;
     kernelInfo.workloadInfo.localWorkSizeOffsets[1] = 4;
     kernelInfo.workloadInfo.localWorkSizeOffsets[2] = 8;
@@ -532,7 +532,7 @@ HWTEST_F(DispatchWalkerTest, GivenNoLocalWorkSizeWhenDispatchingWalkerThenLwsIsC
 }
 
 HWTEST_F(DispatchWalkerTest, GivenTwoSetsOfLwsOffsetsWhenDispatchingWalkerThenLwsIsCorrect) {
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     kernelInfo.workloadInfo.localWorkSizeOffsets[0] = 0;
     kernelInfo.workloadInfo.localWorkSizeOffsets[1] = 4;
     kernelInfo.workloadInfo.localWorkSizeOffsets[2] = 8;
@@ -567,13 +567,13 @@ HWTEST_F(DispatchWalkerTest, GivenTwoSetsOfLwsOffsetsWhenDispatchingWalkerThenLw
 }
 
 HWTEST_F(DispatchWalkerTest, GivenSplitKernelWhenDispatchingWalkerThenLwsIsCorrect) {
-    MockKernel kernel1(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel1(program.get(), kernelInfo);
     kernelInfo.workloadInfo.localWorkSizeOffsets[0] = 0;
     kernelInfo.workloadInfo.localWorkSizeOffsets[1] = 4;
     kernelInfo.workloadInfo.localWorkSizeOffsets[2] = 8;
     ASSERT_EQ(CL_SUCCESS, kernel1.initialize());
 
-    MockKernel kernel2(program.get(), kernelInfoWithSampler, *pClDevice);
+    MockKernel kernel2(program.get(), kernelInfoWithSampler);
     kernelInfoWithSampler.workloadInfo.localWorkSizeOffsets[0] = 12;
     kernelInfoWithSampler.workloadInfo.localWorkSizeOffsets[1] = 16;
     kernelInfoWithSampler.workloadInfo.localWorkSizeOffsets[2] = 20;
@@ -613,8 +613,8 @@ HWTEST_F(DispatchWalkerTest, GivenSplitKernelWhenDispatchingWalkerThenLwsIsCorre
 }
 
 HWTEST_F(DispatchWalkerTest, GivenSplitWalkerWhenDispatchingWalkerThenLwsIsCorrect) {
-    MockKernel kernel1(program.get(), kernelInfo, *pClDevice);
-    MockKernel mainKernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel1(program.get(), kernelInfo);
+    MockKernel mainKernel(program.get(), kernelInfo);
     kernelInfo.workloadInfo.localWorkSizeOffsets[0] = 0;
     kernelInfo.workloadInfo.localWorkSizeOffsets[1] = 4;
     kernelInfo.workloadInfo.localWorkSizeOffsets[2] = 8;
@@ -672,7 +672,7 @@ HWTEST_F(DispatchWalkerTest, GivenSplitWalkerWhenDispatchingWalkerThenLwsIsCorre
 }
 
 HWTEST_F(DispatchWalkerTest, GivenBlockedQueueWhenDispatchingWalkerThenCommandSteamIsNotConsumed) {
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     size_t globalOffsets[3] = {0, 0, 0};
@@ -706,7 +706,7 @@ HWTEST_F(DispatchWalkerTest, GivenBlockedQueueWhenDispatchingWalkerThenCommandSt
 }
 
 HWTEST_F(DispatchWalkerTest, GivenBlockedQueueWhenDispatchingWalkerThenRequiredHeaSizesAreTakenFromKernel) {
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     size_t globalOffsets[3] = {0, 0, 0};
@@ -764,7 +764,7 @@ HWTEST_F(DispatchWalkerTest, givenBlockedEnqueueWhenObtainingCommandStreamThenAl
 }
 
 HWTEST_F(DispatchWalkerTest, GivenBlockedQueueWhenDispatchingWalkerThenRequiredHeapSizesAreTakenFromMdi) {
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     MockMultiDispatchInfo multiDispatchInfo(&kernel);
@@ -792,7 +792,7 @@ HWTEST_F(DispatchWalkerTest, GivenBlockedQueueWhenDispatchingWalkerThenRequiredH
 }
 
 HWTEST_F(DispatchWalkerTest, givenBlockedQueueWhenDispatchWalkerIsCalledThenCommandStreamHasGpuAddress) {
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
     MockMultiDispatchInfo multiDispatchInfo(&kernel);
 
@@ -813,7 +813,7 @@ HWTEST_F(DispatchWalkerTest, givenBlockedQueueWhenDispatchWalkerIsCalledThenComm
 }
 
 HWTEST_F(DispatchWalkerTest, givenThereAreAllocationsForReuseWhenDispatchWalkerIsCalledThenCommandStreamObtainsReusableAllocation) {
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
     MockMultiDispatchInfo multiDispatchInfo(&kernel);
 
@@ -840,9 +840,9 @@ HWTEST_F(DispatchWalkerTest, givenThereAreAllocationsForReuseWhenDispatchWalkerI
 }
 
 HWTEST_F(DispatchWalkerTest, GivenMultipleKernelsWhenDispatchingWalkerThenWorkDimensionsAreCorrect) {
-    MockKernel kernel1(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel1(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel1.initialize());
-    MockKernel kernel2(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel2(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel2.initialize());
 
     MockMultiDispatchInfo multiDispatchInfo(std::vector<Kernel *>({&kernel1, &kernel2}));
@@ -875,9 +875,9 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, GivenMultipleKernelsWhenDispatch
     auto gpuAddress1 = kernelIsaAllocation->getGpuAddressToPatch();
     auto gpuAddress2 = kernelIsaWithSamplerAllocation->getGpuAddressToPatch();
 
-    MockKernel kernel1(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel1(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel1.initialize());
-    MockKernel kernel2(program.get(), kernelInfoWithSampler, *pClDevice);
+    MockKernel kernel2(program.get(), kernelInfoWithSampler);
     ASSERT_EQ(CL_SUCCESS, kernel2.initialize());
 
     MockMultiDispatchInfo multiDispatchInfo(std::vector<Kernel *>({&kernel1, &kernel2}));
@@ -962,9 +962,9 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, GivenMultipleKernelsWhenDispatch
 HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, GivenMultipleKernelsWhenDispatchingWalkerThenGpgpuWalkerIdOffsetIsProgrammedCorrectly) {
     using GPGPU_WALKER = typename FamilyType::GPGPU_WALKER;
 
-    MockKernel kernel1(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel1(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel1.initialize());
-    MockKernel kernel2(program.get(), kernelInfoWithSampler, *pClDevice);
+    MockKernel kernel2(program.get(), kernelInfoWithSampler);
     ASSERT_EQ(CL_SUCCESS, kernel2.initialize());
 
     MockMultiDispatchInfo multiDispatchInfo(std::vector<Kernel *>({&kernel1, &kernel2}));
@@ -1007,9 +1007,9 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, GivenMultipleKernelsWhenDispatch
 HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, GivenMultipleKernelsWhenDispatchingWalkerThenThreadGroupIdStartingCoordinatesAreProgrammedCorrectly) {
     using GPGPU_WALKER = typename FamilyType::GPGPU_WALKER;
 
-    MockKernel kernel1(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel1(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel1.initialize());
-    MockKernel kernel2(program.get(), kernelInfoWithSampler, *pClDevice);
+    MockKernel kernel2(program.get(), kernelInfoWithSampler);
     ASSERT_EQ(CL_SUCCESS, kernel2.initialize());
 
     MockMultiDispatchInfo multiDispatchInfo(std::vector<Kernel *>({&kernel1, &kernel2}));
@@ -1056,7 +1056,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, GivenMultipleKernelsWhenDispatch
 HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, GivenMultipleDispatchInfoAndSameKernelWhenDispatchingWalkerThenGpgpuWalkerThreadGroupIdStartingCoordinatesAreCorrectlyProgrammed) {
     using GPGPU_WALKER = typename FamilyType::GPGPU_WALKER;
 
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     DispatchInfo di1(&kernel, 1, {100, 1, 1}, {10, 1, 1}, {0, 0, 0}, {100, 1, 1}, {10, 1, 1}, {10, 1, 1}, {10, 1, 1}, {0, 0, 0});
@@ -1109,7 +1109,7 @@ HWTEST_F(DispatchWalkerTest, GivenCacheFlushAfterWalkerDisabledWhenAllocationReq
     DebugManagerStateRestore dbgRestore;
     DebugManager.flags.EnableCacheFlushAfterWalker.set(0);
 
-    MockKernel kernel1(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel1(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel1.initialize());
     kernel1.kernelArgRequiresCacheFlush.resize(1);
     MockGraphicsAllocation cacheRequiringAllocation;
@@ -1142,9 +1142,9 @@ HWTEST_F(DispatchWalkerTest, GivenCacheFlushAfterWalkerEnabledWhenWalkerWithTwoK
     DebugManagerStateRestore dbgRestore;
     DebugManager.flags.EnableCacheFlushAfterWalker.set(1);
 
-    MockKernel kernel1(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel1(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel1.initialize());
-    MockKernel kernel2(program.get(), kernelInfoWithSampler, *pClDevice);
+    MockKernel kernel2(program.get(), kernelInfoWithSampler);
     ASSERT_EQ(CL_SUCCESS, kernel2.initialize());
 
     kernel1.kernelArgRequiresCacheFlush.resize(1);
@@ -1180,9 +1180,9 @@ HWTEST_F(DispatchWalkerTest, GivenCacheFlushAfterWalkerEnabledWhenTwoWalkersForQ
     DebugManagerStateRestore dbgRestore;
     DebugManager.flags.EnableCacheFlushAfterWalker.set(1);
 
-    MockKernel kernel1(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel1(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel1.initialize());
-    MockKernel kernel2(program.get(), kernelInfoWithSampler, *pClDevice);
+    MockKernel kernel2(program.get(), kernelInfoWithSampler);
     ASSERT_EQ(CL_SUCCESS, kernel2.initialize());
 
     kernel1.kernelArgRequiresCacheFlush.resize(1);
@@ -1245,7 +1245,7 @@ HWTEST_F(DispatchWalkerTest, givenKernelWhenAuxToNonAuxWhenTranslationRequiredTh
     BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pClDevice);
     auto &builder = static_cast<BuiltInOp<EBuiltInOps::AuxTranslation> &>(baseBuilder);
 
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     kernelInfo.workloadInfo.workDimOffset = 0;
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
@@ -1298,7 +1298,7 @@ HWTEST_F(DispatchWalkerTest, givenKernelWhenNonAuxToAuxWhenTranslationRequiredTh
     BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pClDevice);
     auto &builder = static_cast<BuiltInOp<EBuiltInOps::AuxTranslation> &>(baseBuilder);
 
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     kernelInfo.workloadInfo.workDimOffset = 0;
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
diff --git a/opencl/test/unit_test/device_queue/device_queue_tests.cpp b/opencl/test/unit_test/device_queue/device_queue_tests.cpp
index b05710603b..2342fedc6f 100644
--- a/opencl/test/unit_test/device_queue/device_queue_tests.cpp
+++ b/opencl/test/unit_test/device_queue/device_queue_tests.cpp
@@ -291,7 +291,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DeviceQueueTest, WhenDispatchingSchedulerThenNoAsser
     MockProgram program(toClDeviceVector(*device));
     MockCommandQueue cmdQ(nullptr, nullptr, 0);
     KernelInfo info;
-    MockSchedulerKernel *kernel = new MockSchedulerKernel(&program, info, *device);
+    MockSchedulerKernel *kernel = new MockSchedulerKernel(&program, info);
     LinearStream cmdStream;
 
     devQueue.dispatchScheduler(cmdStream, *kernel, device->getPreemptionMode(), nullptr, nullptr, false);
diff --git a/opencl/test/unit_test/fixtures/cl_preemption_fixture.cpp b/opencl/test/unit_test/fixtures/cl_preemption_fixture.cpp
index 0419290684..a5f741903c 100644
--- a/opencl/test/unit_test/fixtures/cl_preemption_fixture.cpp
+++ b/opencl/test/unit_test/fixtures/cl_preemption_fixture.cpp
@@ -43,7 +43,7 @@ void DevicePreemptionTests::SetUp() {
     memset(executionEnvironment.get(), 0, sizeof(SPatchExecutionEnvironment));
     kernelInfo->patchInfo.executionEnvironment = executionEnvironment.get();
     program = std::make_unique<MockProgram>(toClDeviceVector(*device));
-    kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
+    kernel.reset(new MockKernel(program.get(), *kernelInfo));
     dispatchInfo.reset(new DispatchInfo(kernel.get(), 1, Vec3<size_t>(1, 1, 1), Vec3<size_t>(1, 1, 1), Vec3<size_t>(0, 0, 0)));
 
     ASSERT_NE(nullptr, device);
diff --git a/opencl/test/unit_test/fixtures/kernel_arg_fixture.cpp b/opencl/test/unit_test/fixtures/kernel_arg_fixture.cpp
index aaabec17d2..5648f63990 100644
--- a/opencl/test/unit_test/fixtures/kernel_arg_fixture.cpp
+++ b/opencl/test/unit_test/fixtures/kernel_arg_fixture.cpp
@@ -57,7 +57,7 @@ void KernelImageArgTest::SetUp() {
 
     ClDeviceFixture::SetUp();
     program = std::make_unique<MockProgram>(toClDeviceVector(*pClDevice));
-    pKernel.reset(new MockKernel(program.get(), *pKernelInfo, *pClDevice));
+    pKernel.reset(new MockKernel(program.get(), *pKernelInfo));
     ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
 
     pKernel->setKernelArgHandler(0, &Kernel::setArgImage);
diff --git a/opencl/test/unit_test/gen12lp/gpgpu_walker_tests_gen12lp.cpp b/opencl/test/unit_test/gen12lp/gpgpu_walker_tests_gen12lp.cpp
index 776263fa30..be8b9402a4 100644
--- a/opencl/test/unit_test/gen12lp/gpgpu_walker_tests_gen12lp.cpp
+++ b/opencl/test/unit_test/gen12lp/gpgpu_walker_tests_gen12lp.cpp
@@ -37,7 +37,7 @@ GEN12LPTEST_F(GpgpuWalkerTests, givenMiStoreRegMemWhenAdjustMiStoreRegMemModeThe
 
 class MockKernelWithApplicableWa : public MockKernel {
   public:
-    MockKernelWithApplicableWa(Program *program, KernelInfo &kernelInfo, ClDevice &device) : MockKernel(program, kernelInfo, device) {}
+    MockKernelWithApplicableWa(Program *program, KernelInfo &kernelInfo) : MockKernel(program, kernelInfo) {}
     bool requiresWaDisableRccRhwoOptimization() const override {
         return waApplicable;
     }
@@ -52,7 +52,7 @@ struct HardwareInterfaceTests : public ClDeviceFixture, public LinearStreamFixtu
         pContext = new NEO::MockContext(pClDevice);
         pCommandQueue = new MockCommandQueue(pContext, pClDevice, nullptr);
         pProgram = new MockProgram(pContext, false, toClDeviceVector(*pClDevice));
-        pKernel = new MockKernelWithApplicableWa(static_cast<Program *>(pProgram), pProgram->mockKernelInfo, *pClDevice);
+        pKernel = new MockKernelWithApplicableWa(static_cast<Program *>(pProgram), pProgram->mockKernelInfo);
     }
 
     void TearDown() override {
diff --git a/opencl/test/unit_test/gtpin/gtpin_tests.cpp b/opencl/test/unit_test/gtpin/gtpin_tests.cpp
index 57d4fd197b..20917137a7 100644
--- a/opencl/test/unit_test/gtpin/gtpin_tests.cpp
+++ b/opencl/test/unit_test/gtpin/gtpin_tests.cpp
@@ -2394,7 +2394,7 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenOnKernelSubitIsCalledThenCo
 
     auto pProgramm = std::make_unique<MockProgram>(context.get(), false, toClDeviceVector(*pDevice));
     std::unique_ptr<MockCommandQueue> cmdQ(new MockCommandQueue(context.get(), pDevice, nullptr));
-    std::unique_ptr<MockKernel> pKernel(new MockKernel(pProgramm.get(), *pKernelInfo, *pDevice));
+    std::unique_ptr<MockKernel> pKernel(new MockKernel(pProgramm.get(), *pKernelInfo));
 
     pKernel->setSshLocal(nullptr, sizeof(surfaceStateHeap));
 
diff --git a/opencl/test/unit_test/helpers/dispatch_info_builder_tests.cpp b/opencl/test/unit_test/helpers/dispatch_info_builder_tests.cpp
index de2ec43aee..dd02434117 100644
--- a/opencl/test/unit_test/helpers/dispatch_info_builder_tests.cpp
+++ b/opencl/test/unit_test/helpers/dispatch_info_builder_tests.cpp
@@ -67,7 +67,7 @@ class DispatchInfoBuilderFixture : public ContextFixture, public ClDeviceFixture
 
         pProgram = new MockProgram(pContext, false, toClDeviceVector(*pClDevice));
 
-        pKernel = new MockKernel(pProgram, *pKernelInfo, *pClDevice);
+        pKernel = new MockKernel(pProgram, *pKernelInfo);
         ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
         pKernel->setCrossThreadData(pCrossThreadData, sizeof(pCrossThreadData));
         pKernel->setKernelArgHandler(0, &Kernel::setArgBuffer);
diff --git a/opencl/test/unit_test/helpers/dispatch_info_tests.cpp b/opencl/test/unit_test/helpers/dispatch_info_tests.cpp
index bfe3eb0195..c6884620ec 100644
--- a/opencl/test/unit_test/helpers/dispatch_info_tests.cpp
+++ b/opencl/test/unit_test/helpers/dispatch_info_tests.cpp
@@ -39,7 +39,7 @@ class DispatchInfoFixture : public ContextFixture, public ClDeviceFixture {
         pKernelInfo->patchInfo.pAllocateStatelessPrintfSurface = pPrintfSurface;
         pProgram = new MockProgram(pContext, false, toClDeviceVector(*pClDevice));
 
-        pKernel = new MockKernel(pProgram, *pKernelInfo, *pClDevice);
+        pKernel = new MockKernel(pProgram, *pKernelInfo);
         pKernel->slmTotalSize = 128;
     }
     void TearDown() override {
diff --git a/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp b/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp
index ce3ed6dae2..014562d5c6 100644
--- a/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp
+++ b/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp
@@ -180,7 +180,7 @@ HWTEST_F(HardwareCommandsTest, givenSendCrossThreadDataWhenWhenAddPatchInfoComme
     MockProgram program(&context, false, toClDeviceVector(*pClDevice));
     auto kernelInfo = std::make_unique<KernelInfo>();
 
-    std::unique_ptr<MockKernel> kernel(new MockKernel(&program, *kernelInfo, *pClDevice));
+    std::unique_ptr<MockKernel> kernel(new MockKernel(&program, *kernelInfo));
 
     auto &indirectHeap = cmdQ.getIndirectHeap(IndirectHeap::INDIRECT_OBJECT, 8192);
 
@@ -246,7 +246,7 @@ HWTEST_F(HardwareCommandsTest, givenSendCrossThreadDataWhenWhenAddPatchInfoComme
     MockProgram program(&context, false, toClDeviceVector(*pClDevice));
     auto kernelInfo = std::make_unique<KernelInfo>();
 
-    std::unique_ptr<MockKernel> kernel(new MockKernel(&program, *kernelInfo, *pClDevice));
+    std::unique_ptr<MockKernel> kernel(new MockKernel(&program, *kernelInfo));
 
     auto &indirectHeap = cmdQ.getIndirectHeap(IndirectHeap::INDIRECT_OBJECT, 8192);
     indirectHeap.getSpace(128u);
@@ -548,7 +548,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, whenSendingIndirectStateThenKe
     modifiedKernelInfo.workgroupDimensionsOrder[0] = 2;
     modifiedKernelInfo.workgroupDimensionsOrder[1] = 1;
     modifiedKernelInfo.workgroupDimensionsOrder[2] = 0;
-    MockKernel mockKernel{kernel->getProgram(), modifiedKernelInfo, kernel->getDevice(), false};
+    MockKernel mockKernel{kernel->getProgram(), modifiedKernelInfo, false};
     uint32_t interfaceDescriptorIndex = 0;
     auto isCcsUsed = EngineHelpers::isCcs(cmdQ.getGpgpuEngine().osContext->getEngineType());
     auto kernelUsesLocalIds = HardwareCommandsHelper<FamilyType>::kernelUsesLocalIds(mockKernel);
@@ -724,7 +724,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, WhenGettingBindingTableStateTh
     program.setConstantSurface(&gfxConstAlloc);
 
     // create kernel
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // setup surface state heap
     constexpr uint32_t numSurfaces = 5;
@@ -841,7 +841,7 @@ HWTEST_F(HardwareCommandsTest, GivenBuffersNotRequiringSshWhenSettingBindingTabl
     MockProgram program(&context, false, toClDeviceVector(*pClDevice));
 
     // create kernel
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // setup surface state heap
     char surfaceStateHeap[256];
@@ -896,7 +896,7 @@ HWTEST_F(HardwareCommandsTest, GivenZeroSurfaceStatesWhenSettingBindingTableStat
     MockProgram program(&context, false, toClDeviceVector(*pClDevice));
 
     // create kernel
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // setup surface state heap
     char surfaceStateHeap[256];
diff --git a/opencl/test/unit_test/kernel/clone_kernel_tests.cpp b/opencl/test/unit_test/kernel/clone_kernel_tests.cpp
index 3d20f49cbd..6a4259084f 100644
--- a/opencl/test/unit_test/kernel/clone_kernel_tests.cpp
+++ b/opencl/test/unit_test/kernel/clone_kernel_tests.cpp
@@ -83,12 +83,12 @@ class CloneKernelFixture : public ContextFixture, public ClDeviceFixture {
 
         pProgram = new MockProgram(pContext, false, toClDeviceVector(*pClDevice));
 
-        pSourceKernel = new MockKernel(pProgram, *pKernelInfo, *pClDevice);
+        pSourceKernel = new MockKernel(pProgram, *pKernelInfo);
         ASSERT_EQ(CL_SUCCESS, pSourceKernel->initialize());
         char pSourceCrossThreadData[64] = {};
         pSourceKernel->setCrossThreadData(pSourceCrossThreadData, sizeof(pSourceCrossThreadData));
 
-        pClonedKernel = new MockKernel(pProgram, *pKernelInfo, *pClDevice);
+        pClonedKernel = new MockKernel(pProgram, *pKernelInfo);
         ASSERT_EQ(CL_SUCCESS, pClonedKernel->initialize());
         char pClonedCrossThreadData[64] = {};
         pClonedKernel->setCrossThreadData(pClonedCrossThreadData, sizeof(pClonedCrossThreadData));
diff --git a/opencl/test/unit_test/kernel/kernel_accelerator_arg_tests.cpp b/opencl/test/unit_test/kernel/kernel_accelerator_arg_tests.cpp
index a0ae603a30..c7d989dfbd 100644
--- a/opencl/test/unit_test/kernel/kernel_accelerator_arg_tests.cpp
+++ b/opencl/test/unit_test/kernel/kernel_accelerator_arg_tests.cpp
@@ -61,7 +61,7 @@ class KernelArgAcceleratorFixture : public ContextFixture, public ClDeviceFixtur
         pKernelInfo->kernelArgInfo[0].offsetVmeSearchPathType = 0x1c;
 
         pProgram = new MockProgram(pContext, false, toClDeviceVector(*pClDevice));
-        pKernel = new MockKernel(pProgram, *pKernelInfo, *pClDevice);
+        pKernel = new MockKernel(pProgram, *pKernelInfo);
         ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
 
         pKernel->setKernelArgHandler(0, &Kernel::setArgAccelerator);
diff --git a/opencl/test/unit_test/kernel/kernel_arg_buffer_fixture.cpp b/opencl/test/unit_test/kernel/kernel_arg_buffer_fixture.cpp
index 827195637a..0b44956a9e 100644
--- a/opencl/test/unit_test/kernel/kernel_arg_buffer_fixture.cpp
+++ b/opencl/test/unit_test/kernel/kernel_arg_buffer_fixture.cpp
@@ -48,7 +48,7 @@ void KernelArgBufferFixture::SetUp() {
 
     pProgram = new MockProgram(pContext, false, toClDeviceVector(*pClDevice));
 
-    pKernel = new MockKernel(pProgram, *pKernelInfo, *pClDevice);
+    pKernel = new MockKernel(pProgram, *pKernelInfo);
     ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
     pKernel->setCrossThreadData(pCrossThreadData, sizeof(pCrossThreadData));
 
diff --git a/opencl/test/unit_test/kernel/kernel_arg_dev_queue_tests.cpp b/opencl/test/unit_test/kernel/kernel_arg_dev_queue_tests.cpp
index a9c6093c3d..7221a9d69c 100644
--- a/opencl/test/unit_test/kernel/kernel_arg_dev_queue_tests.cpp
+++ b/opencl/test/unit_test/kernel/kernel_arg_dev_queue_tests.cpp
@@ -33,7 +33,7 @@ struct KernelArgDevQueueTest : public DeviceHostQueueFixture<DeviceQueue> {
         pKernelInfo->kernelArgInfo[0].kernelArgPatchInfoVector.push_back(kernelArgPatchInfo);
 
         program = std::make_unique<MockProgram>(toClDeviceVector(*pDevice));
-        pKernel = new MockKernel(program.get(), *pKernelInfo, *pDevice);
+        pKernel = new MockKernel(program.get(), *pKernelInfo);
         ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
 
         uint8_t pCrossThreadData[crossThreadDataSize];
diff --git a/opencl/test/unit_test/kernel/kernel_arg_pipe_tests.cpp b/opencl/test/unit_test/kernel/kernel_arg_pipe_tests.cpp
index 45a878ad61..7889d1f546 100644
--- a/opencl/test/unit_test/kernel/kernel_arg_pipe_tests.cpp
+++ b/opencl/test/unit_test/kernel/kernel_arg_pipe_tests.cpp
@@ -56,7 +56,7 @@ class KernelArgPipeFixture : public ContextFixture, public ClDeviceFixture {
 
         pProgram = new MockProgram(pContext, false, toClDeviceVector(*pClDevice));
 
-        pKernel = new MockKernel(pProgram, *pKernelInfo, *pClDevice);
+        pKernel = new MockKernel(pProgram, *pKernelInfo);
         ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
         pKernel->setCrossThreadData(pCrossThreadData, sizeof(pCrossThreadData));
 
diff --git a/opencl/test/unit_test/kernel/kernel_arg_svm_tests.cpp b/opencl/test/unit_test/kernel/kernel_arg_svm_tests.cpp
index 0618e810be..978bb88a40 100644
--- a/opencl/test/unit_test/kernel/kernel_arg_svm_tests.cpp
+++ b/opencl/test/unit_test/kernel/kernel_arg_svm_tests.cpp
@@ -55,7 +55,7 @@ class KernelArgSvmFixture_ : public ContextFixture, public ClDeviceFixture {
 
         pProgram = new MockProgram(pContext, false, toClDeviceVector(*pClDevice));
 
-        pKernel = new MockKernel(pProgram, *pKernelInfo, *pClDevice);
+        pKernel = new MockKernel(pProgram, *pKernelInfo);
         ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
         pKernel->setCrossThreadData(pCrossThreadData, sizeof(pCrossThreadData));
     }
diff --git a/opencl/test/unit_test/kernel/kernel_immediate_arg_tests.cpp b/opencl/test/unit_test/kernel/kernel_immediate_arg_tests.cpp
index fe16f933c0..dc38241e4c 100644
--- a/opencl/test/unit_test/kernel/kernel_immediate_arg_tests.cpp
+++ b/opencl/test/unit_test/kernel/kernel_immediate_arg_tests.cpp
@@ -57,7 +57,7 @@ class KernelArgImmediateTest : public Test<ClDeviceFixture> {
         pKernelInfo->kernelArgInfo[0].kernelArgPatchInfoVector[0].size = sizeof(T);
 
         program = std::make_unique<MockProgram>(toClDeviceVector(*pClDevice));
-        pKernel = new MockKernel(program.get(), *pKernelInfo, *pClDevice);
+        pKernel = new MockKernel(program.get(), *pKernelInfo);
         ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
         pKernel->setCrossThreadData(pCrossThreadData, sizeof(pCrossThreadData));
 
diff --git a/opencl/test/unit_test/kernel/kernel_reflection_surface_tests.cpp b/opencl/test/unit_test/kernel/kernel_reflection_surface_tests.cpp
index 13ee5141d9..db42720915 100644
--- a/opencl/test/unit_test/kernel/kernel_reflection_surface_tests.cpp
+++ b/opencl/test/unit_test/kernel/kernel_reflection_surface_tests.cpp
@@ -606,7 +606,7 @@ TEST(KernelReflectionSurfaceTestSingle, GivenNonParentKernelWhenCreatingKernelRe
     MockClDevice device{new MockDevice};
     MockProgram program(toClDeviceVector(device));
     KernelInfo info;
-    MockKernel kernel(&program, info, device);
+    MockKernel kernel(&program, info);
 
     EXPECT_FALSE(kernel.isParentKernel);
 
@@ -624,7 +624,7 @@ TEST(KernelReflectionSurfaceTestSingle, GivenNonSchedulerKernelWithForcedSchedul
     MockClDevice device{new MockDevice};
     MockProgram program(toClDeviceVector(device));
     KernelInfo info;
-    MockKernel kernel(&program, info, device);
+    MockKernel kernel(&program, info);
 
     EXPECT_FALSE(kernel.isParentKernel);
 
@@ -661,7 +661,7 @@ TEST(KernelReflectionSurfaceTestSingle, GivenNoKernelArgsWhenObtainingKernelRefl
     bindingTableState.SurfaceStateOffset = 0;
     info.patchInfo.bindingTableState = &bindingTableState;
 
-    MockKernel kernel(&program, info, *device.get());
+    MockKernel kernel(&program, info);
 
     EXPECT_TRUE(kernel.isParentKernel);
 
@@ -724,7 +724,7 @@ TEST(KernelReflectionSurfaceTestSingle, GivenDeviceQueueKernelArgWhenObtainingKe
     info.kernelArgInfo[0].kernelArgPatchInfoVector[0].crossthreadOffset = devQueueCurbeOffset;
     info.kernelArgInfo[0].kernelArgPatchInfoVector[0].size = devQueueCurbeSize;
 
-    MockKernel kernel(&program, info, *device.get());
+    MockKernel kernel(&program, info);
 
     EXPECT_TRUE(kernel.isParentKernel);
 
@@ -2131,7 +2131,7 @@ TEST_F(KernelReflectionMultiDeviceTest, GivenNoKernelArgsWhenObtainingKernelRefl
     bindingTableState.SurfaceStateOffset = 0;
     info.patchInfo.bindingTableState = &bindingTableState;
 
-    MockKernel kernel(&program, info, *device.get());
+    MockKernel kernel(&program, info);
 
     EXPECT_TRUE(kernel.isParentKernel);
 
@@ -2194,7 +2194,7 @@ TEST_F(KernelReflectionMultiDeviceTest, GivenDeviceQueueKernelArgWhenObtainingKe
     info.kernelArgInfo[0].kernelArgPatchInfoVector[0].crossthreadOffset = devQueueCurbeOffset;
     info.kernelArgInfo[0].kernelArgPatchInfoVector[0].size = devQueueCurbeSize;
 
-    MockKernel kernel(&program, info, *device.get());
+    MockKernel kernel(&program, info);
 
     EXPECT_TRUE(kernel.isParentKernel);
 
diff --git a/opencl/test/unit_test/kernel/kernel_slm_arg_tests.cpp b/opencl/test/unit_test/kernel/kernel_slm_arg_tests.cpp
index 0d767eae72..f230fd335e 100644
--- a/opencl/test/unit_test/kernel/kernel_slm_arg_tests.cpp
+++ b/opencl/test/unit_test/kernel/kernel_slm_arg_tests.cpp
@@ -40,7 +40,7 @@ class KernelSlmArgTest : public Test<ClDeviceFixture> {
         pKernelInfo->workloadInfo.slmStaticSize = 3 * KB;
 
         program = std::make_unique<MockProgram>(toClDeviceVector(*pClDevice));
-        pKernel = new MockKernel(program.get(), *pKernelInfo, *pClDevice);
+        pKernel = new MockKernel(program.get(), *pKernelInfo);
         ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
 
         pKernel->setKernelArgHandler(0, &Kernel::setArgLocal);
diff --git a/opencl/test/unit_test/kernel/kernel_slm_tests.cpp b/opencl/test/unit_test/kernel/kernel_slm_tests.cpp
index acb37dfaef..fad9f93f49 100644
--- a/opencl/test/unit_test/kernel/kernel_slm_tests.cpp
+++ b/opencl/test/unit_test/kernel/kernel_slm_tests.cpp
@@ -72,7 +72,7 @@ HWCMDTEST_P(IGFX_GEN8_CORE, KernelSLMAndBarrierTest, GivenStaticSlmSizeWhenProgr
     executionEnvironment.HasBarriers = 1;
     kernelInfo.workloadInfo.slmStaticSize = GetParam() * KB;
 
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     // After creating Mock Kernel now create Indirect Heap
diff --git a/opencl/test/unit_test/kernel/kernel_tests.cpp b/opencl/test/unit_test/kernel/kernel_tests.cpp
index bf2122416e..98311ec7d1 100644
--- a/opencl/test/unit_test/kernel/kernel_tests.cpp
+++ b/opencl/test/unit_test/kernel/kernel_tests.cpp
@@ -562,7 +562,7 @@ TEST_F(KernelPrivateSurfaceTest, WhenChangingResidencyThenCsrResidencySizeIsUpda
     // create kernel
     MockContext context;
     MockProgram program(&context, false, toClDeviceVector(*pClDevice));
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
     ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
 
     // Test it
@@ -600,7 +600,7 @@ TEST_F(KernelPrivateSurfaceTest, givenKernelWithPrivateSurfaceThatIsInUseByGpuWh
 
     MockContext context;
     MockProgram program(&context, false, toClDeviceVector(*pClDevice));
-    std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo, *pClDevice));
+    std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo));
     pKernel->initialize();
 
     auto &csr = pDevice->getGpgpuCommandStreamReceiver();
@@ -645,7 +645,7 @@ TEST_F(KernelPrivateSurfaceTest, WhenPrivateSurfaceAllocationFailsThenOutOfResou
     MockContext context;
     MockProgram program(&context, false, toClDeviceVector(*pClDevice));
     MemoryManagementFixture::InjectedFunction method = [&](size_t failureIndex) {
-        MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+        MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
         if (MemoryManagement::nonfailingAllocation == failureIndex) {
             EXPECT_EQ(CL_SUCCESS, pKernel->initialize());
@@ -689,7 +689,7 @@ TEST_F(KernelPrivateSurfaceTest, given32BitDeviceWhenKernelIsCreatedThenPrivateS
         // create kernel
         MockContext context;
         MockProgram program(&context, false, toClDeviceVector(*pClDevice));
-        MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+        MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
         ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
 
@@ -723,7 +723,7 @@ HWTEST_F(KernelPrivateSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenPri
     MockProgram program(&context, false, toClDeviceVector(*pClDevice));
 
     // create kernel
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // setup surface state heap
     char surfaceStateHeap[0x80];
@@ -771,7 +771,7 @@ TEST_F(KernelPrivateSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenPriv
     program.setConstantSurface(&gfxAlloc);
 
     // create kernel
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // define stateful path
     pKernelInfo->usesSsh = false;
@@ -813,7 +813,7 @@ TEST_F(KernelPrivateSurfaceTest, GivenKernelWhenPrivateSurfaceTooBigAndGpuPointe
     pKernelInfo->patchInfo.executionEnvironment = executionEnvironment.get();
     MockContext context;
     MockProgram program(&context, false, toClDeviceVector(*pClDevice));
-    std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo, *pClDevice));
+    std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo));
     pKernelInfo->gpuPointerSize = 4;
     pDevice->getMemoryManager()->setForce32BitAllocations(false);
     if (pDevice->getDeviceInfo().computeUnitsUsedForScratch == 0)
@@ -832,7 +832,7 @@ TEST_F(KernelPrivateSurfaceTest, GivenKernelWhenPrivateSurfaceTooBigAndGpuPointe
     pKernelInfo->patchInfo.executionEnvironment = executionEnvironment.get();
     MockContext context;
     MockProgram program(&context, false, toClDeviceVector(*pClDevice));
-    std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo, *pClDevice));
+    std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo));
     pKernelInfo->gpuPointerSize = 4;
     pDevice->getMemoryManager()->setForce32BitAllocations(true);
     if (pDevice->getDeviceInfo().computeUnitsUsedForScratch == 0)
@@ -851,7 +851,7 @@ TEST_F(KernelPrivateSurfaceTest, GivenKernelWhenPrivateSurfaceTooBigAndGpuPointe
     pKernelInfo->patchInfo.executionEnvironment = executionEnvironment.get();
     MockContext context;
     MockProgram program(&context, false, toClDeviceVector(*pClDevice));
-    std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo, *pClDevice));
+    std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo));
     pKernelInfo->gpuPointerSize = 8;
     pDevice->getMemoryManager()->setForce32BitAllocations(true);
     if (pDevice->getDeviceInfo().computeUnitsUsedForScratch == 0)
@@ -890,7 +890,7 @@ TEST_F(KernelGlobalSurfaceTest, givenBuiltInKernelWhenKernelIsCreatedThenGlobalS
     MockContext context;
     MockProgram program(&context, false, toClDeviceVector(*pClDevice));
     program.setGlobalSurface(&gfxAlloc);
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     pKernel->isBuiltIn = true;
 
@@ -932,7 +932,7 @@ TEST_F(KernelGlobalSurfaceTest, givenNDRangeKernelWhenKernelIsCreatedThenGlobalS
     // create kernel
     MockProgram program(toClDeviceVector(*pClDevice));
     program.setGlobalSurface(&gfxAlloc);
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
 
@@ -971,7 +971,7 @@ HWTEST_F(KernelGlobalSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenGlob
     program.setGlobalSurface(&gfxAlloc);
 
     // create kernel
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // setup surface state heap
     char surfaceStateHeap[0x80];
@@ -1017,7 +1017,7 @@ TEST_F(KernelGlobalSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenGloba
     program.setGlobalSurface(&gfxAlloc);
 
     // create kernel
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // define stateful path
     pKernelInfo->usesSsh = false;
@@ -1062,7 +1062,7 @@ TEST_F(KernelConstantSurfaceTest, givenBuiltInKernelWhenKernelIsCreatedThenConst
     // create kernel
     MockProgram program(toClDeviceVector(*pClDevice));
     program.setConstantSurface(&gfxAlloc);
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     pKernel->isBuiltIn = true;
 
@@ -1104,7 +1104,7 @@ TEST_F(KernelConstantSurfaceTest, givenNDRangeKernelWhenKernelIsCreatedThenConst
     // create kernel
     MockProgram program(toClDeviceVector(*pClDevice));
     program.setConstantSurface(&gfxAlloc);
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
 
@@ -1143,7 +1143,7 @@ HWTEST_F(KernelConstantSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenCo
     program.setConstantSurface(&gfxAlloc);
 
     // create kernel
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // setup surface state heap
     char surfaceStateHeap[0x80];
@@ -1189,7 +1189,7 @@ TEST_F(KernelConstantSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenCon
     program.setConstantSurface(&gfxAlloc);
 
     // create kernel
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // define stateful path
     pKernelInfo->usesSsh = false;
@@ -1225,7 +1225,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, KernelEventPoolSurfaceTest, givenStatefulKernelWhenK
 
     // create kernel
     MockProgram program(&context, false, toClDeviceVector(*pClDevice));
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // setup surface state heap
     char surfaceStateHeap[0x80];
@@ -1274,7 +1274,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, KernelEventPoolSurfaceTest, givenStatefulKernelWhenE
 
     // create kernel
     MockProgram program(&context, false, toClDeviceVector(*pClDevice));
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // setup surface state heap
     char surfaceStateHeap[0x80];
@@ -1317,7 +1317,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, KernelEventPoolSurfaceTest, givenKernelWithNullEvent
 
     // create kernel
     MockProgram program(toClDeviceVector(*pClDevice));
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // define stateful path
     pKernelInfo->usesSsh = false;
@@ -1355,7 +1355,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, KernelEventPoolSurfaceTest, givenStatelessKernelWhen
 
     // create kernel
     MockProgram program(toClDeviceVector(*pClDevice));
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // define stateful path
     pKernelInfo->usesSsh = false;
@@ -1391,7 +1391,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, KernelEventPoolSurfaceTest, givenStatelessKernelWhen
 
     // create kernel
     MockProgram program(toClDeviceVector(*pClDevice));
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // define stateful path
     pKernelInfo->usesSsh = false;
@@ -1429,7 +1429,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, KernelDefaultDeviceQueueSurfaceTest, givenStatefulKe
 
     // create kernel
     MockProgram program(&context, false, toClDeviceVector(*pClDevice));
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // setup surface state heap
     char surfaceStateHeap[0x80];
@@ -1478,7 +1478,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, KernelDefaultDeviceQueueSurfaceTest, givenStatefulKe
 
     // create kernel
     MockProgram program(&context, false, toClDeviceVector(*pClDevice));
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // setup surface state heap
     char surfaceStateHeap[0x80];
@@ -1529,7 +1529,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, KernelDefaultDeviceQueueSurfaceTest, givenStatelessK
 
     // create kernel
     MockProgram program(toClDeviceVector(*pClDevice));
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // define stateful path
     pKernelInfo->usesSsh = false;
@@ -1557,7 +1557,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, KernelDefaultDeviceQueueSurfaceTest, givenKernelWith
 
     // create kernel
     MockProgram program(toClDeviceVector(*pClDevice));
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // define stateful path
     pKernelInfo->usesSsh = false;
@@ -1595,7 +1595,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, KernelDefaultDeviceQueueSurfaceTest, givenStatelessK
 
     // create kernel
     MockProgram program(toClDeviceVector(*pClDevice));
-    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
+    MockKernel *pKernel = new MockKernel(&program, *pKernelInfo);
 
     // define stateful path
     pKernelInfo->usesSsh = false;
@@ -1641,7 +1641,7 @@ HWTEST_F(KernelResidencyTest, givenKernelWhenMakeResidentIsCalledThenKernelIsaIs
     MockProgram program(toClDeviceVector(*pClDevice));
     MockContext ctx;
     program.setContext(&ctx);
-    std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo, *pClDevice));
+    std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo));
     ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
     pKernel->setCrossThreadData(pCrossThreadData, sizeof(pCrossThreadData));
 
@@ -1666,7 +1666,7 @@ HWTEST_F(KernelResidencyTest, givenKernelWhenMakeResidentIsCalledThenExportedFun
     program.buildInfos[pDevice->getRootDeviceIndex()].exportedFunctionsSurface = exportedFunctionsSurface.get();
     MockContext ctx;
     program.setContext(&ctx);
-    std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo, *pClDevice));
+    std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo));
     ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
 
     EXPECT_EQ(0u, commandStreamReceiver.makeResidentAllocations.size());
@@ -1703,7 +1703,7 @@ HWTEST_F(KernelResidencyTest, givenKernelWhenMakeResidentIsCalledThenGlobalBuffe
     MockContext ctx;
     program.setContext(&ctx);
     program.buildInfos[pDevice->getRootDeviceIndex()].globalSurface = new MockGraphicsAllocation();
-    std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo, *pClDevice));
+    std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo));
     ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
 
     EXPECT_EQ(0u, commandStreamReceiver.makeResidentAllocations.size());
@@ -2042,7 +2042,7 @@ TEST(KernelImageDetectionTests, givenKernelWithImagesOnlyWhenItIsAskedIfItHasIma
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
     auto context = clUniquePtr(new MockContext(device.get()));
     auto program = clUniquePtr(new MockProgram(context.get(), false, toClDeviceVector(*device)));
-    auto kernel = clUniquePtr(new MockKernel(program.get(), *pKernelInfo, *device));
+    auto kernel = clUniquePtr(new MockKernel(program.get(), *pKernelInfo));
     EXPECT_FALSE(kernel->usesOnlyImages());
     kernel->initialize();
     EXPECT_TRUE(kernel->usesOnlyImages());
@@ -2058,7 +2058,7 @@ TEST(KernelImageDetectionTests, givenKernelWithImagesAndBuffersWhenItIsAskedIfIt
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
     auto context = clUniquePtr(new MockContext(device.get()));
     auto program = clUniquePtr(new MockProgram(context.get(), false, toClDeviceVector(*device)));
-    auto kernel = clUniquePtr(new MockKernel(program.get(), *pKernelInfo, *device));
+    auto kernel = clUniquePtr(new MockKernel(program.get(), *pKernelInfo));
     EXPECT_FALSE(kernel->usesOnlyImages());
     kernel->initialize();
     EXPECT_FALSE(kernel->usesOnlyImages());
@@ -2072,7 +2072,7 @@ TEST(KernelImageDetectionTests, givenKernelWithNoImagesWhenItIsAskedIfItHasImage
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
     auto context = clUniquePtr(new MockContext(device.get()));
     auto program = clUniquePtr(new MockProgram(context.get(), false, toClDeviceVector(*device)));
-    auto kernel = clUniquePtr(new MockKernel(program.get(), *pKernelInfo, *device));
+    auto kernel = clUniquePtr(new MockKernel(program.get(), *pKernelInfo));
     EXPECT_FALSE(kernel->usesOnlyImages());
     kernel->initialize();
     EXPECT_FALSE(kernel->usesOnlyImages());
@@ -2126,7 +2126,7 @@ HWTEST_F(KernelResidencyTest, WhenMakingArgsResidentThenImageFromImageCheckIsCor
 
     auto program = std::make_unique<MockProgram>(toClDeviceVector(*pClDevice));
     program->setContext(&context);
-    std::unique_ptr<MockKernel> pKernel(new MockKernel(program.get(), *pKernelInfo, *pClDevice));
+    std::unique_ptr<MockKernel> pKernel(new MockKernel(program.get(), *pKernelInfo));
 
     ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
     pKernel->storeKernelArg(0, Kernel::IMAGE_OBJ, (cl_mem)imageY.get(), NULL, 0);
@@ -2148,7 +2148,7 @@ struct KernelExecutionEnvironmentTest : public Test<ClDeviceFixture> {
         executionEnvironment.CompiledSIMD32 = 1;
         pKernelInfo->patchInfo.executionEnvironment = &executionEnvironment;
 
-        pKernel = new MockKernel(program.get(), *pKernelInfo, *pClDevice);
+        pKernel = new MockKernel(program.get(), *pKernelInfo);
         ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
     }
 
@@ -2305,7 +2305,7 @@ TEST_F(KernelCrossThreadTests, WhenKernelIsInitializedThenGlobalWorkOffsetIsCorr
 
     pKernelInfo->workloadInfo.globalWorkOffsetOffsets[1] = 4;
 
-    MockKernel kernel(program.get(), *pKernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), *pKernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     EXPECT_EQ(&Kernel::dummyPatchLocation, kernel.globalWorkOffsetX);
@@ -2318,7 +2318,7 @@ TEST_F(KernelCrossThreadTests, WhenKernelIsInitializedThenLocalWorkSizeIsCorrect
 
     pKernelInfo->workloadInfo.localWorkSizeOffsets[0] = 0xc;
 
-    MockKernel kernel(program.get(), *pKernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), *pKernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     EXPECT_NE(nullptr, kernel.localWorkSizeX);
@@ -2331,7 +2331,7 @@ TEST_F(KernelCrossThreadTests, WhenKernelIsInitializedThenLocalWorkSize2IsCorrec
 
     pKernelInfo->workloadInfo.localWorkSizeOffsets2[1] = 0xd;
 
-    MockKernel kernel(program.get(), *pKernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), *pKernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     EXPECT_EQ(&Kernel::dummyPatchLocation, kernel.localWorkSizeX2);
@@ -2344,7 +2344,7 @@ TEST_F(KernelCrossThreadTests, WhenKernelIsInitializedThenGlobalWorkSizeIsCorrec
 
     pKernelInfo->workloadInfo.globalWorkSizeOffsets[2] = 8;
 
-    MockKernel kernel(program.get(), *pKernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), *pKernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     EXPECT_EQ(&Kernel::dummyPatchLocation, kernel.globalWorkSizeX);
@@ -2357,7 +2357,7 @@ TEST_F(KernelCrossThreadTests, WhenKernelIsInitializedThenLocalWorkDimIsCorrect)
 
     pKernelInfo->workloadInfo.workDimOffset = 12;
 
-    MockKernel kernel(program.get(), *pKernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), *pKernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     EXPECT_NE(nullptr, kernel.workDim);
@@ -2370,7 +2370,7 @@ TEST_F(KernelCrossThreadTests, WhenKernelIsInitializedThenNumWorkGroupsIsCorrect
     pKernelInfo->workloadInfo.numWorkGroupsOffset[1] = 1 * sizeof(uint32_t);
     pKernelInfo->workloadInfo.numWorkGroupsOffset[2] = 2 * sizeof(uint32_t);
 
-    MockKernel kernel(program.get(), *pKernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), *pKernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     EXPECT_NE(nullptr, kernel.numWorkGroupsX);
@@ -2385,7 +2385,7 @@ TEST_F(KernelCrossThreadTests, WhenKernelIsInitializedThenEnqueuedLocalWorkSizeI
 
     pKernelInfo->workloadInfo.enqueuedLocalWorkSizeOffsets[0] = 0;
 
-    MockKernel kernel(program.get(), *pKernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), *pKernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     EXPECT_NE(nullptr, kernel.enqueuedLocalWorkSizeX);
@@ -2398,7 +2398,7 @@ TEST_F(KernelCrossThreadTests, WhenKernelIsInitializedThenEnqueuedMaxWorkGroupSi
 
     pKernelInfo->workloadInfo.maxWorkGroupSizeOffset = 12;
 
-    MockKernel kernel(program.get(), *pKernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), *pKernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     EXPECT_NE(nullptr, kernel.maxWorkGroupSizeForCrossThreadData);
@@ -2411,7 +2411,7 @@ TEST_F(KernelCrossThreadTests, WhenKernelIsInitializedThenEnqueuedMaxWorkGroupSi
 TEST_F(KernelCrossThreadTests, WhenKernelIsInitializedThenDataParameterSimdSizeIsCorrect) {
 
     pKernelInfo->workloadInfo.simdSizeOffset = 16;
-    MockKernel kernel(program.get(), *pKernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), *pKernelInfo);
     executionEnvironment.CompiledSIMD32 = false;
     executionEnvironment.CompiledSIMD16 = true;
     executionEnvironment.CompiledSIMD8 = true;
@@ -2425,7 +2425,7 @@ TEST_F(KernelCrossThreadTests, WhenKernelIsInitializedThenDataParameterSimdSizeI
 
 TEST_F(KernelCrossThreadTests, GivenParentEventOffsetWhenKernelIsInitializedThenParentEventIsInitiatedWithInvalid) {
     pKernelInfo->workloadInfo.parentEventOffset = 16;
-    MockKernel kernel(program.get(), *pKernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), *pKernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     EXPECT_NE(nullptr, kernel.parentEventOffset);
@@ -2437,7 +2437,7 @@ TEST_F(KernelCrossThreadTests, GivenParentEventOffsetWhenKernelIsInitializedThen
 TEST_F(KernelCrossThreadTests, WhenAddingKernelThenProgramRefCountIsIncremented) {
 
     auto refCount = program->getReference();
-    MockKernel *kernel = new MockKernel(program.get(), *pKernelInfo, *pClDevice);
+    MockKernel *kernel = new MockKernel(program.get(), *pKernelInfo);
     auto refCount2 = program->getReference();
     EXPECT_EQ(refCount2, refCount + 1);
 
@@ -2450,7 +2450,7 @@ TEST_F(KernelCrossThreadTests, GivenSlmStatisSizeWhenCreatingKernelThenSlmTotalS
 
     pKernelInfo->workloadInfo.slmStaticSize = 1024;
 
-    MockKernel *kernel = new MockKernel(program.get(), *pKernelInfo, *pClDevice);
+    MockKernel *kernel = new MockKernel(program.get(), *pKernelInfo);
 
     EXPECT_EQ(1024u, kernel->slmTotalSize);
 
@@ -2464,7 +2464,7 @@ TEST_F(KernelCrossThreadTests, givenKernelWithPrivateMemoryWhenItIsCreatedThenCu
     allocatePrivate.PerThreadPrivateMemorySize = 1;
     pKernelInfo->patchInfo.pAllocateStatelessPrivateSurface = &allocatePrivate;
 
-    MockKernel *kernel = new MockKernel(program.get(), *pKernelInfo, *pClDevice);
+    MockKernel *kernel = new MockKernel(program.get(), *pKernelInfo);
 
     kernel->initialize();
 
@@ -2483,7 +2483,7 @@ TEST_F(KernelCrossThreadTests, givenKernelWithPrivateMemoryWhenItIsCreatedThenCu
 TEST_F(KernelCrossThreadTests, givenKernelWithPreferredWkgMultipleWhenItIsCreatedThenCurbeIsPatchedProperly) {
 
     pKernelInfo->workloadInfo.preferredWkgMultipleOffset = 8;
-    MockKernel *kernel = new MockKernel(program.get(), *pKernelInfo, *pClDevice);
+    MockKernel *kernel = new MockKernel(program.get(), *pKernelInfo);
 
     kernel->initialize();
 
@@ -2672,7 +2672,7 @@ TEST(KernelTest, givenKernelWithKernelInfoWith32bitPointerSizeThenReport32bit) {
     MockContext context;
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
     MockProgram program(&context, false, toClDeviceVector(*device));
-    std::unique_ptr<MockKernel> kernel(new MockKernel(&program, info, *device.get()));
+    std::unique_ptr<MockKernel> kernel(new MockKernel(&program, info));
 
     EXPECT_TRUE(kernel->is32Bit());
 }
@@ -2684,7 +2684,7 @@ TEST(KernelTest, givenKernelWithKernelInfoWith64bitPointerSizeThenReport64bit) {
     MockContext context;
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
     MockProgram program(&context, false, toClDeviceVector(*device));
-    std::unique_ptr<MockKernel> kernel(new MockKernel(&program, info, *device.get()));
+    std::unique_ptr<MockKernel> kernel(new MockKernel(&program, info));
 
     EXPECT_FALSE(kernel->is32Bit());
 }
@@ -3227,7 +3227,7 @@ TEST_F(KernelMultiRootDeviceTest, WhenGettingRootDeviceIndexThenCorrectRootDevic
     kernelInfo->patchInfo.pAllocateStatelessPrivateSurface = &tokenSPS;
 
     MockProgram program(context.get(), false, toClDeviceVector(*device));
-    std::unique_ptr<MockKernel> kernel(new MockKernel(&program, *kernelInfo, *device.get()));
+    std::unique_ptr<MockKernel> kernel(new MockKernel(&program, *kernelInfo));
     kernel->initialize();
 
     auto privateSurface = kernel->getPrivateSurface();
@@ -3246,7 +3246,7 @@ TEST(KernelCreateTest, whenInitFailedThenReturnNull) {
         MockClDevice mDevice{new MockDevice};
     } mockProgram;
     struct MockKernel {
-        MockKernel(MockProgram *, const KernelInfo &, ClDevice &) {}
+        MockKernel(MockProgram *, const KernelInfo &) {}
         int initialize() { return -1; };
     };
 
diff --git a/opencl/test/unit_test/kernel/kernel_transformable_tests.cpp b/opencl/test/unit_test/kernel/kernel_transformable_tests.cpp
index 2c878028b3..a13c1c736d 100644
--- a/opencl/test/unit_test/kernel/kernel_transformable_tests.cpp
+++ b/opencl/test/unit_test/kernel/kernel_transformable_tests.cpp
@@ -45,7 +45,7 @@ class KernelTransformableTest : public ::testing::Test {
         pKernelInfo->argumentsToPatchNum = 4;
 
         program = std::make_unique<MockProgram>(toClDeviceVector(*context.getDevice(0)));
-        pKernel.reset(new MockKernel(program.get(), *pKernelInfo, *context.getDevice(0)));
+        pKernel.reset(new MockKernel(program.get(), *pKernelInfo));
         ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
 
         pKernel->setKernelArgHandler(0, &Kernel::setArgSampler);
diff --git a/opencl/test/unit_test/kernel/parent_kernel_tests.cpp b/opencl/test/unit_test/kernel/parent_kernel_tests.cpp
index e9858aaf42..59f0672a8a 100644
--- a/opencl/test/unit_test/kernel/parent_kernel_tests.cpp
+++ b/opencl/test/unit_test/kernel/parent_kernel_tests.cpp
@@ -27,7 +27,7 @@ class MockKernelWithArgumentAccess : public Kernel {
     class ObjectCountsPublic : public Kernel::ObjectCounts {
     };
 
-    MockKernelWithArgumentAccess(Program *programArg, const KernelInfo &kernelInfoArg, const ClDevice &deviceArg) : Kernel(programArg, kernelInfoArg, deviceArg) {
+    MockKernelWithArgumentAccess(Program *programArg, const KernelInfo &kernelInfoArg) : Kernel(programArg, kernelInfoArg, false) {
     }
 
     void getParentObjectCountsPublic(MockKernelWithArgumentAccess::ObjectCountsPublic &objectCount) {
@@ -44,7 +44,7 @@ TEST(ParentKernelTest, WhenArgsAddedThenObjectCountsAreIncremented) {
 
     info.patchInfo.executionEnvironment = &environment;
 
-    MockKernelWithArgumentAccess kernel(&program, info, *device);
+    MockKernelWithArgumentAccess kernel(&program, info);
 
     std::vector<Kernel::SimpleKernelArgInfo> &args = kernel.getKernelArguments();
 
diff --git a/opencl/test/unit_test/mem_obj/buffer_set_arg_tests.cpp b/opencl/test/unit_test/mem_obj/buffer_set_arg_tests.cpp
index f296b941f2..806f1cae3e 100644
--- a/opencl/test/unit_test/mem_obj/buffer_set_arg_tests.cpp
+++ b/opencl/test/unit_test/mem_obj/buffer_set_arg_tests.cpp
@@ -70,7 +70,7 @@ class BufferSetArgTest : public ContextFixture,
 
         pProgram = new MockProgram(pContext, false, toClDeviceVector(*pClDevice));
 
-        pKernel = new MockKernel(pProgram, *pKernelInfo, *pClDevice);
+        pKernel = new MockKernel(pProgram, *pKernelInfo);
         ASSERT_NE(nullptr, pKernel);
         ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
         pKernel->setCrossThreadData(pCrossThreadData, sizeof(pCrossThreadData));
diff --git a/opencl/test/unit_test/mem_obj/image_set_arg_tests.cpp b/opencl/test/unit_test/mem_obj/image_set_arg_tests.cpp
index e8f1cebf0f..7c45dc5f38 100644
--- a/opencl/test/unit_test/mem_obj/image_set_arg_tests.cpp
+++ b/opencl/test/unit_test/mem_obj/image_set_arg_tests.cpp
@@ -79,7 +79,7 @@ class ImageSetArgTest : public ClDeviceFixture,
         pKernelInfo->kernelArgInfo[0].isImage = true;
 
         program = std::make_unique<MockProgram>(toClDeviceVector(*pClDevice));
-        pKernel = new MockKernel(program.get(), *pKernelInfo, *pClDevice);
+        pKernel = new MockKernel(program.get(), *pKernelInfo);
         ASSERT_NE(nullptr, pKernel);
         ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
 
@@ -936,7 +936,7 @@ class ImageMediaBlockSetArgTest : public ImageSetArgTest {
         pKernelInfo->kernelArgInfo[0].isMediaBlockImage = true;
 
         program = std::make_unique<MockProgram>(toClDeviceVector(*pClDevice));
-        pKernel = new MockKernel(program.get(), *pKernelInfo, *pClDevice);
+        pKernel = new MockKernel(program.get(), *pKernelInfo);
         ASSERT_NE(nullptr, pKernel);
         ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
 
diff --git a/opencl/test/unit_test/mocks/mock_kernel.h b/opencl/test/unit_test/mocks/mock_kernel.h
index 575a983258..8b51673ee2 100644
--- a/opencl/test/unit_test/mocks/mock_kernel.h
+++ b/opencl/test/unit_test/mocks/mock_kernel.h
@@ -92,8 +92,8 @@ class MockKernel : public Kernel {
         }
     };
 
-    MockKernel(Program *programArg, const KernelInfo &kernelInfoArg, const ClDevice &deviceArg, bool scheduler = false)
-        : Kernel(programArg, kernelInfoArg, deviceArg, scheduler) {
+    MockKernel(Program *programArg, const KernelInfo &kernelInfoArg, bool scheduler = false)
+        : Kernel(programArg, kernelInfoArg, scheduler) {
     }
 
     ~MockKernel() override {
@@ -118,7 +118,6 @@ class MockKernel : public Kernel {
     static KernelType *create(Device &device, Program *program, uint32_t grfNumber) {
         auto info = new KernelInfo();
         const size_t crossThreadSize = 160;
-        auto pClDevice = device.getSpecializedDevice<ClDevice>();
 
         SPatchThreadPayload *threadPayload = new SPatchThreadPayload;
         threadPayload->LocalIDXPresent = 0;
@@ -138,7 +137,7 @@ class MockKernel : public Kernel {
 
         info->crossThreadData = new char[crossThreadSize];
 
-        auto kernel = new KernelType(program, *info, *pClDevice);
+        auto kernel = new KernelType(program, *info);
         kernel->crossThreadData = new char[crossThreadSize];
         memset(kernel->crossThreadData, 0, crossThreadSize);
         kernel->crossThreadDataSize = crossThreadSize;
@@ -289,7 +288,7 @@ class MockKernelWithInternals {
         deviceVector.push_back(&deviceArg);
 
         mockProgram = new MockProgram(context, false, deviceVector);
-        mockKernel = new MockKernel(mockProgram, kernelInfo, deviceArg);
+        mockKernel = new MockKernel(mockProgram, kernelInfo);
         mockKernel->setCrossThreadData(&crossThreadData, sizeof(crossThreadData));
         mockKernel->setSshLocal(&sshLocal, sizeof(sshLocal));
 
@@ -428,7 +427,7 @@ class MockParentKernel : public Kernel {
         UNRECOVERABLE_IF(crossThreadSize < crossThreadOffset + 8);
         info->crossThreadData = new char[crossThreadSize];
 
-        auto parent = new MockParentKernel(mockProgram, *info, *clDevice);
+        auto parent = new MockParentKernel(mockProgram, *info);
         parent->crossThreadData = new char[crossThreadSize];
         memset(parent->crossThreadData, 0, crossThreadSize);
         parent->crossThreadDataSize = crossThreadSize;
@@ -534,7 +533,7 @@ class MockParentKernel : public Kernel {
         return parent;
     }
 
-    MockParentKernel(Program *programArg, const KernelInfo &kernelInfoArg, const ClDevice &deviceArg) : Kernel(programArg, kernelInfoArg, deviceArg) {
+    MockParentKernel(Program *programArg, const KernelInfo &kernelInfoArg) : Kernel(programArg, kernelInfoArg, false) {
     }
 
     ~MockParentKernel() override {
@@ -579,12 +578,12 @@ class MockParentKernel : public Kernel {
 
 class MockSchedulerKernel : public SchedulerKernel {
   public:
-    MockSchedulerKernel(Program *programArg, const KernelInfo &kernelInfoArg, const ClDevice &deviceArg) : SchedulerKernel(programArg, kernelInfoArg, deviceArg){};
+    MockSchedulerKernel(Program *programArg, const KernelInfo &kernelInfoArg) : SchedulerKernel(programArg, kernelInfoArg){};
 };
 
 class MockDebugKernel : public MockKernel {
   public:
-    MockDebugKernel(Program *program, KernelInfo &kernelInfo, const ClDevice &device) : MockKernel(program, kernelInfo, device) {
+    MockDebugKernel(Program *program, KernelInfo &kernelInfo) : MockKernel(program, kernelInfo) {
         if (!kernelInfo.patchInfo.pAllocateSystemThreadSurface) {
             SPatchAllocateSystemThreadSurface *patchToken = new SPatchAllocateSystemThreadSurface;
 
diff --git a/opencl/test/unit_test/preemption/preemption_tests.cpp b/opencl/test/unit_test/preemption/preemption_tests.cpp
index f9e98fd848..d89de6aa1d 100644
--- a/opencl/test/unit_test/preemption/preemption_tests.cpp
+++ b/opencl/test/unit_test/preemption/preemption_tests.cpp
@@ -59,7 +59,7 @@ TEST_F(ThreadGroupPreemptionTests, disallowByReadWriteFencesWA) {
 
 TEST_F(ThreadGroupPreemptionTests, disallowBySchedulerKernel) {
     PreemptionFlags flags = {};
-    kernel.reset(new MockKernel(program.get(), *kernelInfo, *device, true));
+    kernel.reset(new MockKernel(program.get(), *kernelInfo, true));
     PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags));
     EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
@@ -68,7 +68,7 @@ TEST_F(ThreadGroupPreemptionTests, disallowBySchedulerKernel) {
 TEST_F(ThreadGroupPreemptionTests, disallowByVmeKernel) {
     PreemptionFlags flags = {};
     kernelInfo->isVmeWorkload = true;
-    kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
+    kernel.reset(new MockKernel(program.get(), *kernelInfo));
     PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags));
     EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
@@ -148,7 +148,7 @@ TEST_F(ThreadGroupPreemptionTests, disallowDefaultDeviceModeForValidKernelsInMdi
 }
 
 TEST_F(ThreadGroupPreemptionTests, disallowDefaultDeviceModeWhenAtLeastOneInvalidKernelInMdi) {
-    MockKernel schedulerKernel(program.get(), *kernelInfo, *device, true);
+    MockKernel schedulerKernel(program.get(), *kernelInfo, true);
     DispatchInfo schedulerDispatchInfo(&schedulerKernel, 1, Vec3<size_t>(1, 1, 1), Vec3<size_t>(1, 1, 1), Vec3<size_t>(0, 0, 0));
 
     PreemptionFlags flags = {};
@@ -183,7 +183,7 @@ TEST_F(MidThreadPreemptionTests, allowMidThreadPreemptionDeviceSupportPreemption
     device->setPreemptionMode(PreemptionMode::MidThread);
     device->sharedDeviceInfo.vmeAvcSupportsPreemption = true;
     kernelInfo->isVmeWorkload = true;
-    kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
+    kernel.reset(new MockKernel(program.get(), *kernelInfo));
     PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     EXPECT_TRUE(PreemptionHelper::allowMidThreadPreemption(flags));
 }
@@ -210,7 +210,7 @@ TEST_F(MidThreadPreemptionTests, disallowMidThreadPreemptionByVmeKernel) {
     device->setPreemptionMode(PreemptionMode::MidThread);
     device->sharedDeviceInfo.vmeAvcSupportsPreemption = false;
     kernelInfo->isVmeWorkload = true;
-    kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
+    kernel.reset(new MockKernel(program.get(), *kernelInfo));
     PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     EXPECT_FALSE(PreemptionHelper::allowMidThreadPreemption(flags));
 }
@@ -237,7 +237,7 @@ TEST_F(MidThreadPreemptionTests, taskPreemptionDisallowMidThreadByVmeKernel) {
     PreemptionFlags flags = {};
     kernelInfo->isVmeWorkload = true;
     device->sharedDeviceInfo.vmeAvcSupportsPreemption = false;
-    kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
+    kernel.reset(new MockKernel(program.get(), *kernelInfo));
     device->setPreemptionMode(PreemptionMode::MidThread);
     PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
@@ -258,7 +258,7 @@ TEST_F(MidThreadPreemptionTests, taskPreemptionAllowDeviceSupportsPreemptionOnVm
     PreemptionFlags flags = {};
     executionEnvironment->DisableMidThreadPreemption = 0;
     kernelInfo->isVmeWorkload = true;
-    kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
+    kernel.reset(new MockKernel(program.get(), *kernelInfo));
     device->sharedDeviceInfo.vmeAvcSupportsPreemption = true;
     device->setPreemptionMode(PreemptionMode::MidThread);
     PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
@@ -272,7 +272,7 @@ TEST_F(ThreadGroupPreemptionTests, GivenDebugKernelPreemptionWhenDeviceSupportsT
     EXPECT_EQ(PreemptionMode::ThreadGroup, device->getPreemptionMode());
 
     PreemptionFlags flags = {};
-    kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
+    kernel.reset(new MockKernel(program.get(), *kernelInfo));
     PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
     EXPECT_EQ(PreemptionMode::MidThread, outMode);
@@ -284,7 +284,7 @@ TEST_F(MidThreadPreemptionTests, GivenDebugKernelPreemptionWhenDeviceSupportsMid
     EXPECT_EQ(PreemptionMode::MidThread, device->getPreemptionMode());
 
     PreemptionFlags flags = {};
-    kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
+    kernel.reset(new MockKernel(program.get(), *kernelInfo));
     PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
     EXPECT_EQ(PreemptionMode::MidBatch, outMode);
diff --git a/opencl/test/unit_test/profiling/profiling_tests.cpp b/opencl/test/unit_test/profiling/profiling_tests.cpp
index a1b6e2ffee..b672ecce4b 100644
--- a/opencl/test/unit_test/profiling/profiling_tests.cpp
+++ b/opencl/test/unit_test/profiling/profiling_tests.cpp
@@ -78,7 +78,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingTests, GivenCommandQueueWithProfilingAndFor
     typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
     typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
 
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
 
     uint64_t requiredSize = 2 * sizeof(PIPE_CONTROL) + 2 * sizeof(MI_STORE_REGISTER_MEM) + sizeof(GPGPU_WALKER) + HardwareCommandsHelper<FamilyType>::getSizeRequiredCS(&kernel);
 
@@ -123,7 +123,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingTests, GivenCommandQueueWithProfilingAndFor
     typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
     typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
 
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
 
     uint64_t requiredSize = 2 * sizeof(PIPE_CONTROL) + 4 * sizeof(MI_STORE_REGISTER_MEM) + HardwareCommandsHelper<FamilyType>::getSizeRequiredCS(&kernel);
     requiredSize += 2 * sizeof(GPGPU_WALKER);
@@ -149,7 +149,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingTests, GivenCommandQueueWithProfolingWhenWa
     typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
     typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
 
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     size_t globalOffsets[3] = {0, 0, 0};
@@ -196,7 +196,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingTests, GivenCommandQueueWithProfolingWhenWa
 }
 
 HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingTests, GivenCommandQueueWithProfilingWhenNonBlockedEnqueueIsExecutedThenSubmittedTimestampDoesntHaveGPUTime) {
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     size_t globalOffsets[3] = {0, 0, 0};
@@ -232,7 +232,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingTests, GivenCommandQueueWithProflingWhenWal
     typedef typename FamilyType::MI_STORE_REGISTER_MEM MI_STORE_REGISTER_MEM;
     typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
 
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     size_t globalOffsets[3] = {0, 0, 0};
@@ -286,7 +286,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingTests, GivenCommandQueueBlockedWithProfilin
     typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
     typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
 
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     size_t globalOffsets[3] = {0, 0, 0};
@@ -343,7 +343,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingTests, GivenCommandQueueBlockedWithProfilin
     typedef typename FamilyType::MI_STORE_REGISTER_MEM MI_STORE_REGISTER_MEM;
     typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
 
-    MockKernel kernel(program.get(), kernelInfo, *pClDevice);
+    MockKernel kernel(program.get(), kernelInfo);
     ASSERT_EQ(CL_SUCCESS, kernel.initialize());
 
     size_t globalOffsets[3] = {0, 0, 0};
diff --git a/opencl/test/unit_test/program/printf_handler_tests.cpp b/opencl/test/unit_test/program/printf_handler_tests.cpp
index 6200441cdd..4d8dbbccce 100644
--- a/opencl/test/unit_test/program/printf_handler_tests.cpp
+++ b/opencl/test/unit_test/program/printf_handler_tests.cpp
@@ -31,7 +31,7 @@ TEST(PrintfHandlerTest, givenNotPreparedPrintfHandlerWhenGetSurfaceIsCalledThenR
     pKernelInfo->patchInfo.pAllocateStatelessPrintfSurface = pPrintfSurface;
 
     MockProgram *pProgram = new MockProgram(&context, false, toClDeviceVector(*device));
-    MockKernel *pKernel = new MockKernel(pProgram, *pKernelInfo, *device);
+    MockKernel *pKernel = new MockKernel(pProgram, *pKernelInfo);
 
     MockMultiDispatchInfo multiDispatchInfo(pKernel);
     PrintfHandler *printfHandler = PrintfHandler::create(multiDispatchInfo, *device);
@@ -59,7 +59,7 @@ TEST(PrintfHandlerTest, givenPreparedPrintfHandlerWhenGetSurfaceIsCalledThenResu
     MockProgram *pProgram = new MockProgram(&context, false, toClDeviceVector(*device));
 
     uint64_t crossThread[10];
-    MockKernel *pKernel = new MockKernel(pProgram, *pKernelInfo, *device);
+    MockKernel *pKernel = new MockKernel(pProgram, *pKernelInfo);
     pKernel->setCrossThreadData(&crossThread, sizeof(uint64_t) * 8);
 
     MockMultiDispatchInfo multiDispatchInfo(pKernel);
@@ -127,9 +127,9 @@ TEST(PrintfHandlerTest, givenMultiDispatchInfoWithMultipleKernelsWhenCreatingAnd
     mainKernelInfo->patchInfo.pAllocateStatelessPrintfSurface = printfSurface.get();
 
     uint64_t crossThread[8];
-    auto mainKernel = std::make_unique<MockKernel>(program.get(), *mainKernelInfo, *device);
-    auto kernel1 = std::make_unique<MockKernel>(program.get(), *kernelInfo, *device);
-    auto kernel2 = std::make_unique<MockKernel>(program.get(), *kernelInfo, *device);
+    auto mainKernel = std::make_unique<MockKernel>(program.get(), *mainKernelInfo);
+    auto kernel1 = std::make_unique<MockKernel>(program.get(), *kernelInfo);
+    auto kernel2 = std::make_unique<MockKernel>(program.get(), *kernelInfo);
     mainKernel->setCrossThreadData(&crossThread, sizeof(uint64_t) * 8);
 
     DispatchInfo mainDispatchInfo(mainKernel.get(), 1, {1, 1, 1}, {1, 1, 1}, {1, 1, 1});
@@ -198,7 +198,7 @@ TEST(PrintfHandlerTest, GivenAllocationInLocalMemoryWhichRequiresBlitterWhenPrep
 
             auto program = std::make_unique<MockProgram>(&context, false, toClDeviceVector(*pClDevice));
             uint64_t crossThread[10];
-            auto kernel = std::make_unique<MockKernel>(program.get(), *kernelInfo, *pClDevice);
+            auto kernel = std::make_unique<MockKernel>(program.get(), *kernelInfo);
             kernel->setCrossThreadData(&crossThread, sizeof(uint64_t) * 8);
 
             MockMultiDispatchInfo multiDispatchInfo(kernel.get());
@@ -227,7 +227,7 @@ TEST_F(PrintfHandlerMultiRootDeviceTests, printfSurfaceHasCorrectRootDeviceIndex
     auto program = std::make_unique<MockProgram>(context.get(), false, toClDeviceVector(*device));
 
     uint64_t crossThread[10];
-    auto kernel = std::make_unique<MockKernel>(program.get(), *kernelInfo, *device);
+    auto kernel = std::make_unique<MockKernel>(program.get(), *kernelInfo);
     kernel->setCrossThreadData(&crossThread, sizeof(uint64_t) * 8);
 
     MockMultiDispatchInfo multiDispatchInfo(kernel.get());
diff --git a/opencl/test/unit_test/program/printf_helper_tests.cpp b/opencl/test/unit_test/program/printf_helper_tests.cpp
index 6c767620c8..94f1c5a05b 100644
--- a/opencl/test/unit_test/program/printf_helper_tests.cpp
+++ b/opencl/test/unit_test/program/printf_helper_tests.cpp
@@ -50,7 +50,7 @@ class PrintFormatterTest : public testing::Test {
         kernelInfo = std::make_unique<KernelInfo>();
         device = new MockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr)};
         program = std::make_unique<MockProgram>(toClDeviceVector(*device));
-        kernel = new MockKernel(program.get(), *kernelInfo, *device);
+        kernel = new MockKernel(program.get(), *kernelInfo);
 
         printFormatter = std::unique_ptr<PrintFormatter>(new PrintFormatter(static_cast<uint8_t *>(data->getUnderlyingBuffer()), PrintFormatter::maxPrintfOutputLength, is32bit, kernelInfo->patchInfo.stringDataMap));
 
diff --git a/opencl/test/unit_test/program/program_nonuniform.cpp b/opencl/test/unit_test/program/program_nonuniform.cpp
index 405ea5806b..4219c2e892 100644
--- a/opencl/test/unit_test/program/program_nonuniform.cpp
+++ b/opencl/test/unit_test/program/program_nonuniform.cpp
@@ -106,12 +106,12 @@ TEST(KernelNonUniform, WhenSettingAllowNonUniformThenGettingAllowNonUniformRetur
     MockClDevice device{new MockDevice()};
     MockProgram program(toClDeviceVector(device));
     struct KernelMock : Kernel {
-        KernelMock(Program *p, KernelInfo &ki, ClDevice &d)
-            : Kernel(p, ki, d) {
+        KernelMock(Program *p, KernelInfo &ki)
+            : Kernel(p, ki, false) {
         }
     };
 
-    KernelMock k{&program, kernelInfo, device};
+    KernelMock k{&program, kernelInfo};
     program.setAllowNonUniform(false);
     EXPECT_FALSE(k.getAllowNonUniform());
     program.setAllowNonUniform(true);
diff --git a/opencl/test/unit_test/sampler/sampler_set_arg_tests.cpp b/opencl/test/unit_test/sampler/sampler_set_arg_tests.cpp
index d7bdc8b9a4..60f9942544 100644
--- a/opencl/test/unit_test/sampler/sampler_set_arg_tests.cpp
+++ b/opencl/test/unit_test/sampler/sampler_set_arg_tests.cpp
@@ -55,7 +55,7 @@ class SamplerSetArgFixture : public ClDeviceFixture {
         pKernelInfo->kernelArgInfo[1].isSampler = true;
 
         program = std::make_unique<MockProgram>(toClDeviceVector(*pClDevice));
-        pKernel = new MockKernel(program.get(), *pKernelInfo, *pClDevice);
+        pKernel = new MockKernel(program.get(), *pKernelInfo);
         ASSERT_NE(nullptr, pKernel);
         ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
 
@@ -200,7 +200,7 @@ HWTEST_F(SamplerSetArgTest, GivenSamplerObjectWhenSetKernelArgIsCalledThenSample
 }
 
 HWTEST_F(SamplerSetArgTest, GivenSamplerObjectWhenSetKernelArgIsCalledAndKernelIsDeletedThenRefCountIsUnchanged) {
-    auto myKernel = std::make_unique<MockKernel>(program.get(), *pKernelInfo, *pClDevice);
+    auto myKernel = std::make_unique<MockKernel>(program.get(), *pKernelInfo);
     ASSERT_NE(nullptr, myKernel.get());
     ASSERT_EQ(CL_SUCCESS, myKernel->initialize());
 
@@ -374,7 +374,7 @@ TEST_F(SamplerSetArgTest, givenSamplerTypeStrAndIsSamplerTrueWhenInitializeKerne
     pKernelInfo->kernelArgInfo[1].metadataExtended->type = "sampler";
     pKernelInfo->kernelArgInfo[1].isSampler = true;
 
-    auto pMockKernell = std::make_unique<MockKernel>(program.get(), *pKernelInfo, *pClDevice);
+    auto pMockKernell = std::make_unique<MockKernel>(program.get(), *pKernelInfo);
     ASSERT_EQ(CL_SUCCESS, pMockKernell->initialize());
     EXPECT_EQ(pMockKernell->getKernelArguments()[0].type, MockKernel::SAMPLER_OBJ);
     EXPECT_EQ(pMockKernell->getKernelArguments()[1].type, MockKernel::SAMPLER_OBJ);
@@ -389,7 +389,7 @@ TEST_F(SamplerSetArgTest, givenSamplerTypeStrAndAndIsSamplerFalseWhenInitializeK
     pKernelInfo->kernelArgInfo[1].metadataExtended->type = "sampler";
     pKernelInfo->kernelArgInfo[1].isSampler = false;
 
-    auto pMockKernell = std::make_unique<MockKernel>(program.get(), *pKernelInfo, *pClDevice);
+    auto pMockKernell = std::make_unique<MockKernel>(program.get(), *pKernelInfo);
     ASSERT_EQ(CL_SUCCESS, pMockKernell->initialize());
     EXPECT_NE(pMockKernell->getKernelArguments()[0].type, MockKernel::SAMPLER_OBJ);
     EXPECT_NE(pMockKernell->getKernelArguments()[1].type, MockKernel::SAMPLER_OBJ);
diff --git a/opencl/test/unit_test/scheduler/scheduler_kernel_tests.cpp b/opencl/test/unit_test/scheduler/scheduler_kernel_tests.cpp
index 9902114d52..acad5c8912 100644
--- a/opencl/test/unit_test/scheduler/scheduler_kernel_tests.cpp
+++ b/opencl/test/unit_test/scheduler/scheduler_kernel_tests.cpp
@@ -26,10 +26,10 @@ using namespace NEO;
 
 class MockSchedulerKernel : public SchedulerKernel {
   public:
-    MockSchedulerKernel(Program *program, const KernelInfo &info, const ClDevice &device) : SchedulerKernel(program, info, device) {
+    MockSchedulerKernel(Program *program, const KernelInfo &info) : SchedulerKernel(program, info) {
     }
 
-    static MockSchedulerKernel *create(Program &program, Device &device, KernelInfo *&info) {
+    static MockSchedulerKernel *create(Program &program, KernelInfo *&info) {
         info = new KernelInfo;
         SPatchDataParameterStream dataParametrStream;
         dataParametrStream.DataParameterStreamSize = 8;
@@ -61,7 +61,7 @@ TEST(SchedulerKernelTest, WhenSchedulerKernelIsCreatedThenLwsIs24) {
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
     MockProgram program(toClDeviceVector(*device));
     KernelInfo info;
-    MockSchedulerKernel kernel(&program, info, *device);
+    MockSchedulerKernel kernel(&program, info);
 
     size_t lws = kernel.getLws();
     EXPECT_EQ((size_t)24u, lws);
@@ -71,7 +71,7 @@ TEST(SchedulerKernelTest, WhenSchedulerKernelIsCreatedThenGwsIs24) {
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
     MockProgram program(toClDeviceVector(*device));
     KernelInfo info;
-    MockSchedulerKernel kernel(&program, info, *device);
+    MockSchedulerKernel kernel(&program, info);
 
     const size_t hwThreads = 3;
     const size_t simdSize = 8;
@@ -87,7 +87,7 @@ TEST(SchedulerKernelTest, WhenSettingGwsThenGetGwsReturnedSetValue) {
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
     MockProgram program(toClDeviceVector(*device));
     KernelInfo info;
-    MockSchedulerKernel kernel(&program, info, *device);
+    MockSchedulerKernel kernel(&program, info);
 
     kernel.setGws(24);
 
@@ -109,7 +109,7 @@ TEST(SchedulerKernelTest, WhenSchedulerKernelIsCreatedThenCurbeSizeIsCorrect) {
     info.patchInfo.dataParameterStream = &dataParameterStream;
     info.heapInfo.DynamicStateHeapSize = dshSize;
 
-    MockSchedulerKernel kernel(&program, info, *device);
+    MockSchedulerKernel kernel(&program, info);
 
     uint32_t expectedCurbeSize = alignUp(crossTrheadDataSize, 64) + alignUp(dshSize, 64) + alignUp(SCHEDULER_DYNAMIC_PAYLOAD_SIZE, 64);
     EXPECT_GE((size_t)expectedCurbeSize, kernel.getCurbeSize());
@@ -121,7 +121,7 @@ TEST(SchedulerKernelTest, WhenSettingArgsForSchedulerKernelThenAllocationsAreCor
     auto program = clUniquePtr(new MockProgram(context.get(), false, toClDeviceVector(*device)));
     std::unique_ptr<KernelInfo> info(nullptr);
     KernelInfo *infoPtr = nullptr;
-    std::unique_ptr<MockSchedulerKernel> scheduler = std::unique_ptr<MockSchedulerKernel>(MockSchedulerKernel::create(*program, device->getDevice(), infoPtr));
+    std::unique_ptr<MockSchedulerKernel> scheduler = std::unique_ptr<MockSchedulerKernel>(MockSchedulerKernel::create(*program, infoPtr));
     info.reset(infoPtr);
     std::unique_ptr<MockGraphicsAllocation> allocs[9];
 
@@ -151,7 +151,7 @@ TEST(SchedulerKernelTest, GivenNullDebugQueueWhenSettingArgsForSchedulerKernelTh
 
     std::unique_ptr<KernelInfo> info(nullptr);
     KernelInfo *infoPtr = nullptr;
-    std::unique_ptr<MockSchedulerKernel> scheduler = std::unique_ptr<MockSchedulerKernel>(MockSchedulerKernel::create(*program, device->getDevice(), infoPtr));
+    std::unique_ptr<MockSchedulerKernel> scheduler = std::unique_ptr<MockSchedulerKernel>(MockSchedulerKernel::create(*program, infoPtr));
     info.reset(infoPtr);
     std::unique_ptr<MockGraphicsAllocation> allocs[9];
 
@@ -181,7 +181,7 @@ TEST(SchedulerKernelTest, givenGraphicsAllocationWithDifferentCpuAndGpuAddresses
 
     std::unique_ptr<KernelInfo> info(nullptr);
     KernelInfo *infoPtr = nullptr;
-    auto scheduler = clUniquePtr(MockSchedulerKernel::create(*program, device->getDevice(), infoPtr));
+    auto scheduler = clUniquePtr(MockSchedulerKernel::create(*program, infoPtr));
     info.reset(infoPtr);
     std::unique_ptr<MockGraphicsAllocation> allocs[9];
 
@@ -215,7 +215,7 @@ TEST(SchedulerKernelTest, GivenForceDispatchSchedulerWhenCreatingKernelReflectio
 
     std::unique_ptr<KernelInfo> info(nullptr);
     KernelInfo *infoPtr = nullptr;
-    std::unique_ptr<MockSchedulerKernel> scheduler = std::unique_ptr<MockSchedulerKernel>(MockSchedulerKernel::create(*program, device->getDevice(), infoPtr));
+    std::unique_ptr<MockSchedulerKernel> scheduler = std::unique_ptr<MockSchedulerKernel>(MockSchedulerKernel::create(*program, infoPtr));
     info.reset(infoPtr);
 
     scheduler->createReflectionSurface();
@@ -233,7 +233,7 @@ TEST(SchedulerKernelTest, GivenForceDispatchSchedulerWhenCreatingKernelReflectio
 
     std::unique_ptr<KernelInfo> info(nullptr);
     KernelInfo *infoPtr = nullptr;
-    std::unique_ptr<MockSchedulerKernel> scheduler = std::unique_ptr<MockSchedulerKernel>(MockSchedulerKernel::create(*program, device->getDevice(), infoPtr));
+    std::unique_ptr<MockSchedulerKernel> scheduler = std::unique_ptr<MockSchedulerKernel>(MockSchedulerKernel::create(*program, infoPtr));
     info.reset(infoPtr);
 
     scheduler->createReflectionSurface();
@@ -255,7 +255,7 @@ TEST(SchedulerKernelTest, GivenNoForceDispatchSchedulerWhenCreatingKernelReflect
 
     std::unique_ptr<KernelInfo> info(nullptr);
     KernelInfo *infoPtr = nullptr;
-    std::unique_ptr<MockSchedulerKernel> scheduler = std::unique_ptr<MockSchedulerKernel>(MockSchedulerKernel::create(*program, device->getDevice(), infoPtr));
+    std::unique_ptr<MockSchedulerKernel> scheduler = std::unique_ptr<MockSchedulerKernel>(MockSchedulerKernel::create(*program, infoPtr));
     info.reset(infoPtr);
 
     scheduler->createReflectionSurface();
@@ -270,7 +270,7 @@ TEST(SchedulerKernelTest, GivenNullKernelInfoWhenGettingCurbeSizeThenSizeIsCorre
 
     info.patchInfo.dataParameterStream = nullptr;
 
-    MockSchedulerKernel kernel(&program, info, *device);
+    MockSchedulerKernel kernel(&program, info);
 
     uint32_t expectedCurbeSize = alignUp(SCHEDULER_DYNAMIC_PAYLOAD_SIZE, 64);
     EXPECT_GE((size_t)expectedCurbeSize, kernel.getCurbeSize());
@@ -283,7 +283,7 @@ TEST(SchedulerKernelTest, givenForcedSchedulerGwsByDebugVariableWhenSchedulerKer
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
     MockProgram program(toClDeviceVector(*device));
     KernelInfo info;
-    MockSchedulerKernel kernel(&program, info, *device);
+    MockSchedulerKernel kernel(&program, info);
 
     size_t gws = kernel.getGws();
     EXPECT_EQ(static_cast<size_t>(48u), gws);
@@ -297,7 +297,7 @@ TEST(SchedulerKernelTest, givenSimulationModeWhenSchedulerKernelIsCreatedThenGws
     MockProgram program(toClDeviceVector(*device));
 
     KernelInfo info;
-    MockSchedulerKernel kernel(&program, info, *device);
+    MockSchedulerKernel kernel(&program, info);
     size_t gws = kernel.getGws();
     EXPECT_EQ(static_cast<size_t>(24u), gws);
 }
@@ -313,7 +313,7 @@ TEST(SchedulerKernelTest, givenForcedSchedulerGwsByDebugVariableAndSimulationMod
     MockProgram program(toClDeviceVector(*device));
 
     KernelInfo info;
-    MockSchedulerKernel kernel(&program, info, *device);
+    MockSchedulerKernel kernel(&program, info);
     size_t gws = kernel.getGws();
     EXPECT_EQ(static_cast<size_t>(48u), gws);
 }
diff --git a/opencl/test/unit_test/utilities/file_logger_tests.cpp b/opencl/test/unit_test/utilities/file_logger_tests.cpp
index 1d33286f69..c7a5b265b7 100644
--- a/opencl/test/unit_test/utilities/file_logger_tests.cpp
+++ b/opencl/test/unit_test/utilities/file_logger_tests.cpp
@@ -348,7 +348,7 @@ TEST(FileLogger, GivenDebugFunctionalityWhenDebugFlagIsDisabledThenDoNotDumpKern
     auto kernelInfo = std::make_unique<KernelInfo>();
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
     MockProgram program(toClDeviceVector(*device));
-    auto kernel = std::unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
+    auto kernel = std::unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo));
     auto multiDispatchInfo = std::unique_ptr<MockMultiDispatchInfo>(new MockMultiDispatchInfo(kernel.get()));
 
     KernelArgPatchInfo kernelArgPatchInfo;
@@ -383,7 +383,7 @@ TEST(FileLogger, GivenMdiWhenDumpingKernelArgsThenFileIsCreated) {
     auto kernelInfo = std::make_unique<KernelInfo>();
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
     MockProgram program(toClDeviceVector(*device));
-    auto kernel = std::unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
+    auto kernel = std::unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo));
     auto multiDispatchInfo = std::unique_ptr<MockMultiDispatchInfo>(new MockMultiDispatchInfo(kernel.get()));
 
     KernelArgPatchInfo kernelArgPatchInfo;
@@ -428,7 +428,7 @@ TEST(FileLogger, GivenEmptyKernelWhenDumpingKernelArgsThenFileIsNotCreated) {
     auto kernelInfo = std::make_unique<KernelInfo>();
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
     MockProgram program(toClDeviceVector(*device));
-    auto kernel = std::unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
+    auto kernel = std::unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo));
 
     std::string testFile = "testfile";
     DebugVariables flags;
@@ -444,7 +444,7 @@ TEST(FileLogger, GivenImmediateWhenDumpingKernelArgsThenFileIsCreated) {
     auto kernelInfo = std::make_unique<KernelInfo>();
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
     MockProgram program(toClDeviceVector(*device));
-    auto kernel = std::unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
+    auto kernel = std::unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo));
 
     KernelArgPatchInfo kernelArgPatchInfo;
 
@@ -478,7 +478,7 @@ TEST(FileLogger, GivenImmediateZeroSizeWhenDumpingKernelArgsThenFileIsNotCreated
     auto kernelInfo = std::make_unique<KernelInfo>();
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
     MockProgram program(toClDeviceVector(*device));
-    auto kernel = std::unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
+    auto kernel = std::unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo));
 
     KernelArgPatchInfo kernelArgPatchInfo;
 
@@ -508,7 +508,7 @@ TEST(FileLogger, GivenLocalBufferWhenDumpingKernelArgsThenFileIsNotCreated) {
     auto kernelInfo = std::make_unique<KernelInfo>();
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
     MockProgram program(toClDeviceVector(*device));
-    auto kernel = std::unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
+    auto kernel = std::unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo));
 
     KernelArgPatchInfo kernelArgPatchInfo;
 
@@ -531,7 +531,7 @@ TEST(FileLogger, GivenBufferNotSetWhenDumpingKernelArgsThenFileIsNotCreated) {
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
     auto context = clUniquePtr(new MockContext(device.get()));
     auto program = clUniquePtr(new MockProgram(context.get(), false, toClDeviceVector(*device)));
-    auto kernel = clUniquePtr(new MockKernel(program.get(), *kernelInfo, *device));
+    auto kernel = clUniquePtr(new MockKernel(program.get(), *kernelInfo));
 
     KernelArgPatchInfo kernelArgPatchInfo;
 
@@ -565,7 +565,7 @@ TEST(FileLogger, GivenBufferWhenDumpingKernelArgsThenFileIsCreated) {
 
     auto kernelInfo = std::make_unique<KernelInfo>();
     auto program = clUniquePtr(new MockProgram(context.get(), false, toClDeviceVector(*device)));
-    auto kernel = clUniquePtr(new MockKernel(program.get(), *kernelInfo, *device));
+    auto kernel = clUniquePtr(new MockKernel(program.get(), *kernelInfo));
 
     KernelArgPatchInfo kernelArgPatchInfo;
 
@@ -604,7 +604,7 @@ TEST(FileLogger, GivenSamplerWhenDumpingKernelArgsThenFileIsNotCreated) {
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
     auto context = clUniquePtr(new MockContext(device.get()));
     auto program = clUniquePtr(new MockProgram(context.get(), false, toClDeviceVector(*device)));
-    auto kernel = clUniquePtr(new MockKernel(program.get(), *kernelInfo, *device));
+    auto kernel = clUniquePtr(new MockKernel(program.get(), *kernelInfo));
 
     KernelArgPatchInfo kernelArgPatchInfo;
 
@@ -632,7 +632,7 @@ TEST(FileLogger, GivenImageNotSetWhenDumpingKernelArgsThenFileIsNotCreated) {
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
     auto context = clUniquePtr(new MockContext(device.get()));
     auto program = clUniquePtr(new MockProgram(context.get(), false, toClDeviceVector(*device)));
-    auto kernel = clUniquePtr(new MockKernel(program.get(), *kernelInfo, *device));
+    auto kernel = clUniquePtr(new MockKernel(program.get(), *kernelInfo));
 
     char surfaceStateHeap[0x80];
     kernelInfo->heapInfo.pSsh = surfaceStateHeap;