Store multiple Kernels in MultiDeviceKernel

Related-To: NEO-5001
Signed-off-by: Mateusz Jablonski <[email protected]>

Author: JablonskiMateusz

opencl/source/kernel/multi_device_kernel.cpp

@@ -9,11 +9,22 @@
 namespace NEO {
 
 MultiDeviceKernel::~MultiDeviceKernel() {
-    kernel->decRefInternal();
+    for (auto &pKernel : kernels) {
+        if (pKernel) {
+            pKernel->decRefInternal();
+        }
+    }
 }
-MultiDeviceKernel::MultiDeviceKernel(Kernel *pKernel) : kernel(pKernel) {
-    pKernel->incRefInternal();
-    pKernel->setMultiDeviceKernel(this);
+MultiDeviceKernel::MultiDeviceKernel(KernelVectorType kernelVector) : kernels(std::move(kernelVector)) {
+    for (auto &pKernel : kernels) {
+        if (pKernel) {
+            if (!defaultKernel) {
+                defaultKernel = kernels[(*pKernel->getDevices().begin())->getRootDeviceIndex()];
+            }
+            pKernel->incRefInternal();
+            pKernel->setMultiDeviceKernel(this);
+        }
+    }
 };
 
 } // namespace NEO

opencl/source/kernel/multi_device_kernel.h

@@ -14,48 +14,59 @@ struct OpenCLObjectMapper<_cl_kernel> {
     typedef class MultiDeviceKernel DerivedType;
 };
 
+using KernelVectorType = StackVec<Kernel *, 4>;
+
 class MultiDeviceKernel : public BaseObject<_cl_kernel> {
   public:
     static const cl_ulong objectMagic = 0x3284ADC8EA0AFE25LL;
 
     ~MultiDeviceKernel() override;
-    MultiDeviceKernel(Kernel *pKernel);
+    MultiDeviceKernel(KernelVectorType kernelVector);
 
-    Kernel *getKernel(uint32_t rootDeviceIndex) const { return kernel; }
-    Kernel *getDefaultKernel() const { return kernel; }
+    Kernel *getKernel(uint32_t rootDeviceIndex) const { return kernels[rootDeviceIndex]; }
+    Kernel *getDefaultKernel() const { return defaultKernel; }
 
     template <typename kernel_t = Kernel, typename program_t = Program, typename multi_device_kernel_t = MultiDeviceKernel>
     static multi_device_kernel_t *create(program_t *program, const KernelInfoContainer &kernelInfos, cl_int *errcodeRet) {
+        KernelVectorType kernels{};
+        kernels.resize(program->getMaxRootDeviceIndex() + 1);
 
-        auto pKernel = Kernel::create<kernel_t, program_t>(program, kernelInfos, errcodeRet);
-        auto pMultiDeviceKernel = new multi_device_kernel_t(pKernel);
+        for (auto &pDevice : program->getDevices()) {
+            auto rootDeviceIndex = pDevice->getRootDeviceIndex();
+            if (kernels[rootDeviceIndex]) {
+                continue;
+            }
+            kernels[rootDeviceIndex] = Kernel::create<kernel_t, program_t>(program, kernelInfos, errcodeRet);
+        }
+        auto pMultiDeviceKernel = new multi_device_kernel_t(std::move(kernels));
 
         return pMultiDeviceKernel;
     }
 
-    cl_int cloneKernel(Kernel *pSourceKernel) { return kernel->cloneKernel(pSourceKernel); }
-    const std::vector<Kernel::SimpleKernelArgInfo> &getKernelArguments() const { return kernel->getKernelArguments(); }
-    cl_int checkCorrectImageAccessQualifier(cl_uint argIndex, size_t argSize, const void *argValue) const { return kernel->checkCorrectImageAccessQualifier(argIndex, argSize, argValue); }
-    void unsetArg(uint32_t argIndex) { return kernel->unsetArg(argIndex); }
-    cl_int setArg(uint32_t argIndex, size_t argSize, const void *argVal) { return kernel->setArg(argIndex, argSize, argVal); }
-    cl_int getInfo(cl_kernel_info paramName, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) const { return kernel->getInfo(paramName, paramValueSize, paramValue, paramValueSizeRet); }
-    cl_int getArgInfo(cl_uint argIndx, cl_kernel_arg_info paramName, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) const { return kernel->getArgInfo(argIndx, paramName, paramValueSize, paramValue, paramValueSizeRet); }
-    const ClDeviceVector &getDevices() const { return kernel->getDevices(); }
-    size_t getKernelArgsNumber() const { return kernel->getKernelArgsNumber(); }
-    Context &getContext() const { return kernel->getContext(); }
-    cl_int setArgSvmAlloc(uint32_t argIndex, void *svmPtr, GraphicsAllocation *svmAlloc) { return kernel->setArgSvmAlloc(argIndex, svmPtr, svmAlloc); }
-    bool getHasIndirectAccess() const { return kernel->getHasIndirectAccess(); }
-    void setUnifiedMemoryProperty(cl_kernel_exec_info infoType, bool infoValue) { return kernel->setUnifiedMemoryProperty(infoType, infoValue); }
-    void setSvmKernelExecInfo(GraphicsAllocation *argValue) { return kernel->setSvmKernelExecInfo(argValue); }
-    void clearSvmKernelExecInfo() { return kernel->clearSvmKernelExecInfo(); }
-    void setUnifiedMemoryExecInfo(GraphicsAllocation *argValue) { return kernel->setUnifiedMemoryExecInfo(argValue); }
-    void clearUnifiedMemoryExecInfo() { return kernel->clearUnifiedMemoryExecInfo(); }
-    int setKernelThreadArbitrationPolicy(uint32_t propertyValue) { return kernel->setKernelThreadArbitrationPolicy(propertyValue); }
-    cl_int setKernelExecutionType(cl_execution_info_kernel_type_intel executionType) { return kernel->setKernelExecutionType(executionType); }
-    int32_t setAdditionalKernelExecInfoWithParam(uint32_t paramName, size_t paramValueSize, const void *paramValue) { return kernel->setAdditionalKernelExecInfoWithParam(paramName, paramValueSize, paramValue); }
+    cl_int cloneKernel(Kernel *pSourceKernel) { return defaultKernel->cloneKernel(pSourceKernel); }
+    const std::vector<Kernel::SimpleKernelArgInfo> &getKernelArguments() const { return defaultKernel->getKernelArguments(); }
+    cl_int checkCorrectImageAccessQualifier(cl_uint argIndex, size_t argSize, const void *argValue) const { return defaultKernel->checkCorrectImageAccessQualifier(argIndex, argSize, argValue); }
+    void unsetArg(uint32_t argIndex) { return defaultKernel->unsetArg(argIndex); }
+    cl_int setArg(uint32_t argIndex, size_t argSize, const void *argVal) { return defaultKernel->setArg(argIndex, argSize, argVal); }
+    cl_int getInfo(cl_kernel_info paramName, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) const { return defaultKernel->getInfo(paramName, paramValueSize, paramValue, paramValueSizeRet); }
+    cl_int getArgInfo(cl_uint argIndx, cl_kernel_arg_info paramName, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) const { return defaultKernel->getArgInfo(argIndx, paramName, paramValueSize, paramValue, paramValueSizeRet); }
+    const ClDeviceVector &getDevices() const { return defaultKernel->getDevices(); }
+    size_t getKernelArgsNumber() const { return defaultKernel->getKernelArgsNumber(); }
+    Context &getContext() const { return defaultKernel->getContext(); }
+    cl_int setArgSvmAlloc(uint32_t argIndex, void *svmPtr, GraphicsAllocation *svmAlloc) { return defaultKernel->setArgSvmAlloc(argIndex, svmPtr, svmAlloc); }
+    bool getHasIndirectAccess() const { return defaultKernel->getHasIndirectAccess(); }
+    void setUnifiedMemoryProperty(cl_kernel_exec_info infoType, bool infoValue) { return defaultKernel->setUnifiedMemoryProperty(infoType, infoValue); }
+    void setSvmKernelExecInfo(GraphicsAllocation *argValue) { return defaultKernel->setSvmKernelExecInfo(argValue); }
+    void clearSvmKernelExecInfo() { return defaultKernel->clearSvmKernelExecInfo(); }
+    void setUnifiedMemoryExecInfo(GraphicsAllocation *argValue) { return defaultKernel->setUnifiedMemoryExecInfo(argValue); }
+    void clearUnifiedMemoryExecInfo() { return defaultKernel->clearUnifiedMemoryExecInfo(); }
+    int setKernelThreadArbitrationPolicy(uint32_t propertyValue) { return defaultKernel->setKernelThreadArbitrationPolicy(propertyValue); }
+    cl_int setKernelExecutionType(cl_execution_info_kernel_type_intel executionType) { return defaultKernel->setKernelExecutionType(executionType); }
+    int32_t setAdditionalKernelExecInfoWithParam(uint32_t paramName, size_t paramValueSize, const void *paramValue) { return defaultKernel->setAdditionalKernelExecInfoWithParam(paramName, paramValueSize, paramValue); }
 
   protected:
-    Kernel *kernel = nullptr;
+    KernelVectorType kernels;
+    Kernel *defaultKernel = nullptr;
 };
 
 } // namespace NEO

