diff --git a/opencl/source/api/api.cpp b/opencl/source/api/api.cpp
index 55c6658e34..4e1694da80 100644
--- a/opencl/source/api/api.cpp
+++ b/opencl/source/api/api.cpp
@@ -1713,7 +1713,8 @@ cl_kernel CL_API_CALL clCreateKernel(cl_program clProgram,
             break;
         }
 
-        const KernelInfo *pKernelInfo = pProgram->getKernelInfo(kernelName);
+        auto rootDeviceIndex = pProgram->getDevices()[0]->getRootDeviceIndex();
+        const KernelInfo *pKernelInfo = pProgram->getKernelInfo(kernelName, rootDeviceIndex);
         if (!pKernelInfo) {
             retVal = CL_INVALID_KERNEL_NAME;
             break;
@@ -1746,9 +1747,9 @@ cl_int CL_API_CALL clCreateKernelsInProgram(cl_program clProgram,
                    "numKernels", numKernels,
                    "kernels", kernels,
                    "numKernelsRet", numKernelsRet);
-    auto program = castToObject<Program>(clProgram);
-    if (program) {
-        auto numKernelsInProgram = program->getNumKernels();
+    auto pProgram = castToObject<Program>(clProgram);
+    if (pProgram) {
+        auto numKernelsInProgram = pProgram->getNumKernels();
 
         if (kernels) {
             if (numKernels < numKernelsInProgram) {
@@ -1757,11 +1758,12 @@ cl_int CL_API_CALL clCreateKernelsInProgram(cl_program clProgram,
                 return retVal;
             }
 
+            auto rootDeviceIndex = pProgram->getDevices()[0]->getRootDeviceIndex();
             for (unsigned int i = 0; i < numKernelsInProgram; ++i) {
-                const auto kernelInfo = program->getKernelInfo(i);
+                const auto kernelInfo = pProgram->getKernelInfo(i, rootDeviceIndex);
                 DEBUG_BREAK_IF(kernelInfo == nullptr);
                 kernels[i] = Kernel::create(
-                    program,
+                    pProgram,
                     *kernelInfo,
                     nullptr);
                 gtpinNotifyKernelCreate(kernels[i]);
diff --git a/opencl/source/built_ins/builtins_dispatch_builder.h b/opencl/source/built_ins/builtins_dispatch_builder.h
index d95cf5cf67..097176e421 100644
--- a/opencl/source/built_ins/builtins_dispatch_builder.h
+++ b/opencl/source/built_ins/builtins_dispatch_builder.h
@@ -88,7 +88,7 @@ class BuiltinDispatchInfoBuilder {
   protected:
     template <typename KernelNameT, typename... KernelsDescArgsT>
     void grabKernels(KernelNameT &&kernelName, Kernel *&kernelDst, KernelsDescArgsT &&... kernelsDesc) {
-        const KernelInfo *kernelInfo = prog->getKernelInfo(kernelName);
+        const KernelInfo *kernelInfo = prog->getKernelInfo(kernelName, prog->getDevices()[0]->getRootDeviceIndex());
         UNRECOVERABLE_IF(nullptr == kernelInfo);
         cl_int err = 0;
         kernelDst = Kernel::create(prog.get(), *kernelInfo, &err);
diff --git a/opencl/source/context/context.cpp b/opencl/source/context/context.cpp
index 5c3b377d19..f0f196c8b9 100644
--- a/opencl/source/context/context.cpp
+++ b/opencl/source/context/context.cpp
@@ -399,7 +399,7 @@ SchedulerKernel &Context::getSchedulerKernel() {
 
         schedulerBuiltIn->pProgram = program;
 
-        auto kernelInfo = schedulerBuiltIn->pProgram->getKernelInfo(SchedulerKernel::schedulerName);
+        auto kernelInfo = schedulerBuiltIn->pProgram->getKernelInfo(SchedulerKernel::schedulerName, clDevice->getRootDeviceIndex());
         DEBUG_BREAK_IF(!kernelInfo);
 
         schedulerBuiltIn->pKernel = Kernel::create<SchedulerKernel>(
diff --git a/opencl/source/program/build.cpp b/opencl/source/program/build.cpp
index babadd1a3a..a59e8e54a4 100644
--- a/opencl/source/program/build.cpp
+++ b/opencl/source/program/build.cpp
@@ -172,25 +172,28 @@ cl_int Program::build(
         }
 
         if (isKernelDebugEnabled()) {
-            processDebugData();
 
             for (auto &clDevice : deviceVector) {
-                if (BuildPhase::DebugDataNotification == phaseReached[clDevice->getRootDeviceIndex()]) {
+                auto rootDeviceIndex = clDevice->getRootDeviceIndex();
+                if (BuildPhase::DebugDataNotification == phaseReached[rootDeviceIndex]) {
                     continue;
                 }
+                processDebugData(rootDeviceIndex);
                 if (clDevice->getSourceLevelDebugger()) {
-                    for (auto kernelInfo : kernelInfoArray) {
+                    for (auto kernelInfo : buildInfos[rootDeviceIndex].kernelInfoArray) {
                         clDevice->getSourceLevelDebugger()->notifyKernelDebugData(&kernelInfo->debugData,
                                                                                   kernelInfo->kernelDescriptor.kernelMetadata.kernelName,
                                                                                   kernelInfo->heapInfo.pKernelHeap,
                                                                                   kernelInfo->heapInfo.KernelHeapSize);
                     }
                 }
-                phaseReached[clDevice->getRootDeviceIndex()] = BuildPhase::DebugDataNotification;
+                phaseReached[rootDeviceIndex] = BuildPhase::DebugDataNotification;
             }
         }
 
-        separateBlockKernels();
+        for (const auto &device : deviceVector) {
+            separateBlockKernels(device->getRootDeviceIndex());
+        }
     } while (false);
 
     if (retVal != CL_SUCCESS) {
@@ -229,7 +232,7 @@ cl_int Program::build(const ClDeviceVector &deviceVector, const char *buildOptio
         return ret;
     }
 
-    for (auto &ki : this->kernelInfoArray) {
+    for (auto &ki : buildInfos[deviceVector[0]->getRootDeviceIndex()].kernelInfoArray) {
         auto fit = builtinsMap.find(ki->kernelDescriptor.kernelMetadata.kernelName);
         if (fit == builtinsMap.end()) {
             continue;
diff --git a/opencl/source/program/get_info.cpp b/opencl/source/program/get_info.cpp
index 599dabba79..b98c84cbff 100644
--- a/opencl/source/program/get_info.cpp
+++ b/opencl/source/program/get_info.cpp
@@ -77,7 +77,7 @@ cl_int Program::getInfo(cl_program_info paramName, size_t paramValueSize,
         break;
 
     case CL_PROGRAM_KERNEL_NAMES:
-        kernelNamesString = concatenateKernelNames(kernelInfoArray);
+        kernelNamesString = concatenateKernelNames(buildInfos[clDevices[0]->getRootDeviceIndex()].kernelInfoArray);
         pSrc = kernelNamesString.c_str();
         retSize = srcSize = kernelNamesString.length() + 1;
 
@@ -87,7 +87,7 @@ cl_int Program::getInfo(cl_program_info paramName, size_t paramValueSize,
         break;
 
     case CL_PROGRAM_NUM_KERNELS:
-        numKernels = kernelInfoArray.size();
+        numKernels = getNumKernels();
         pSrc = &numKernels;
         retSize = srcSize = sizeof(numKernels);
 
diff --git a/opencl/source/program/link.cpp b/opencl/source/program/link.cpp
index fd1a0d4be4..3d01cf9bb0 100644
--- a/opencl/source/program/link.cpp
+++ b/opencl/source/program/link.cpp
@@ -146,6 +146,7 @@ cl_int Program::link(
 
         if (!isCreateLibrary) {
             for (const auto &device : deviceVector) {
+                auto rootDeviceIndex = device->getRootDeviceIndex();
                 inputArgs.outType = IGC::CodeType::oclGenBin;
                 NEO::TranslationOutput compilerOuput = {};
                 auto compilerErr = pCompilerInterface->link(device->getDevice(), inputArgs, compilerOuput);
@@ -156,7 +157,7 @@ cl_int Program::link(
                     break;
                 }
 
-                this->replaceDeviceBinary(std::move(compilerOuput.deviceBinary.mem), compilerOuput.deviceBinary.size, device->getRootDeviceIndex());
+                this->replaceDeviceBinary(std::move(compilerOuput.deviceBinary.mem), compilerOuput.deviceBinary.size, rootDeviceIndex);
                 this->debugData = std::move(compilerOuput.debugData.mem);
                 this->debugDataSize = compilerOuput.debugData.size;
 
@@ -167,11 +168,11 @@ cl_int Program::link(
                 binaryType = CL_PROGRAM_BINARY_TYPE_EXECUTABLE;
 
                 if (isKernelDebugEnabled()) {
-                    if (kernelDebugDataNotified[device->getRootDeviceIndex()]) {
+                    if (kernelDebugDataNotified[rootDeviceIndex]) {
                         continue;
                     }
-                    processDebugData();
-                    for (auto kernelInfo : kernelInfoArray) {
+                    processDebugData(rootDeviceIndex);
+                    for (auto kernelInfo : buildInfos[rootDeviceIndex].kernelInfoArray) {
                         device->getSourceLevelDebugger()->notifyKernelDebugData(&kernelInfo->debugData,
                                                                                 kernelInfo->kernelDescriptor.kernelMetadata.kernelName,
                                                                                 kernelInfo->heapInfo.pKernelHeap,
@@ -204,7 +205,9 @@ cl_int Program::link(
             break;
         }
         updateNonUniformFlag(&*inputProgramsInternal.begin(), inputProgramsInternal.size());
-        separateBlockKernels();
+        for (const auto &device : deviceVector) {
+            separateBlockKernels(device->getRootDeviceIndex());
+        }
     } while (false);
 
     if (retVal != CL_SUCCESS) {
diff --git a/opencl/source/program/process_device_binary.cpp b/opencl/source/program/process_device_binary.cpp
index 4cdc80a796..ed1de25f6a 100644
--- a/opencl/source/program/process_device_binary.cpp
+++ b/opencl/source/program/process_device_binary.cpp
@@ -31,11 +31,13 @@ namespace NEO {
 extern bool familyEnabled[];
 
 const KernelInfo *Program::getKernelInfo(
-    const char *kernelName) const {
+    const char *kernelName, uint32_t rootDeviceIndex) const {
     if (kernelName == nullptr) {
         return nullptr;
     }
 
+    auto &kernelInfoArray = buildInfos[rootDeviceIndex].kernelInfoArray;
+
     auto it = std::find_if(kernelInfoArray.begin(), kernelInfoArray.end(),
                            [=](const KernelInfo *kInfo) { return (0 == strcmp(kInfo->kernelDescriptor.kernelMetadata.kernelName.c_str(), kernelName)); });
 
@@ -43,10 +45,11 @@ const KernelInfo *Program::getKernelInfo(
 }
 
 size_t Program::getNumKernels() const {
-    return kernelInfoArray.size();
+    return buildInfos[clDevices[0]->getRootDeviceIndex()].kernelInfoArray.size();
 }
 
-const KernelInfo *Program::getKernelInfo(size_t ordinal) const {
+const KernelInfo *Program::getKernelInfo(size_t ordinal, uint32_t rootDeviceIndex) const {
+    auto &kernelInfoArray = buildInfos[rootDeviceIndex].kernelInfoArray;
     DEBUG_BREAK_IF(ordinal >= kernelInfoArray.size());
     return kernelInfoArray[ordinal];
 }
@@ -57,6 +60,7 @@ cl_int Program::linkBinary(Device *pDevice, const void *constantsInitData, const
         return CL_SUCCESS;
     }
     auto rootDeviceIndex = pDevice->getRootDeviceIndex();
+    auto &kernelInfoArray = buildInfos[rootDeviceIndex].kernelInfoArray;
     Linker linker(*linkerInput);
     Linker::SegmentInfo globals;
     Linker::SegmentInfo constants;
@@ -74,15 +78,15 @@ cl_int Program::linkBinary(Device *pDevice, const void *constantsInitData, const
     if (linkerInput->getExportedFunctionsSegmentId() >= 0) {
         // Exported functions reside in instruction heap of one of kernels
         auto exportedFunctionHeapId = linkerInput->getExportedFunctionsSegmentId();
-        buildInfos[rootDeviceIndex].exportedFunctionsSurface = this->kernelInfoArray[exportedFunctionHeapId]->getGraphicsAllocation();
+        buildInfos[rootDeviceIndex].exportedFunctionsSurface = kernelInfoArray[exportedFunctionHeapId]->getGraphicsAllocation();
         exportedFunctions.gpuAddress = static_cast<uintptr_t>(buildInfos[rootDeviceIndex].exportedFunctionsSurface->getGpuAddressToPatch());
         exportedFunctions.segmentSize = buildInfos[rootDeviceIndex].exportedFunctionsSurface->getUnderlyingBufferSize();
     }
     Linker::PatchableSegments isaSegmentsForPatching;
     std::vector<std::vector<char>> patchedIsaTempStorage;
     if (linkerInput->getTraits().requiresPatchingOfInstructionSegments) {
-        patchedIsaTempStorage.reserve(this->kernelInfoArray.size());
-        for (const auto &kernelInfo : this->kernelInfoArray) {
+        patchedIsaTempStorage.reserve(kernelInfoArray.size());
+        for (const auto &kernelInfo : kernelInfoArray) {
             auto &kernHeapInfo = kernelInfo->heapInfo;
             const char *originalIsa = reinterpret_cast<const char *>(kernHeapInfo.pKernelHeap);
             patchedIsaTempStorage.push_back(std::vector<char>(originalIsa, originalIsa + kernHeapInfo.KernelHeapSize));
@@ -95,22 +99,22 @@ cl_int Program::linkBinary(Device *pDevice, const void *constantsInitData, const
                                                                  globalsForPatching, constantsForPatching,
                                                                  isaSegmentsForPatching, unresolvedExternalsInfo,
                                                                  pDevice, constantsInitData, variablesInitData);
-    setSymbols(pDevice->getRootDeviceIndex(), linker.extractRelocatedSymbols());
+    setSymbols(rootDeviceIndex, linker.extractRelocatedSymbols());
     if (false == linkSuccess) {
         std::vector<std::string> kernelNames;
-        for (const auto &kernelInfo : this->kernelInfoArray) {
+        for (const auto &kernelInfo : kernelInfoArray) {
             kernelNames.push_back("kernel : " + kernelInfo->kernelDescriptor.kernelMetadata.kernelName);
         }
         auto error = constructLinkerErrorMessage(unresolvedExternalsInfo, kernelNames);
         updateBuildLog(pDevice->getRootDeviceIndex(), error.c_str(), error.size());
         return CL_INVALID_BINARY;
     } else if (linkerInput->getTraits().requiresPatchingOfInstructionSegments) {
-        for (const auto &kernelInfo : this->kernelInfoArray) {
+        for (const auto &kernelInfo : kernelInfoArray) {
             if (nullptr == kernelInfo->getGraphicsAllocation()) {
                 continue;
             }
             auto &kernHeapInfo = kernelInfo->heapInfo;
-            auto segmentId = &kernelInfo - &this->kernelInfoArray[0];
+            auto segmentId = &kernelInfo - &kernelInfoArray[0];
             pDevice->getMemoryManager()->copyMemoryToAllocation(kernelInfo->getGraphicsAllocation(), 0,
                                                                 isaSegmentsForPatching[segmentId].hostPointer,
                                                                 kernHeapInfo.KernelHeapSize);
@@ -160,6 +164,7 @@ cl_int Program::processGenBinary(const ClDevice &clDevice) {
 
 cl_int Program::processProgramInfo(ProgramInfo &src, const ClDevice &clDevice) {
     auto rootDeviceIndex = clDevice.getRootDeviceIndex();
+    auto &kernelInfoArray = buildInfos[rootDeviceIndex].kernelInfoArray;
     size_t slmNeeded = getMaxInlineSlmNeeded(src);
     size_t slmAvailable = 0U;
     NEO::DeviceInfoKernelPayloadConstants deviceInfoConstants;
@@ -178,7 +183,7 @@ cl_int Program::processProgramInfo(ProgramInfo &src, const ClDevice &clDevice) {
         return CL_OUT_OF_RESOURCES;
     }
 
-    this->kernelInfoArray = std::move(src.kernelInfos);
+    kernelInfoArray = std::move(src.kernelInfos);
     auto svmAllocsManager = context ? context->getSVMAllocsManager() : nullptr;
     if (src.globalConstants.size != 0) {
         buildInfos[rootDeviceIndex].constantSurface = allocateGlobalsSurface(svmAllocsManager, clDevice.getDevice(), src.globalConstants.size, true, linkerInput, src.globalConstants.initData);
@@ -193,7 +198,7 @@ cl_int Program::processProgramInfo(ProgramInfo &src, const ClDevice &clDevice) {
         }
     }
 
-    for (auto &kernelInfo : this->kernelInfoArray) {
+    for (auto &kernelInfo : kernelInfoArray) {
         cl_int retVal = CL_SUCCESS;
         if (kernelInfo->heapInfo.KernelHeapSize) {
             retVal = kernelInfo->createKernelAllocation(clDevice.getDevice(), isBuiltIn) ? CL_SUCCESS : CL_OUT_OF_HOST_MEMORY;
@@ -204,10 +209,10 @@ cl_int Program::processProgramInfo(ProgramInfo &src, const ClDevice &clDevice) {
         }
 
         if (kernelInfo->hasDeviceEnqueue()) {
-            parentKernelInfoArray.push_back(kernelInfo);
+            buildInfos[rootDeviceIndex].parentKernelInfoArray.push_back(kernelInfo);
         }
         if (kernelInfo->requiresSubgroupIndependentForwardProgress()) {
-            subgroupKernelInfoArray.push_back(kernelInfo);
+            buildInfos[rootDeviceIndex].subgroupKernelInfoArray.push_back(kernelInfo);
         }
 
         kernelInfo->apply(deviceInfoConstants);
@@ -216,8 +221,9 @@ cl_int Program::processProgramInfo(ProgramInfo &src, const ClDevice &clDevice) {
     return linkBinary(&clDevice.getDevice(), src.globalConstants.initData, src.globalVariables.initData);
 }
 
-void Program::processDebugData() {
+void Program::processDebugData(uint32_t rootDeviceIndex) {
     if (debugData != nullptr) {
+        auto &kernelInfoArray = buildInfos[rootDeviceIndex].kernelInfoArray;
         SProgramDebugDataHeaderIGC *programDebugHeader = reinterpret_cast<SProgramDebugDataHeaderIGC *>(debugData.get());
 
         DEBUG_BREAK_IF(programDebugHeader->NumberOfKernels != kernelInfoArray.size());
diff --git a/opencl/source/program/program.cpp b/opencl/source/program/program.cpp
index 5cf873abe1..33d7e58cab 100644
--- a/opencl/source/program/program.cpp
+++ b/opencl/source/program/program.cpp
@@ -294,26 +294,26 @@ const char *Program::getBuildLog(uint32_t rootDeviceIndex) const {
     return currentLog.c_str();
 }
 
-void Program::separateBlockKernels() {
-    if ((0 == parentKernelInfoArray.size()) && (0 == subgroupKernelInfoArray.size())) {
+void Program::separateBlockKernels(uint32_t rootDeviceIndex) {
+    if ((0 == buildInfos[rootDeviceIndex].parentKernelInfoArray.size()) && (0 == buildInfos[rootDeviceIndex].subgroupKernelInfoArray.size())) {
         return;
     }
 
-    auto allKernelInfos(kernelInfoArray);
-    kernelInfoArray.clear();
+    auto allKernelInfos(buildInfos[rootDeviceIndex].kernelInfoArray);
+    buildInfos[rootDeviceIndex].kernelInfoArray.clear();
     for (auto &i : allKernelInfos) {
         auto end = i->kernelDescriptor.kernelMetadata.kernelName.rfind("_dispatch_");
         if (end != std::string::npos) {
             bool baseKernelFound = false;
             std::string baseKernelName(i->kernelDescriptor.kernelMetadata.kernelName, 0, end);
-            for (auto &j : parentKernelInfoArray) {
+            for (auto &j : buildInfos[rootDeviceIndex].parentKernelInfoArray) {
                 if (j->kernelDescriptor.kernelMetadata.kernelName.compare(baseKernelName) == 0) {
                     baseKernelFound = true;
                     break;
                 }
             }
             if (!baseKernelFound) {
-                for (auto &j : subgroupKernelInfoArray) {
+                for (auto &j : buildInfos[rootDeviceIndex].subgroupKernelInfoArray) {
                     if (j->kernelDescriptor.kernelMetadata.kernelName.compare(baseKernelName) == 0) {
                         baseKernelFound = true;
                         break;
@@ -324,11 +324,11 @@ void Program::separateBlockKernels() {
                 //Parent or subgroup kernel found -> child kernel
                 blockKernelManager->addBlockKernelInfo(i);
             } else {
-                kernelInfoArray.push_back(i);
+                buildInfos[rootDeviceIndex].kernelInfoArray.push_back(i);
             }
         } else {
             //Regular kernel found
-            kernelInfoArray.push_back(i);
+            buildInfos[rootDeviceIndex].kernelInfoArray.push_back(i);
         }
     }
     allKernelInfos.clear();
@@ -375,21 +375,23 @@ void Program::freeBlockResources() {
 }
 
 void Program::cleanCurrentKernelInfo() {
-    for (auto &kernelInfo : kernelInfoArray) {
-        if (kernelInfo->kernelAllocation) {
-            //register cache flush in all csrs where kernel allocation was used
-            for (auto &engine : this->executionEnvironment.memoryManager->getRegisteredEngines()) {
-                auto contextId = engine.osContext->getContextId();
-                if (kernelInfo->kernelAllocation->isUsedByOsContext(contextId)) {
-                    engine.commandStreamReceiver->registerInstructionCacheFlush();
+    for (auto &buildInfo : buildInfos) {
+        for (auto &kernelInfo : buildInfo.kernelInfoArray) {
+            if (kernelInfo->kernelAllocation) {
+                //register cache flush in all csrs where kernel allocation was used
+                for (auto &engine : this->executionEnvironment.memoryManager->getRegisteredEngines()) {
+                    auto contextId = engine.osContext->getContextId();
+                    if (kernelInfo->kernelAllocation->isUsedByOsContext(contextId)) {
+                        engine.commandStreamReceiver->registerInstructionCacheFlush();
+                    }
                 }
-            }
 
-            this->executionEnvironment.memoryManager->checkGpuUsageAndDestroyGraphicsAllocations(kernelInfo->kernelAllocation);
+                this->executionEnvironment.memoryManager->checkGpuUsageAndDestroyGraphicsAllocations(kernelInfo->kernelAllocation);
+            }
+            delete kernelInfo;
         }
-        delete kernelInfo;
+        buildInfo.kernelInfoArray.clear();
     }
-    kernelInfoArray.clear();
 }
 
 void Program::updateNonUniformFlag() {
diff --git a/opencl/source/program/program.h b/opencl/source/program/program.h
index 1c2526c2ad..b70ec2fe1a 100644
--- a/opencl/source/program/program.h
+++ b/opencl/source/program/program.h
@@ -144,8 +144,8 @@ class Program : public BaseObject<_cl_program> {
     MOCKABLE_VIRTUAL cl_int updateSpecializationConstant(cl_uint specId, size_t specSize, const void *specValue);
 
     size_t getNumKernels() const;
-    const KernelInfo *getKernelInfo(const char *kernelName) const;
-    const KernelInfo *getKernelInfo(size_t ordinal) const;
+    const KernelInfo *getKernelInfo(const char *kernelName, uint32_t rootDeviceIndex) const;
+    const KernelInfo *getKernelInfo(size_t ordinal, uint32_t rootDeviceIndex) const;
 
     cl_int getInfo(cl_program_info paramName, size_t paramValueSize,
                    void *paramValue, size_t *paramValueSizeRet);
@@ -173,7 +173,7 @@ class Program : public BaseObject<_cl_program> {
 
     cl_int getSource(std::string &binary) const;
 
-    void processDebugData();
+    void processDebugData(uint32_t rootDeviceIndex);
 
     void updateBuildLog(uint32_t rootDeviceIndex, const char *pErrorString, const size_t errorStringSize);
 
@@ -284,7 +284,7 @@ class Program : public BaseObject<_cl_program> {
 
     MOCKABLE_VIRTUAL cl_int linkBinary(Device *pDevice, const void *constantsInitData, const void *variablesInitData);
 
-    void separateBlockKernels();
+    void separateBlockKernels(uint32_t rootDeviceIndex);
 
     void updateNonUniformFlag();
     void updateNonUniformFlag(const Program **inputProgram, size_t numInputPrograms);
@@ -310,10 +310,6 @@ class Program : public BaseObject<_cl_program> {
 
     CreatedFrom createdFrom = CreatedFrom::UNKNOWN;
 
-    std::vector<KernelInfo *> kernelInfoArray;
-    std::vector<KernelInfo *> parentKernelInfoArray;
-    std::vector<KernelInfo *> subgroupKernelInfoArray;
-
     struct DeviceBuildInfo {
         StackVec<ClDevice *, 2> associatedSubDevices;
         cl_build_status buildStatus = CL_BUILD_NONE;
@@ -331,6 +327,9 @@ class Program : public BaseObject<_cl_program> {
     bool allowNonUniform = false;
 
     struct BuildInfo : public NonCopyableClass {
+        std::vector<KernelInfo *> kernelInfoArray;
+        std::vector<KernelInfo *> parentKernelInfoArray;
+        std::vector<KernelInfo *> subgroupKernelInfoArray;
         GraphicsAllocation *constantSurface = nullptr;
         GraphicsAllocation *globalSurface = nullptr;
         GraphicsAllocation *exportedFunctionsSurface = nullptr;
diff --git a/opencl/test/unit_test/api/cl_create_kernel_tests.inl b/opencl/test/unit_test/api/cl_create_kernel_tests.inl
index 30838b8d4b..f9265fb4f5 100644
--- a/opencl/test/unit_test/api/cl_create_kernel_tests.inl
+++ b/opencl/test/unit_test/api/cl_create_kernel_tests.inl
@@ -142,7 +142,7 @@ TEST_F(clCreateKernelTests, GivenNullKernelNameWhenCreatingNewKernelThenInvalidV
     KernelInfo *pKernelInfo = new KernelInfo();
 
     std::unique_ptr<MockProgram> pMockProg = std::make_unique<MockProgram>(pContext, false, toClDeviceVector(*pDevice));
-    pMockProg->addKernelInfo(pKernelInfo);
+    pMockProg->addKernelInfo(pKernelInfo, testedRootDeviceIndex);
 
     kernel = clCreateKernel(
         pMockProg.get(),
diff --git a/opencl/test/unit_test/aub_tests/gen9/skl/command_queue/run_kernel_aub_tests_skl.cpp b/opencl/test/unit_test/aub_tests/gen9/skl/command_queue/run_kernel_aub_tests_skl.cpp
index b625b5f0fa..e75cad4aa7 100644
--- a/opencl/test/unit_test/aub_tests/gen9/skl/command_queue/run_kernel_aub_tests_skl.cpp
+++ b/opencl/test/unit_test/aub_tests/gen9/skl/command_queue/run_kernel_aub_tests_skl.cpp
@@ -48,7 +48,7 @@ SKLTEST_F(AUBRunKernelIntegrateTest, ooqExecution) {
         false);
     ASSERT_EQ(CL_SUCCESS, retVal);
 
-    const KernelInfo *pKernelInfo0 = pProgram->getKernelInfo("simple_kernel_0");
+    const KernelInfo *pKernelInfo0 = pProgram->getKernelInfo("simple_kernel_0", rootDeviceIndex);
     ASSERT_NE(nullptr, pKernelInfo0);
 
     Kernel *pKernel0 = Kernel::create<MockKernel>(
@@ -57,7 +57,7 @@ SKLTEST_F(AUBRunKernelIntegrateTest, ooqExecution) {
         &retVal);
     ASSERT_NE(nullptr, pKernel0);
 
-    const KernelInfo *pKernelInfo1 = pProgram->getKernelInfo("simple_kernel_1");
+    const KernelInfo *pKernelInfo1 = pProgram->getKernelInfo("simple_kernel_1", rootDeviceIndex);
     ASSERT_NE(nullptr, pKernelInfo1);
 
     Kernel *pKernel1 = Kernel::create<MockKernel>(
@@ -66,7 +66,7 @@ SKLTEST_F(AUBRunKernelIntegrateTest, ooqExecution) {
         &retVal);
     ASSERT_NE(nullptr, pKernel1);
 
-    const KernelInfo *pKernelInfo2 = pProgram->getKernelInfo("simple_kernel_2");
+    const KernelInfo *pKernelInfo2 = pProgram->getKernelInfo("simple_kernel_2", rootDeviceIndex);
     ASSERT_NE(nullptr, pKernelInfo2);
 
     Kernel *pKernel2 = Kernel::create<MockKernel>(
@@ -271,7 +271,7 @@ SKLTEST_F(AUBRunKernelIntegrateTest, deviceSideVme) {
         false);
     ASSERT_EQ(CL_SUCCESS, retVal);
 
-    const KernelInfo *pKernelInfo = pProgram->getKernelInfo("device_side_block_motion_estimate_intel");
+    const KernelInfo *pKernelInfo = pProgram->getKernelInfo("device_side_block_motion_estimate_intel", rootDeviceIndex);
     EXPECT_NE(nullptr, pKernelInfo);
 
     Kernel *pKernel = Kernel::create<MockKernel>(
diff --git a/opencl/test/unit_test/built_ins/built_in_tests.cpp b/opencl/test/unit_test/built_ins/built_in_tests.cpp
index 2c4f8c1274..32c6ce5cce 100644
--- a/opencl/test/unit_test/built_ins/built_in_tests.cpp
+++ b/opencl/test/unit_test/built_ins/built_in_tests.cpp
@@ -2017,7 +2017,7 @@ TEST_F(BuiltInTests, WhenGettingSipKernelThenReturnProgramCreatedFromIsaAcquired
 
     const SipKernel &sipKern = mockBuiltins.getSipKernel(SipKernelType::Csr, pContext->getDevice(0)->getDevice());
 
-    const auto &sipKernelInfo = p->getKernelInfo(static_cast<size_t>(0));
+    const auto &sipKernelInfo = p->getKernelInfo(static_cast<size_t>(0), rootDeviceIndex);
 
     auto compbinedKernelHeapSize = sipKernelInfo->heapInfo.KernelHeapSize;
     auto sipOffset = sipKernelInfo->systemKernelOffset;
diff --git a/opencl/test/unit_test/command_queue/enqueue_debug_kernel_tests.cpp b/opencl/test/unit_test/command_queue/enqueue_debug_kernel_tests.cpp
index e80b8da9c8..a8f1824230 100644
--- a/opencl/test/unit_test/command_queue/enqueue_debug_kernel_tests.cpp
+++ b/opencl/test/unit_test/command_queue/enqueue_debug_kernel_tests.cpp
@@ -53,7 +53,7 @@ class EnqueueDebugKernelTest : public ProgramSimpleFixture,
             // create a kernel
             debugKernel = Kernel::create(
                 pProgram,
-                *pProgram->getKernelInfo("CopyBuffer"),
+                *pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex),
                 &retVal);
 
             ASSERT_EQ(CL_SUCCESS, retVal);
diff --git a/opencl/test/unit_test/command_queue/enqueue_kernel_1_tests.cpp b/opencl/test/unit_test/command_queue/enqueue_kernel_1_tests.cpp
index 3a86288ae2..2c5c583f70 100644
--- a/opencl/test/unit_test/command_queue/enqueue_kernel_1_tests.cpp
+++ b/opencl/test/unit_test/command_queue/enqueue_kernel_1_tests.cpp
@@ -47,7 +47,7 @@ TEST_F(EnqueueKernelTest, givenKernelWhenAllArgsAreSetThenClEnqueueNDRangeKernel
     cl_int retVal = CL_SUCCESS;
     CommandQueue *pCmdQ2 = createCommandQueue(pClDevice);
 
-    std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal));
+    std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex), &retVal));
     EXPECT_EQ(CL_SUCCESS, retVal);
 
     auto b0 = clCreateBuffer(context, 0, n * sizeof(float), nullptr, nullptr);
@@ -86,7 +86,7 @@ TEST_F(EnqueueKernelTest, givenKernelWhenNotAllArgsAreSetButSetKernelArgIsCalled
     cl_int retVal = CL_SUCCESS;
     CommandQueue *pCmdQ2 = createCommandQueue(pClDevice);
 
-    std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal));
+    std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex), &retVal));
     EXPECT_EQ(CL_SUCCESS, retVal);
 
     auto b0 = clCreateBuffer(context, 0, n * sizeof(float), nullptr, nullptr);
@@ -125,7 +125,7 @@ TEST_F(EnqueueKernelTest, givenKernelWhenSetKernelArgIsCalledForEachArgButAtLeas
     cl_int retVal = CL_SUCCESS;
     CommandQueue *pCmdQ2 = createCommandQueue(pClDevice);
 
-    std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal));
+    std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex), &retVal));
     EXPECT_EQ(CL_SUCCESS, retVal);
 
     auto b0 = clCreateBuffer(context, 0, n * sizeof(float), nullptr, nullptr);
@@ -248,7 +248,7 @@ TEST_F(EnqueueKernelTest, givenKernelWhenAllArgsAreSetThenClEnqueueNDCountKernel
         pCmdQ2->getGpgpuEngine().osContext = pCmdQ2->getDevice().getEngine(aub_stream::ENGINE_CCS, true, false).osContext;
     }
 
-    std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal));
+    std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex), &retVal));
     EXPECT_EQ(CL_SUCCESS, retVal);
 
     auto b0 = clCreateBuffer(context, 0, n * sizeof(float), nullptr, nullptr);
@@ -292,7 +292,7 @@ TEST_F(EnqueueKernelTest, givenKernelWhenNotAllArgsAreSetButSetKernelArgIsCalled
         pCmdQ2->getGpgpuEngine().osContext = pCmdQ2->getDevice().getEngine(aub_stream::ENGINE_CCS, true, false).osContext;
     }
 
-    std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal));
+    std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex), &retVal));
     EXPECT_EQ(CL_SUCCESS, retVal);
 
     auto b0 = clCreateBuffer(context, 0, n * sizeof(float), nullptr, nullptr);
@@ -336,7 +336,7 @@ TEST_F(EnqueueKernelTest, givenKernelWhenSetKernelArgIsCalledForEachArgButAtLeas
         pCmdQ2->getGpgpuEngine().osContext = pCmdQ2->getDevice().getEngine(aub_stream::ENGINE_CCS, true, false).osContext;
     }
 
-    std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal));
+    std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex), &retVal));
     EXPECT_EQ(CL_SUCCESS, retVal);
 
     auto b0 = clCreateBuffer(context, 0, n * sizeof(float), nullptr, nullptr);
@@ -1263,7 +1263,7 @@ TEST_F(EnqueueKernelTest, givenKernelWhenAllArgsAreNotAndEventExistSetThenClEnqu
     cl_int retVal = CL_SUCCESS;
     CommandQueue *pCmdQ2 = createCommandQueue(pClDevice);
 
-    std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal));
+    std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex), &retVal));
     EXPECT_EQ(CL_SUCCESS, retVal);
 
     EXPECT_FALSE(kernel->isPatched());
diff --git a/opencl/test/unit_test/command_queue/enqueue_svm_tests.cpp b/opencl/test/unit_test/command_queue/enqueue_svm_tests.cpp
index 510984ecdb..1f13bee2c2 100644
--- a/opencl/test/unit_test/command_queue/enqueue_svm_tests.cpp
+++ b/opencl/test/unit_test/command_queue/enqueue_svm_tests.cpp
@@ -738,7 +738,7 @@ TEST_F(EnqueueSvmTest, GivenSvmAllocationWhenEnqueingKernelThenSuccessIsReturned
 
     std::unique_ptr<Program> program(Program::createBuiltInFromSource("FillBufferBytes", context, context->getDevices(), &retVal));
     program->build(program->getDevices(), nullptr, false);
-    std::unique_ptr<MockKernel> kernel(Kernel::create<MockKernel>(program.get(), *program->getKernelInfo("FillBufferBytes"), &retVal));
+    std::unique_ptr<MockKernel> kernel(Kernel::create<MockKernel>(program.get(), *program->getKernelInfo("FillBufferBytes", rootDeviceIndex), &retVal));
 
     kernel->setSvmKernelExecInfo(pSvmAlloc);
 
@@ -766,7 +766,7 @@ TEST_F(EnqueueSvmTest, givenEnqueueTaskBlockedOnUserEventWhenItIsEnqueuedThenSur
 
     auto program = clUniquePtr(Program::createBuiltInFromSource("FillBufferBytes", context, context->getDevices(), &retVal));
     program->build(program->getDevices(), nullptr, false);
-    auto kernel = clUniquePtr(Kernel::create<MockKernel>(program.get(), *program->getKernelInfo("FillBufferBytes"), &retVal));
+    auto kernel = clUniquePtr(Kernel::create<MockKernel>(program.get(), *program->getKernelInfo("FillBufferBytes", rootDeviceIndex), &retVal));
 
     std::vector<Surface *> allSurfaces;
     kernel->getResidency(allSurfaces, rootDeviceIndex);
diff --git a/opencl/test/unit_test/command_queue/get_size_required_image_tests.cpp b/opencl/test/unit_test/command_queue/get_size_required_image_tests.cpp
index 6d73880ecc..ce065a9b78 100644
--- a/opencl/test/unit_test/command_queue/get_size_required_image_tests.cpp
+++ b/opencl/test/unit_test/command_queue/get_size_required_image_tests.cpp
@@ -121,7 +121,7 @@ HWTEST_F(GetSizeRequiredImageTest, WhenCopyingReadWriteImageThenHeapsAndCommandB
 
     std::unique_ptr<Program> program(Program::createBuiltInFromSource("CopyImageToImage3d", context, context->getDevices(), nullptr));
     program->build(program->getDevices(), nullptr, false);
-    std::unique_ptr<Kernel> kernel(Kernel::create<MockKernel>(program.get(), *program->getKernelInfo("CopyImageToImage3d"), nullptr));
+    std::unique_ptr<Kernel> kernel(Kernel::create<MockKernel>(program.get(), *program->getKernelInfo("CopyImageToImage3d", rootDeviceIndex), nullptr));
 
     EXPECT_NE(nullptr, kernel);
     // This kernel does not operate on OpenCL 2.0 Read and Write images
diff --git a/opencl/test/unit_test/context/driver_diagnostics_tests.h b/opencl/test/unit_test/context/driver_diagnostics_tests.h
index 2a722f54ae..24a80a730e 100644
--- a/opencl/test/unit_test/context/driver_diagnostics_tests.h
+++ b/opencl/test/unit_test/context/driver_diagnostics_tests.h
@@ -230,7 +230,7 @@ struct PerformanceHintEnqueueKernelTest : public PerformanceHintEnqueueTest,
         CreateProgramFromBinary(context, context->getDevices(), "CopyBuffer_simd32");
         retVal = pProgram->build(pProgram->getDevices(), nullptr, false);
         ASSERT_EQ(CL_SUCCESS, retVal);
-        kernel = Kernel::create<MockKernel>(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal);
+        kernel = Kernel::create<MockKernel>(pProgram, *pProgram->getKernelInfo("CopyBuffer", context->getDevice(0)->getRootDeviceIndex()), &retVal);
 
         globalWorkGroupSize[0] = globalWorkGroupSize[1] = globalWorkGroupSize[2] = 1;
     }
@@ -265,7 +265,7 @@ struct PerformanceHintEnqueueKernelPrintfTest : public PerformanceHintEnqueueTes
         CreateProgramFromBinary(context, context->getDevices(), "printf");
         retVal = pProgram->build(pProgram->getDevices(), nullptr, false);
         ASSERT_EQ(CL_SUCCESS, retVal);
-        kernel = Kernel::create(pProgram, *pProgram->getKernelInfo("test"), &retVal);
+        kernel = Kernel::create(pProgram, *pProgram->getKernelInfo("test", context->getDevice(0)->getRootDeviceIndex()), &retVal);
 
         globalWorkGroupSize[0] = globalWorkGroupSize[1] = globalWorkGroupSize[2] = 1;
     }
diff --git a/opencl/test/unit_test/fixtures/execution_model_kernel_fixture.h b/opencl/test/unit_test/fixtures/execution_model_kernel_fixture.h
index 32bc4d7f31..9217a826a2 100644
--- a/opencl/test/unit_test/fixtures/execution_model_kernel_fixture.h
+++ b/opencl/test/unit_test/fixtures/execution_model_kernel_fixture.h
@@ -40,7 +40,7 @@ class ExecutionModelKernelFixture : public ProgramFromBinaryTest,
         // create a kernel
         pKernel = Kernel::create<MockKernel>(
             pProgram,
-            *pProgram->getKernelInfo(KernelName),
+            *pProgram->getKernelInfo(kernelName, rootDeviceIndex),
             &retVal);
 
         ASSERT_EQ(CL_SUCCESS, retVal);
diff --git a/opencl/test/unit_test/fixtures/hello_world_kernel_fixture.h b/opencl/test/unit_test/fixtures/hello_world_kernel_fixture.h
index b08dfb300f..fd745471f5 100644
--- a/opencl/test/unit_test/fixtures/hello_world_kernel_fixture.h
+++ b/opencl/test/unit_test/fixtures/hello_world_kernel_fixture.h
@@ -77,7 +77,7 @@ struct HelloWorldKernelFixture : public ProgramFixture {
         // create a kernel
         pKernel = Kernel::create<MockKernel>(
             pProgram,
-            *pProgram->getKernelInfo(pKernelName->c_str()),
+            *pProgram->getKernelInfo(pKernelName->c_str(), pDevice->getRootDeviceIndex()),
             &retVal);
 
         EXPECT_NE(nullptr, pKernel);
diff --git a/opencl/test/unit_test/fixtures/kernel_data_fixture.cpp b/opencl/test/unit_test/fixtures/kernel_data_fixture.cpp
index 90e343b9c9..27fd7444aa 100644
--- a/opencl/test/unit_test/fixtures/kernel_data_fixture.cpp
+++ b/opencl/test/unit_test/fixtures/kernel_data_fixture.cpp
@@ -95,7 +95,7 @@ void KernelDataTest::buildAndDecode() {
     EXPECT_EQ(CL_SUCCESS, error);
 
     // extract the kernel info
-    pKernelInfo = program->Program::getKernelInfo(kernelName.c_str());
+    pKernelInfo = program->Program::getKernelInfo(kernelName.c_str(), rootDeviceIndex);
 
     // validate name
     EXPECT_STREQ(pKernelInfo->kernelDescriptor.kernelMetadata.kernelName.c_str(), kernelName.c_str());
diff --git a/opencl/test/unit_test/fixtures/kernel_data_fixture.h b/opencl/test/unit_test/fixtures/kernel_data_fixture.h
index 67c35fca0e..a0554a8ef6 100644
--- a/opencl/test/unit_test/fixtures/kernel_data_fixture.h
+++ b/opencl/test/unit_test/fixtures/kernel_data_fixture.h
@@ -53,6 +53,7 @@ class KernelDataTest : public testing::Test {
     void SetUp() override {
         kernelBinaryHeader.KernelNameSize = kernelNameSize;
         pContext = new MockContext;
+        rootDeviceIndex = pContext->getDevice(0)->getRootDeviceIndex();
         program = std::make_unique<MockProgram>(pContext, false, toClDeviceVector(*pContext->getDevice(0)));
     }
 
@@ -91,4 +92,5 @@ class KernelDataTest : public testing::Test {
     std::unique_ptr<MockProgram> program;
     MockContext *pContext;
     const KernelInfo *pKernelInfo;
+    uint32_t rootDeviceIndex = std::numeric_limits<uint32_t>::max();
 };
diff --git a/opencl/test/unit_test/fixtures/media_kernel_fixture.h b/opencl/test/unit_test/fixtures/media_kernel_fixture.h
index a5cd41ed65..bf243cb868 100644
--- a/opencl/test/unit_test/fixtures/media_kernel_fixture.h
+++ b/opencl/test/unit_test/fixtures/media_kernel_fixture.h
@@ -76,7 +76,7 @@ struct MediaKernelFixture : public HelloWorldFixture<FactoryType>,
         // create the VME kernel
         pVmeKernel = Kernel::create<MockKernel>(
             pProgram,
-            *pProgram->getKernelInfo("device_side_block_motion_estimate_intel"),
+            *pProgram->getKernelInfo("device_side_block_motion_estimate_intel", pProgram->getDevices()[0]->getRootDeviceIndex()),
             &retVal);
 
         ASSERT_NE(nullptr, pVmeKernel);
diff --git a/opencl/test/unit_test/fixtures/simple_arg_kernel_fixture.h b/opencl/test/unit_test/fixtures/simple_arg_kernel_fixture.h
index c53052afc7..d5e6768405 100644
--- a/opencl/test/unit_test/fixtures/simple_arg_kernel_fixture.h
+++ b/opencl/test/unit_test/fixtures/simple_arg_kernel_fixture.h
@@ -110,7 +110,7 @@ class SimpleArgKernelFixture : public ProgramFixture {
         // create a kernel
         pKernel = Kernel::create<MockKernel>(
             pProgram,
-            *pProgram->getKernelInfo("SimpleArg"),
+            *pProgram->getKernelInfo("SimpleArg", pDevice->getRootDeviceIndex()),
             &retVal);
 
         ASSERT_NE(nullptr, pKernel);
@@ -156,7 +156,7 @@ class SimpleArgNonUniformKernelFixture : public ProgramFixture {
 
         kernel = Kernel::create<MockKernel>(
             pProgram,
-            *pProgram->getKernelInfo("simpleNonUniform"),
+            *pProgram->getKernelInfo("simpleNonUniform", device->getRootDeviceIndex()),
             &retVal);
         ASSERT_NE(nullptr, kernel);
         ASSERT_EQ(CL_SUCCESS, retVal);
@@ -202,7 +202,7 @@ class SimpleKernelFixture : public ProgramFixture {
                 kernelName.append(std::to_string(i));
                 kernels[i].reset(Kernel::create<MockKernel>(
                     pProgram,
-                    *pProgram->getKernelInfo(kernelName.c_str()),
+                    *pProgram->getKernelInfo(kernelName.c_str(), device->getRootDeviceIndex()),
                     &retVal));
                 ASSERT_NE(nullptr, kernels[i]);
                 ASSERT_EQ(CL_SUCCESS, retVal);
@@ -251,7 +251,7 @@ class SimpleKernelStatelessFixture : public ProgramFixture {
 
         kernel.reset(Kernel::create<MockKernel>(
             pProgram,
-            *pProgram->getKernelInfo("statelessKernel"),
+            *pProgram->getKernelInfo("statelessKernel", device->getRootDeviceIndex()),
             &retVal));
         ASSERT_NE(nullptr, kernel);
         ASSERT_EQ(CL_SUCCESS, retVal);
@@ -294,7 +294,7 @@ class BindlessKernelFixture : public ProgramFixture {
 
         kernel.reset(Kernel::create<MockKernel>(
             pProgram,
-            *pProgram->getKernelInfo(kernelName.c_str()),
+            *pProgram->getKernelInfo(kernelName.c_str(), deviceCl->getRootDeviceIndex()),
             &retVal));
         ASSERT_NE(nullptr, kernel);
         ASSERT_EQ(CL_SUCCESS, retVal);
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 3b67236c3f..c387b984c2 100644
--- a/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp
+++ b/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp
@@ -1318,7 +1318,7 @@ HWTEST_F(KernelCacheFlushTests, givenLocallyUncachedBufferWhenGettingAllocations
     DebugManagerStateRestore dbgRestore;
     DebugManager.flags.EnableCacheFlushAfterWalker.set(-1);
 
-    auto kernel = clUniquePtr(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal));
+    auto kernel = clUniquePtr(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex), &retVal));
 
     cl_mem_properties_intel bufferPropertiesUncachedResource[] = {CL_MEM_FLAGS_INTEL, CL_MEM_LOCALLY_UNCACHED_RESOURCE, 0};
     auto bufferLocallyUncached = clCreateBufferWithPropertiesINTEL(context, bufferPropertiesUncachedResource, 0, 1, nullptr, nullptr);
diff --git a/opencl/test/unit_test/kernel/kernel_arg_info_tests.cpp b/opencl/test/unit_test/kernel/kernel_arg_info_tests.cpp
index 2627a0e51f..b4cb7e857f 100644
--- a/opencl/test/unit_test/kernel/kernel_arg_info_tests.cpp
+++ b/opencl/test/unit_test/kernel/kernel_arg_info_tests.cpp
@@ -40,7 +40,7 @@ class KernelArgInfoTest : public ProgramFromSourceTest {
         // create a kernel
         pKernel = Kernel::create(
             pProgram,
-            *pProgram->getKernelInfo(KernelName),
+            *pProgram->getKernelInfo(kernelName, rootDeviceIndex),
             &retVal);
 
         ASSERT_EQ(CL_SUCCESS, retVal);
@@ -87,7 +87,7 @@ class KernelArgInfoTest : public ProgramFromSourceTest {
 };
 
 TEST_P(KernelArgInfoTest, GivenNullWhenGettingKernelInfoThenNullIsReturned) {
-    auto kernelInfo = this->pProgram->getKernelInfo(nullptr);
+    auto kernelInfo = this->pProgram->getKernelInfo(nullptr, 0);
     EXPECT_EQ(nullptr, kernelInfo);
 }
 
diff --git a/opencl/test/unit_test/kernel/kernel_is_patched_tests.cpp b/opencl/test/unit_test/kernel/kernel_is_patched_tests.cpp
index 513584fbc5..87143b29dd 100644
--- a/opencl/test/unit_test/kernel/kernel_is_patched_tests.cpp
+++ b/opencl/test/unit_test/kernel/kernel_is_patched_tests.cpp
@@ -18,18 +18,19 @@ using namespace NEO;
 class PatchedKernelTest : public ::testing::Test {
   public:
     void SetUp() override {
-        device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+        device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get(), rootDeviceIndex));
         context.reset(new MockContext(device.get()));
         program.reset(Program::createBuiltInFromSource("FillBufferBytes", context.get(), context->getDevices(), &retVal));
         EXPECT_EQ(CL_SUCCESS, retVal);
         program->build(program->getDevices(), nullptr, false);
-        kernel.reset(Kernel::create(program.get(), *program->getKernelInfo("FillBufferBytes"), &retVal));
+        kernel.reset(Kernel::create(program.get(), *program->getKernelInfo("FillBufferBytes", rootDeviceIndex), &retVal));
         EXPECT_EQ(CL_SUCCESS, retVal);
     }
     void TearDown() override {
         context.reset();
     }
 
+    const uint32_t rootDeviceIndex = 0u;
     std::unique_ptr<MockContext> context;
     std::unique_ptr<MockClDevice> device;
     std::unique_ptr<Program> program;
diff --git a/opencl/test/unit_test/kernel/kernel_tests.cpp b/opencl/test/unit_test/kernel/kernel_tests.cpp
index 0c5e38cb65..3710e2992c 100644
--- a/opencl/test/unit_test/kernel/kernel_tests.cpp
+++ b/opencl/test/unit_test/kernel/kernel_tests.cpp
@@ -67,7 +67,7 @@ class KernelTest : public ProgramFromBinaryTest {
         // create a kernel
         pKernel = Kernel::create(
             pProgram,
-            *pProgram->getKernelInfo(KernelName),
+            *pProgram->getKernelInfo(kernelName, rootDeviceIndex),
             &retVal);
 
         ASSERT_EQ(CL_SUCCESS, retVal);
@@ -156,7 +156,7 @@ TEST_P(KernelTest, GivenKernelFunctionNameWhenGettingInfoThenKernelFunctionNameI
         nullptr);
 
     EXPECT_NE(nullptr, paramValue);
-    EXPECT_EQ(0, strcmp(paramValue, KernelName));
+    EXPECT_EQ(0, strcmp(paramValue, kernelName));
     EXPECT_EQ(CL_SUCCESS, retVal);
 
     delete[] paramValue;
@@ -351,7 +351,7 @@ TEST_F(KernelFromBinaryTests, GivenKernelNumArgsWhenGettingInfoThenNumberOfKerne
 
     ASSERT_EQ(CL_SUCCESS, retVal);
 
-    auto pKernelInfo = pProgram->getKernelInfo("test");
+    auto pKernelInfo = pProgram->getKernelInfo("test", rootDeviceIndex);
 
     // create a kernel
     auto pKernel = Kernel::create(
@@ -389,7 +389,7 @@ TEST_F(KernelFromBinaryTests, WhenRegularKernelIsCreatedThenItIsNotBuiltIn) {
 
     ASSERT_EQ(CL_SUCCESS, retVal);
 
-    auto pKernelInfo = pProgram->getKernelInfo("simple_kernel_0");
+    auto pKernelInfo = pProgram->getKernelInfo("simple_kernel_0", rootDeviceIndex);
 
     // create a kernel
     auto pKernel = Kernel::create(
@@ -419,9 +419,9 @@ TEST_F(KernelFromBinaryTests, givenArgumentDeclaredAsConstantWhenKernelIsCreated
 
     ASSERT_EQ(CL_SUCCESS, retVal);
 
-    auto pKernelInfo = pProgram->getKernelInfo("simple_kernel_6");
+    auto pKernelInfo = pProgram->getKernelInfo("simple_kernel_6", rootDeviceIndex);
     EXPECT_TRUE(pKernelInfo->kernelArgInfo[1].isReadOnly);
-    pKernelInfo = pProgram->getKernelInfo("simple_kernel_1");
+    pKernelInfo = pProgram->getKernelInfo("simple_kernel_1", rootDeviceIndex);
     EXPECT_TRUE(pKernelInfo->kernelArgInfo[0].isReadOnly);
 }
 
diff --git a/opencl/test/unit_test/mocks/mock_program.h b/opencl/test/unit_test/mocks/mock_program.h
index f6b5503690..1603cf54dd 100644
--- a/opencl/test/unit_test/mocks/mock_program.h
+++ b/opencl/test/unit_test/mocks/mock_program.h
@@ -91,17 +91,17 @@ class MockProgram : public Program {
             }
         }
     }
-    std::vector<KernelInfo *> &getKernelInfoArray() {
-        return kernelInfoArray;
+    std::vector<KernelInfo *> &getKernelInfoArray(uint32_t rootDeviceIndex) {
+        return buildInfos[rootDeviceIndex].kernelInfoArray;
     }
-    void addKernelInfo(KernelInfo *inInfo) {
-        kernelInfoArray.push_back(inInfo);
+    void addKernelInfo(KernelInfo *inInfo, uint32_t rootDeviceIndex) {
+        buildInfos[rootDeviceIndex].kernelInfoArray.push_back(inInfo);
     }
-    std::vector<KernelInfo *> &getParentKernelInfoArray() {
-        return parentKernelInfoArray;
+    std::vector<KernelInfo *> &getParentKernelInfoArray(uint32_t rootDeviceIndex) {
+        return buildInfos[rootDeviceIndex].parentKernelInfoArray;
     }
-    std::vector<KernelInfo *> &getSubgroupKernelInfoArray() {
-        return subgroupKernelInfoArray;
+    std::vector<KernelInfo *> &getSubgroupKernelInfoArray(uint32_t rootDeviceIndex) {
+        return buildInfos[rootDeviceIndex].subgroupKernelInfoArray;
     }
     void setContext(Context *context) {
         this->context = context;
diff --git a/opencl/test/unit_test/program/kernel_data.cpp b/opencl/test/unit_test/program/kernel_data.cpp
index 86c5d8fbeb..be37cbf48e 100644
--- a/opencl/test/unit_test/program/kernel_data.cpp
+++ b/opencl/test/unit_test/program/kernel_data.cpp
@@ -408,7 +408,7 @@ TEST_F(KernelDataTest, GivenExecutionEnvironmentDoesntHaveDeviceEnqueueWhenBuild
     buildAndDecode();
 
     EXPECT_EQ_CONST(PATCH_TOKEN_EXECUTION_ENVIRONMENT, pKernelInfo->patchInfo.executionEnvironment->Token);
-    EXPECT_EQ_VAL(0u, program->getParentKernelInfoArray().size());
+    EXPECT_EQ_VAL(0u, program->getParentKernelInfoArray(rootDeviceIndex).size());
 }
 
 TEST_F(KernelDataTest, GivenExecutionEnvironmentHasDeviceEnqueueWhenBuildingThenProgramIsCorrect) {
@@ -423,7 +423,7 @@ TEST_F(KernelDataTest, GivenExecutionEnvironmentHasDeviceEnqueueWhenBuildingThen
     buildAndDecode();
 
     EXPECT_EQ_CONST(PATCH_TOKEN_EXECUTION_ENVIRONMENT, pKernelInfo->patchInfo.executionEnvironment->Token);
-    EXPECT_EQ_VAL(1u, program->getParentKernelInfoArray().size());
+    EXPECT_EQ_VAL(1u, program->getParentKernelInfoArray(rootDeviceIndex).size());
 }
 
 TEST_F(KernelDataTest, GivenExecutionEnvironmentDoesntRequireSubgroupIndependentForwardProgressWhenBuildingThenProgramIsCorrect) {
@@ -438,7 +438,7 @@ TEST_F(KernelDataTest, GivenExecutionEnvironmentDoesntRequireSubgroupIndependent
     buildAndDecode();
 
     EXPECT_EQ_CONST(PATCH_TOKEN_EXECUTION_ENVIRONMENT, pKernelInfo->patchInfo.executionEnvironment->Token);
-    EXPECT_EQ_VAL(0u, program->getSubgroupKernelInfoArray().size());
+    EXPECT_EQ_VAL(0u, program->getSubgroupKernelInfoArray(rootDeviceIndex).size());
 }
 
 TEST_F(KernelDataTest, GivenExecutionEnvironmentRequiresSubgroupIndependentForwardProgressWhenBuildingThenProgramIsCorrect) {
@@ -453,7 +453,7 @@ TEST_F(KernelDataTest, GivenExecutionEnvironmentRequiresSubgroupIndependentForwa
     buildAndDecode();
 
     EXPECT_EQ_CONST(PATCH_TOKEN_EXECUTION_ENVIRONMENT, pKernelInfo->patchInfo.executionEnvironment->Token);
-    EXPECT_EQ_VAL(1u, program->getSubgroupKernelInfoArray().size());
+    EXPECT_EQ_VAL(1u, program->getSubgroupKernelInfoArray(rootDeviceIndex).size());
 }
 
 TEST_F(KernelDataTest, GivenKernelAttributesInfoWhenBuildingThenProgramIsCorrect) {
diff --git a/opencl/test/unit_test/program/process_debug_data_tests.cpp b/opencl/test/unit_test/program/process_debug_data_tests.cpp
index cf7a37e38f..9dc6afa282 100644
--- a/opencl/test/unit_test/program/process_debug_data_tests.cpp
+++ b/opencl/test/unit_test/program/process_debug_data_tests.cpp
@@ -64,10 +64,10 @@ TEST_F(ProgramTests, GivenProgramWithDebugDataForTwoKernelsWhenPorcessedThenDebu
     program->debugData = makeCopy(debugData.get(), debugDataSize);
     program->debugDataSize = debugDataSize;
 
-    program->addKernelInfo(kernelInfo1);
-    program->addKernelInfo(kernelInfo2);
+    program->addKernelInfo(kernelInfo1, rootDeviceIndex);
+    program->addKernelInfo(kernelInfo2, rootDeviceIndex);
 
-    program->processDebugData();
+    program->processDebugData(rootDeviceIndex);
     EXPECT_EQ(genIsaSize, kernelInfo1->debugData.genIsaSize);
     EXPECT_EQ(visaSize, kernelInfo1->debugData.vIsaSize);
     EXPECT_EQ(ptrDiff(vIsa1, debugData.get()), ptrDiff(kernelInfo1->debugData.vIsa, program->getDebugData()));
@@ -86,8 +86,8 @@ TEST_F(ProgramTests, GivenProgramWithoutDebugDataWhenPorcessedThenDebugDataIsNot
     kernelInfo1->kernelDescriptor.kernelMetadata.kernelName = kernelName1;
     auto program = std::make_unique<MockProgram>(toClDeviceVector(*pClDevice));
 
-    program->addKernelInfo(kernelInfo1);
-    program->processDebugData();
+    program->addKernelInfo(kernelInfo1, rootDeviceIndex);
+    program->processDebugData(rootDeviceIndex);
 
     EXPECT_EQ(0u, kernelInfo1->debugData.genIsaSize);
     EXPECT_EQ(0u, kernelInfo1->debugData.vIsaSize);
diff --git a/opencl/test/unit_test/program/program_data_tests.cpp b/opencl/test/unit_test/program/program_data_tests.cpp
index e82b746f5e..5858e6c4ae 100644
--- a/opencl/test/unit_test/program/program_data_tests.cpp
+++ b/opencl/test/unit_test/program/program_data_tests.cpp
@@ -51,6 +51,7 @@ class ProgramDataTestBase : public testing::Test,
     void SetUp() override {
         PlatformFixture::SetUp();
         pClDevice = pPlatform->getClDevice(0);
+        rootDeviceIndex = pClDevice->getRootDeviceIndex();
         cl_device_id device = pClDevice;
 
         ContextFixture::SetUp(1, &device);
@@ -128,6 +129,7 @@ class ProgramDataTestBase : public testing::Test,
     cl_int patchlistDecodeErrorCode = 0;
     bool allowDecodeFailure = false;
     ClDevice *pClDevice = nullptr;
+    uint32_t rootDeviceIndex;
 };
 
 void ProgramDataTestBase::buildAndDecodeProgramPatchList() {
@@ -555,6 +557,7 @@ TEST(ProgramLinkBinaryTest, whenLinkerUnresolvedExternalThenLinkFailedAndBuildLo
     linkerInput->relocations.push_back(NEO::LinkerInput::Relocations{relocation});
     linkerInput->traits.requiresPatchingOfInstructionSegments = true;
     auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
+    auto rootDeviceIndex = device->getRootDeviceIndex();
     MockProgram program{nullptr, false, toClDeviceVector(*device)};
     KernelInfo kernelInfo = {};
     kernelInfo.kernelDescriptor.kernelMetadata.kernelName = "onlyKernel";
@@ -562,15 +565,15 @@ TEST(ProgramLinkBinaryTest, whenLinkerUnresolvedExternalThenLinkFailedAndBuildLo
     kernelHeap.resize(32, 7);
     kernelInfo.heapInfo.pKernelHeap = kernelHeap.data();
     kernelInfo.heapInfo.KernelHeapSize = static_cast<uint32_t>(kernelHeap.size());
-    program.getKernelInfoArray().push_back(&kernelInfo);
-    program.setLinkerInput(device->getRootDeviceIndex(), std::move(linkerInput));
+    program.getKernelInfoArray(rootDeviceIndex).push_back(&kernelInfo);
+    program.setLinkerInput(rootDeviceIndex, std::move(linkerInput));
 
     std::string buildLog = program.getBuildLog(device->getRootDeviceIndex());
     EXPECT_TRUE(buildLog.empty());
     auto ret = program.linkBinary(&device->getDevice(), nullptr, nullptr);
     EXPECT_NE(CL_SUCCESS, ret);
-    program.getKernelInfoArray().clear();
-    buildLog = program.getBuildLog(device->getRootDeviceIndex());
+    program.getKernelInfoArray(rootDeviceIndex).clear();
+    buildLog = program.getBuildLog(rootDeviceIndex);
     EXPECT_FALSE(buildLog.empty());
     Linker::UnresolvedExternals expectedUnresolvedExternals;
     expectedUnresolvedExternals.push_back(Linker::UnresolvedExternal{relocation, 0, false});
@@ -601,7 +604,7 @@ TEST_F(ProgramDataTest, whenLinkerInputValidThenIsaIsProperlyPatched) {
     kernelInfo.heapInfo.KernelHeapSize = static_cast<uint32_t>(kernelHeap.size());
     MockGraphicsAllocation kernelIsa(kernelHeap.data(), kernelHeap.size());
     kernelInfo.kernelAllocation = &kernelIsa;
-    program.getKernelInfoArray().push_back(&kernelInfo);
+    program.getKernelInfoArray(rootDeviceIndex).push_back(&kernelInfo);
     program.setLinkerInput(device->getRootDeviceIndex(), std::move(linkerInput));
 
     buildInfo.exportedFunctionsSurface = kernelInfo.kernelAllocation;
@@ -626,7 +629,7 @@ TEST_F(ProgramDataTest, whenLinkerInputValidThenIsaIsProperlyPatched) {
         EXPECT_EQ(static_cast<uintptr_t>(expectedPatch), *reinterpret_cast<uintptr_t *>(relocationAddress)) << i;
     }
 
-    program.getKernelInfoArray().clear();
+    program.getKernelInfoArray(rootDeviceIndex).clear();
     delete buildInfo.globalSurface;
     buildInfo.globalSurface = nullptr;
     delete buildInfo.constantSurface;
@@ -650,8 +653,8 @@ TEST_F(ProgramDataTest, whenRelocationsAreNotNeededThenIsaIsPreserved) {
     kernelInfo.heapInfo.KernelHeapSize = static_cast<uint32_t>(kernelHeap.size());
     MockGraphicsAllocation kernelIsa(kernelHeap.data(), kernelHeap.size());
     kernelInfo.kernelAllocation = &kernelIsa;
-    program.getKernelInfoArray().push_back(&kernelInfo);
-    program.setLinkerInput(device->getRootDeviceIndex(), std::move(linkerInput));
+    program.getKernelInfoArray(rootDeviceIndex).push_back(&kernelInfo);
+    program.setLinkerInput(rootDeviceIndex, std::move(linkerInput));
 
     std::vector<char> globalVariablesBuffer;
     globalVariablesBuffer.resize(32, 7);
@@ -666,7 +669,7 @@ TEST_F(ProgramDataTest, whenRelocationsAreNotNeededThenIsaIsPreserved) {
     EXPECT_EQ(CL_SUCCESS, ret);
     EXPECT_EQ(kernelHeapData, kernelHeap);
 
-    program.getKernelInfoArray().clear();
+    program.getKernelInfoArray(rootDeviceIndex).clear();
     delete buildInfo.globalSurface;
     buildInfo.globalSurface = nullptr;
     delete buildInfo.constantSurface;
diff --git a/opencl/test/unit_test/program/program_from_binary.h b/opencl/test/unit_test/program/program_from_binary.h
index 513917e0fa..8c3471460d 100644
--- a/opencl/test/unit_test/program/program_from_binary.h
+++ b/opencl/test/unit_test/program/program_from_binary.h
@@ -30,7 +30,7 @@ class ProgramFromBinaryTest : public ClDeviceFixture,
 
   protected:
     void SetUp() override {
-        std::tie(BinaryFileName, KernelName) = GetParam();
+        std::tie(BinaryFileName, kernelName) = GetParam();
 
         ClDeviceFixture::SetUp();
 
@@ -56,7 +56,7 @@ class ProgramFromBinaryTest : public ClDeviceFixture,
     }
 
     const char *BinaryFileName = nullptr;
-    const char *KernelName = nullptr;
+    const char *kernelName = nullptr;
     cl_int retVal = CL_SUCCESS;
     std::string options;
 };
diff --git a/opencl/test/unit_test/program/program_nonuniform.cpp b/opencl/test/unit_test/program/program_nonuniform.cpp
index 4219c2e892..3017a36f47 100644
--- a/opencl/test/unit_test/program/program_nonuniform.cpp
+++ b/opencl/test/unit_test/program/program_nonuniform.cpp
@@ -166,6 +166,7 @@ class ProgramNonUniformTest : public ContextFixture,
     void SetUp() override {
         PlatformFixture::SetUp();
         device = pPlatform->getClDevice(0);
+        rootDeviceIndex = pPlatform->getClDevice(0)->getRootDeviceIndex();
         ContextFixture::SetUp(1, &device);
         ProgramFixture::SetUp();
         CommandQueueHwFixture::SetUp(pPlatform->getClDevice(0), 0);
@@ -178,6 +179,7 @@ class ProgramNonUniformTest : public ContextFixture,
         PlatformFixture::TearDown();
     }
     cl_device_id device;
+    uint32_t rootDeviceIndex;
     cl_int retVal = CL_SUCCESS;
 };
 
@@ -195,7 +197,7 @@ TEST_F(ProgramNonUniformTest, GivenCl21WhenExecutingKernelWithNonUniformThenEnqu
         false);
     EXPECT_EQ(CL_SUCCESS, retVal);
 
-    auto pKernelInfo = mockProgram->Program::getKernelInfo("test_get_local_size");
+    auto pKernelInfo = mockProgram->Program::getKernelInfo("test_get_local_size", rootDeviceIndex);
     EXPECT_NE(nullptr, pKernelInfo);
 
     // create a kernel
@@ -234,7 +236,7 @@ TEST_F(ProgramNonUniformTest, GivenCl20WhenExecutingKernelWithNonUniformThenEnqu
         false);
     EXPECT_EQ(CL_SUCCESS, retVal);
 
-    auto pKernelInfo = mockProgram->Program::getKernelInfo("test_get_local_size");
+    auto pKernelInfo = mockProgram->Program::getKernelInfo("test_get_local_size", rootDeviceIndex);
     EXPECT_NE(nullptr, pKernelInfo);
 
     // create a kernel
@@ -271,7 +273,7 @@ TEST_F(ProgramNonUniformTest, GivenCl12WhenExecutingKernelWithNonUniformThenInva
         false);
     EXPECT_EQ(CL_SUCCESS, retVal);
 
-    auto pKernelInfo = mockProgram->Program::getKernelInfo("test_get_local_size");
+    auto pKernelInfo = mockProgram->Program::getKernelInfo("test_get_local_size", rootDeviceIndex);
     EXPECT_NE(nullptr, pKernelInfo);
 
     // create a kernel
diff --git a/opencl/test/unit_test/program/program_tests.cpp b/opencl/test/unit_test/program/program_tests.cpp
index bf94b1d016..4a8796d9ce 100644
--- a/opencl/test/unit_test/program/program_tests.cpp
+++ b/opencl/test/unit_test/program/program_tests.cpp
@@ -277,7 +277,7 @@ TEST_P(ProgramFromBinaryTest, WhenGettingKernelNamesThenCorrectNameIsReturned) {
     paramValueSize = paramValueSizeRet;
     ASSERT_NE(paramValue, nullptr);
 
-    size_t expectedKernelsStringSize = strlen(KernelName) + 1;
+    size_t expectedKernelsStringSize = strlen(kernelName) + 1;
     retVal = pProgram->getInfo(
         CL_PROGRAM_KERNEL_NAMES,
         paramValueSize,
@@ -285,7 +285,7 @@ TEST_P(ProgramFromBinaryTest, WhenGettingKernelNamesThenCorrectNameIsReturned) {
         &paramValueSizeRet);
 
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_STREQ(KernelName, (char *)paramValue.get());
+    EXPECT_STREQ(kernelName, (char *)paramValue.get());
     EXPECT_EQ(expectedKernelsStringSize, paramValueSizeRet);
 }
 
@@ -588,7 +588,7 @@ TEST_P(ProgramFromBinaryTest, GivenGlobalVariableTotalSizeSetWhenGettingBuildGlo
 
 TEST_P(ProgramFromBinaryTest, givenProgramWhenItIsBeingBuildThenItContainsGraphicsAllocationInKernelInfo) {
     pProgram->build(pProgram->getDevices(), nullptr, true);
-    auto kernelInfo = pProgram->getKernelInfo(size_t(0));
+    auto kernelInfo = pProgram->getKernelInfo(size_t(0), rootDeviceIndex);
 
     auto graphicsAllocation = kernelInfo->getGraphicsAllocation();
     ASSERT_NE(nullptr, graphicsAllocation);
@@ -629,7 +629,7 @@ HWTEST_P(ProgramFromBinaryTest, givenProgramWhenCleanCurrentKernelInfoIsCalledBu
     auto &csr = pDevice->getGpgpuCommandStreamReceiver();
     EXPECT_TRUE(csr.getTemporaryAllocations().peekIsEmpty());
     pProgram->build(pProgram->getDevices(), nullptr, true);
-    auto kernelAllocation = pProgram->getKernelInfo(size_t(0))->getGraphicsAllocation();
+    auto kernelAllocation = pProgram->getKernelInfo(static_cast<size_t>(0u), rootDeviceIndex)->getGraphicsAllocation();
     kernelAllocation->updateTaskCount(100, csr.getOsContext().getContextId());
     *csr.getTagAddress() = 0;
     pProgram->cleanCurrentKernelInfo();
@@ -644,7 +644,7 @@ HWTEST_P(ProgramFromBinaryTest, givenIsaAllocationUsedByMultipleCsrsWhenItIsDele
 
     pProgram->build(pProgram->getDevices(), nullptr, true);
 
-    auto kernelAllocation = pProgram->getKernelInfo(size_t(0))->getGraphicsAllocation();
+    auto kernelAllocation = pProgram->getKernelInfo(static_cast<size_t>(0u), rootDeviceIndex)->getGraphicsAllocation();
 
     csr0.makeResident(*kernelAllocation);
     csr1.makeResident(*kernelAllocation);
@@ -909,6 +909,8 @@ std::map<const void *, uint32_t> Callback::watchList;
 TEST_P(ProgramFromSourceTest, GivenDifferentCommpilerOptionsWhenBuildingProgramThenKernelHashesAreDifferent) {
     KernelBinaryHelper kbHelper(BinaryFileName, true);
 
+    auto rootDeviceIndex = pContext->getDevice(0)->getRootDeviceIndex();
+
     CreateProgramWithSource(
         pContext,
         SourceFileName);
@@ -918,14 +920,14 @@ TEST_P(ProgramFromSourceTest, GivenDifferentCommpilerOptionsWhenBuildingProgramT
     retVal = pProgram->build(pProgram->getDevices(), nullptr, true);
     EXPECT_EQ(CL_SUCCESS, retVal);
     auto hash1 = pProgram->getCachedFileName();
-    auto kernel1 = pProgram->getKernelInfo("CopyBuffer");
+    auto kernel1 = pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex);
     Callback::watch(kernel1);
     EXPECT_NE(nullptr, kernel1);
 
     retVal = pProgram->build(pProgram->getDevices(), CompilerOptions::fastRelaxedMath.data(), true);
     EXPECT_EQ(CL_SUCCESS, retVal);
     auto hash2 = pProgram->getCachedFileName();
-    auto kernel2 = pProgram->getKernelInfo("CopyBuffer");
+    auto kernel2 = pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex);
     EXPECT_NE(nullptr, kernel2);
     EXPECT_NE(hash1, hash2);
     Callback::unwatch(kernel1);
@@ -934,7 +936,7 @@ TEST_P(ProgramFromSourceTest, GivenDifferentCommpilerOptionsWhenBuildingProgramT
     retVal = pProgram->build(pProgram->getDevices(), CompilerOptions::finiteMathOnly.data(), true);
     EXPECT_EQ(CL_SUCCESS, retVal);
     auto hash3 = pProgram->getCachedFileName();
-    auto kernel3 = pProgram->getKernelInfo("CopyBuffer");
+    auto kernel3 = pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex);
     EXPECT_NE(nullptr, kernel3);
     EXPECT_NE(hash1, hash3);
     EXPECT_NE(hash2, hash3);
@@ -947,7 +949,7 @@ TEST_P(ProgramFromSourceTest, GivenDifferentCommpilerOptionsWhenBuildingProgramT
     retVal = pProgram->build(pProgram->getDevices(), nullptr, true);
     EXPECT_EQ(CL_SUCCESS, retVal);
     auto hash4 = pProgram->getCachedFileName();
-    auto kernel4 = pProgram->getKernelInfo("CopyBuffer");
+    auto kernel4 = pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex);
     EXPECT_NE(nullptr, kernel4);
     EXPECT_EQ(hash3, hash4);
     Callback::unwatch(kernel3);
@@ -957,7 +959,7 @@ TEST_P(ProgramFromSourceTest, GivenDifferentCommpilerOptionsWhenBuildingProgramT
     retVal = pProgram->build(pProgram->getDevices(), nullptr, true);
     EXPECT_EQ(CL_SUCCESS, retVal);
     auto hash5 = pProgram->getCachedFileName();
-    auto kernel5 = pProgram->getKernelInfo("CopyBuffer");
+    auto kernel5 = pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex);
     EXPECT_NE(nullptr, kernel5);
     EXPECT_EQ(hash1, hash5);
     Callback::unwatch(kernel4);
@@ -1310,7 +1312,7 @@ HWTEST_F(PatchTokenTests, givenKernelRequiringConstantAllocationWhenMakeResident
 
     ASSERT_EQ(CL_SUCCESS, retVal);
 
-    auto pKernelInfo = pProgram->getKernelInfo("test");
+    auto pKernelInfo = pProgram->getKernelInfo("test", rootDeviceIndex);
 
     EXPECT_NE(nullptr, pKernelInfo->patchInfo.pAllocateStatelessConstantMemorySurfaceWithInitialization);
     ASSERT_NE(nullptr, pProgram->getConstantSurface(pClDevice->getRootDeviceIndex()));
@@ -1374,7 +1376,7 @@ TEST_F(PatchTokenTests, WhenBuildingProgramThenGwsIsSet) {
 
     ASSERT_EQ(CL_SUCCESS, retVal);
 
-    auto pKernelInfo = pProgram->getKernelInfo("test");
+    auto pKernelInfo = pProgram->getKernelInfo("test", rootDeviceIndex);
 
     ASSERT_NE(nullptr, pKernelInfo->patchInfo.dataParameterStream);
     ASSERT_NE(static_cast<uint32_t>(-1), pKernelInfo->workloadInfo.globalWorkSizeOffsets[0]);
@@ -1393,14 +1395,14 @@ TEST_F(PatchTokenTests, WhenBuildingProgramThenLwsIsSet) {
 
     ASSERT_EQ(CL_SUCCESS, retVal);
 
-    auto pKernelInfo = pProgram->getKernelInfo("test");
+    auto pKernelInfo = pProgram->getKernelInfo("test", rootDeviceIndex);
 
     ASSERT_NE(nullptr, pKernelInfo->patchInfo.dataParameterStream);
     ASSERT_NE(static_cast<uint32_t>(-1), pKernelInfo->workloadInfo.localWorkSizeOffsets[0]);
     ASSERT_NE(static_cast<uint32_t>(-1), pKernelInfo->workloadInfo.localWorkSizeOffsets[1]);
     ASSERT_NE(static_cast<uint32_t>(-1), pKernelInfo->workloadInfo.localWorkSizeOffsets[2]);
 
-    pKernelInfo = pProgram->getKernelInfo("test_get_local_size");
+    pKernelInfo = pProgram->getKernelInfo("test_get_local_size", rootDeviceIndex);
 
     ASSERT_NE(nullptr, pKernelInfo->patchInfo.dataParameterStream);
     ASSERT_NE(static_cast<uint32_t>(-1), pKernelInfo->workloadInfo.localWorkSizeOffsets[0]);
@@ -1424,7 +1426,7 @@ TEST_F(PatchTokenTests, WhenBuildingProgramThenConstantKernelArgsAreAvailable) {
 
     EXPECT_EQ(CL_SUCCESS, retVal);
 
-    auto pKernelInfo = pProgram->getKernelInfo("constant_kernel");
+    auto pKernelInfo = pProgram->getKernelInfo("constant_kernel", rootDeviceIndex);
     ASSERT_NE(nullptr, pKernelInfo);
 
     auto pKernel = Kernel::create(
@@ -1463,7 +1465,7 @@ TEST_F(PatchTokenTests, GivenVmeKernelWhenBuildingKernelThenArgAvailable) {
 
     EXPECT_EQ(CL_SUCCESS, retVal);
 
-    auto pKernelInfo = pProgram->getKernelInfo("device_side_block_motion_estimate_intel");
+    auto pKernelInfo = pProgram->getKernelInfo("device_side_block_motion_estimate_intel", rootDeviceIndex);
     ASSERT_NE(nullptr, pKernelInfo);
     EXPECT_EQ(true, pKernelInfo->isVmeWorkload);
 
@@ -2322,13 +2324,13 @@ TEST_F(ProgramTests, WhenLinkingTwoValidSpirvProgramsThenValidProgramIsReturned)
 TEST_F(ProgramTests, givenSeparateBlockKernelsWhenNoParentAndSubgroupKernelsThenSeparateNoneKernel) {
     MockProgram program(pContext, false, toClDeviceVector(*pClDevice));
 
-    EXPECT_EQ(0u, program.getKernelInfoArray().size());
-    EXPECT_EQ(0u, program.getParentKernelInfoArray().size());
-    EXPECT_EQ(0u, program.getSubgroupKernelInfoArray().size());
+    EXPECT_EQ(0u, program.getKernelInfoArray(rootDeviceIndex).size());
+    EXPECT_EQ(0u, program.getParentKernelInfoArray(rootDeviceIndex).size());
+    EXPECT_EQ(0u, program.getSubgroupKernelInfoArray(rootDeviceIndex).size());
 
-    program.separateBlockKernels();
+    program.separateBlockKernels(rootDeviceIndex);
 
-    EXPECT_EQ(0u, program.getKernelInfoArray().size());
+    EXPECT_EQ(0u, program.getKernelInfoArray(rootDeviceIndex).size());
     EXPECT_EQ(0u, program.getBlockKernelManager()->getCount());
 }
 
@@ -2337,19 +2339,19 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenRegularKernelsThenSeparateNone
 
     auto pRegularKernel1Info = new KernelInfo();
     pRegularKernel1Info->kernelDescriptor.kernelMetadata.kernelName = "regular_kernel_1";
-    program.getKernelInfoArray().push_back(pRegularKernel1Info);
+    program.getKernelInfoArray(rootDeviceIndex).push_back(pRegularKernel1Info);
 
     auto pRegularKernel2Info = new KernelInfo();
     pRegularKernel2Info->kernelDescriptor.kernelMetadata.kernelName = "regular_kernel_2";
-    program.getKernelInfoArray().push_back(pRegularKernel2Info);
+    program.getKernelInfoArray(rootDeviceIndex).push_back(pRegularKernel2Info);
 
-    EXPECT_EQ(2u, program.getKernelInfoArray().size());
+    EXPECT_EQ(2u, program.getKernelInfoArray(rootDeviceIndex).size());
 
-    program.separateBlockKernels();
+    program.separateBlockKernels(rootDeviceIndex);
 
-    EXPECT_EQ(2u, program.getKernelInfoArray().size());
-    EXPECT_EQ(0, strcmp("regular_kernel_1", program.getKernelInfoArray().at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
-    EXPECT_EQ(0, strcmp("regular_kernel_2", program.getKernelInfoArray().at(1)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
+    EXPECT_EQ(2u, program.getKernelInfoArray(rootDeviceIndex).size());
+    EXPECT_EQ(0, strcmp("regular_kernel_1", program.getKernelInfoArray(rootDeviceIndex).at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
+    EXPECT_EQ(0, strcmp("regular_kernel_2", program.getKernelInfoArray(rootDeviceIndex).at(1)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
 
     EXPECT_EQ(0u, program.getBlockKernelManager()->getCount());
 }
@@ -2359,21 +2361,21 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenChildLikeKernelWithoutParentKe
 
     auto pParentKernelInfo = new KernelInfo();
     pParentKernelInfo->kernelDescriptor.kernelMetadata.kernelName = "another_parent_kernel";
-    program.getKernelInfoArray().push_back(pParentKernelInfo);
-    program.getParentKernelInfoArray().push_back(pParentKernelInfo);
+    program.getKernelInfoArray(rootDeviceIndex).push_back(pParentKernelInfo);
+    program.getParentKernelInfoArray(rootDeviceIndex).push_back(pParentKernelInfo);
 
     auto pChildKernelInfo = new KernelInfo();
     pChildKernelInfo->kernelDescriptor.kernelMetadata.kernelName = "childlike_kernel_dispatch_0";
-    program.getKernelInfoArray().push_back(pChildKernelInfo);
+    program.getKernelInfoArray(rootDeviceIndex).push_back(pChildKernelInfo);
 
-    EXPECT_EQ(2u, program.getKernelInfoArray().size());
-    EXPECT_EQ(1u, program.getParentKernelInfoArray().size());
+    EXPECT_EQ(2u, program.getKernelInfoArray(rootDeviceIndex).size());
+    EXPECT_EQ(1u, program.getParentKernelInfoArray(rootDeviceIndex).size());
 
-    program.separateBlockKernels();
+    program.separateBlockKernels(rootDeviceIndex);
 
-    EXPECT_EQ(2u, program.getKernelInfoArray().size());
-    EXPECT_EQ(0, strcmp("another_parent_kernel", program.getKernelInfoArray().at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
-    EXPECT_EQ(0, strcmp("childlike_kernel_dispatch_0", program.getKernelInfoArray().at(1)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
+    EXPECT_EQ(2u, program.getKernelInfoArray(rootDeviceIndex).size());
+    EXPECT_EQ(0, strcmp("another_parent_kernel", program.getKernelInfoArray(rootDeviceIndex).at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
+    EXPECT_EQ(0, strcmp("childlike_kernel_dispatch_0", program.getKernelInfoArray(rootDeviceIndex).at(1)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
 
     EXPECT_EQ(0u, program.getBlockKernelManager()->getCount());
 }
@@ -2383,21 +2385,21 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenChildLikeKernelWithoutSubgroup
 
     auto pSubgroupKernelInfo = new KernelInfo();
     pSubgroupKernelInfo->kernelDescriptor.kernelMetadata.kernelName = "another_subgroup_kernel";
-    program.getKernelInfoArray().push_back(pSubgroupKernelInfo);
-    program.getSubgroupKernelInfoArray().push_back(pSubgroupKernelInfo);
+    program.getKernelInfoArray(rootDeviceIndex).push_back(pSubgroupKernelInfo);
+    program.getSubgroupKernelInfoArray(rootDeviceIndex).push_back(pSubgroupKernelInfo);
 
     auto pChildKernelInfo = new KernelInfo();
     pChildKernelInfo->kernelDescriptor.kernelMetadata.kernelName = "childlike_kernel_dispatch_0";
-    program.getKernelInfoArray().push_back(pChildKernelInfo);
+    program.getKernelInfoArray(rootDeviceIndex).push_back(pChildKernelInfo);
 
-    EXPECT_EQ(2u, program.getKernelInfoArray().size());
-    EXPECT_EQ(1u, program.getSubgroupKernelInfoArray().size());
+    EXPECT_EQ(2u, program.getKernelInfoArray(rootDeviceIndex).size());
+    EXPECT_EQ(1u, program.getSubgroupKernelInfoArray(rootDeviceIndex).size());
 
-    program.separateBlockKernels();
+    program.separateBlockKernels(rootDeviceIndex);
 
-    EXPECT_EQ(2u, program.getKernelInfoArray().size());
-    EXPECT_EQ(0, strcmp("another_subgroup_kernel", program.getKernelInfoArray().at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
-    EXPECT_EQ(0, strcmp("childlike_kernel_dispatch_0", program.getKernelInfoArray().at(1)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
+    EXPECT_EQ(2u, program.getKernelInfoArray(rootDeviceIndex).size());
+    EXPECT_EQ(0, strcmp("another_subgroup_kernel", program.getKernelInfoArray(rootDeviceIndex).at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
+    EXPECT_EQ(0, strcmp("childlike_kernel_dispatch_0", program.getKernelInfoArray(rootDeviceIndex).at(1)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
 
     EXPECT_EQ(0u, program.getBlockKernelManager()->getCount());
 }
@@ -2407,20 +2409,20 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenParentKernelWithChildKernelThe
 
     auto pParentKernelInfo = new KernelInfo();
     pParentKernelInfo->kernelDescriptor.kernelMetadata.kernelName = "parent_kernel";
-    program.getKernelInfoArray().push_back(pParentKernelInfo);
-    program.getParentKernelInfoArray().push_back(pParentKernelInfo);
+    program.getKernelInfoArray(rootDeviceIndex).push_back(pParentKernelInfo);
+    program.getParentKernelInfoArray(rootDeviceIndex).push_back(pParentKernelInfo);
 
     auto pChildKernelInfo = new KernelInfo();
     pChildKernelInfo->kernelDescriptor.kernelMetadata.kernelName = "parent_kernel_dispatch_0";
-    program.getKernelInfoArray().push_back(pChildKernelInfo);
+    program.getKernelInfoArray(rootDeviceIndex).push_back(pChildKernelInfo);
 
-    EXPECT_EQ(2u, program.getKernelInfoArray().size());
-    EXPECT_EQ(1u, program.getParentKernelInfoArray().size());
+    EXPECT_EQ(2u, program.getKernelInfoArray(rootDeviceIndex).size());
+    EXPECT_EQ(1u, program.getParentKernelInfoArray(rootDeviceIndex).size());
 
-    program.separateBlockKernels();
+    program.separateBlockKernels(rootDeviceIndex);
 
-    EXPECT_EQ(1u, program.getKernelInfoArray().size());
-    EXPECT_EQ(0, strcmp("parent_kernel", program.getKernelInfoArray().at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
+    EXPECT_EQ(1u, program.getKernelInfoArray(rootDeviceIndex).size());
+    EXPECT_EQ(0, strcmp("parent_kernel", program.getKernelInfoArray(rootDeviceIndex).at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
 
     EXPECT_EQ(1u, program.getBlockKernelManager()->getCount());
     EXPECT_EQ(0, strcmp("parent_kernel_dispatch_0", program.getBlockKernelManager()->getBlockKernelInfo(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
@@ -2431,20 +2433,20 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenSubgroupKernelWithChildKernelT
 
     auto pSubgroupKernelInfo = new KernelInfo();
     pSubgroupKernelInfo->kernelDescriptor.kernelMetadata.kernelName = "subgroup_kernel";
-    program.getKernelInfoArray().push_back(pSubgroupKernelInfo);
-    program.getSubgroupKernelInfoArray().push_back(pSubgroupKernelInfo);
+    program.getKernelInfoArray(rootDeviceIndex).push_back(pSubgroupKernelInfo);
+    program.getSubgroupKernelInfoArray(rootDeviceIndex).push_back(pSubgroupKernelInfo);
 
     auto pChildKernelInfo = new KernelInfo();
     pChildKernelInfo->kernelDescriptor.kernelMetadata.kernelName = "subgroup_kernel_dispatch_0";
-    program.getKernelInfoArray().push_back(pChildKernelInfo);
+    program.getKernelInfoArray(rootDeviceIndex).push_back(pChildKernelInfo);
 
-    EXPECT_EQ(2u, program.getKernelInfoArray().size());
-    EXPECT_EQ(1u, program.getSubgroupKernelInfoArray().size());
+    EXPECT_EQ(2u, program.getKernelInfoArray(rootDeviceIndex).size());
+    EXPECT_EQ(1u, program.getSubgroupKernelInfoArray(rootDeviceIndex).size());
 
-    program.separateBlockKernels();
+    program.separateBlockKernels(rootDeviceIndex);
 
-    EXPECT_EQ(1u, program.getKernelInfoArray().size());
-    EXPECT_EQ(0, strcmp("subgroup_kernel", program.getKernelInfoArray().at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
+    EXPECT_EQ(1u, program.getKernelInfoArray(rootDeviceIndex).size());
+    EXPECT_EQ(0, strcmp("subgroup_kernel", program.getKernelInfoArray(rootDeviceIndex).at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
 
     EXPECT_EQ(1u, program.getBlockKernelManager()->getCount());
     EXPECT_EQ(0, strcmp("subgroup_kernel_dispatch_0", program.getBlockKernelManager()->getBlockKernelInfo(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
diff --git a/opencl/test/unit_test/program/program_with_block_kernels_tests.cpp b/opencl/test/unit_test/program/program_with_block_kernels_tests.cpp
index 17df864cce..5d609980b2 100644
--- a/opencl/test/unit_test/program/program_with_block_kernels_tests.cpp
+++ b/opencl/test/unit_test/program/program_with_block_kernels_tests.cpp
@@ -53,6 +53,7 @@ class ProgramWithBlockKernelsTest : public ContextFixture,
 
 TEST_F(ProgramWithBlockKernelsTest, GivenKernelWithBlockKernelsWhenProgramIsBuildingThenKernelInfosHaveCorrectNames) {
     CreateProgramFromBinary(pContext, pContext->getDevices(), "simple_block_kernel", "-cl-std=CL2.0");
+    auto rootDeviceIndex = pContext->getDevice(0)->getRootDeviceIndex();
     auto mockProgram = pProgram;
     ASSERT_NE(nullptr, mockProgram);
 
@@ -62,10 +63,10 @@ TEST_F(ProgramWithBlockKernelsTest, GivenKernelWithBlockKernelsWhenProgramIsBuil
         false);
     EXPECT_EQ(CL_SUCCESS, retVal);
 
-    auto kernelInfo = mockProgram->Program::getKernelInfo("simple_block_kernel");
+    auto kernelInfo = mockProgram->Program::getKernelInfo("simple_block_kernel", rootDeviceIndex);
     EXPECT_NE(nullptr, kernelInfo);
 
-    auto blockKernelInfo = mockProgram->Program::getKernelInfo("simple_block_kernel_dispatch_0");
+    auto blockKernelInfo = mockProgram->Program::getKernelInfo("simple_block_kernel_dispatch_0", rootDeviceIndex);
     EXPECT_EQ(nullptr, blockKernelInfo);
 
     std::vector<const KernelInfo *> blockKernelInfos(mockProgram->blockKernelManager->getCount());
diff --git a/opencl/test/unit_test/program/program_with_kernel_debug_tests.cpp b/opencl/test/unit_test/program/program_with_kernel_debug_tests.cpp
index 5820212326..082178862a 100644
--- a/opencl/test/unit_test/program/program_with_kernel_debug_tests.cpp
+++ b/opencl/test/unit_test/program/program_with_kernel_debug_tests.cpp
@@ -232,7 +232,7 @@ TEST_F(ProgramWithKernelDebuggingTest, givenProgramWithKernelDebugEnabledWhenBui
     auto retVal = pProgram->build(pProgram->getDevices(), CompilerOptions::debugKernelEnable.data(), false);
     EXPECT_EQ(CL_SUCCESS, retVal);
 
-    auto kernelInfo = pProgram->getKernelInfo("CopyBuffer");
+    auto kernelInfo = pProgram->getKernelInfo("CopyBuffer", pDevice->getRootDeviceIndex());
     EXPECT_NE(0u, kernelInfo->patchInfo.pAllocateSystemThreadSurface->PerThreadSystemThreadSurfaceSize);
 }
 
@@ -249,9 +249,9 @@ TEST_F(ProgramWithKernelDebuggingTest, givenProgramWithKernelDebugEnabledWhenPro
     auto retVal = pProgram->build(pProgram->getDevices(), nullptr, false);
     EXPECT_EQ(CL_SUCCESS, retVal);
 
-    pProgram->processDebugData();
+    pProgram->processDebugData(pDevice->getRootDeviceIndex());
 
-    auto kernelInfo = pProgram->getKernelInfo("CopyBuffer");
+    auto kernelInfo = pProgram->getKernelInfo("CopyBuffer", pDevice->getRootDeviceIndex());
 
     EXPECT_NE(0u, kernelInfo->debugData.vIsaSize);
     EXPECT_NE(nullptr, kernelInfo->debugData.vIsa);
diff --git a/opencl/test/unit_test/program/program_with_source.h b/opencl/test/unit_test/program/program_with_source.h
index 3123e64ae8..66c75ac6cf 100644
--- a/opencl/test/unit_test/program/program_with_source.h
+++ b/opencl/test/unit_test/program/program_with_source.h
@@ -31,11 +31,12 @@ class ProgramFromSourceTest : public ContextFixture,
 
   protected:
     void SetUp() override {
-        std::tie(SourceFileName, BinaryFileName, KernelName) = GetParam();
+        std::tie(SourceFileName, BinaryFileName, kernelName) = GetParam();
         kbHelper = new KernelBinaryHelper(BinaryFileName);
 
         PlatformFixture::SetUp();
         cl_device_id device = pPlatform->getClDevice(0);
+        rootDeviceIndex = pPlatform->getClDevice(0)->getRootDeviceIndex();
         ContextFixture::SetUp(1, &device);
         ProgramFixture::SetUp();
 
@@ -55,7 +56,8 @@ class ProgramFromSourceTest : public ContextFixture,
     KernelBinaryHelper *kbHelper = nullptr;
     const char *SourceFileName = nullptr;
     const char *BinaryFileName = nullptr;
-    const char *KernelName = nullptr;
+    const char *kernelName = nullptr;
     cl_int retVal = CL_SUCCESS;
+    uint32_t rootDeviceIndex = std::numeric_limits<uint32_t>::max();
 };
 } // namespace NEO