intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-22 10:17:01 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add initial implementation of specialization constants

Browse Source 
Related-To: NEO-2260

Change-Id: Ib722109039555a028eb4ec0862e9de72342f9730
Signed-off-by: Jobczyk, Lukasz <lukasz.jobczyk@intel.com>
This commit is contained in:
Jobczyk, Lukasz
2019-04-25 12:46:43 +02:00
committed by sys_ocldev
parent 3a75c4fb71
commit 971eb7a1b4
16 changed files with 561 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

207
unit_tests/compiler_interface/compiler_interface_tests.cpp
View File

@@ -572,7 +572,18 @@ struct TranslationCtxMock {
CIF::Builtins::BufferSimple *options,
CIF::Builtins::BufferSimple *internalOptions,
CIF::Builtins::BufferSimple *tracingOptions,
uint32_t tracingOptionsCount, void *gtpinInit) {
uint32_t tracingOptionsCount,
void *gtpinInit) {
return this->Translate(src, options, internalOptions, tracingOptions, tracingOptionsCount);
}
CIF::RAII::UPtr_t<IGC::OclTranslationOutputTagOCL> Translate(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) {
return this->Translate(src, options, internalOptions, tracingOptions, tracingOptionsCount);
}
};
@@ -591,6 +602,40 @@ TEST(TranslateTest, whenArgsAreValidAndTranslatorReturnsValidOutputThenValidOutp
EXPECT_EQ(mockIntOpt.get(), mockTranslationCtx.receivedIntOpt);
}
TEST(TranslateTest, givenGtPinInputWhenArgsAreValidAndTranslatorReturnsValidOutputThenValidOutputIsReturned) {
TranslationCtxMock mockTranslationCtx;
auto mockSrc = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
auto mockOpt = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
auto mockIntOpt = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
auto ret = NEO::translate(&mockTranslationCtx, mockSrc.get(), mockOpt.get(), mockIntOpt.get(), nullptr);
EXPECT_NE(nullptr, ret);
EXPECT_EQ(mockSrc.get(), mockTranslationCtx.receivedSrc);
EXPECT_EQ(mockOpt.get(), mockTranslationCtx.receivedOpt);
EXPECT_EQ(mockIntOpt.get(), mockTranslationCtx.receivedIntOpt);
}
TEST(TranslateTest, whenArgsAreInvalidThenNullptrIsReturned) {
auto mockSrc = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
auto mockOpt = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
auto mockIntOpt = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
auto ret = NEO::translate<TranslationCtxMock>(nullptr, mockSrc.get(), mockOpt.get(), mockIntOpt.get());
EXPECT_EQ(nullptr, ret);
}
TEST(TranslateTest, givenGtPinInputWhenArgsAreInvalidThenNullptrIsReturned) {
auto mockSrc = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
auto mockOpt = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
auto mockIntOpt = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
auto ret = NEO::translate<TranslationCtxMock>(nullptr, mockSrc.get(), mockOpt.get(), mockIntOpt.get(), nullptr);
EXPECT_EQ(nullptr, ret);
}
TEST(TranslateTest, whenTranslatorReturnsNullptrThenNullptrIsReturned) {
TranslationCtxMock mockTranslationCtx;
mockTranslationCtx.returnNullptr = true;
@@ -600,6 +645,15 @@ TEST(TranslateTest, whenTranslatorReturnsNullptrThenNullptrIsReturned) {
EXPECT_EQ(nullptr, ret);
}
TEST(TranslateTest, givenSpecConstantsBuffersWhenTranslatorReturnsNullptrThenNullptrIsReturned) {
TranslationCtxMock mockTranslationCtx;
mockTranslationCtx.returnNullptr = true;
auto mockCifBuffer = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
auto ret = NEO::translate(&mockTranslationCtx, mockCifBuffer.get(), mockCifBuffer.get(), mockCifBuffer.get(), mockCifBuffer.get(), mockCifBuffer.get(), nullptr);
EXPECT_EQ(nullptr, ret);
}
TEST(TranslateTest, givenNullPtrAsGtPinInputWhenTranslatorReturnsNullptrThenNullptrIsReturned) {
TranslationCtxMock mockTranslationCtx;
mockTranslationCtx.returnNullptr = true;
@@ -633,6 +687,18 @@ TEST(TranslateTest, givenNullPtrAsGtPinInputWhenTranslatorReturnsInvalidOutputTh
}
}
TEST(TranslateTest, givenSpecConstantsBuffersAndNullPtrAsGtPinInputWhenTranslatorReturnsInvalidOutputThenNullptrIsReturned) {
TranslationCtxMock mockTranslationCtx;
auto mockCifBuffer = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
for (uint32_t i = 1; i <= (1 << 3) - 1; ++i) {
mockTranslationCtx.returnNullptrDebugData = (i & 1) != 0;
mockTranslationCtx.returnNullptrLog = (i & (1 << 1)) != 0;
mockTranslationCtx.returnNullptrOutput = (i & (1 << 2)) != 0;
auto ret = NEO::translate(&mockTranslationCtx, mockCifBuffer.get(), mockCifBuffer.get(), mockCifBuffer.get(), mockCifBuffer.get(), mockCifBuffer.get(), nullptr);
EXPECT_EQ(nullptr, ret);
}
}
TEST(TranslateTest, whenAnyArgIsNullThenNullptrIsReturnedAndTranslatorIsNotInvoked) {
TranslationCtxMock mockTranslationCtx;
auto mockCifBuffer = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
@@ -961,3 +1027,142 @@ TEST_F(CompilerInterfaceTest, whenRequestingSipKernelBinaryThenProperInternalOpt
gEnvironment->igcPopDebugVars();
}
TEST_F(CompilerInterfaceTest, whenCompilerIsNotAvailableThenGetSpecializationConstantsFails) {
pCompilerInterface->GetIgcMain()->Release();
pCompilerInterface->SetIgcMain(nullptr);
TranslationArgs inputArgs;
retVal = pCompilerInterface->getSpecConstantsInfo(*pProgram, inputArgs);
EXPECT_EQ(CL_COMPILER_NOT_AVAILABLE, retVal);
}
struct SpecConstantsTranslationCtxMock {
bool returnFalse = false;
CIF::Builtins::BufferSimple *receivedSrc = nullptr;
CIF::Builtins::BufferSimple *receivedOutSpecConstantsIds = nullptr;
CIF::Builtins::BufferSimple *receivedOutSpecConstantsSizes = nullptr;
bool GetSpecConstantsInfoImpl(CIFBuffer *src, CIFBuffer *outSpecConstantsIds, CIFBuffer *outSpecConstantsSizes) {
this->receivedSrc = src;
this->receivedOutSpecConstantsIds = outSpecConstantsIds;
this->receivedOutSpecConstantsSizes = outSpecConstantsSizes;
return !returnFalse;
}
};
TEST(GetSpecConstantsTest, givenNullptrTranslationContextAndBuffersWhenGetSpecializationConstantsThenErrorIsReturned) {
EXPECT_FALSE(NEO::getSpecConstantsInfoImpl<SpecConstantsTranslationCtxMock>(nullptr, nullptr, nullptr, nullptr, nullptr));
}
TEST(GetSpecConstantsTest, whenGetSpecializationConstantsSuccedThenSuccessIsReturnedAndBuffersArePassed) {
SpecConstantsTranslationCtxMock tCtxMock;
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());
EXPECT_TRUE(ret);
EXPECT_EQ(mockSrc.get(), tCtxMock.receivedSrc);
EXPECT_EQ(mockIds.get(), tCtxMock.receivedOutSpecConstantsIds);
EXPECT_EQ(mockSizes.get(), tCtxMock.receivedOutSpecConstantsSizes);
}
TEST(GetSpecConstantsTest, whenGetSpecializationConstantsFailThenErrorIsReturnedAndBuffersArePassed) {
SpecConstantsTranslationCtxMock tCtxMock;
tCtxMock.returnFalse = true;
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());
EXPECT_FALSE(ret);
EXPECT_EQ(mockSrc.get(), tCtxMock.receivedSrc);
EXPECT_EQ(mockIds.get(), tCtxMock.receivedOutSpecConstantsIds);
EXPECT_EQ(mockSizes.get(), tCtxMock.receivedOutSpecConstantsSizes);
}
TEST_F(CompilerInterfaceTest, whenIgcTranlationContextCreationFailsThenErrorIsReturned) {
pCompilerInterface->failCreateIgcTranslationCtx = true;
retVal = pCompilerInterface->getSpecConstantsInfo(*pProgram, inputArgs);
EXPECT_EQ(CL_OUT_OF_HOST_MEMORY, retVal);
}
TEST_F(CompilerInterfaceTest, givenCompilerInterfaceWhenGetSpecializationConstantsThenSuccesIsReturned) {
retVal = pCompilerInterface->getSpecConstantsInfo(*pProgram, inputArgs);
EXPECT_EQ(CL_SUCCESS, retVal);
}
struct UpdateSpecConstantsTest : public ::testing::Test {
void SetUp() override {
mockProgram.reset(new MockProgram(executionEnvironment));
mockProgram->specConstantsIds.reset(new MockCIFBuffer());
mockProgram->specConstantsSizes.reset(new MockCIFBuffer());
mockProgram->specConstantsValues.reset(new MockCIFBuffer());
mockProgram->specConstantsIds->PushBackRawCopy(1);
mockProgram->specConstantsIds->PushBackRawCopy(2);
mockProgram->specConstantsIds->PushBackRawCopy(3);
mockProgram->specConstantsSizes->PushBackRawCopy(sizeof(char));
mockProgram->specConstantsSizes->PushBackRawCopy(sizeof(uint16_t));
mockProgram->specConstantsSizes->PushBackRawCopy(sizeof(int));
mockProgram->specConstantsValues->PushBackRawCopy(&val1);
mockProgram->specConstantsValues->PushBackRawCopy(&val2);
mockProgram->specConstantsValues->PushBackRawCopy(&val3);
values = mockProgram->specConstantsValues->GetMemory<const void *>();
EXPECT_EQ(val1, *reinterpret_cast<const char *>(values[0]));
EXPECT_EQ(val2, *reinterpret_cast<const uint16_t *>(values[1]));
EXPECT_EQ(val3, *reinterpret_cast<const int *>(values[2]));
}
ExecutionEnvironment executionEnvironment;
std::unique_ptr<MockProgram> mockProgram;
char val1 = 5;
uint16_t val2 = 50;
int val3 = 500;
const void *const *values;
};
TEST_F(UpdateSpecConstantsTest, givenNewSpecConstValueWhenUpdateSpecializationConstantThenProperValueIsUpdated) {
int newSpecConstVal3 = 5000;
auto ret = mockProgram->updateSpecializationConstant(3, sizeof(int), &newSpecConstVal3);
EXPECT_EQ(CL_SUCCESS, ret);
EXPECT_EQ(val1, *reinterpret_cast<const char *>(values[0]));
EXPECT_EQ(val2, *reinterpret_cast<const uint16_t *>(values[1]));
EXPECT_EQ(newSpecConstVal3, *reinterpret_cast<const int *>(values[2]));
}
TEST_F(UpdateSpecConstantsTest, givenNewSpecConstValueWithUnproperSizeWhenUpdateSpecializationConstantThenErrorIsReturned) {
int newSpecConstVal3 = 5000;
auto ret = mockProgram->updateSpecializationConstant(3, 10 * sizeof(int), &newSpecConstVal3);
EXPECT_EQ(CL_INVALID_VALUE, ret);
EXPECT_EQ(val1, *reinterpret_cast<const char *>(values[0]));
EXPECT_EQ(val2, *reinterpret_cast<const uint16_t *>(values[1]));
EXPECT_EQ(val3, *reinterpret_cast<const int *>(values[2]));
}
TEST_F(UpdateSpecConstantsTest, givenNewSpecConstValueWithUnproperIdAndSizeWhenUpdateSpecializationConstantThenErrorIsReturned) {
int newSpecConstVal3 = 5000;
auto ret = mockProgram->updateSpecializationConstant(4, sizeof(int), &newSpecConstVal3);
EXPECT_EQ(CL_INVALID_SPEC_ID, ret);
EXPECT_EQ(val1, *reinterpret_cast<const char *>(values[0]));
EXPECT_EQ(val2, *reinterpret_cast<const uint16_t *>(values[1]));
EXPECT_EQ(val3, *reinterpret_cast<const int *>(values[2]));
}