Create structure for per root device build info in program

JablonskiMateusz · Compute-Runtime-Automation · commit 9394f5755e54 · 2020-08-26T13:16:30.000+02:00
define build log per root device

Related-To: NEO-5001
Change-Id: Id507485e7f2bdd4e0d96948450da49a9f67dd2a8
Signed-off-by: Mateusz Jablonski &lt;mateusz.jablonski@intel.com&gt;
diff --git a/opencl/source/program/build.cpp b/opencl/source/program/build.cpp
@@ -120,8 +120,8 @@ cl_int Program::build(
             inputArgs.allowCaching = enableCaching;
             NEO::TranslationOutput compilerOuput = {};
             auto compilerErr = pCompilerInterface->build(*this->pDevice, inputArgs, compilerOuput);
-            this->updateBuildLog(this->pDevice, compilerOuput.frontendCompilerLog.c_str(), compilerOuput.frontendCompilerLog.size());
-            this->updateBuildLog(this->pDevice, compilerOuput.backendCompilerLog.c_str(), compilerOuput.backendCompilerLog.size());
+            this->updateBuildLog(this->pDevice->getRootDeviceIndex(), compilerOuput.frontendCompilerLog.c_str(), compilerOuput.frontendCompilerLog.size());
+            this->updateBuildLog(this->pDevice->getRootDeviceIndex(), compilerOuput.backendCompilerLog.c_str(), compilerOuput.backendCompilerLog.size());
             retVal = asClError(compilerErr);
             if (retVal != CL_SUCCESS) {
                 break;
diff --git a/opencl/source/program/compile.cpp b/opencl/source/program/compile.cpp
@@ -151,8 +151,8 @@ cl_int Program::compile(
 
         TranslationOutput compilerOuput;
         auto compilerErr = pCompilerInterface->compile(*this->pDevice, inputArgs, compilerOuput);
-        this->updateBuildLog(this->pDevice, compilerOuput.frontendCompilerLog.c_str(), compilerOuput.frontendCompilerLog.size());
-        this->updateBuildLog(this->pDevice, compilerOuput.backendCompilerLog.c_str(), compilerOuput.backendCompilerLog.size());
+        this->updateBuildLog(this->pDevice->getRootDeviceIndex(), compilerOuput.frontendCompilerLog.c_str(), compilerOuput.frontendCompilerLog.size());
+        this->updateBuildLog(this->pDevice->getRootDeviceIndex(), compilerOuput.backendCompilerLog.c_str(), compilerOuput.backendCompilerLog.size());
         retVal = asClError(compilerErr);
         if (retVal != CL_SUCCESS) {
             break;
diff --git a/opencl/source/program/get_info.cpp b/opencl/source/program/get_info.cpp
@@ -184,15 +184,10 @@ cl_int Program::getBuildInfo(cl_device_id device, cl_program_build_info paramNam
         break;
 
     case CL_PROGRAM_BUILD_LOG: {
-        const char *pBuildLog = getBuildLog(&pClDev->getDevice());
+        const char *pBuildLog = getBuildLog(pClDev->getRootDeviceIndex());
 
-        if (pBuildLog != nullptr) {
-            pSrc = pBuildLog;
-            srcSize = retSize = strlen(pBuildLog) + 1;
-        } else {
-            pSrc = "";
-            srcSize = retSize = 1;
-        }
+        pSrc = pBuildLog;
+        srcSize = retSize = strlen(pBuildLog) + 1;
     } break;
 
     case CL_PROGRAM_BINARY_TYPE:
diff --git a/opencl/source/program/link.cpp b/opencl/source/program/link.cpp
@@ -149,8 +149,8 @@ cl_int Program::link(
             inputArgs.outType = IGC::CodeType::oclGenBin;
             NEO::TranslationOutput compilerOuput = {};
             auto compilerErr = pCompilerInterface->link(this->getDevice(), inputArgs, compilerOuput);
-            this->updateBuildLog(this->pDevice, compilerOuput.frontendCompilerLog.c_str(), compilerOuput.frontendCompilerLog.size());
-            this->updateBuildLog(this->pDevice, compilerOuput.backendCompilerLog.c_str(), compilerOuput.backendCompilerLog.size());
+            this->updateBuildLog(this->pDevice->getRootDeviceIndex(), compilerOuput.frontendCompilerLog.c_str(), compilerOuput.frontendCompilerLog.size());
+            this->updateBuildLog(this->pDevice->getRootDeviceIndex(), compilerOuput.backendCompilerLog.c_str(), compilerOuput.backendCompilerLog.size());
             retVal = asClError(compilerErr);
             if (retVal != CL_SUCCESS) {
                 break;
@@ -181,8 +181,8 @@ cl_int Program::link(
             inputArgs.outType = IGC::CodeType::llvmBc;
             NEO::TranslationOutput compilerOuput = {};
             auto compilerErr = pCompilerInterface->createLibrary(*this->pDevice, inputArgs, compilerOuput);
-            this->updateBuildLog(this->pDevice, compilerOuput.frontendCompilerLog.c_str(), compilerOuput.frontendCompilerLog.size());
-            this->updateBuildLog(this->pDevice, compilerOuput.backendCompilerLog.c_str(), compilerOuput.backendCompilerLog.size());
+            this->updateBuildLog(this->pDevice->getRootDeviceIndex(), compilerOuput.frontendCompilerLog.c_str(), compilerOuput.frontendCompilerLog.size());
+            this->updateBuildLog(this->pDevice->getRootDeviceIndex(), compilerOuput.backendCompilerLog.c_str(), compilerOuput.backendCompilerLog.size());
             retVal = asClError(compilerErr);
             if (retVal != CL_SUCCESS) {
                 break;
diff --git a/opencl/source/program/process_device_binary.cpp b/opencl/source/program/process_device_binary.cpp
@@ -100,7 +100,7 @@ cl_int Program::linkBinary(Device *pDevice, const void *constantsInitData, const
             kernelNames.push_back("kernel : " + kernelInfo->name);
         }
         auto error = constructLinkerErrorMessage(unresolvedExternalsInfo, kernelNames);
-        updateBuildLog(pDevice, error.c_str(), error.size());
+        updateBuildLog(pDevice->getRootDeviceIndex(), error.c_str(), error.size());
         return CL_INVALID_BINARY;
     } else if (linkerInput->getTraits().requiresPatchingOfInstructionSegments) {
         for (const auto &kernelInfo : this->kernelInfoArray) {
diff --git a/opencl/source/program/program.cpp b/opencl/source/program/program.cpp
@@ -58,6 +58,12 @@ Program::Program(ExecutionEnvironment &executionEnvironment, Context *context, b
     numDevices = 1;
     bool force32BitAddressess = false;
 
+    uint32_t maxRootDeviceIndex = 0u;
+    if (device) {
+        maxRootDeviceIndex = device->getRootDeviceIndex();
+    }
+    buildInfos.resize(maxRootDeviceIndex + 1);
+
     if (pClDevice) {
         auto enabledClVersion = pClDevice->getEnabledClVersion();
         if (enabledClVersion == 30) {
@@ -280,7 +286,7 @@ cl_int Program::getSource(std::string &binary) const {
     return retVal;
 }
 
-void Program::updateBuildLog(const Device *pDevice, const char *pErrorString,
+void Program::updateBuildLog(uint32_t rootDeviceIndex, const char *pErrorString,
                              size_t errorStringSize) {
     if ((pErrorString == nullptr) || (errorStringSize == 0) || (pErrorString[0] == '\0')) {
         return;
@@ -290,27 +296,20 @@ void Program::updateBuildLog(const Device *pDevice, const char *pErrorString,
         --errorStringSize;
     }
 
-    auto it = buildLog.find(pDevice);
+    auto &currentLog = buildInfos[rootDeviceIndex].buildLog;
 
-    if (it == buildLog.end()) {
-        buildLog[pDevice].assign(pErrorString, pErrorString + errorStringSize);
+    if (currentLog.empty()) {
+        currentLog.assign(pErrorString, pErrorString + errorStringSize);
         return;
     }
 
-    buildLog[pDevice].append("\n");
-    buildLog[pDevice].append(pErrorString, pErrorString + errorStringSize);
+    currentLog.append("\n");
+    currentLog.append(pErrorString, pErrorString + errorStringSize);
 }
 
-const char *Program::getBuildLog(const Device *pDevice) const {
-    const char *entry = nullptr;
-
-    auto it = buildLog.find(pDevice);
-
-    if (it != buildLog.end()) {
-        entry = it->second.c_str();
-    }
-
-    return entry;
+const char *Program::getBuildLog(uint32_t rootDeviceIndex) const {
+    auto &currentLog = buildInfos[rootDeviceIndex].buildLog;
+    return currentLog.c_str();
 }
 
 void Program::separateBlockKernels() {
diff --git a/opencl/source/program/program.h b/opencl/source/program/program.h
@@ -187,9 +187,9 @@ class Program : public BaseObject<_cl_program> {
 
     void processDebugData();
 
-    void updateBuildLog(const Device *pDevice, const char *pErrorString, const size_t errorStringSize);
+    void updateBuildLog(uint32_t rootDeviceIndex, const char *pErrorString, const size_t errorStringSize);
 
-    const char *getBuildLog(const Device *pDevice) const;
+    const char *getBuildLog(uint32_t rootDeviceIndex) const;
 
     cl_uint getProgramBinaryType() const {
         return programBinaryType;
@@ -322,7 +322,11 @@ class Program : public BaseObject<_cl_program> {
     std::unique_ptr<LinkerInput> linkerInput;
     Linker::RelocatedSymbolsMap symbols;
 
-    std::map<const Device *, std::string> buildLog;
+    struct BuildInfo {
+        std::string buildLog{};
+    };
+
+    StackVec<BuildInfo, 1> buildInfos;
 
     bool areSpecializationConstantsInitialized = false;
     CIF::RAII::UPtr_t<CIF::Builtins::BufferSimple> specConstantsIds;
diff --git a/opencl/test/unit_test/api/cl_create_kernel_tests.inl b/opencl/test/unit_test/api/cl_create_kernel_tests.inl
@@ -168,7 +168,7 @@ TEST_F(clCreateKernelTests, GivenInvalidProgramWhenCreatingNewKernelThenInvalidP
 TEST_F(clCreateKernelTests, GivenProgramWithBuildErrorWhenCreatingNewKernelThenInvalidProgramExecutableErrorIsReturned) {
     cl_kernel kernel = nullptr;
     std::unique_ptr<MockProgram> pMockProg = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment(), pContext, false, nullptr);
-    pMockProg->SetBuildStatus(CL_BUILD_ERROR);
+    pMockProg->setBuildStatus(CL_BUILD_ERROR);
 
     kernel = clCreateKernel(
         pMockProg.get(),
diff --git a/opencl/test/unit_test/api/cl_link_program_tests.inl b/opencl/test/unit_test/api/cl_link_program_tests.inl
@@ -175,7 +175,7 @@ TEST_F(clLinkProgramTests, GivenProgramsWithSpecConstantsThenSpecConstantsAreEmb
     uint32_t prog2Keys[1] = {11};
     uint64_t prog2Values[1] = {13};
 
-    auto progSrc1 = clUniquePtr(new MockProgram(*pProgram->getDevice().getExecutionEnvironment()));
+    auto progSrc1 = clUniquePtr(new MockProgram(*pProgram->getDevice().getExecutionEnvironment(), pContext, false, pProgram->pDevice));
     progSrc1->pDevice = pProgram->pDevice;
     progSrc1->specConstantsValues[prog1Keys[0]] = prog1Values[0];
     progSrc1->specConstantsValues[prog1Keys[1]] = prog1Values[1];
@@ -184,21 +184,21 @@ TEST_F(clLinkProgramTests, GivenProgramsWithSpecConstantsThenSpecConstantsAreEmb
     progSrc1->irBinarySize = sizeof(ir1);
     progSrc1->isSpirV = true;
 
-    auto progSrc2 = clUniquePtr(new MockProgram(*pProgram->getDevice().getExecutionEnvironment()));
+    auto progSrc2 = clUniquePtr(new MockProgram(*pProgram->getDevice().getExecutionEnvironment(), pContext, false, pProgram->pDevice));
     progSrc2->pDevice = pProgram->pDevice;
     progSrc2->specConstantsValues[prog2Keys[0]] = prog2Values[0];
     progSrc2->areSpecializationConstantsInitialized = true;
     progSrc2->irBinary = makeCopy(ir2, sizeof(ir2));
     progSrc2->irBinarySize = sizeof(ir2);
     progSrc2->isSpirV = true;
 
-    auto progSrc3 = clUniquePtr(new MockProgram(*pProgram->getDevice().getExecutionEnvironment()));
+    auto progSrc3 = clUniquePtr(new MockProgram(*pProgram->getDevice().getExecutionEnvironment(), pContext, false, pProgram->pDevice));
     progSrc3->pDevice = pProgram->pDevice;
     progSrc3->irBinary = makeCopy(ir3, sizeof(ir3));
     progSrc3->irBinarySize = sizeof(ir3);
     progSrc3->isSpirV = true;
 
-    auto progDst = clUniquePtr(new MockProgram(*pProgram->getDevice().getExecutionEnvironment()));
+    auto progDst = clUniquePtr(new MockProgram(*pProgram->getDevice().getExecutionEnvironment(), pContext, false, pProgram->pDevice));
     progDst->pDevice = pProgram->pDevice;
     cl_program inputPrograms[3] = {progSrc1.get(), progSrc2.get(), progSrc3.get()};
 
diff --git a/opencl/test/unit_test/mocks/mock_program.h b/opencl/test/unit_test/mocks/mock_program.h
@@ -65,7 +65,8 @@ class MockProgram : public Program {
     using Program::unpackedDeviceBinary;
     using Program::unpackedDeviceBinarySize;
 
-    MockProgram(ExecutionEnvironment &executionEnvironment) : Program(executionEnvironment, nullptr, false, nullptr) {}
+    MockProgram(ExecutionEnvironment &executionEnvironment) : Program(executionEnvironment, nullptr, false, nullptr) {
+    }
 
     ~MockProgram() override {
         if (contextSet)
@@ -102,18 +103,17 @@ class MockProgram : public Program {
         contextSet = true;
     }
 
-    void SetBuildStatus(cl_build_status st) { buildStatus = st; }
-    void SetSourceCode(const char *ptr) { sourceCode = ptr; }
-    void ClearOptions() { options = ""; }
-    void SetCreatedFromBinary(bool createdFromBin) { isCreatedFromBinary = createdFromBin; }
-    void ClearLog() { buildLog.clear(); }
-    void SetDevice(Device *pDev) { pDevice = pDev; }
+    void setBuildStatus(cl_build_status st) { buildStatus = st; }
+    void setSourceCode(const char *ptr) { sourceCode = ptr; }
+    void clearOptions() { options = ""; }
+    void setCreatedFromBinary(bool createdFromBin) { isCreatedFromBinary = createdFromBin; }
+    void clearLog(uint32_t rootDeviceIndex) { buildInfos[rootDeviceIndex].buildLog.clear(); }
 
-    void SetIrBinary(char *ptr, bool isSpirv) {
+    void setIrBinary(char *ptr, bool isSpirv) {
         irBinary.reset(ptr);
         this->isSpirV = isSpirV;
     }
-    void SetIrBinarySize(size_t bsz, bool isSpirv) {
+    void setIrBinarySize(size_t bsz, bool isSpirv) {
         irBinarySize = bsz;
         this->isSpirV = isSpirV;
     }
diff --git a/opencl/test/unit_test/program/process_spir_binary_tests.cpp b/opencl/test/unit_test/program/process_spir_binary_tests.cpp
@@ -51,8 +51,8 @@ TEST_F(ProcessSpirBinaryTests, WhenProcessingSpirBinaryThenIrBinaryIsSetCorrectl
     EXPECT_EQ(binarySize, program->irBinarySize);
 
     // Verify no built log is available
-    auto pBuildLog = program->getBuildLog(program->getDevicePtr());
-    EXPECT_EQ(nullptr, pBuildLog);
+    std::string buildLog = program->getBuildLog(0);
+    EXPECT_TRUE(buildLog.empty());
 }
 
 TEST_F(ProcessSpirBinaryTests, WhenProcessingSpirBinaryThenIsSpirvIsSetBasedonPassedValue) {
diff --git a/opencl/test/unit_test/program/program_data_tests.cpp b/opencl/test/unit_test/program/program_data_tests.cpp
@@ -546,8 +546,8 @@ TEST(ProgramLinkBinaryTest, whenLinkerUnresolvedExternalThenLinkFailedAndBuildLo
     relocation.offset = 0;
     linkerInput->relocations.push_back(NEO::LinkerInput::Relocations{relocation});
     linkerInput->traits.requiresPatchingOfInstructionSegments = true;
-    NEO::ExecutionEnvironment env;
-    MockProgram program{env};
+    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
+    MockProgram program{*device->getExecutionEnvironment(), nullptr, false, device.get()};
     KernelInfo kernelInfo = {};
     kernelInfo.name = "onlyKernel";
     std::vector<char> kernelHeap;
@@ -557,16 +557,17 @@ TEST(ProgramLinkBinaryTest, whenLinkerUnresolvedExternalThenLinkFailedAndBuildLo
     program.getKernelInfoArray().push_back(&kernelInfo);
     program.linkerInput = std::move(linkerInput);
 
-    EXPECT_EQ(nullptr, program.getBuildLog(nullptr));
+    std::string buildLog = program.getBuildLog(device->getRootDeviceIndex());
+    EXPECT_TRUE(buildLog.empty());
     auto ret = program.linkBinary(program.pDevice, nullptr, nullptr);
     EXPECT_NE(CL_SUCCESS, ret);
     program.getKernelInfoArray().clear();
-    auto buildLog = program.getBuildLog(nullptr);
-    ASSERT_NE(nullptr, buildLog);
+    buildLog = program.getBuildLog(device->getRootDeviceIndex());
+    EXPECT_FALSE(buildLog.empty());
     Linker::UnresolvedExternals expectedUnresolvedExternals;
     expectedUnresolvedExternals.push_back(Linker::UnresolvedExternal{relocation, 0, false});
     auto expectedError = constructLinkerErrorMessage(expectedUnresolvedExternals, std::vector<std::string>{"kernel : " + kernelInfo.name});
-    EXPECT_THAT(buildLog, ::testing::HasSubstr(expectedError));
+    EXPECT_THAT(buildLog.c_str(), ::testing::HasSubstr(expectedError));
 }
 
 TEST_F(ProgramDataTest, whenLinkerInputValidThenIsaIsProperlyPatched) {
diff --git a/opencl/test/unit_test/program/program_tests.cpp b/opencl/test/unit_test/program/program_tests.cpp

Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ cl_int Program::linkBinary(Device pDevice, const void constantsInitData, const`
`100`	`100`	`kernelNames.push_back("kernel : " + kernelInfo->name);`
`101`	`101`	`}`
`102`	`102`	`auto error = constructLinkerErrorMessage(unresolvedExternalsInfo, kernelNames);`
`103`		`- updateBuildLog(pDevice, error.c_str(), error.size());`
	`103`	`+ updateBuildLog(pDevice->getRootDeviceIndex(), error.c_str(), error.size());`
`104`	`104`	`return CL_INVALID_BINARY;`
`105`	`105`	`} else if (linkerInput->getTraits().requiresPatchingOfInstructionSegments) {`
`106`	`106`	`for (const auto &kernelInfo : this->kernelInfoArray) {`