Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Pass only updated spec const values

Browse Source 
Change-Id: Idc9720fb700e7ce9745872e08038b31836300a38
Signed-off-by: Lukasz Jobczyk <lukasz.jobczyk@intel.com>
This commit is contained in:
Lukasz Jobczyk
2020-03-19 08:58:12 +01:00
committed by sys_ocldev
parent b546e89f99
commit ab7a846514
9 changed files with 70 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
opencl/source/program/build.cpp
View File

@ -109,9 +109,7 @@ cl_int Program::build(
inputArgs.apiOptions = ArrayRef<const char>(options.c_str(), options.length());
inputArgs.internalOptions = ArrayRef<const char>(internalOptions.c_str(), internalOptions.length());
inputArgs.GTPinInput = gtpinGetIgcInit();
inputArgs.specConstants.idsBuffer = this->specConstantsIds.get();
inputArgs.specConstants.sizesBuffer = this->specConstantsSizes.get();
inputArgs.specConstants.valuesBuffer = this->specConstantsValues.get();
inputArgs.specConstants.specializedValues = this->specConstantsValues;
DBG_LOG(LogApiCalls,
"Build Options", inputArgs.apiOptions.begin(),
"\nBuild Internal Options", inputArgs.internalOptions.begin());

3
opencl/source/program/program.cpp
View File

@ -238,7 +238,6 @@ cl_int Program::setProgramSpecializationConstant(cl_uint specId, size_t specSize
this->specConstantsIds.reset(specConstInfo.idsBuffer.release());
this->specConstantsSizes.reset(specConstInfo.sizesBuffer.release());
this->specConstantsValues.reset(specConstInfo.valuesBuffer.release());
areSpecializationConstantsInitialized = true;
}
@ -252,7 +251,7 @@ cl_int Program::updateSpecializationConstant(cl_uint specId, size_t specSize, co
if (specConstantsSizes->GetMemory<uint32_t>()[i] == static_cast<uint32_t>(specSize)) {
uint64_t specConstValue = 0u;
memcpy_s(&specConstValue, sizeof(uint64_t), specValue, specSize);
specConstantsValues->GetMemoryWriteable<uint64_t>()[i] = specConstValue;
specConstantsValues[specId] = specConstValue;
return CL_SUCCESS;
} else {
return CL_INVALID_VALUE;

2
opencl/source/program/program.h
View File

@ -330,7 +330,7 @@ class Program : public BaseObject<_cl_program> {
bool areSpecializationConstantsInitialized = false;
CIF::RAII::UPtr_t<CIF::Builtins::BufferSimple> specConstantsIds;
CIF::RAII::UPtr_t<CIF::Builtins::BufferSimple> specConstantsSizes;
CIF::RAII::UPtr_t<CIF::Builtins::BufferSimple> specConstantsValues;
std::map<uint32_t, uint64_t> specConstantsValues;
BlockKernelManager *blockKernelManager = nullptr;
ExecutionEnvironment &executionEnvironment;

3
opencl/test/unit_test/mocks/mock_compilers.cpp
View File

@ -504,9 +504,6 @@ bool MockIgcOclTranslationCtx::GetSpecConstantsInfoImpl(
CIF::Builtins::BufferSimple *src,
CIF::Builtins::BufferSimple *outSpecConstantsIds,
CIF::Builtins::BufferSimple *outSpecConstantsSizes) {
uint32_t id = 1u;
outSpecConstantsIds->PushBackRawCopy(id);
outSpecConstantsSizes->PushBackRawCopy(sizeof(uint32_t));
return true;
}

44
opencl/test/unit_test/program/program_spec_constants_tests.cpp
View File

@ -30,9 +30,7 @@ struct UpdateSpecConstantsTest : public ::testing::Test {
mockProgram->specConstantsIds.reset(new MockCIFBuffer());
mockProgram->specConstantsSizes.reset(new MockCIFBuffer());
mockProgram->specConstantsValues.reset(new MockCIFBuffer());
uint32_t id1 = 1u, id2 = 2u, id3 = 3u;
mockProgram->specConstantsIds->PushBackRawCopy(id1);
mockProgram->specConstantsIds->PushBackRawCopy(id2);
mockProgram->specConstantsIds->PushBackRawCopy(id3);
@ -42,23 +40,26 @@ struct UpdateSpecConstantsTest : public ::testing::Test {
mockProgram->specConstantsSizes->PushBackRawCopy(size2);
mockProgram->specConstantsSizes->PushBackRawCopy(size3);
mockProgram->specConstantsValues->PushBackRawCopy(static_cast<uint64_t>(val1));
mockProgram->specConstantsValues->PushBackRawCopy(static_cast<uint64_t>(val2));
mockProgram->specConstantsValues->PushBackRawCopy(static_cast<uint64_t>(val3));
mockProgram->specConstantsValues.insert({id1, static_cast<uint64_t>(val1)});
mockProgram->specConstantsValues.insert({id2, static_cast<uint64_t>(val2)});
mockProgram->specConstantsValues.insert({id3, static_cast<uint64_t>(val3)});
values = mockProgram->specConstantsValues->GetMemoryWriteable<uint64_t>();
values = &mockProgram->specConstantsValues;
EXPECT_EQ(val1, static_cast<char>(values[0]));
EXPECT_EQ(val2, static_cast<uint16_t>(values[1]));
EXPECT_EQ(val3, static_cast<int>(values[2]));
EXPECT_EQ(val1, static_cast<char>(values->at(id1)));
EXPECT_EQ(val2, static_cast<uint16_t>(values->at(id2)));
EXPECT_EQ(val3, static_cast<int>(values->at(id3)));
}
ExecutionEnvironment executionEnvironment;
std::unique_ptr<MockProgram> mockProgram;
uint32_t id1 = 1u;
uint32_t id2 = 2u;
uint32_t id3 = 3u;
char val1 = 5;
uint16_t val2 = 50;
int val3 = 500;
uint64_t *values;
std::map<uint32_t, uint64_t> *values;
};
TEST_F(UpdateSpecConstantsTest, givenNewSpecConstValueWhenUpdateSpecializationConstantThenProperValueIsCopiedAndUpdated) {
@ -67,17 +68,16 @@ TEST_F(UpdateSpecConstantsTest, givenNewSpecConstValueWhenUpdateSpecializationCo
auto ret = mockProgram->updateSpecializationConstant(3, sizeof(int), &newSpecConstVal3);
EXPECT_EQ(CL_SUCCESS, ret);
EXPECT_EQ(val1, static_cast<char>(values[0]));
EXPECT_EQ(val2, static_cast<uint16_t>(values[1]));
EXPECT_EQ(newSpecConstVal3, static_cast<int>(values[2]));
EXPECT_NE(val3, static_cast<int>(values[2]));
EXPECT_EQ(val1, static_cast<char>(values->at(id1)));
EXPECT_EQ(val2, static_cast<uint16_t>(values->at(id2)));
EXPECT_EQ(newSpecConstVal3, static_cast<int>(values->at(id3)));
newSpecConstVal3 = 50000;
EXPECT_NE(newSpecConstVal3, static_cast<int>(values[2]));
EXPECT_NE(newSpecConstVal3, static_cast<int>(values->at(id3)));
ret = mockProgram->updateSpecializationConstant(3, sizeof(int), &newSpecConstVal3);
EXPECT_EQ(CL_SUCCESS, ret);
EXPECT_EQ(newSpecConstVal3, static_cast<int>(values[2]));
EXPECT_EQ(newSpecConstVal3, static_cast<int>(values->at(id3)));
}
TEST_F(UpdateSpecConstantsTest, givenNewSpecConstValueWithUnproperSizeWhenUpdateSpecializationConstantThenErrorIsReturned) {
@ -86,9 +86,9 @@ TEST_F(UpdateSpecConstantsTest, givenNewSpecConstValueWithUnproperSizeWhenUpdate
auto ret = mockProgram->updateSpecializationConstant(3, 10 * sizeof(int), &newSpecConstVal3);
EXPECT_EQ(CL_INVALID_VALUE, ret);
EXPECT_EQ(val1, static_cast<char>(values[0]));
EXPECT_EQ(val2, static_cast<uint16_t>(values[1]));
EXPECT_EQ(val3, static_cast<int>(values[2]));
EXPECT_EQ(val1, static_cast<char>(values->at(id1)));
EXPECT_EQ(val2, static_cast<uint16_t>(values->at(id2)));
EXPECT_EQ(val3, static_cast<int>(values->at(id3)));
}
TEST_F(UpdateSpecConstantsTest, givenNewSpecConstValueWithUnproperIdAndSizeWhenUpdateSpecializationConstantThenErrorIsReturned) {
@ -97,7 +97,7 @@ TEST_F(UpdateSpecConstantsTest, givenNewSpecConstValueWithUnproperIdAndSizeWhenU
auto ret = mockProgram->updateSpecializationConstant(4, sizeof(int), &newSpecConstVal3);
EXPECT_EQ(CL_INVALID_SPEC_ID, ret);
EXPECT_EQ(val1, static_cast<char>(values[0]));
EXPECT_EQ(val2, static_cast<uint16_t>(values[1]));
EXPECT_EQ(val3, static_cast<int>(values[2]));
EXPECT_EQ(val1, static_cast<char>(values->at(id1)));
EXPECT_EQ(val2, static_cast<uint16_t>(values->at(id2)));
EXPECT_EQ(val3, static_cast<int>(values->at(id3)));
}

17
shared/source/compiler_interface/compiler_interface.cpp
View File

@ -80,6 +80,13 @@ TranslationOutput::ErrorCode CompilerInterface::build(
auto fclOptions = CIF::Builtins::CreateConstBuffer(igcMain.get(), input.apiOptions.begin(), input.apiOptions.size());
auto fclInternalOptions = CIF::Builtins::CreateConstBuffer(igcMain.get(), input.internalOptions.begin(), input.internalOptions.size());
auto idsBuffer = CIF::Builtins::CreateConstBuffer(igcMain.get(), nullptr, 0);
auto valuesBuffer = CIF::Builtins::CreateConstBuffer(igcMain.get(), nullptr, 0);
for (const auto &specConst : input.specConstants.specializedValues) {
idsBuffer->PushBackRawCopy(specConst.first);
valuesBuffer->PushBackRawCopy(specConst.second);
}
CIF::RAII::UPtr_t<CIF::Builtins::BufferSimple> intermediateRepresentation;
if (srcCodeType == IGC::CodeType::oclC) {
@ -124,7 +131,7 @@ TranslationOutput::ErrorCode CompilerInterface::build(
auto igcTranslationCtx = createIgcTranslationCtx(device, intermediateCodeType, IGC::CodeType::oclGenBin);
auto igcOutput = translate(igcTranslationCtx.get(), intermediateRepresentation.get(), input.specConstants.idsBuffer, input.specConstants.valuesBuffer,
auto igcOutput = translate(igcTranslationCtx.get(), intermediateRepresentation.get(), idsBuffer.get(), valuesBuffer.get(),
fclOptions.get(), fclInternalOptions.get(), input.GTPinInput);
if (igcOutput == nullptr) {
@ -250,19 +257,13 @@ TranslationOutput::ErrorCode CompilerInterface::getSpecConstantsInfo(const NEO::
auto inSrc = CIF::Builtins::CreateConstBuffer(igcMain.get(), srcSpirV.begin(), srcSpirV.size());
output.idsBuffer = CIF::Builtins::CreateConstBuffer(igcMain.get(), nullptr, 0);
output.sizesBuffer = CIF::Builtins::CreateConstBuffer(igcMain.get(), nullptr, 0);
output.valuesBuffer = CIF::Builtins::CreateConstBuffer(igcMain.get(), nullptr, 0);
auto retVal = getSpecConstantsInfoImpl(igcTranslationCtx.get(), inSrc.get(), output.idsBuffer.get(), output.sizesBuffer.get(), output.valuesBuffer.get());
auto retVal = getSpecConstantsInfoImpl(igcTranslationCtx.get(), inSrc.get(), output.idsBuffer.get(), output.sizesBuffer.get());
if (!retVal) {
return TranslationOutput::ErrorCode::UnknownError;
}
output.valuesBuffer->Resize(output.idsBuffer->GetSizeRaw() * 2);
for (uint32_t i = 0; i < output.valuesBuffer->GetSize<uint64_t>(); i++) {
output.valuesBuffer->GetMemoryWriteable<uint64_t>()[i] = 0u;
}
return TranslationOutput::ErrorCode::Success;
}

5
shared/source/compiler_interface/compiler_interface.h
View File

@ -41,9 +41,7 @@ struct TranslationInput {
void *GTPinInput = nullptr;
struct SpecConstants {
CIF::Builtins::BufferLatest *idsBuffer = nullptr;
CIF::Builtins::BufferLatest *sizesBuffer = nullptr;
CIF::Builtins::BufferLatest *valuesBuffer = nullptr;
std::map<uint32_t, uint64_t> specializedValues;
} specConstants;
};
@ -94,7 +92,6 @@ struct TranslationOutput {
struct SpecConstantInfo {
CIF::RAII::UPtr_t<CIF::Builtins::BufferLatest> idsBuffer;
CIF::RAII::UPtr_t<CIF::Builtins::BufferLatest> sizesBuffer;
CIF::RAII::UPtr_t<CIF::Builtins::BufferLatest> valuesBuffer;
};
class CompilerInterface {

5
shared/source/compiler_interface/compiler_interface.inl
View File

@ -59,9 +59,8 @@ template <typename TranslationCtx>
inline bool getSpecConstantsInfoImpl(TranslationCtx *tCtx,
CIFBuffer *src,
CIFBuffer *outSpecConstantsIds,
CIFBuffer *outSpecConstantsSizes,
CIFBuffer *outSpecConstantsValues) {
if (!NEO::areNotNullptr(tCtx, src, outSpecConstantsIds, outSpecConstantsSizes, outSpecConstantsValues)) {
CIFBuffer *outSpecConstantsSizes) {
if (!NEO::areNotNullptr(tCtx, src, outSpecConstantsIds, outSpecConstantsSizes)) {
return false;
}
return tCtx->GetSpecConstantsInfoImpl(src, outSpecConstantsIds, outSpecConstantsSizes);

38
shared/test/unit_test/compiler_interface/compiler_interface_tests.cpp
View File

@ -725,6 +725,36 @@ struct WasLockedListener {
bool wasLocked = false;
};
TEST_F(CompilerInterfaceTest, givenUpdatedSpecConstValuesWhenBuildProgramThenProperValuesArePassed) {
struct MockTranslationContextSpecConst : public MockIgcOclTranslationCtx {
IGC::OclTranslationOutputBase *TranslateImpl(
CIF::Version_t outVersion,
CIF::Builtins::BufferSimple *src,
CIF::Builtins::BufferSimple *specConstantsIds,
CIF::Builtins::BufferSimple *specConstantsValues,
CIF::Builtins::BufferSimple *options,
CIF::Builtins::BufferSimple *internalOptions,
CIF::Builtins::BufferSimple *tracingOptions,
uint32_t tracingOptionsCount,
void *gtPinInput) override {
EXPECT_EQ(10u, specConstantsIds->GetMemory<uint32_t>()[0]);
EXPECT_EQ(100u, specConstantsValues->GetMemory<uint64_t>()[0]);
return new MockOclTranslationOutput();
}
};
auto specConstCtx = CIF::RAII::UPtr(new MockCompilerDeviceCtx<MockIgcOclDeviceCtx, MockTranslationContextSpecConst>());
pCompilerInterface->setDeviceCtx(*pDevice, specConstCtx.get());
std::map<uint32_t, uint64_t> specConst{{10, 100}};
inputArgs.specConstants.specializedValues = specConst;
TranslationOutput translationOutput;
auto err = pCompilerInterface->build(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::Success, err);
}
TEST_F(CompilerInterfaceTest, GivenRequestForNewFclTranslationCtxWhenDeviceCtxIsNotAvailableThenCreateNewDeviceCtxAndUseItToReturnValidTranslationCtx) {
auto device = this->pDevice;
auto ret = this->pCompilerInterface->createFclTranslationCtx(*device, IGC::CodeType::oclC, IGC::CodeType::spirV);
@ -1039,7 +1069,7 @@ struct SpecConstantsTranslationCtxMock {
};
TEST(GetSpecConstantsTest, givenNullptrTranslationContextAndBuffersWhenGetSpecializationConstantsThenErrorIsReturned) {
EXPECT_FALSE(NEO::getSpecConstantsInfoImpl<SpecConstantsTranslationCtxMock>(nullptr, nullptr, nullptr, nullptr, nullptr));
EXPECT_FALSE(NEO::getSpecConstantsInfoImpl<SpecConstantsTranslationCtxMock>(nullptr, nullptr, nullptr, nullptr));
}
TEST(GetSpecConstantsTest, whenGetSpecializationConstantsSuccedThenSuccessIsReturnedAndBuffersArePassed) {
@ -1048,9 +1078,8 @@ TEST(GetSpecConstantsTest, whenGetSpecializationConstantsSuccedThenSuccessIsRetu
auto mockSrc = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
auto mockIds = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
auto mockSizes = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
auto mockValues = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
auto ret = NEO::getSpecConstantsInfoImpl(&tCtxMock, mockSrc.get(), mockIds.get(), mockSizes.get(), mockValues.get());
auto ret = NEO::getSpecConstantsInfoImpl(&tCtxMock, mockSrc.get(), mockIds.get(), mockSizes.get());
EXPECT_TRUE(ret);
EXPECT_EQ(mockSrc.get(), tCtxMock.receivedSrc);
@ -1065,9 +1094,8 @@ TEST(GetSpecConstantsTest, whenGetSpecializationConstantsFailThenErrorIsReturned
auto mockSrc = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
auto mockIds = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
auto mockSizes = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
auto mockValues = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
auto ret = NEO::getSpecConstantsInfoImpl(&tCtxMock, mockSrc.get(), mockIds.get(), mockSizes.get(), mockValues.get());
auto ret = NEO::getSpecConstantsInfoImpl(&tCtxMock, mockSrc.get(), mockIds.get(), mockSizes.get());
EXPECT_FALSE(ret);
EXPECT_EQ(mockSrc.get(), tCtxMock.receivedSrc);