opencl/test/unit_test/accelerators/media_image_arg_tests.cpp

@@ -49,10 +49,11 @@ class MediaImageSetArgTest : public ClDeviceFixture,
         pKernelInfo->kernelArgInfo[1].isImage = true;
         pKernelInfo->kernelArgInfo[0].isImage = true;
 
-        pKernel = new MockKernel(program.get(), MockKernel::toKernelInfoContainer(*pKernelInfo, rootDeviceIndex));
+        int32_t retVal = CL_INVALID_PLATFORM;
+        pMultiDeviceKernel = MultiDeviceKernel::create<MockKernel>(program.get(), MockKernel::toKernelInfoContainer(*pKernelInfo, rootDeviceIndex), &retVal);
+        pKernel = static_cast<MockKernel *>(pMultiDeviceKernel->getKernel(rootDeviceIndex));
         ASSERT_NE(nullptr, pKernel);
-        ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
-        pMultiDeviceKernel = new MultiDeviceKernel(pKernel);
+        ASSERT_EQ(CL_SUCCESS, retVal);
 
         ASSERT_EQ(true, pKernel->isVmeKernel());
 

opencl/test/unit_test/api/cl_api_tests.h

@@ -49,9 +49,9 @@ struct ApiFixture {
 
         pProgram = new MockProgram(pContext, false, toClDeviceVector(*pDevice));
 
-        pKernel = new MockKernel(pProgram, MockKernel::toKernelInfoContainer(pProgram->mockKernelInfo, testedRootDeviceIndex));
+        pMultiDeviceKernel = MockMultiDeviceKernel::create<MockKernel>(pProgram, MockKernel::toKernelInfoContainer(pProgram->mockKernelInfo, testedRootDeviceIndex));
+        pKernel = static_cast<MockKernel *>(pMultiDeviceKernel->getKernel(testedRootDeviceIndex));
         ASSERT_NE(nullptr, pKernel);
-        pMultiDeviceKernel = new MultiDeviceKernel(pKernel);
     }
 
     virtual void TearDown() {

opencl/test/unit_test/api/cl_get_kernel_max_concurrent_work_group_count_intel_tests.inl

@@ -72,7 +72,7 @@ TEST_F(clGetKernelMaxConcurrentWorkGroupCountTests, GivenVariousInputWhenGetting
     EXPECT_EQ(expectedMaxConcurrentWorkGroupCount, maxConcurrentWorkGroupCount);
 
     auto pKernelWithExecutionEnvironmentPatch = MockKernel::create(pCommandQueue->getDevice(), pProgram);
-    MultiDeviceKernel multiDeviceKernelWithExecutionEnvironmentPatch(pKernelWithExecutionEnvironmentPatch);
+    MultiDeviceKernel multiDeviceKernelWithExecutionEnvironmentPatch(MockMultiDeviceKernel::toKernelVector(pKernelWithExecutionEnvironmentPatch));
     retVal = clGetKernelMaxConcurrentWorkGroupCountINTEL(pCommandQueue, &multiDeviceKernelWithExecutionEnvironmentPatch, workDim,
                                                          globalWorkOffset, localWorkSize,
                                                          &maxConcurrentWorkGroupCount);

opencl/test/unit_test/api/cl_get_kernel_sub_group_info_khr_tests.inl

@@ -199,8 +199,8 @@ TEST_F(KernelSubGroupInfoKhrTest, GivenNullDeviceWhenGettingSubGroupInfoFromMult
 
     MockUnrestrictiveContext context;
     auto mockProgram = std::make_unique<MockProgram>(&context, false, context.getDevices());
-    auto mockKernel = new MockKernel(mockProgram.get(), pKernel->getKernelInfos());
-    auto pMultiDeviceKernel = std::make_unique<MultiDeviceKernel>(mockKernel);
+    std::unique_ptr<MultiDeviceKernel> pMultiDeviceKernel(
+        MultiDeviceKernel::create<MockKernel>(mockProgram.get(), pKernel->getKernelInfos(), nullptr));
 
     retVal = clGetKernelSubGroupInfoKHR(
         pMultiDeviceKernel.get(),

opencl/test/unit_test/api/cl_get_kernel_sub_group_info_tests.inl

@@ -348,8 +348,7 @@ TEST_F(KernelSubGroupInfoTest, GivenNullDeviceWhenGettingSubGroupInfoFromMultiDe
 
     MockUnrestrictiveContext context;
     auto mockProgram = std::make_unique<MockProgram>(&context, false, context.getDevices());
-    auto mockKernel = new MockKernel(mockProgram.get(), pKernel->getKernelInfos());
-    auto pMultiDeviceKernel = std::make_unique<MultiDeviceKernel>(mockKernel);
+    std::unique_ptr<MultiDeviceKernel> pMultiDeviceKernel(MultiDeviceKernel::create<MockKernel>(mockProgram.get(), pKernel->getKernelInfos(), nullptr));
 
     retVal = clGetKernelSubGroupInfo(
         pMultiDeviceKernel.get(),

opencl/test/unit_test/api/cl_get_kernel_suggested_local_work_size_intel_tests.inl

@@ -98,7 +98,7 @@ TEST_F(clGetKernelSuggestedLocalWorkSizeTests, GivenVariousInputWhenGettingSugge
 
 TEST_F(clGetKernelSuggestedLocalWorkSizeTests, GivenKernelWithExecutionEnvironmentPatchedWhenGettingSuggestedLocalWorkSizeThenCorrectValuesAreReturned) {
     auto pKernelWithExecutionEnvironmentPatch = MockKernel::create(pCommandQueue->getDevice(), pProgram);
-    MultiDeviceKernel multiDeviceKernelWithExecutionEnvironmentPatch(pKernelWithExecutionEnvironmentPatch);
+    MultiDeviceKernel multiDeviceKernelWithExecutionEnvironmentPatch(MockMultiDeviceKernel::toKernelVector(pKernelWithExecutionEnvironmentPatch));
 
     size_t globalWorkOffset[] = {0, 0, 0};
     size_t globalWorkSize[] = {128, 128, 128};

opencl/test/unit_test/api/cl_get_kernel_work_group_info_tests.inl

@@ -61,8 +61,8 @@ TEST_F(clGetKernelWorkGroupInfoTest, GivenNullDeviceWhenGettingWorkGroupInfoFrom
     size_t paramValueSizeRet;
     MockUnrestrictiveContext context;
     auto mockProgram = std::make_unique<MockProgram>(&context, false, context.getDevices());
-    auto pMockKernel = new MockKernel(mockProgram.get(), MockKernel::toKernelInfoContainer(pKernel->getKernelInfo(testedRootDeviceIndex), context.getDevice(0)->getRootDeviceIndex()));
-    auto pMultiDeviceKernel = std::make_unique<MultiDeviceKernel>(pMockKernel);
+    std::unique_ptr<MultiDeviceKernel> pMultiDeviceKernel(
+        MockMultiDeviceKernel::create<MockKernel>(mockProgram.get(), MockKernel::toKernelInfoContainer(pKernel->getKernelInfo(testedRootDeviceIndex), context.getDevice(0)->getRootDeviceIndex())));
 
     retVal = clGetKernelWorkGroupInfo(
         pMultiDeviceKernel.get(),

opencl/test/unit_test/api/cl_set_kernel_arg_svm_pointer_tests.inl

@@ -40,9 +40,9 @@ class KernelArgSvmFixture : public ApiFixture<> {
         pKernelInfo->kernelArgInfo[0].kernelArgPatchInfoVector[0].size = (uint32_t)sizeof(void *);
         pKernelInfo->kernelArgInfo[0].metadata.addressQualifier = KernelArgMetadata::AddrGlobal;
 
-        pMockKernel = new MockKernel(pProgram, MockKernel::toKernelInfoContainer(*pKernelInfo, testedRootDeviceIndex));
-        ASSERT_EQ(CL_SUCCESS, pMockKernel->initialize());
-        pMockMultiDeviceKernel = new MultiDeviceKernel(pMockKernel);
+        pMockMultiDeviceKernel = MultiDeviceKernel::create<MockKernel>(pProgram, MockKernel::toKernelInfoContainer(*pKernelInfo, testedRootDeviceIndex), nullptr);
+        pMockKernel = static_cast<MockKernel *>(pMockMultiDeviceKernel->getKernel(testedRootDeviceIndex));
+        ASSERT_NE(nullptr, pMockKernel);
         pMockKernel->setCrossThreadData(pCrossThreadData, sizeof(pCrossThreadData));
     }
 
@@ -88,8 +88,9 @@ TEST_F(clSetKernelArgSVMPointerTests, GivenDeviceNotSupportingSvmWhenSettingKern
     auto hwInfo = executionEnvironment->rootDeviceEnvironments[ApiFixture::testedRootDeviceIndex]->getMutableHardwareInfo();
     hwInfo->capabilityTable.ftrSvm = false;
 
-    auto pMockKernel = new MockKernel(pProgram, MockKernel::toKernelInfoContainer(*pKernelInfo, testedRootDeviceIndex));
-    auto pMultiDeviceKernel = std::make_unique<MultiDeviceKernel>(pMockKernel);
+    std::unique_ptr<MultiDeviceKernel> pMultiDeviceKernel(
+        MultiDeviceKernel::create<MockKernel>(pProgram, MockKernel::toKernelInfoContainer(*pKernelInfo, testedRootDeviceIndex), nullptr));
+
     auto retVal = clSetKernelArgSVMPointer(
         pMultiDeviceKernel.get(), // cl_kernel kernel
         (cl_uint)-1,              // cl_uint arg_index