diff --git a/opencl/source/context/context.cpp b/opencl/source/context/context.cpp index 104ec6ab87..2db99a7cf4 100644 --- a/opencl/source/context/context.cpp +++ b/opencl/source/context/context.cpp @@ -382,20 +382,20 @@ SchedulerKernel &Context::getSchedulerKernel() { auto initializeSchedulerProgramAndKernel = [&] { cl_int retVal = CL_SUCCESS; + auto device = &getDevice(0)->getDevice(); + auto src = SchedulerKernel::loadSchedulerKernel(device); - auto src = SchedulerKernel::loadSchedulerKernel(&getDevice(0)->getDevice()); - - auto program = Program::createFromGenBinary(*getDevice(0)->getExecutionEnvironment(), + auto program = Program::createFromGenBinary(*device->getExecutionEnvironment(), this, src.resource.data(), src.resource.size(), true, &retVal, - &getDevice(0)->getDevice()); + device); DEBUG_BREAK_IF(retVal != CL_SUCCESS); DEBUG_BREAK_IF(!program); - retVal = program->processGenBinary(); + retVal = program->processGenBinary(device->getRootDeviceIndex()); DEBUG_BREAK_IF(retVal != CL_SUCCESS); schedulerBuiltIn->pProgram = program; diff --git a/opencl/source/program/build.cpp b/opencl/source/program/build.cpp index 69147f60c6..a699000712 100644 --- a/opencl/source/program/build.cpp +++ b/opencl/source/program/build.cpp @@ -143,16 +143,16 @@ cl_int Program::build( this->irBinarySize = compilerOuput.intermediateRepresentation.size; this->isSpirV = compilerOuput.intermediateCodeType == IGC::CodeType::spirV; } - this->replaceDeviceBinary(std::move(compilerOuput.deviceBinary.mem), compilerOuput.deviceBinary.size); + this->replaceDeviceBinary(std::move(compilerOuput.deviceBinary.mem), compilerOuput.deviceBinary.size, clDevice->getRootDeviceIndex()); this->debugData = std::move(compilerOuput.debugData.mem); this->debugDataSize = compilerOuput.debugData.size; } updateNonUniformFlag(); if (DebugManager.flags.PrintProgramBinaryProcessingTime.get()) { - retVal = TimeMeasureWrapper::functionExecution(*this, &Program::processGenBinary); + retVal = TimeMeasureWrapper::functionExecution(*this, &Program::processGenBinary, pDevice->getRootDeviceIndex()); } else { - retVal = processGenBinary(); + retVal = processGenBinary(pDevice->getRootDeviceIndex()); } if (retVal != CL_SUCCESS) { diff --git a/opencl/source/program/create.inl b/opencl/source/program/create.inl index 0979885191..61cc8f4aa6 100644 --- a/opencl/source/program/create.inl +++ b/opencl/source/program/create.inl @@ -31,9 +31,10 @@ T *Program::create( auto pContext = castToObject(context); DEBUG_BREAK_IF(!pContext); - auto program = new T(*pContext->getDevice(0)->getExecutionEnvironment(), pContext, false, &pContext->getDevice(0)->getDevice()); + auto device = pContext->getDevice(0); + auto program = new T(*device->getExecutionEnvironment(), pContext, false, &device->getDevice()); - auto retVal = program->createProgramFromBinary(binaries[0], lengths[0]); + auto retVal = program->createProgramFromBinary(binaries[0], lengths[0], device->getRootDeviceIndex()); program->createdFrom = CreatedFrom::BINARY; @@ -137,7 +138,7 @@ T *Program::createFromGenBinary( if (CL_SUCCESS == retVal) { program = new T(executionEnvironment, context, isBuiltIn, device); program->numDevices = 1; - program->replaceDeviceBinary(makeCopy(binary, size), size); + program->replaceDeviceBinary(makeCopy(binary, size), size, device->getRootDeviceIndex()); program->isCreatedFromBinary = true; program->programBinaryType = CL_PROGRAM_BINARY_TYPE_EXECUTABLE; program->buildStatus = CL_BUILD_SUCCESS; @@ -152,7 +153,7 @@ T *Program::createFromGenBinary( } template -T *Program::createFromIL(Context *ctx, +T *Program::createFromIL(Context *context, const void *il, size_t length, cl_int &errcodeRet) { @@ -163,8 +164,9 @@ T *Program::createFromIL(Context *ctx, return nullptr; } - T *program = new T(*ctx->getDevice(0)->getExecutionEnvironment(), ctx, false, &ctx->getDevice(0)->getDevice()); - errcodeRet = program->createProgramFromBinary(il, length); + auto device = context->getDevice(0); + T *program = new T(*device->getExecutionEnvironment(), context, false, &device->getDevice()); + errcodeRet = program->createProgramFromBinary(il, length, device->getRootDeviceIndex()); program->createdFrom = CreatedFrom::IL; if (errcodeRet != CL_SUCCESS) { diff --git a/opencl/source/program/get_info.cpp b/opencl/source/program/get_info.cpp index 1f006da062..c249dde65d 100644 --- a/opencl/source/program/get_info.cpp +++ b/opencl/source/program/get_info.cpp @@ -32,6 +32,7 @@ cl_int Program::getInfo(cl_program_info paramName, size_t paramValueSize, size_t numKernels; cl_context clContext = context; cl_uint clFalse = CL_FALSE; + auto rootDeviceIndex = pDevice->getRootDeviceIndex(); switch (paramName) { case CL_PROGRAM_CONTEXT: @@ -40,10 +41,10 @@ cl_int Program::getInfo(cl_program_info paramName, size_t paramValueSize, break; case CL_PROGRAM_BINARIES: - packDeviceBinary(); - pSrc = packedDeviceBinary.get(); + packDeviceBinary(rootDeviceIndex); + pSrc = buildInfos[rootDeviceIndex].packedDeviceBinary.get(); retSize = sizeof(void **); - srcSize = packedDeviceBinarySize; + srcSize = buildInfos[rootDeviceIndex].packedDeviceBinarySize; if (paramValue != nullptr) { if (paramValueSize < retSize) { retVal = CL_INVALID_VALUE; @@ -55,8 +56,8 @@ cl_int Program::getInfo(cl_program_info paramName, size_t paramValueSize, break; case CL_PROGRAM_BINARY_SIZES: - packDeviceBinary(); - pSrc = &packedDeviceBinarySize; + packDeviceBinary(rootDeviceIndex); + pSrc = &buildInfos[rootDeviceIndex].packedDeviceBinarySize; retSize = srcSize = sizeof(size_t *); break; diff --git a/opencl/source/program/link.cpp b/opencl/source/program/link.cpp index 3559baceb8..902b30da52 100644 --- a/opencl/source/program/link.cpp +++ b/opencl/source/program/link.cpp @@ -156,11 +156,11 @@ cl_int Program::link( break; } - this->replaceDeviceBinary(std::move(compilerOuput.deviceBinary.mem), compilerOuput.deviceBinary.size); + this->replaceDeviceBinary(std::move(compilerOuput.deviceBinary.mem), compilerOuput.deviceBinary.size, pDevice->getRootDeviceIndex()); this->debugData = std::move(compilerOuput.debugData.mem); this->debugDataSize = compilerOuput.debugData.size; - retVal = processGenBinary(); + retVal = processGenBinary(pDevice->getRootDeviceIndex()); if (retVal != CL_SUCCESS) { break; } diff --git a/opencl/source/program/process_device_binary.cpp b/opencl/source/program/process_device_binary.cpp index ebf77a6536..180de21c59 100644 --- a/opencl/source/program/process_device_binary.cpp +++ b/opencl/source/program/process_device_binary.cpp @@ -120,8 +120,8 @@ cl_int Program::linkBinary(Device *pDevice, const void *constantsInitData, const return CL_SUCCESS; } -cl_int Program::processGenBinary() { - if (nullptr == this->unpackedDeviceBinary) { +cl_int Program::processGenBinary(uint32_t rootDeviceIndex) { + if (nullptr == this->buildInfos[rootDeviceIndex].unpackedDeviceBinary) { return CL_INVALID_BINARY; } @@ -136,7 +136,7 @@ cl_int Program::processGenBinary() { } ProgramInfo programInfo; - auto blob = ArrayRef(reinterpret_cast(this->unpackedDeviceBinary.get()), this->unpackedDeviceBinarySize); + auto blob = ArrayRef(reinterpret_cast(this->buildInfos[rootDeviceIndex].unpackedDeviceBinary.get()), this->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize); SingleDeviceBinary binary = {}; binary.deviceBinary = blob; std::string decodeErrors; diff --git a/opencl/source/program/program.cpp b/opencl/source/program/program.cpp index b4b14b0a81..be8f0f8953 100644 --- a/opencl/source/program/program.cpp +++ b/opencl/source/program/program.cpp @@ -142,17 +142,17 @@ Program::~Program() { cl_int Program::createProgramFromBinary( const void *pBinary, - size_t binarySize) { + size_t binarySize, uint32_t rootDeviceIndex) { cl_int retVal = CL_INVALID_BINARY; this->irBinary.reset(); this->irBinarySize = 0U; this->isSpirV = false; - this->unpackedDeviceBinary.reset(); - this->unpackedDeviceBinarySize = 0U; - this->packedDeviceBinary.reset(); - this->packedDeviceBinarySize = 0U; + this->buildInfos[rootDeviceIndex].unpackedDeviceBinary.reset(); + this->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize = 0U; + this->buildInfos[rootDeviceIndex].packedDeviceBinary.reset(); + this->buildInfos[rootDeviceIndex].packedDeviceBinarySize = 0U; this->createdFrom = CreatedFrom::BINARY; ArrayRef archive(reinterpret_cast(pBinary), binarySize); @@ -165,11 +165,12 @@ cl_int Program::createProgramFromBinary( this->programBinaryType = CL_PROGRAM_BINARY_TYPE_EXECUTABLE; this->isCreatedFromBinary = true; - auto productAbbreviation = hardwarePrefix[pDevice->getHardwareInfo().platform.eProductFamily]; + auto hwInfo = executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo(); + auto productAbbreviation = hardwarePrefix[hwInfo->platform.eProductFamily]; TargetDevice targetDevice = {}; - targetDevice.coreFamily = pDevice->getHardwareInfo().platform.eRenderCoreFamily; - targetDevice.stepping = pDevice->getHardwareInfo().platform.usRevId; + targetDevice.coreFamily = hwInfo->platform.eRenderCoreFamily; + targetDevice.stepping = hwInfo->platform.usRevId; targetDevice.maxPointerSizeInBytes = sizeof(uintptr_t); std::string decodeErrors; std::string decodeWarnings; @@ -195,10 +196,10 @@ cl_int Program::createProgramFromBinary( } if ((false == singleDeviceBinary.deviceBinary.empty()) && (false == DebugManager.flags.RebuildPrecompiledKernels.get())) { - this->unpackedDeviceBinary = makeCopy(reinterpret_cast(singleDeviceBinary.deviceBinary.begin()), singleDeviceBinary.deviceBinary.size()); - this->unpackedDeviceBinarySize = singleDeviceBinary.deviceBinary.size(); - this->packedDeviceBinary = makeCopy(reinterpret_cast(archive.begin()), archive.size()); - this->packedDeviceBinarySize = archive.size(); + this->buildInfos[rootDeviceIndex].unpackedDeviceBinary = makeCopy(reinterpret_cast(singleDeviceBinary.deviceBinary.begin()), singleDeviceBinary.deviceBinary.size()); + this->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize = singleDeviceBinary.deviceBinary.size(); + this->buildInfos[rootDeviceIndex].packedDeviceBinary = makeCopy(reinterpret_cast(archive.begin()), archive.size()); + this->buildInfos[rootDeviceIndex].packedDeviceBinarySize = archive.size(); } else { this->isCreatedFromBinary = false; } @@ -428,38 +429,39 @@ void Program::updateNonUniformFlag(const Program **inputPrograms, size_t numInpu this->allowNonUniform = allowNonUniform; } -void Program::replaceDeviceBinary(std::unique_ptr newBinary, size_t newBinarySize) { +void Program::replaceDeviceBinary(std::unique_ptr newBinary, size_t newBinarySize, uint32_t rootDeviceIndex) { if (isAnyPackedDeviceBinaryFormat(ArrayRef(reinterpret_cast(newBinary.get()), newBinarySize))) { - this->packedDeviceBinary = std::move(newBinary); - this->packedDeviceBinarySize = newBinarySize; - this->unpackedDeviceBinary.reset(); - this->unpackedDeviceBinarySize = 0U; - if (isAnySingleDeviceBinaryFormat(ArrayRef(reinterpret_cast(this->packedDeviceBinary.get()), this->packedDeviceBinarySize))) { - this->unpackedDeviceBinary = makeCopy(packedDeviceBinary.get(), packedDeviceBinarySize); - this->unpackedDeviceBinarySize = packedDeviceBinarySize; + this->buildInfos[rootDeviceIndex].packedDeviceBinary = std::move(newBinary); + this->buildInfos[rootDeviceIndex].packedDeviceBinarySize = newBinarySize; + this->buildInfos[rootDeviceIndex].unpackedDeviceBinary.reset(); + this->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize = 0U; + if (isAnySingleDeviceBinaryFormat(ArrayRef(reinterpret_cast(this->buildInfos[rootDeviceIndex].packedDeviceBinary.get()), this->buildInfos[rootDeviceIndex].packedDeviceBinarySize))) { + this->buildInfos[rootDeviceIndex].unpackedDeviceBinary = makeCopy(buildInfos[rootDeviceIndex].packedDeviceBinary.get(), buildInfos[rootDeviceIndex].packedDeviceBinarySize); + this->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize = buildInfos[rootDeviceIndex].packedDeviceBinarySize; } } else { - this->packedDeviceBinary.reset(); - this->packedDeviceBinarySize = 0U; - this->unpackedDeviceBinary = std::move(newBinary); - this->unpackedDeviceBinarySize = newBinarySize; + this->buildInfos[rootDeviceIndex].packedDeviceBinary.reset(); + this->buildInfos[rootDeviceIndex].packedDeviceBinarySize = 0U; + this->buildInfos[rootDeviceIndex].unpackedDeviceBinary = std::move(newBinary); + this->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize = newBinarySize; } } -cl_int Program::packDeviceBinary() { - if (nullptr != packedDeviceBinary) { +cl_int Program::packDeviceBinary(uint32_t rootDeviceIndex) { + if (nullptr != buildInfos[rootDeviceIndex].packedDeviceBinary) { return CL_SUCCESS; } - auto gfxCore = pDevice->getHardwareInfo().platform.eRenderCoreFamily; - auto stepping = pDevice->getHardwareInfo().platform.usRevId; + auto hwInfo = executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo(); + auto gfxCore = hwInfo->platform.eRenderCoreFamily; + auto stepping = hwInfo->platform.usRevId; - if (nullptr != this->unpackedDeviceBinary.get()) { + if (nullptr != this->buildInfos[rootDeviceIndex].unpackedDeviceBinary.get()) { SingleDeviceBinary singleDeviceBinary; singleDeviceBinary.buildOptions = this->options; singleDeviceBinary.targetDevice.coreFamily = gfxCore; singleDeviceBinary.targetDevice.stepping = stepping; - singleDeviceBinary.deviceBinary = ArrayRef(reinterpret_cast(this->unpackedDeviceBinary.get()), this->unpackedDeviceBinarySize); + singleDeviceBinary.deviceBinary = ArrayRef(reinterpret_cast(this->buildInfos[rootDeviceIndex].unpackedDeviceBinary.get()), this->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize); singleDeviceBinary.intermediateRepresentation = ArrayRef(reinterpret_cast(this->irBinary.get()), this->irBinarySize); singleDeviceBinary.debugData = ArrayRef(reinterpret_cast(this->debugData.get()), this->debugDataSize); @@ -470,8 +472,8 @@ cl_int Program::packDeviceBinary() { DEBUG_BREAK_IF(true); return CL_OUT_OF_HOST_MEMORY; } - this->packedDeviceBinary = makeCopy(packedDeviceBinary.data(), packedDeviceBinary.size()); - this->packedDeviceBinarySize = packedDeviceBinary.size(); + this->buildInfos[rootDeviceIndex].packedDeviceBinary = makeCopy(packedDeviceBinary.data(), packedDeviceBinary.size()); + this->buildInfos[rootDeviceIndex].packedDeviceBinarySize = packedDeviceBinary.size(); } else if (nullptr != this->irBinary.get()) { NEO::Elf::ElfEncoder<> elfEncoder(true, true, 1U); if (this->programBinaryType == CL_PROGRAM_BINARY_TYPE_LIBRARY) { @@ -482,8 +484,8 @@ cl_int Program::packDeviceBinary() { elfEncoder.appendSection(NEO::Elf::SHT_OPENCL_SPIRV, NEO::Elf::SectionNamesOpenCl::spirvObject, ArrayRef::fromAny(this->irBinary.get(), this->irBinarySize)); elfEncoder.appendSection(NEO::Elf::SHT_OPENCL_OPTIONS, NEO::Elf::SectionNamesOpenCl::buildOptions, this->options); auto elfData = elfEncoder.encode(); - this->packedDeviceBinary = makeCopy(elfData.data(), elfData.size()); - this->packedDeviceBinarySize = elfData.size(); + this->buildInfos[rootDeviceIndex].packedDeviceBinary = makeCopy(elfData.data(), elfData.size()); + this->buildInfos[rootDeviceIndex].packedDeviceBinarySize = elfData.size(); } else { return CL_INVALID_PROGRAM; } diff --git a/opencl/source/program/program.h b/opencl/source/program/program.h index 6ff660bdbd..9f8f6fbd6d 100644 --- a/opencl/source/program/program.h +++ b/opencl/source/program/program.h @@ -135,7 +135,7 @@ class Program : public BaseObject<_cl_program> { cl_int build(const Device *pDevice, const char *buildOptions, bool enableCaching, std::unordered_map &builtinsMap); - MOCKABLE_VIRTUAL cl_int processGenBinary(); + MOCKABLE_VIRTUAL cl_int processGenBinary(uint32_t rootDeviceIndex); MOCKABLE_VIRTUAL cl_int processProgramInfo(ProgramInfo &dst); cl_int compile(cl_uint numDevices, const cl_device_id *deviceList, const char *buildOptions, @@ -267,12 +267,12 @@ class Program : public BaseObject<_cl_program> { buildInfos[rootDeviceIndex].linkerInput = std::move(linkerInput); } - MOCKABLE_VIRTUAL void replaceDeviceBinary(std::unique_ptr newBinary, size_t newBinarySize); + MOCKABLE_VIRTUAL void replaceDeviceBinary(std::unique_ptr newBinary, size_t newBinarySize, uint32_t rootDeviceIndex); protected: - MOCKABLE_VIRTUAL cl_int createProgramFromBinary(const void *pBinary, size_t binarySize); + MOCKABLE_VIRTUAL cl_int createProgramFromBinary(const void *pBinary, size_t binarySize, uint32_t rootDeviceIndex); - cl_int packDeviceBinary(); + cl_int packDeviceBinary(uint32_t rootDeviceIndex); MOCKABLE_VIRTUAL cl_int linkBinary(Device *pDevice, const void *constantsInitData, const void *variablesInitData); @@ -295,12 +295,6 @@ class Program : public BaseObject<_cl_program> { std::unique_ptr irBinary; size_t irBinarySize = 0U; - std::unique_ptr unpackedDeviceBinary; - size_t unpackedDeviceBinarySize = 0U; - - std::unique_ptr packedDeviceBinary; - size_t packedDeviceBinarySize = 0U; - std::unique_ptr debugData; size_t debugDataSize = 0U; @@ -329,6 +323,12 @@ class Program : public BaseObject<_cl_program> { std::unique_ptr linkerInput; Linker::RelocatedSymbolsMap symbols{}; std::string buildLog{}; + + std::unique_ptr unpackedDeviceBinary; + size_t unpackedDeviceBinarySize = 0U; + + std::unique_ptr packedDeviceBinary; + size_t packedDeviceBinarySize = 0U; }; std::vector buildInfos; 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 03f4aee459..f64481fcaf 100644 --- a/opencl/test/unit_test/built_ins/built_in_tests.cpp +++ b/opencl/test/unit_test/built_ins/built_in_tests.cpp @@ -2006,13 +2006,13 @@ TEST_F(BuiltInTests, createBuiltInProgramForInvalidBuiltinKernelName) { TEST_F(BuiltInTests, WhenGettingSipKernelThenReturnProgramCreatedFromIsaAcquiredThroughCompilerInterface) { MockBuiltins mockBuiltins; auto mockCompilerInterface = new MockCompilerInterface(); - pDevice->getExecutionEnvironment()->rootDeviceEnvironments[pDevice->getRootDeviceIndex()]->compilerInterface.reset(mockCompilerInterface); + pDevice->getExecutionEnvironment()->rootDeviceEnvironments[rootDeviceIndex]->compilerInterface.reset(mockCompilerInterface); mockCompilerInterface->sipKernelBinaryOverride = mockCompilerInterface->getDummyGenBinary(); cl_int errCode = CL_BUILD_PROGRAM_FAILURE; auto p = Program::createFromGenBinary(*pDevice->getExecutionEnvironment(), pContext, mockCompilerInterface->sipKernelBinaryOverride.data(), mockCompilerInterface->sipKernelBinaryOverride.size(), - false, &errCode, nullptr); + false, &errCode, pDevice); ASSERT_EQ(CL_SUCCESS, errCode); - errCode = p->processGenBinary(); + errCode = p->processGenBinary(rootDeviceIndex); ASSERT_EQ(CL_SUCCESS, errCode); const SipKernel &sipKern = mockBuiltins.getSipKernel(SipKernelType::Csr, pContext->getDevice(0)->getDevice()); diff --git a/opencl/test/unit_test/fixtures/cl_device_fixture.cpp b/opencl/test/unit_test/fixtures/cl_device_fixture.cpp index 7057a97b4c..7e947e58a7 100644 --- a/opencl/test/unit_test/fixtures/cl_device_fixture.cpp +++ b/opencl/test/unit_test/fixtures/cl_device_fixture.cpp @@ -16,7 +16,7 @@ void ClDeviceFixture::SetUp() { } void ClDeviceFixture::SetUpImpl(const NEO::HardwareInfo *hardwareInfo) { - pDevice = MockDevice::createWithNewExecutionEnvironment(hardwareInfo); + pDevice = MockDevice::createWithNewExecutionEnvironment(hardwareInfo, rootDeviceIndex); ASSERT_NE(nullptr, pDevice); pClDevice = new MockClDevice{pDevice}; ASSERT_NE(nullptr, pClDevice); @@ -35,6 +35,6 @@ void ClDeviceFixture::TearDown() { MockDevice *ClDeviceFixture::createWithUsDeviceId(unsigned short usDeviceId) { hardwareInfo = *defaultHwInfo; hardwareInfo.platform.usDeviceID = usDeviceId; - return MockDevice::createWithNewExecutionEnvironment(&hardwareInfo); + return MockDevice::createWithNewExecutionEnvironment(&hardwareInfo, rootDeviceIndex); } } // namespace NEO diff --git a/opencl/test/unit_test/fixtures/cl_device_fixture.h b/opencl/test/unit_test/fixtures/cl_device_fixture.h index 6da0bf4128..07087c76f1 100644 --- a/opencl/test/unit_test/fixtures/cl_device_fixture.h +++ b/opencl/test/unit_test/fixtures/cl_device_fixture.h @@ -25,5 +25,6 @@ struct ClDeviceFixture { volatile uint32_t *pTagMemory = nullptr; HardwareInfo hardwareInfo = {}; PLATFORM platformHelper = {}; + const uint32_t rootDeviceIndex = 0u; }; } // namespace NEO diff --git a/opencl/test/unit_test/gtpin/gtpin_tests.cpp b/opencl/test/unit_test/gtpin/gtpin_tests.cpp index dd192fbe98..ff8eeb4af3 100644 --- a/opencl/test/unit_test/gtpin/gtpin_tests.cpp +++ b/opencl/test/unit_test/gtpin/gtpin_tests.cpp @@ -1009,6 +1009,7 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenKernelWithoutSSHIsUsedThenK EXPECT_EQ(CL_SUCCESS, retVal); EXPECT_NE(nullptr, context); auto pContext = castToObject(context); + auto rootDeviceIndex = pDevice->getRootDeviceIndex(); char binary[1024] = {1, 2, 3, 4, 5, 6, 7, 8, 9, '\0'}; size_t binSize = 10; @@ -1018,9 +1019,9 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenKernelWithoutSSHIsUsedThenK PatchTokensTestData::ValidProgramWithKernel programTokens; - pProgram->unpackedDeviceBinary = makeCopy(reinterpret_cast(programTokens.storage.data()), programTokens.storage.size()); - pProgram->unpackedDeviceBinarySize = programTokens.storage.size(); - retVal = pProgram->processGenBinary(); + pProgram->buildInfos[rootDeviceIndex].unpackedDeviceBinary = makeCopy(reinterpret_cast(programTokens.storage.data()), programTokens.storage.size()); + pProgram->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize = programTokens.storage.size(); + retVal = pProgram->processGenBinary(rootDeviceIndex); EXPECT_EQ(CL_SUCCESS, retVal); int prevCount = KernelCreateCallbackCount; @@ -1056,6 +1057,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, GTPinTests, givenInitializedGTPinInterfaceWhenKernel EXPECT_EQ(CL_SUCCESS, retVal); EXPECT_NE(nullptr, context); auto pContext = castToObject(context); + auto rootDeviceIndex = pDevice->getRootDeviceIndex(); cl_queue_properties devQproperties = 0; auto devQ = std::make_unique>(pContext, pDevice, devQproperties); @@ -1156,9 +1158,9 @@ HWCMDTEST_F(IGFX_GEN8_CORE, GTPinTests, givenInitializedGTPinInterfaceWhenKernel uint64_t hashValue = Hash::hash(reinterpret_cast(pKernelBin), kernelBinSize); pKHdr->CheckSum = static_cast(hashValue & 0xFFFFFFFF); - pProgram->unpackedDeviceBinary = makeCopy(&binary[0], binSize); - pProgram->unpackedDeviceBinarySize = binSize; - retVal = pProgram->processGenBinary(); + pProgram->buildInfos[rootDeviceIndex].unpackedDeviceBinary = makeCopy(&binary[0], binSize); + pProgram->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize = binSize; + retVal = pProgram->processGenBinary(rootDeviceIndex); EXPECT_EQ(CL_SUCCESS, retVal); // Verify that GT-Pin Kernel Create callback is not called @@ -2100,9 +2102,11 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenLowMemoryConditionOccursThe PatchTokensTestData::ValidProgramWithKernel programTokens; - pProgram->unpackedDeviceBinary = makeCopy(programTokens.storage.data(), programTokens.storage.size()); - pProgram->unpackedDeviceBinarySize = programTokens.storage.size(); - retVal = pProgram->processGenBinary(); + auto rootDeviceIndex = pDevice->getRootDeviceIndex(); + + pProgram->buildInfos[rootDeviceIndex].unpackedDeviceBinary = makeCopy(programTokens.storage.data(), programTokens.storage.size()); + pProgram->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize = programTokens.storage.size(); + retVal = pProgram->processGenBinary(rootDeviceIndex); if (retVal == CL_OUT_OF_HOST_MEMORY) { auto nonFailingAlloc = MemoryManagement::nonfailingAllocation; EXPECT_NE(nonFailingAlloc, failureIndex); diff --git a/opencl/test/unit_test/mocks/mock_program.cpp b/opencl/test/unit_test/mocks/mock_program.cpp index c88838a524..3e8fcfec8b 100644 --- a/opencl/test/unit_test/mocks/mock_program.cpp +++ b/opencl/test/unit_test/mocks/mock_program.cpp @@ -18,6 +18,7 @@ #include "opencl/source/program/create.inl" #include "opencl/source/program/kernel_info.h" #include "opencl/test/unit_test/helpers/ult_limits.h" +#include "opencl/test/unit_test/mocks/mock_cl_device.h" #include "opencl/test/unit_test/mocks/mock_compilers.h" #include "opencl/test/unit_test/mocks/mock_graphics_allocation.h" @@ -34,12 +35,12 @@ std::string MockProgram::getCachedFileName() const { auto internalOpts = ArrayRef(this->internalOptions.c_str(), this->internalOptions.size()); return CompilerCache::getCachedFileName(hwInfo, input, opts, internalOpts); } -cl_int GlobalMockSipProgram::processGenBinary() { +cl_int GlobalMockSipProgram::processGenBinary(uint32_t rootDeviceIndex) { return CL_SUCCESS; } -cl_int GlobalMockSipProgram::processGenBinaryOnce() { - cl_int ret = Program::processGenBinary(); +cl_int GlobalMockSipProgram::processGenBinaryOnce(uint32_t rootDeviceIndex) { + cl_int ret = Program::processGenBinary(rootDeviceIndex); sipAllocationStorage = alignedMalloc(this->kernelInfoArray[0]->heapInfo.KernelHeapSize, MemoryConstants::pageSize); this->kernelInfoArray[0]->kernelAllocation = new MockGraphicsAllocation(sipAllocationStorage, this->kernelInfoArray[0]->heapInfo.KernelHeapSize); return ret; @@ -59,15 +60,17 @@ void GlobalMockSipProgram::initSipProgram() { executionEnvironment.rootDeviceEnvironments[i]->setHwInfo(defaultHwInfo.get()); } executionEnvironment.calculateMaxOsContextCount(); + executionEnvironment.incRefInternal(); + MockDevice device(&executionEnvironment, mockRootDeviceIndex); sipProgram = Program::createFromGenBinary(executionEnvironment, nullptr, binary.data(), binary.size(), true, &retVal, - nullptr); + &device); DEBUG_BREAK_IF(retVal != 0); - sipProgram->processGenBinaryOnce(); + sipProgram->processGenBinaryOnce(mockRootDeviceIndex); } void GlobalMockSipProgram::resetAllocation(GraphicsAllocation *allocation) { diff --git a/opencl/test/unit_test/mocks/mock_program.h b/opencl/test/unit_test/mocks/mock_program.h index c326fbe468..f4a6c246ac 100644 --- a/opencl/test/unit_test/mocks/mock_program.h +++ b/opencl/test/unit_test/mocks/mock_program.h @@ -49,8 +49,6 @@ class MockProgram : public Program { using Program::isSpirV; using Program::options; using Program::packDeviceBinary; - using Program::packedDeviceBinary; - using Program::packedDeviceBinarySize; using Program::pDevice; using Program::Program; using Program::programBinaryType; @@ -58,8 +56,6 @@ class MockProgram : public Program { using Program::specConstantsIds; using Program::specConstantsSizes; using Program::specConstantsValues; - using Program::unpackedDeviceBinary; - using Program::unpackedDeviceBinarySize; MockProgram(ExecutionEnvironment &executionEnvironment) : Program(executionEnvironment, nullptr, false, nullptr) { } @@ -165,8 +161,8 @@ class GlobalMockSipProgram : public Program { using Program::Program; GlobalMockSipProgram(ExecutionEnvironment &executionEnvironment) : Program(executionEnvironment, nullptr, false, nullptr) { } - cl_int processGenBinary() override; - cl_int processGenBinaryOnce(); + cl_int processGenBinary(uint32_t rootDeviceIndex) override; + cl_int processGenBinaryOnce(uint32_t rootDeviceIndex); void resetAllocationState(); void resetAllocation(GraphicsAllocation *allocation); void deleteAllocation(); diff --git a/opencl/test/unit_test/program/process_elf_binary_tests.cpp b/opencl/test/unit_test/program/process_elf_binary_tests.cpp index ddeafafc9c..f7013d9ebd 100644 --- a/opencl/test/unit_test/program/process_elf_binary_tests.cpp +++ b/opencl/test/unit_test/program/process_elf_binary_tests.cpp @@ -28,24 +28,24 @@ using namespace NEO; class ProcessElfBinaryTests : public ::testing::Test { public: void SetUp() override { - device = std::make_unique(MockDevice::createWithNewExecutionEnvironment(nullptr)); - program = std::make_unique(*device->getExecutionEnvironment()); - program->pDevice = &device->getDevice(); + device = std::make_unique(MockDevice::createWithNewExecutionEnvironment(nullptr, rootDeviceIndex)); + program = std::make_unique(*device->getExecutionEnvironment(), nullptr, false, &device->getDevice()); } std::unique_ptr program; std::unique_ptr device; + const uint32_t rootDeviceIndex = 1; }; TEST_F(ProcessElfBinaryTests, GivenNullWhenCreatingProgramFromBinaryThenInvalidBinaryErrorIsReturned) { - cl_int retVal = program->createProgramFromBinary(nullptr, 0); + cl_int retVal = program->createProgramFromBinary(nullptr, 0, rootDeviceIndex); EXPECT_EQ(CL_INVALID_BINARY, retVal); } TEST_F(ProcessElfBinaryTests, GivenInvalidBinaryWhenCreatingProgramFromBinaryThenInvalidBinaryErrorIsReturned) { char pBinary[] = "thisistotallyinvalid\0"; size_t binarySize = strnlen_s(pBinary, 21); - cl_int retVal = program->createProgramFromBinary(pBinary, binarySize); + cl_int retVal = program->createProgramFromBinary(pBinary, binarySize, rootDeviceIndex); EXPECT_EQ(CL_INVALID_BINARY, retVal); } @@ -56,10 +56,10 @@ TEST_F(ProcessElfBinaryTests, GivenValidBinaryWhenCreatingProgramFromBinaryThenS size_t binarySize = 0; auto pBinary = loadDataFromFile(filePath.c_str(), binarySize); - cl_int retVal = program->createProgramFromBinary(pBinary.get(), binarySize); + cl_int retVal = program->createProgramFromBinary(pBinary.get(), binarySize, rootDeviceIndex); EXPECT_EQ(CL_SUCCESS, retVal); - EXPECT_EQ(0, memcmp(pBinary.get(), program->packedDeviceBinary.get(), binarySize)); + EXPECT_EQ(0, memcmp(pBinary.get(), program->buildInfos[rootDeviceIndex].packedDeviceBinary.get(), binarySize)); } TEST_F(ProcessElfBinaryTests, GivenValidSpirBinaryWhenCreatingProgramFromBinaryThenSuccessIsReturned) { @@ -77,15 +77,15 @@ TEST_F(ProcessElfBinaryTests, GivenValidSpirBinaryWhenCreatingProgramFromBinaryT EXPECT_TRUE(program->getIsSpirV()); //clGetProgramInfo => SPIR-V stored as ELF binary - cl_int retVal = program->packDeviceBinary(); + cl_int retVal = program->packDeviceBinary(rootDeviceIndex); EXPECT_EQ(CL_SUCCESS, retVal); - EXPECT_NE(nullptr, program->packedDeviceBinary); - EXPECT_NE(0u, program->packedDeviceBinarySize); + EXPECT_NE(nullptr, program->buildInfos[rootDeviceIndex].packedDeviceBinary); + EXPECT_NE(0u, program->buildInfos[rootDeviceIndex].packedDeviceBinarySize); //use ELF reader to parse and validate ELF binary std::string decodeErrors; std::string decodeWarnings; - auto elf = NEO::Elf::decodeElf(ArrayRef(reinterpret_cast(program->packedDeviceBinary.get()), program->packedDeviceBinarySize), decodeErrors, decodeWarnings); + auto elf = NEO::Elf::decodeElf(ArrayRef(reinterpret_cast(program->buildInfos[rootDeviceIndex].packedDeviceBinary.get()), program->buildInfos[rootDeviceIndex].packedDeviceBinarySize), decodeErrors, decodeWarnings); auto header = elf.elfFileHeader; ASSERT_NE(nullptr, header); @@ -101,8 +101,8 @@ TEST_F(ProcessElfBinaryTests, GivenValidSpirBinaryWhenCreatingProgramFromBinaryT //clCreateProgramWithBinary => new program should recognize SPIR-V binary program->isSpirV = false; - auto elfBinary = makeCopy(program->packedDeviceBinary.get(), program->packedDeviceBinarySize); - retVal = program->createProgramFromBinary(elfBinary.get(), program->packedDeviceBinarySize); + auto elfBinary = makeCopy(program->buildInfos[rootDeviceIndex].packedDeviceBinary.get(), program->buildInfos[rootDeviceIndex].packedDeviceBinarySize); + retVal = program->createProgramFromBinary(elfBinary.get(), program->buildInfos[rootDeviceIndex].packedDeviceBinarySize, rootDeviceIndex); EXPECT_EQ(CL_SUCCESS, retVal); EXPECT_TRUE(program->getIsSpirV()); } @@ -115,13 +115,13 @@ unsigned int BinaryTypeValues[] = { class ProcessElfBinaryTestsWithBinaryType : public ::testing::TestWithParam { public: void SetUp() override { - device = std::make_unique(MockDevice::createWithNewExecutionEnvironment(nullptr)); - program = std::make_unique(*device->getExecutionEnvironment()); - program->pDevice = &device->getDevice(); + device = std::make_unique(MockDevice::createWithNewExecutionEnvironment(nullptr, rootDeviceIndex)); + program = std::make_unique(*device->getExecutionEnvironment(), nullptr, false, &device->getDevice()); } std::unique_ptr program; std::unique_ptr device; + const uint32_t rootDeviceIndex = 1; }; TEST_P(ProcessElfBinaryTestsWithBinaryType, GivenBinaryTypeWhenResolveProgramThenProgramIsProperlyResolved) { @@ -130,28 +130,28 @@ TEST_P(ProcessElfBinaryTestsWithBinaryType, GivenBinaryTypeWhenResolveProgramThe size_t binarySize = 0; auto pBinary = loadDataFromFile(filePath.c_str(), binarySize); - cl_int retVal = program->createProgramFromBinary(pBinary.get(), binarySize); + cl_int retVal = program->createProgramFromBinary(pBinary.get(), binarySize, rootDeviceIndex); auto options = program->options; - auto genBinary = makeCopy(program->unpackedDeviceBinary.get(), program->unpackedDeviceBinarySize); - auto genBinarySize = program->unpackedDeviceBinarySize; + auto genBinary = makeCopy(program->buildInfos[rootDeviceIndex].unpackedDeviceBinary.get(), program->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize); + auto genBinarySize = program->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize; auto irBinary = makeCopy(program->irBinary.get(), program->irBinarySize); auto irBinarySize = program->irBinarySize; EXPECT_EQ(CL_SUCCESS, retVal); - ASSERT_EQ(binarySize, program->packedDeviceBinarySize); - EXPECT_EQ(0, memcmp(pBinary.get(), program->packedDeviceBinary.get(), binarySize)); + ASSERT_EQ(binarySize, program->buildInfos[rootDeviceIndex].packedDeviceBinarySize); + EXPECT_EQ(0, memcmp(pBinary.get(), program->buildInfos[rootDeviceIndex].packedDeviceBinary.get(), binarySize)); // delete program's elf reference to force a resolve - program->packedDeviceBinary.reset(); - program->packedDeviceBinarySize = 0U; + program->buildInfos[rootDeviceIndex].packedDeviceBinary.reset(); + program->buildInfos[rootDeviceIndex].packedDeviceBinarySize = 0U; program->programBinaryType = GetParam(); - retVal = program->packDeviceBinary(); + retVal = program->packDeviceBinary(rootDeviceIndex); EXPECT_EQ(CL_SUCCESS, retVal); - ASSERT_NE(nullptr, program->packedDeviceBinary); + ASSERT_NE(nullptr, program->buildInfos[rootDeviceIndex].packedDeviceBinary); std::string decodeErrors; std::string decodeWarnings; - auto elf = NEO::Elf::decodeElf(ArrayRef(reinterpret_cast(program->packedDeviceBinary.get()), program->packedDeviceBinarySize), decodeErrors, decodeWarnings); + auto elf = NEO::Elf::decodeElf(ArrayRef(reinterpret_cast(program->buildInfos[rootDeviceIndex].packedDeviceBinary.get()), program->buildInfos[rootDeviceIndex].packedDeviceBinarySize), decodeErrors, decodeWarnings); ASSERT_NE(nullptr, elf.elfFileHeader); ArrayRef decodedIr; ArrayRef decodedDeviceBinary; @@ -192,19 +192,19 @@ TEST_F(ProcessElfBinaryTests, GivenMultipleCallsWhenCreatingProgramFromBinaryThe size_t binarySize = 0; auto pBinary = loadDataFromFile(filePath.c_str(), binarySize); - cl_int retVal = program->createProgramFromBinary(pBinary.get(), binarySize); + cl_int retVal = program->createProgramFromBinary(pBinary.get(), binarySize, rootDeviceIndex); EXPECT_EQ(CL_SUCCESS, retVal); - EXPECT_EQ(0, memcmp(pBinary.get(), program->packedDeviceBinary.get(), binarySize)); + EXPECT_EQ(0, memcmp(pBinary.get(), program->buildInfos[rootDeviceIndex].packedDeviceBinary.get(), binarySize)); std::string filePath2; retrieveBinaryKernelFilename(filePath2, "simple_arg_int_", ".bin"); pBinary = loadDataFromFile(filePath2.c_str(), binarySize); - retVal = program->createProgramFromBinary(pBinary.get(), binarySize); + retVal = program->createProgramFromBinary(pBinary.get(), binarySize, rootDeviceIndex); EXPECT_EQ(CL_SUCCESS, retVal); - EXPECT_EQ(0, memcmp(pBinary.get(), program->packedDeviceBinary.get(), binarySize)); + EXPECT_EQ(0, memcmp(pBinary.get(), program->buildInfos[rootDeviceIndex].packedDeviceBinary.get(), binarySize)); } TEST_F(ProcessElfBinaryTests, GivenEmptyBuildOptionsWhenCreatingProgramFromBinaryThenSuccessIsReturned) { @@ -213,7 +213,7 @@ TEST_F(ProcessElfBinaryTests, GivenEmptyBuildOptionsWhenCreatingProgramFromBinar size_t binarySize = 0; auto pBinary = loadDataFromFile(filePath.c_str(), binarySize); - cl_int retVal = program->createProgramFromBinary(pBinary.get(), binarySize); + cl_int retVal = program->createProgramFromBinary(pBinary.get(), binarySize, rootDeviceIndex); EXPECT_EQ(CL_SUCCESS, retVal); const auto &options = program->getOptions(); @@ -227,7 +227,7 @@ TEST_F(ProcessElfBinaryTests, GivenNonEmptyBuildOptionsWhenCreatingProgramFromBi size_t binarySize = 0; auto pBinary = loadDataFromFile(filePath.c_str(), binarySize); - cl_int retVal = program->createProgramFromBinary(pBinary.get(), binarySize); + cl_int retVal = program->createProgramFromBinary(pBinary.get(), binarySize, rootDeviceIndex); EXPECT_EQ(CL_SUCCESS, retVal); const auto &options = program->getOptions(); @@ -242,7 +242,7 @@ TEST_F(ProcessElfBinaryTests, GivenBinaryWhenIncompatiblePatchtokenVerionThenPro elfEncoder.getElfFileHeader().type = NEO::Elf::ET_OPENCL_EXECUTABLE; elfEncoder.appendSection(NEO::Elf::SHT_OPENCL_DEV_BINARY, NEO::Elf::SectionNamesOpenCl::deviceBinary, programTokens.storage); auto elfBinary = elfEncoder.encode(); - cl_int retVal = program->createProgramFromBinary(elfBinary.data(), elfBinary.size()); + cl_int retVal = program->createProgramFromBinary(elfBinary.data(), elfBinary.size(), rootDeviceIndex); EXPECT_EQ(CL_SUCCESS, retVal); } @@ -252,7 +252,7 @@ TEST_F(ProcessElfBinaryTests, GivenBinaryWhenIncompatiblePatchtokenVerionThenPro elfEncoder.getElfFileHeader().type = NEO::Elf::ET_OPENCL_EXECUTABLE; elfEncoder.appendSection(NEO::Elf::SHT_OPENCL_DEV_BINARY, NEO::Elf::SectionNamesOpenCl::deviceBinary, programTokens.storage); auto elfBinary = elfEncoder.encode(); - cl_int retVal = program->createProgramFromBinary(elfBinary.data(), elfBinary.size()); + cl_int retVal = program->createProgramFromBinary(elfBinary.data(), elfBinary.size(), rootDeviceIndex); EXPECT_EQ(CL_INVALID_BINARY, retVal); } } diff --git a/opencl/test/unit_test/program/program_data_tests.cpp b/opencl/test/unit_test/program/program_data_tests.cpp index 36371ccb9c..501e3a753c 100644 --- a/opencl/test/unit_test/program/program_data_tests.cpp +++ b/opencl/test/unit_test/program/program_data_tests.cpp @@ -154,11 +154,12 @@ void ProgramDataTestBase::buildAndDecodeProgramPatchList() { memcpy_s(pCurPtr, programPatchListSize, pProgramPatchList, programPatchListSize); pCurPtr += programPatchListSize; + auto rootDeviceIndex = pPlatform->getClDevice(0)->getRootDeviceIndex(); //as we use mock compiler in unit test, replace the genBinary here. - pProgram->unpackedDeviceBinary = makeCopy(pProgramData, headerSize + programBinaryHeader.PatchListSize); - pProgram->unpackedDeviceBinarySize = headerSize + programBinaryHeader.PatchListSize; + pProgram->buildInfos[rootDeviceIndex].unpackedDeviceBinary = makeCopy(pProgramData, headerSize + programBinaryHeader.PatchListSize); + pProgram->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize = headerSize + programBinaryHeader.PatchListSize; - error = pProgram->processGenBinary(); + error = pProgram->processGenBinary(rootDeviceIndex); patchlistDecodeErrorCode = error; if (allowDecodeFailure == false) { EXPECT_EQ(CL_SUCCESS, error); diff --git a/opencl/test/unit_test/program/program_tests.cpp b/opencl/test/unit_test/program/program_tests.cpp index 68894cad1d..8278233c80 100644 --- a/opencl/test/unit_test/program/program_tests.cpp +++ b/opencl/test/unit_test/program/program_tests.cpp @@ -104,13 +104,13 @@ class NoCompilerInterfaceRootDeviceEnvironment : public RootDeviceEnvironment { class FailingGenBinaryProgram : public MockProgram { public: FailingGenBinaryProgram(ExecutionEnvironment &executionEnvironment) : MockProgram(executionEnvironment) {} - cl_int processGenBinary() override { return CL_INVALID_BINARY; } + cl_int processGenBinary(uint32_t rootDeviceIndex) override { return CL_INVALID_BINARY; } }; class SucceedingGenBinaryProgram : public MockProgram { public: SucceedingGenBinaryProgram(ExecutionEnvironment &executionEnvironment) : MockProgram(executionEnvironment) {} - cl_int processGenBinary() override { return CL_SUCCESS; } + cl_int processGenBinary(uint32_t rootDeviceIndex) override { return CL_SUCCESS; } }; TEST_P(ProgramFromBinaryTest, WhenBuildingProgramThenSuccessIsReturned) { @@ -663,12 +663,12 @@ TEST_P(ProgramFromBinaryTest, whenProgramIsBeingRebuildThenOutdatedGlobalBuffers EXPECT_EQ(nullptr, pProgram->buildInfos[pClDevice->getRootDeviceIndex()].globalSurface); pProgram->buildInfos[pClDevice->getRootDeviceIndex()].constantSurface = new MockGraphicsAllocation(); - pProgram->processGenBinary(); + pProgram->processGenBinary(rootDeviceIndex); EXPECT_EQ(nullptr, pProgram->buildInfos[pClDevice->getRootDeviceIndex()].constantSurface); EXPECT_EQ(nullptr, pProgram->buildInfos[pClDevice->getRootDeviceIndex()].globalSurface); pProgram->buildInfos[pClDevice->getRootDeviceIndex()].globalSurface = new MockGraphicsAllocation(); - pProgram->processGenBinary(); + pProgram->processGenBinary(rootDeviceIndex); EXPECT_EQ(nullptr, pProgram->buildInfos[pClDevice->getRootDeviceIndex()].constantSurface); EXPECT_EQ(nullptr, pProgram->buildInfos[pClDevice->getRootDeviceIndex()].globalSurface); } @@ -1648,8 +1648,9 @@ TEST(ProgramFromBinaryTests, givenBinaryWithInvalidICBEThenErrorIsReturned) { { const unsigned char *binaries[1] = {reinterpret_cast(&binHeader)}; - const cl_device_id deviceId = 0; MockContext context; + cl_device_id deviceId = context.getDevice(0); + std::unique_ptr pProgram(Program::create(&context, 0, &deviceId, &binSize, binaries, nullptr, retVal)); EXPECT_EQ(nullptr, pProgram.get()); EXPECT_EQ(CL_INVALID_BINARY, retVal); @@ -1657,12 +1658,12 @@ TEST(ProgramFromBinaryTests, givenBinaryWithInvalidICBEThenErrorIsReturned) { { // whatever method we choose CL_INVALID_BINARY is always returned - ExecutionEnvironment executionEnvironment; - std::unique_ptr pProgram(Program::createFromGenBinary(executionEnvironment, nullptr, &binHeader, binSize, false, &retVal, nullptr)); + auto device = std::make_unique(MockDevice::createWithNewExecutionEnvironment(nullptr, mockRootDeviceIndex)); + std::unique_ptr pProgram(Program::createFromGenBinary(*device->getExecutionEnvironment(), nullptr, &binHeader, binSize, false, &retVal, &device->getDevice())); ASSERT_NE(nullptr, pProgram.get()); EXPECT_EQ(CL_SUCCESS, retVal); - retVal = pProgram->processGenBinary(); + retVal = pProgram->processGenBinary(mockRootDeviceIndex); EXPECT_EQ(CL_INVALID_BINARY, retVal); } } @@ -1681,13 +1682,14 @@ TEST(ProgramFromBinaryTests, givenEmptyProgramThenErrorIsReturned) { binHeader.PatchListSize = 0; size_t binSize = sizeof(SProgramBinaryHeader); - ExecutionEnvironment executionEnvironment; - std::unique_ptr pProgram(MockProgram::createFromGenBinary(executionEnvironment, nullptr, &binHeader, binSize, false, &retVal, nullptr)); + auto device = std::make_unique(MockDevice::createWithNewExecutionEnvironment(nullptr, mockRootDeviceIndex)); + std::unique_ptr pProgram(MockProgram::createFromGenBinary(*device->getExecutionEnvironment(), nullptr, &binHeader, binSize, false, &retVal, &device->getDevice())); ASSERT_NE(nullptr, pProgram.get()); EXPECT_EQ(CL_SUCCESS, retVal); - pProgram->unpackedDeviceBinary.reset(nullptr); - retVal = pProgram->processGenBinary(); + auto rootDeviceIndex = mockRootDeviceIndex; + pProgram->buildInfos[rootDeviceIndex].unpackedDeviceBinary.reset(nullptr); + retVal = pProgram->processGenBinary(rootDeviceIndex); EXPECT_EQ(CL_INVALID_BINARY, retVal); } @@ -1726,10 +1728,10 @@ TEST_F(ProgramWithDebugSymbolsTests, GivenProgramCreatedWithDashGOptionWhenGetti size_t paramValueSizeRet = 0; size_t size = 0; - pProgram->packedDeviceBinary.reset(); - pProgram->packedDeviceBinarySize = 0U; + pProgram->buildInfos[rootDeviceIndex].packedDeviceBinary.reset(); + pProgram->buildInfos[rootDeviceIndex].packedDeviceBinarySize = 0U; - retVal = pProgram->packDeviceBinary(); + retVal = pProgram->packDeviceBinary(rootDeviceIndex); retVal = pProgram->getInfo( CL_PROGRAM_BINARY_SIZES, @@ -2080,9 +2082,9 @@ TEST_F(ProgramTests, givenProgramFromGenBinaryWhenSLMSizeIsBiggerThenDeviceLimit patchtokensProgram.slmMutable->TotalInlineLocalMemorySize = static_cast(pDevice->getDeviceInfo().localMemSize * 2); patchtokensProgram.recalcTokPtr(); auto program = std::make_unique(*pDevice->getExecutionEnvironment(), nullptr, false, pDevice); - program->unpackedDeviceBinary = makeCopy(patchtokensProgram.storage.data(), patchtokensProgram.storage.size()); - program->unpackedDeviceBinarySize = patchtokensProgram.storage.size(); - auto retVal = program->processGenBinary(); + program->buildInfos[rootDeviceIndex].unpackedDeviceBinary = makeCopy(patchtokensProgram.storage.data(), patchtokensProgram.storage.size()); + program->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize = patchtokensProgram.storage.size(); + auto retVal = program->processGenBinary(rootDeviceIndex); EXPECT_EQ(CL_OUT_OF_RESOURCES, retVal); } @@ -2105,7 +2107,7 @@ TEST_F(ProgramTests, GivenNoCompilerInterfaceRootDeviceEnvironmentWhenRebuilding EXPECT_NE(0u, binarySize); // Create program from loaded binary - cl_int retVal = program->createProgramFromBinary(pBinary.get(), binarySize); + cl_int retVal = program->createProgramFromBinary(pBinary.get(), binarySize, rootDeviceIndex); EXPECT_EQ(CL_SUCCESS, retVal); // Ask to rebuild program from its IR binary - it should fail (no Compiler Interface) @@ -2161,7 +2163,7 @@ TEST_F(ProgramTests, GivenFailingGenBinaryProgramWhenRebuildingBinaryThenInvalid EXPECT_NE(0u, binarySize); // Create program from loaded binary - retVal = program->createProgramFromBinary(pBinary.get(), binarySize); + retVal = program->createProgramFromBinary(pBinary.get(), binarySize, rootDeviceIndex); EXPECT_EQ(CL_SUCCESS, retVal); // Ask to rebuild program from its IR binary - it should fail (simulated invalid binary) @@ -2334,7 +2336,7 @@ struct CreateProgramFromBinaryMock : public MockProgram { } cl_int createProgramFromBinary(const void *pBinary, - size_t binarySize) override { + size_t binarySize, uint32_t rootDeviceIndex) override { this->irBinary.reset(new char[binarySize]); this->irBinarySize = binarySize; this->isSpirV = spirv; @@ -2709,12 +2711,12 @@ TEST_F(ProgramTests, whenRebuildingProgramThenStoreDeviceBinaryProperly) { uint32_t ir[16] = {0x03022307, 0x23471113, 0x17192329}; program->irBinary = makeCopy(ir, sizeof(ir)); program->irBinarySize = sizeof(ir); - EXPECT_EQ(nullptr, program->unpackedDeviceBinary); - EXPECT_EQ(0U, program->unpackedDeviceBinarySize); + EXPECT_EQ(nullptr, program->buildInfos[rootDeviceIndex].unpackedDeviceBinary); + EXPECT_EQ(0U, program->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize); program->rebuildProgramFromIr(); - ASSERT_NE(nullptr, program->unpackedDeviceBinary); - ASSERT_EQ(sizeof(binaryToReturn), program->unpackedDeviceBinarySize); - EXPECT_EQ(0, memcmp(binaryToReturn, program->unpackedDeviceBinary.get(), program->unpackedDeviceBinarySize)); + ASSERT_NE(nullptr, program->buildInfos[rootDeviceIndex].unpackedDeviceBinary); + ASSERT_EQ(sizeof(binaryToReturn), program->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize); + EXPECT_EQ(0, memcmp(binaryToReturn, program->buildInfos[rootDeviceIndex].unpackedDeviceBinary.get(), program->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize)); } TEST_F(ProgramTests, givenProgramWhenInternalOptionsArePassedThenTheyAreAddedToProgramInternalOptions) { @@ -2846,12 +2848,13 @@ TEST(CreateProgramFromBinaryTests, givenBinaryProgramWhenKernelRebulildIsForcedT ASSERT_NE(nullptr, pProgram.get()); EXPECT_EQ(CL_SUCCESS, retVal); - retVal = pProgram->createProgramFromBinary(programTokens.storage.data(), programTokens.storage.size()); + auto rootDeviceIndex = clDevice->getRootDeviceIndex(); + retVal = pProgram->createProgramFromBinary(programTokens.storage.data(), programTokens.storage.size(), rootDeviceIndex); EXPECT_EQ(CL_SUCCESS, retVal); - EXPECT_EQ(nullptr, pProgram->unpackedDeviceBinary.get()); - EXPECT_EQ(0U, pProgram->unpackedDeviceBinarySize); - EXPECT_EQ(nullptr, pProgram->packedDeviceBinary); - EXPECT_EQ(0U, pProgram->packedDeviceBinarySize); + EXPECT_EQ(nullptr, pProgram->buildInfos[rootDeviceIndex].unpackedDeviceBinary.get()); + EXPECT_EQ(0U, pProgram->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize); + EXPECT_EQ(nullptr, pProgram->buildInfos[rootDeviceIndex].packedDeviceBinary); + EXPECT_EQ(0U, pProgram->buildInfos[rootDeviceIndex].packedDeviceBinarySize); } TEST(CreateProgramFromBinaryTests, givenBinaryProgramWhenKernelRebulildIsNotForcedThenDeviceBinaryIsUsed) { @@ -2865,12 +2868,13 @@ TEST(CreateProgramFromBinaryTests, givenBinaryProgramWhenKernelRebulildIsNotForc ASSERT_NE(nullptr, pProgram.get()); EXPECT_EQ(CL_SUCCESS, retVal); - retVal = pProgram->createProgramFromBinary(programTokens.storage.data(), programTokens.storage.size()); + auto rootDeviceIndex = clDevice->getRootDeviceIndex(); + retVal = pProgram->createProgramFromBinary(programTokens.storage.data(), programTokens.storage.size(), rootDeviceIndex); EXPECT_EQ(CL_SUCCESS, retVal); - EXPECT_NE(nullptr, reinterpret_cast(pProgram->unpackedDeviceBinary.get())); - EXPECT_EQ(programTokens.storage.size(), pProgram->unpackedDeviceBinarySize); - EXPECT_NE(nullptr, reinterpret_cast(pProgram->packedDeviceBinary.get())); - EXPECT_EQ(programTokens.storage.size(), pProgram->packedDeviceBinarySize); + EXPECT_NE(nullptr, reinterpret_cast(pProgram->buildInfos[rootDeviceIndex].unpackedDeviceBinary.get())); + EXPECT_EQ(programTokens.storage.size(), pProgram->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize); + EXPECT_NE(nullptr, reinterpret_cast(pProgram->buildInfos[rootDeviceIndex].packedDeviceBinary.get())); + EXPECT_EQ(programTokens.storage.size(), pProgram->buildInfos[rootDeviceIndex].packedDeviceBinarySize); } struct SpecializationConstantProgramMock : public MockProgram { @@ -3158,15 +3162,17 @@ TEST_F(ProgramBinTest, GivenSourceKernelWhenLinkingProgramThenGtpinInitInfoIsPas } TEST(ProgramReplaceDeviceBinary, GivenBinaryZebinThenUseAsBothPackedAndUnpackedBinaryContainer) { - MockExecutionEnvironment execEnv; ZebinTestData::ValidEmptyProgram zebin; std::unique_ptr src = makeCopy(zebin.storage.data(), zebin.storage.size()); - MockProgram program{execEnv}; - program.replaceDeviceBinary(std::move(src), zebin.storage.size()); - ASSERT_EQ(zebin.storage.size(), program.packedDeviceBinarySize); - ASSERT_EQ(zebin.storage.size(), program.unpackedDeviceBinarySize); - ASSERT_NE(nullptr, program.packedDeviceBinary); - ASSERT_NE(nullptr, program.unpackedDeviceBinary); - EXPECT_EQ(0, memcmp(program.packedDeviceBinary.get(), zebin.storage.data(), program.packedDeviceBinarySize)); - EXPECT_EQ(0, memcmp(program.unpackedDeviceBinary.get(), zebin.storage.data(), program.unpackedDeviceBinarySize)); + MockContext context; + auto device = &context.getDevice(0)->getDevice(); + auto rootDeviceIndex = device->getRootDeviceIndex(); + MockProgram program{*device->getExecutionEnvironment(), &context, false, device}; + program.replaceDeviceBinary(std::move(src), zebin.storage.size(), rootDeviceIndex); + ASSERT_EQ(zebin.storage.size(), program.buildInfos[rootDeviceIndex].packedDeviceBinarySize); + ASSERT_EQ(zebin.storage.size(), program.buildInfos[rootDeviceIndex].unpackedDeviceBinarySize); + ASSERT_NE(nullptr, program.buildInfos[rootDeviceIndex].packedDeviceBinary); + ASSERT_NE(nullptr, program.buildInfos[rootDeviceIndex].unpackedDeviceBinary); + EXPECT_EQ(0, memcmp(program.buildInfos[rootDeviceIndex].packedDeviceBinary.get(), zebin.storage.data(), program.buildInfos[rootDeviceIndex].packedDeviceBinarySize)); + EXPECT_EQ(0, memcmp(program.buildInfos[rootDeviceIndex].unpackedDeviceBinary.get(), zebin.storage.data(), program.buildInfos[rootDeviceIndex].unpackedDeviceBinarySize)); } 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 ee153a95ee..1f41478edc 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 @@ -49,7 +49,7 @@ TEST(ProgramFromBinary, givenBinaryWithDebugDataWhenCreatingProgramFromBinaryThe size_t binarySize = 0; auto pBinary = loadDataFromFile(filePath.c_str(), binarySize); - cl_int retVal = program->createProgramFromBinary(pBinary.get(), binarySize); + cl_int retVal = program->createProgramFromBinary(pBinary.get(), binarySize, device->getRootDeviceIndex()); EXPECT_EQ(CL_SUCCESS, retVal); EXPECT_NE(nullptr, program->getDebugData()); diff --git a/shared/source/built_ins/built_ins.cpp b/shared/source/built_ins/built_ins.cpp index 3bdae262fc..0e4bc21a00 100644 --- a/shared/source/built_ins/built_ins.cpp +++ b/shared/source/built_ins/built_ins.cpp @@ -56,7 +56,7 @@ const SipKernel &BuiltIns::getSipKernel(SipKernelType type, Device &device) { program->setDevice(&device); - retVal = program->processGenBinary(); + retVal = program->processGenBinary(device.getRootDeviceIndex()); DEBUG_BREAK_IF(retVal != 0); sipBuiltIn.first.reset(new SipKernel(type, program)); diff --git a/shared/test/unit_test/mocks/mock_device.h b/shared/test/unit_test/mocks/mock_device.h index 83c9c5b922..a295b40fd1 100644 --- a/shared/test/unit_test/mocks/mock_device.h +++ b/shared/test/unit_test/mocks/mock_device.h @@ -107,7 +107,7 @@ class MockDevice : public RootDevice { template static T *createWithNewExecutionEnvironment(const HardwareInfo *pHwInfo, uint32_t rootDeviceIndex = 0) { ExecutionEnvironment *executionEnvironment = new ExecutionEnvironment(); - auto numRootDevices = DebugManager.flags.CreateMultipleRootDevices.get() ? DebugManager.flags.CreateMultipleRootDevices.get() : 1u; + auto numRootDevices = DebugManager.flags.CreateMultipleRootDevices.get() ? DebugManager.flags.CreateMultipleRootDevices.get() : rootDeviceIndex + 1; executionEnvironment->prepareRootDeviceEnvironments(numRootDevices); pHwInfo = pHwInfo ? pHwInfo : defaultHwInfo.get(); for (auto i = 0u; i < executionEnvironment->rootDeviceEnvironments.size(); i++) {