Skip to content

Commit acc0ec5

Browse files
DziubanMaciejIntelCompute-Runtime-Automation
DziubanMaciejIntel
authored and
Compute-Runtime-Automation
committed
Decrease number of classes deriving from Program 3/n
Change-Id: Id5211d4acb46d770dd57b91896af81427d370e0c Signed-off-by: Maciej Dziuban <[email protected]>
1 parent f0e53d5 commit acc0ec5

File tree

2 files changed

+71
-45
lines changed

2 files changed

+71
-45
lines changed

‎unit_tests/mocks/mock_program.h‎

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -41,6 +41,17 @@ class MockProgram : public Program {
4141
using Program::getProgramCompilerVersion;
4242
using Program::isKernelDebugEnabled;
4343
using Program::rebuildProgramFromIr;
44+
using Program::resolveProgramBinary;
45+
46+
using Program::elfBinary;
47+
using Program::elfBinarySize;
48+
using Program::genBinary;
49+
using Program::genBinarySize;
50+
using Program::irBinary;
51+
using Program::irBinarySize;
52+
using Program::isProgramBinaryResolved;
53+
using Program::isSpirV;
54+
using Program::programBinaryType;
4455

4556
using Program::sourceCode;
4657

‎unit_tests/program/process_elf_binary_tests.cpp‎

Lines changed: 60 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -24,34 +24,40 @@
2424
#include "runtime/program/program.h"
2525
#include "runtime/helpers/string.h"
2626
#include "unit_tests/helpers/test_files.h"
27+
#include "unit_tests/mocks/mock_program.h"
2728
#include "gtest/gtest.h"
2829
#include <cstring>
2930

3031
using namespace OCLRT;
3132

32-
class ProcessElfBinaryTests : public Program,
33-
public ::testing::Test {
33+
class ProcessElfBinaryTests : public ::testing::Test {
34+
public:
35+
void SetUp() override {
36+
program = std::make_unique<MockProgram>();
37+
}
38+
39+
std::unique_ptr<MockProgram> program;
3440
};
3541

3642
TEST_F(ProcessElfBinaryTests, NullBinary) {
3743
uint32_t binaryVersion;
38-
cl_int retVal = processElfBinary(nullptr, 0, binaryVersion);
44+
cl_int retVal = program->processElfBinary(nullptr, 0, binaryVersion);
3945

4046
EXPECT_EQ(CL_INVALID_BINARY, retVal);
41-
EXPECT_TRUE(elfBinary.empty());
42-
EXPECT_EQ(0u, elfBinarySize);
47+
EXPECT_TRUE(program->elfBinary.empty());
48+
EXPECT_EQ(0u, program->elfBinarySize);
4349
EXPECT_NE(0u, binaryVersion);
4450
}
4551

4652
TEST_F(ProcessElfBinaryTests, InvalidBinary) {
4753
uint32_t binaryVersion;
4854
char pBinary[] = "thisistotallyinvalid\0";
4955
size_t binarySize = strnlen_s(pBinary, 21);
50-
cl_int retVal = processElfBinary(pBinary, binarySize, binaryVersion);
56+
cl_int retVal = program->processElfBinary(pBinary, binarySize, binaryVersion);
5157

5258
EXPECT_EQ(CL_INVALID_BINARY, retVal);
53-
EXPECT_TRUE(elfBinary.empty());
54-
EXPECT_EQ(0u, elfBinarySize);
59+
EXPECT_TRUE(program->elfBinary.empty());
60+
EXPECT_EQ(0u, program->elfBinarySize);
5561
EXPECT_NE(0u, binaryVersion);
5662
}
5763

@@ -62,10 +68,10 @@ TEST_F(ProcessElfBinaryTests, ValidBinary) {
6268
retrieveBinaryKernelFilename(filePath, "CopyBuffer_simd8_", ".bin");
6369

6470
size_t binarySize = loadDataFromFile(filePath.c_str(), pBinary);
65-
cl_int retVal = processElfBinary(pBinary, binarySize, binaryVersion);
71+
cl_int retVal = program->processElfBinary(pBinary, binarySize, binaryVersion);
6672

6773
EXPECT_EQ(CL_SUCCESS, retVal);
68-
EXPECT_EQ(0, memcmp(pBinary, elfBinary.data(), binarySize));
74+
EXPECT_EQ(0, memcmp(pBinary, program->elfBinary.data(), binarySize));
6975
EXPECT_NE(0u, binaryVersion);
7076
deleteDataReadFromFile(pBinary);
7177
}
@@ -74,30 +80,31 @@ TEST_F(ProcessElfBinaryTests, ValidSpirvBinary) {
7480
//clCreateProgramWithIL => SPIR-V stored as source code
7581
const uint32_t spirvBinary[2] = {0x03022307, 0x07230203};
7682
size_t spirvBinarySize = sizeof(spirvBinary);
77-
isSpirV = Program::isValidSpirvBinary(spirvBinary, spirvBinarySize);
83+
auto isSpirV = Program::isValidSpirvBinary(spirvBinary, spirvBinarySize);
7884
EXPECT_TRUE(isSpirV);
7985

8086
//clCompileProgram => SPIR-V stored as IR binary
81-
storeIrBinary(spirvBinary, spirvBinarySize, true);
82-
programBinaryType = CL_PROGRAM_BINARY_TYPE_LIBRARY;
83-
EXPECT_NE(nullptr, irBinary);
84-
EXPECT_NE(0u, irBinarySize);
85-
EXPECT_TRUE(isSpirV);
87+
program->isSpirV = true;
88+
program->storeIrBinary(spirvBinary, spirvBinarySize, true);
89+
program->programBinaryType = CL_PROGRAM_BINARY_TYPE_LIBRARY;
90+
EXPECT_NE(nullptr, program->irBinary);
91+
EXPECT_NE(0u, program->irBinarySize);
92+
EXPECT_TRUE(program->getIsSpirV());
8693

8794
//clGetProgramInfo => SPIR-V stored as ELF binary
88-
cl_int retVal = resolveProgramBinary();
95+
cl_int retVal = program->resolveProgramBinary();
8996
EXPECT_EQ(CL_SUCCESS, retVal);
90-
EXPECT_FALSE(elfBinary.empty());
91-
EXPECT_NE(0u, elfBinarySize);
97+
EXPECT_FALSE(program->elfBinary.empty());
98+
EXPECT_NE(0u, program->elfBinarySize);
9299

93100
//use ELF reader to parse and validate ELF binary
94101
CLElfLib::CElfReader *pElfReader = CLElfLib::CElfReader::create(
95-
reinterpret_cast<const char *>(elfBinary.data()), elfBinarySize);
102+
reinterpret_cast<const char *>(program->elfBinary.data()), program->elfBinarySize);
96103
ASSERT_NE(nullptr, pElfReader);
97104
const CLElfLib::SElf64Header *pElfHeader = pElfReader->getElfHeader();
98105
ASSERT_NE(nullptr, pElfHeader);
99106
EXPECT_EQ(pElfHeader->Type, CLElfLib::E_EH_TYPE::EH_TYPE_OPENCL_LIBRARY);
100-
EXPECT_TRUE(CLElfLib::CElfReader::isValidElf64(elfBinary.data(), elfBinarySize));
107+
EXPECT_TRUE(CLElfLib::CElfReader::isValidElf64(program->elfBinary.data(), program->elfBinarySize));
101108

102109
//check if ELF binary contains section SH_TYPE_SPIRV
103110
bool hasSpirvSection = false;
@@ -112,13 +119,13 @@ TEST_F(ProcessElfBinaryTests, ValidSpirvBinary) {
112119
EXPECT_TRUE(hasSpirvSection);
113120

114121
//clCreateProgramWithBinary => new program should recognize SPIR-V binary
115-
isSpirV = false;
122+
program->isSpirV = false;
116123
uint32_t elfBinaryVersion;
117-
auto pElfBinary = std::unique_ptr<char>(new char[elfBinarySize]);
118-
memcpy_s(pElfBinary.get(), elfBinarySize, elfBinary.data(), elfBinarySize);
119-
retVal = processElfBinary(pElfBinary.get(), elfBinarySize, elfBinaryVersion);
124+
auto pElfBinary = std::unique_ptr<char>(new char[program->elfBinarySize]);
125+
memcpy_s(pElfBinary.get(), program->elfBinarySize, program->elfBinary.data(), program->elfBinarySize);
126+
retVal = program->processElfBinary(pElfBinary.get(), program->elfBinarySize, elfBinaryVersion);
120127
EXPECT_EQ(CL_SUCCESS, retVal);
121-
EXPECT_TRUE(isSpirV);
128+
EXPECT_TRUE(program->getIsSpirV());
122129

123130
CLElfLib::CElfReader::destroy(pElfReader);
124131
}
@@ -128,8 +135,13 @@ unsigned int BinaryTypeValues[] = {
128135
CL_PROGRAM_BINARY_TYPE_LIBRARY,
129136
CL_PROGRAM_BINARY_TYPE_COMPILED_OBJECT};
130137

131-
class ProcessElfBinaryTestsWithBinaryType : public Program,
132-
public ::testing::TestWithParam<unsigned int> {
138+
class ProcessElfBinaryTestsWithBinaryType : public ::testing::TestWithParam<unsigned int> {
139+
public:
140+
void SetUp() override {
141+
program = std::make_unique<MockProgram>();
142+
}
143+
144+
std::unique_ptr<MockProgram> program;
133145
};
134146

135147
TEST_P(ProcessElfBinaryTestsWithBinaryType, GivenBinaryTypeWhenResolveProgramThenProgramIsProperlyResolved) {
@@ -139,28 +151,29 @@ TEST_P(ProcessElfBinaryTestsWithBinaryType, GivenBinaryTypeWhenResolveProgramThe
139151
retrieveBinaryKernelFilename(filePath, "CopyBuffer_simd8_", ".bin");
140152

141153
size_t binarySize = loadDataFromFile(filePath.c_str(), pBinary);
142-
cl_int retVal = processElfBinary(pBinary, binarySize, binaryVersion);
154+
cl_int retVal = program->processElfBinary(pBinary, binarySize, binaryVersion);
143155

156+
const auto &options = program->getOptions();
144157
size_t optionsSize = strlen(options.c_str()) + 1;
145-
auto pTmpGenBinary = new char[genBinarySize];
146-
auto pTmpIrBinary = new char[irBinarySize];
158+
auto pTmpGenBinary = new char[program->genBinarySize];
159+
auto pTmpIrBinary = new char[program->irBinarySize];
147160
auto pTmpOptions = new char[optionsSize];
148161

149-
memcpy_s(pTmpGenBinary, genBinarySize, genBinary, genBinarySize);
150-
memcpy_s(pTmpIrBinary, irBinarySize, irBinary, irBinarySize);
162+
memcpy_s(pTmpGenBinary, program->genBinarySize, program->genBinary, program->genBinarySize);
163+
memcpy_s(pTmpIrBinary, program->irBinarySize, program->irBinary, program->irBinarySize);
151164
memcpy_s(pTmpOptions, optionsSize, options.c_str(), optionsSize);
152165

153166
EXPECT_EQ(CL_SUCCESS, retVal);
154-
EXPECT_EQ(0, memcmp(pBinary, elfBinary.data(), binarySize));
167+
EXPECT_EQ(0, memcmp(pBinary, program->elfBinary.data(), binarySize));
155168
EXPECT_NE(0u, binaryVersion);
156169

157170
// delete program's elf reference to force a resolve
158-
isProgramBinaryResolved = false;
159-
programBinaryType = GetParam();
160-
retVal = resolveProgramBinary();
171+
program->isProgramBinaryResolved = false;
172+
program->programBinaryType = GetParam();
173+
retVal = program->resolveProgramBinary();
161174
EXPECT_EQ(CL_SUCCESS, retVal);
162-
EXPECT_EQ(0, memcmp(pTmpGenBinary, genBinary, genBinarySize));
163-
EXPECT_EQ(0, memcmp(pTmpIrBinary, irBinary, irBinarySize));
175+
EXPECT_EQ(0, memcmp(pTmpGenBinary, program->genBinary, program->genBinarySize));
176+
EXPECT_EQ(0, memcmp(pTmpIrBinary, program->irBinary, program->irBinarySize));
164177
EXPECT_EQ(0, memcmp(pTmpOptions, options.c_str(), optionsSize));
165178

166179
delete[] pTmpGenBinary;
@@ -181,21 +194,21 @@ TEST_F(ProcessElfBinaryTests, BackToBack) {
181194
retrieveBinaryKernelFilename(filePath, "CopyBuffer_simd8_", ".bin");
182195

183196
size_t binarySize = loadDataFromFile(filePath.c_str(), pBinary);
184-
cl_int retVal = processElfBinary(pBinary, binarySize, binaryVersion);
197+
cl_int retVal = program->processElfBinary(pBinary, binarySize, binaryVersion);
185198

186199
EXPECT_EQ(CL_SUCCESS, retVal);
187-
EXPECT_EQ(0, memcmp(pBinary, elfBinary.data(), binarySize));
200+
EXPECT_EQ(0, memcmp(pBinary, program->elfBinary.data(), binarySize));
188201
EXPECT_NE(0u, binaryVersion);
189202
deleteDataReadFromFile(pBinary);
190203

191204
std::string filePath2;
192205
retrieveBinaryKernelFilename(filePath2, "simple_arg_int_", ".bin");
193206

194207
binarySize = loadDataFromFile(filePath2.c_str(), pBinary);
195-
retVal = processElfBinary(pBinary, binarySize, binaryVersion);
208+
retVal = program->processElfBinary(pBinary, binarySize, binaryVersion);
196209

197210
EXPECT_EQ(CL_SUCCESS, retVal);
198-
EXPECT_EQ(0, memcmp(pBinary, elfBinary.data(), binarySize));
211+
EXPECT_EQ(0, memcmp(pBinary, program->elfBinary.data(), binarySize));
199212
EXPECT_NE(0u, binaryVersion);
200213
deleteDataReadFromFile(pBinary);
201214
}
@@ -207,9 +220,10 @@ TEST_F(ProcessElfBinaryTests, BuildOptionsEmpty) {
207220
retrieveBinaryKernelFilename(filePath, "simple_kernels_", ".bin");
208221

209222
size_t binarySize = loadDataFromFile(filePath.c_str(), pBinary);
210-
cl_int retVal = processElfBinary(pBinary, binarySize, binaryVersion);
223+
cl_int retVal = program->processElfBinary(pBinary, binarySize, binaryVersion);
211224

212225
EXPECT_EQ(CL_SUCCESS, retVal);
226+
const auto &options = program->getOptions();
213227
size_t optionsSize = strlen(options.c_str()) + 1;
214228
EXPECT_EQ(0, memcmp("", options.c_str(), optionsSize));
215229
EXPECT_NE(0u, binaryVersion);
@@ -223,9 +237,10 @@ TEST_F(ProcessElfBinaryTests, BuildOptionsNotEmpty) {
223237
retrieveBinaryKernelFilename(filePath, "simple_kernels_opts_", ".bin");
224238

225239
size_t binarySize = loadDataFromFile(filePath.c_str(), pBinary);
226-
cl_int retVal = processElfBinary(pBinary, binarySize, binaryVersion);
240+
cl_int retVal = program->processElfBinary(pBinary, binarySize, binaryVersion);
227241

228242
EXPECT_EQ(CL_SUCCESS, retVal);
243+
const auto &options = program->getOptions();
229244
size_t optionsSize = strlen(options.c_str()) + 1;
230245
std::string buildOptionsNotEmpty = "-cl-opt-disable -DDEF_WAS_SPECIFIED=1";
231246
EXPECT_EQ(0, memcmp(buildOptionsNotEmpty.c_str(), options.c_str(), optionsSize));

0 commit comments

Comments
 (0)