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

Decrease number of classes deriving from Program 3/n

Browse Source 
Change-Id: Id5211d4acb46d770dd57b91896af81427d370e0c
Signed-off-by: Maciej Dziuban <maciej.dziuban@intel.com>
This commit is contained in:
Maciej Dziuban
2018-08-06 18:12:20 +02:00
committed by sys_ocldev
parent f0e53d5cf1
commit acc0ec539f
2 changed files with 71 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
unit_tests/mocks/mock_program.h
View File

@ -41,6 +41,17 @@ class MockProgram : public Program {
using Program::getProgramCompilerVersion;
using Program::isKernelDebugEnabled;
using Program::rebuildProgramFromIr;
using Program::resolveProgramBinary;
using Program::elfBinary;
using Program::elfBinarySize;
using Program::genBinary;
using Program::genBinarySize;
using Program::irBinary;
using Program::irBinarySize;
using Program::isProgramBinaryResolved;
using Program::isSpirV;
using Program::programBinaryType;
using Program::sourceCode;

105
unit_tests/program/process_elf_binary_tests.cpp
View File

@ -24,22 +24,28 @@
#include "runtime/program/program.h"
#include "runtime/helpers/string.h"
#include "unit_tests/helpers/test_files.h"
#include "unit_tests/mocks/mock_program.h"
#include "gtest/gtest.h"
#include <cstring>
using namespace OCLRT;
class ProcessElfBinaryTests : public Program,
public ::testing::Test {
class ProcessElfBinaryTests : public ::testing::Test {
public:
void SetUp() override {
program = std::make_unique<MockProgram>();
}
std::unique_ptr<MockProgram> program;
};
TEST_F(ProcessElfBinaryTests, NullBinary) {
uint32_t binaryVersion;
cl_int retVal = processElfBinary(nullptr, 0, binaryVersion);
cl_int retVal = program->processElfBinary(nullptr, 0, binaryVersion);
EXPECT_EQ(CL_INVALID_BINARY, retVal);
EXPECT_TRUE(elfBinary.empty());
EXPECT_EQ(0u, elfBinarySize);
EXPECT_TRUE(program->elfBinary.empty());
EXPECT_EQ(0u, program->elfBinarySize);
EXPECT_NE(0u, binaryVersion);
}
@ -47,11 +53,11 @@ TEST_F(ProcessElfBinaryTests, InvalidBinary) {
uint32_t binaryVersion;
char pBinary[] = "thisistotallyinvalid\0";
size_t binarySize = strnlen_s(pBinary, 21);
cl_int retVal = processElfBinary(pBinary, binarySize, binaryVersion);
cl_int retVal = program->processElfBinary(pBinary, binarySize, binaryVersion);
EXPECT_EQ(CL_INVALID_BINARY, retVal);
EXPECT_TRUE(elfBinary.empty());
EXPECT_EQ(0u, elfBinarySize);
EXPECT_TRUE(program->elfBinary.empty());
EXPECT_EQ(0u, program->elfBinarySize);
EXPECT_NE(0u, binaryVersion);
}
@ -62,10 +68,10 @@ TEST_F(ProcessElfBinaryTests, ValidBinary) {
retrieveBinaryKernelFilename(filePath, "CopyBuffer_simd8_", ".bin");
size_t binarySize = loadDataFromFile(filePath.c_str(), pBinary);
cl_int retVal = processElfBinary(pBinary, binarySize, binaryVersion);
cl_int retVal = program->processElfBinary(pBinary, binarySize, binaryVersion);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0, memcmp(pBinary, elfBinary.data(), binarySize));
EXPECT_EQ(0, memcmp(pBinary, program->elfBinary.data(), binarySize));
EXPECT_NE(0u, binaryVersion);
deleteDataReadFromFile(pBinary);
}
@ -74,30 +80,31 @@ TEST_F(ProcessElfBinaryTests, ValidSpirvBinary) {
//clCreateProgramWithIL => SPIR-V stored as source code
const uint32_t spirvBinary[2] = {0x03022307, 0x07230203};
size_t spirvBinarySize = sizeof(spirvBinary);
isSpirV = Program::isValidSpirvBinary(spirvBinary, spirvBinarySize);
auto isSpirV = Program::isValidSpirvBinary(spirvBinary, spirvBinarySize);
EXPECT_TRUE(isSpirV);
//clCompileProgram => SPIR-V stored as IR binary
storeIrBinary(spirvBinary, spirvBinarySize, true);
programBinaryType = CL_PROGRAM_BINARY_TYPE_LIBRARY;
EXPECT_NE(nullptr, irBinary);
EXPECT_NE(0u, irBinarySize);
EXPECT_TRUE(isSpirV);
program->isSpirV = true;
program->storeIrBinary(spirvBinary, spirvBinarySize, true);
program->programBinaryType = CL_PROGRAM_BINARY_TYPE_LIBRARY;
EXPECT_NE(nullptr, program->irBinary);
EXPECT_NE(0u, program->irBinarySize);
EXPECT_TRUE(program->getIsSpirV());
//clGetProgramInfo => SPIR-V stored as ELF binary
cl_int retVal = resolveProgramBinary();
cl_int retVal = program->resolveProgramBinary();
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_FALSE(elfBinary.empty());
EXPECT_NE(0u, elfBinarySize);
EXPECT_FALSE(program->elfBinary.empty());
EXPECT_NE(0u, program->elfBinarySize);
//use ELF reader to parse and validate ELF binary
CLElfLib::CElfReader *pElfReader = CLElfLib::CElfReader::create(
reinterpret_cast<const char *>(elfBinary.data()), elfBinarySize);
reinterpret_cast<const char *>(program->elfBinary.data()), program->elfBinarySize);
ASSERT_NE(nullptr, pElfReader);
const CLElfLib::SElf64Header *pElfHeader = pElfReader->getElfHeader();
ASSERT_NE(nullptr, pElfHeader);
EXPECT_EQ(pElfHeader->Type, CLElfLib::E_EH_TYPE::EH_TYPE_OPENCL_LIBRARY);
EXPECT_TRUE(CLElfLib::CElfReader::isValidElf64(elfBinary.data(), elfBinarySize));
EXPECT_TRUE(CLElfLib::CElfReader::isValidElf64(program->elfBinary.data(), program->elfBinarySize));
//check if ELF binary contains section SH_TYPE_SPIRV
bool hasSpirvSection = false;
@ -112,13 +119,13 @@ TEST_F(ProcessElfBinaryTests, ValidSpirvBinary) {
EXPECT_TRUE(hasSpirvSection);
//clCreateProgramWithBinary => new program should recognize SPIR-V binary
isSpirV = false;
program->isSpirV = false;
uint32_t elfBinaryVersion;
auto pElfBinary = std::unique_ptr<char>(new char[elfBinarySize]);
memcpy_s(pElfBinary.get(), elfBinarySize, elfBinary.data(), elfBinarySize);
retVal = processElfBinary(pElfBinary.get(), elfBinarySize, elfBinaryVersion);
auto pElfBinary = std::unique_ptr<char>(new char[program->elfBinarySize]);
memcpy_s(pElfBinary.get(), program->elfBinarySize, program->elfBinary.data(), program->elfBinarySize);
retVal = program->processElfBinary(pElfBinary.get(), program->elfBinarySize, elfBinaryVersion);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_TRUE(isSpirV);
EXPECT_TRUE(program->getIsSpirV());
CLElfLib::CElfReader::destroy(pElfReader);
}
@ -128,8 +135,13 @@ unsigned int BinaryTypeValues[] = {
CL_PROGRAM_BINARY_TYPE_LIBRARY,
CL_PROGRAM_BINARY_TYPE_COMPILED_OBJECT};
class ProcessElfBinaryTestsWithBinaryType : public Program,
public ::testing::TestWithParam<unsigned int> {
class ProcessElfBinaryTestsWithBinaryType : public ::testing::TestWithParam<unsigned int> {
public:
void SetUp() override {
program = std::make_unique<MockProgram>();
}
std::unique_ptr<MockProgram> program;
};
TEST_P(ProcessElfBinaryTestsWithBinaryType, GivenBinaryTypeWhenResolveProgramThenProgramIsProperlyResolved) {
@ -139,28 +151,29 @@ TEST_P(ProcessElfBinaryTestsWithBinaryType, GivenBinaryTypeWhenResolveProgramThe
retrieveBinaryKernelFilename(filePath, "CopyBuffer_simd8_", ".bin");
size_t binarySize = loadDataFromFile(filePath.c_str(), pBinary);
cl_int retVal = processElfBinary(pBinary, binarySize, binaryVersion);
cl_int retVal = program->processElfBinary(pBinary, binarySize, binaryVersion);
const auto &options = program->getOptions();
size_t optionsSize = strlen(options.c_str()) + 1;
auto pTmpGenBinary = new char[genBinarySize];
auto pTmpIrBinary = new char[irBinarySize];
auto pTmpGenBinary = new char[program->genBinarySize];
auto pTmpIrBinary = new char[program->irBinarySize];
auto pTmpOptions = new char[optionsSize];
memcpy_s(pTmpGenBinary, genBinarySize, genBinary, genBinarySize);
memcpy_s(pTmpIrBinary, irBinarySize, irBinary, irBinarySize);
memcpy_s(pTmpGenBinary, program->genBinarySize, program->genBinary, program->genBinarySize);
memcpy_s(pTmpIrBinary, program->irBinarySize, program->irBinary, program->irBinarySize);
memcpy_s(pTmpOptions, optionsSize, options.c_str(), optionsSize);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0, memcmp(pBinary, elfBinary.data(), binarySize));
EXPECT_EQ(0, memcmp(pBinary, program->elfBinary.data(), binarySize));
EXPECT_NE(0u, binaryVersion);
// delete program's elf reference to force a resolve
isProgramBinaryResolved = false;
programBinaryType = GetParam();
retVal = resolveProgramBinary();
program->isProgramBinaryResolved = false;
program->programBinaryType = GetParam();
retVal = program->resolveProgramBinary();
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0, memcmp(pTmpGenBinary, genBinary, genBinarySize));
EXPECT_EQ(0, memcmp(pTmpIrBinary, irBinary, irBinarySize));
EXPECT_EQ(0, memcmp(pTmpGenBinary, program->genBinary, program->genBinarySize));
EXPECT_EQ(0, memcmp(pTmpIrBinary, program->irBinary, program->irBinarySize));
EXPECT_EQ(0, memcmp(pTmpOptions, options.c_str(), optionsSize));
delete[] pTmpGenBinary;
@ -181,10 +194,10 @@ TEST_F(ProcessElfBinaryTests, BackToBack) {
retrieveBinaryKernelFilename(filePath, "CopyBuffer_simd8_", ".bin");
size_t binarySize = loadDataFromFile(filePath.c_str(), pBinary);
cl_int retVal = processElfBinary(pBinary, binarySize, binaryVersion);
cl_int retVal = program->processElfBinary(pBinary, binarySize, binaryVersion);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0, memcmp(pBinary, elfBinary.data(), binarySize));
EXPECT_EQ(0, memcmp(pBinary, program->elfBinary.data(), binarySize));
EXPECT_NE(0u, binaryVersion);
deleteDataReadFromFile(pBinary);
@ -192,10 +205,10 @@ TEST_F(ProcessElfBinaryTests, BackToBack) {
retrieveBinaryKernelFilename(filePath2, "simple_arg_int_", ".bin");
binarySize = loadDataFromFile(filePath2.c_str(), pBinary);
retVal = processElfBinary(pBinary, binarySize, binaryVersion);
retVal = program->processElfBinary(pBinary, binarySize, binaryVersion);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0, memcmp(pBinary, elfBinary.data(), binarySize));
EXPECT_EQ(0, memcmp(pBinary, program->elfBinary.data(), binarySize));
EXPECT_NE(0u, binaryVersion);
deleteDataReadFromFile(pBinary);
}
@ -207,9 +220,10 @@ TEST_F(ProcessElfBinaryTests, BuildOptionsEmpty) {
retrieveBinaryKernelFilename(filePath, "simple_kernels_", ".bin");
size_t binarySize = loadDataFromFile(filePath.c_str(), pBinary);
cl_int retVal = processElfBinary(pBinary, binarySize, binaryVersion);
cl_int retVal = program->processElfBinary(pBinary, binarySize, binaryVersion);
EXPECT_EQ(CL_SUCCESS, retVal);
const auto &options = program->getOptions();
size_t optionsSize = strlen(options.c_str()) + 1;
EXPECT_EQ(0, memcmp("", options.c_str(), optionsSize));
EXPECT_NE(0u, binaryVersion);
@ -223,9 +237,10 @@ TEST_F(ProcessElfBinaryTests, BuildOptionsNotEmpty) {
retrieveBinaryKernelFilename(filePath, "simple_kernels_opts_", ".bin");
size_t binarySize = loadDataFromFile(filePath.c_str(), pBinary);
cl_int retVal = processElfBinary(pBinary, binarySize, binaryVersion);
cl_int retVal = program->processElfBinary(pBinary, binarySize, binaryVersion);
EXPECT_EQ(CL_SUCCESS, retVal);
const auto &options = program->getOptions();
size_t optionsSize = strlen(options.c_str()) + 1;
std::string buildOptionsNotEmpty = "-cl-opt-disable -DDEF_WAS_SPECIFIED=1";
EXPECT_EQ(0, memcmp(buildOptionsNotEmpty.c_str(), options.c_str(), optionsSize));