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

Improve Program::create functions

Browse Source 
accept multiple devices in createFromGenBinary
remove redundant arguments
rename functions for creating built in program

Related-To: NEO-5001
Change-Id: Ic894fa3014d6eadce3747a6f7530e9848ae1f948
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2020-10-23 09:38:45 +02:00
committed by sys_ocldev
parent c50dc43f5b
commit 495594142c
16 changed files with 157 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
opencl/source/api/api.cpp
View File

@ -1308,12 +1308,13 @@ cl_program CL_API_CALL clCreateProgramWithSource(cl_context context,
"count", count,
"strings", strings,
"lengths", lengths);
retVal = validateObjects(context, count, strings);
Context *pContext = nullptr;
retVal = validateObjects(WithCastToInternal(context, &pContext), count, strings);
cl_program program = nullptr;
if (CL_SUCCESS == retVal) {
program = Program::create(
context,
pContext,
count,
strings,
lengths,

4
opencl/source/built_ins/builtins_dispatch_builder.cpp
View File

@ -799,10 +799,10 @@ std::unique_ptr<Program> BuiltinDispatchInfoBuilder::createProgramFromCode(const
break;
case BuiltinCode::ECodeType::Source:
case BuiltinCode::ECodeType::Intermediate:
ret.reset(Program::create(data, nullptr, deviceVector, true, &err));
ret.reset(Program::createBuiltInFromSource(data, nullptr, deviceVector, &err));
break;
case BuiltinCode::ECodeType::Binary:
ret.reset(Program::createFromGenBinary(*deviceVector[0]->getExecutionEnvironment(), nullptr, data, dataLen, true, nullptr, &deviceVector[0]->getDevice()));
ret.reset(Program::createBuiltInFromGenBinary(nullptr, deviceVector, data, dataLen, &err));
break;
}
return ret;

2
opencl/source/built_ins/vme_builtin.cpp
View File

@ -68,7 +68,7 @@ Program *Vme::createBuiltInProgram(
}
Program *pBuiltInProgram = nullptr;
pBuiltInProgram = Program::create(programSourceStr.c_str(), &context, deviceVector, true, nullptr);
pBuiltInProgram = Program::createBuiltInFromSource(programSourceStr.c_str(), &context, deviceVector, nullptr);
auto &device = *deviceVector[0];

12
opencl/source/context/context.cpp
View File

@ -385,13 +385,11 @@ SchedulerKernel &Context::getSchedulerKernel() {
auto device = &getDevice(0)->getDevice();
auto src = SchedulerKernel::loadSchedulerKernel(device);
auto program = Program::createFromGenBinary(*device->getExecutionEnvironment(),
this,
src.resource.data(),
src.resource.size(),
true,
&retVal,
device);
auto program = Program::createBuiltInFromGenBinary(this,
devices,
src.resource.data(),
src.resource.size(),
&retVal);
DEBUG_BREAK_IF(retVal != CL_SUCCESS);
DEBUG_BREAK_IF(!program);

6
opencl/source/program/create.cpp
View File

@ -16,8 +16,8 @@ CreateFromILFunc createFromIL = Program::createFromIL<Program>;
} // namespace ProgramFunctions
template Program *Program::create<Program>(Context *, const ClDeviceVector &, const size_t *, const unsigned char **, cl_int *, cl_int &);
template Program *Program::create<Program>(cl_context, cl_uint, const char **, const size_t *, cl_int &);
template Program *Program::create<Program>(const char *, Context *, const ClDeviceVector &, bool, cl_int *);
template Program *Program::create<Program>(Context *, cl_uint, const char **, const size_t *, cl_int &);
template Program *Program::createBuiltInFromSource<Program>(const char *, Context *, const ClDeviceVector &, cl_int *);
template Program *Program::createFromIL<Program>(Context *, const void *, size_t length, cl_int &);
template Program *Program::createFromGenBinary<Program>(ExecutionEnvironment &executionEnvironment, Context *context, const void *binary, size_t size, bool isBuiltIn, cl_int *errcodeRet, Device *device);
template Program *Program::createBuiltInFromGenBinary<Program>(Context *context, const ClDeviceVector &, const void *binary, size_t size, cl_int *errcodeRet);
} // namespace NEO

28
opencl/source/program/create.inl
View File

@ -56,7 +56,7 @@ T *Program::create(
template <typename T>
T *Program::create(
cl_context context,
Context *pContext,
cl_uint count,
const char **strings,
const size_t *lengths,
@ -64,8 +64,6 @@ T *Program::create(
std::string combinedString;
size_t combinedStringSize = 0;
T *program = nullptr;
auto pContext = castToObject<Context>(context);
DEBUG_BREAK_IF(!pContext);
auto retVal = createCombinedString(
combinedString,
@ -85,11 +83,10 @@ T *Program::create(
}
template <typename T>
T *Program::create(
T *Program::createBuiltInFromSource(
const char *nullTerminatedString,
Context *context,
const ClDeviceVector &deviceVector,
bool isBuiltIn,
cl_int *errcodeRet) {
cl_int retVal = CL_SUCCESS;
T *program = nullptr;
@ -99,7 +96,7 @@ T *Program::create(
}
if (retVal == CL_SUCCESS) {
program = new T(context, isBuiltIn, deviceVector);
program = new T(context, true, deviceVector);
program->sourceCode = nullTerminatedString;
program->createdFrom = CreatedFrom::SOURCE;
}
@ -112,14 +109,12 @@ T *Program::create(
}
template <typename T>
T *Program::createFromGenBinary(
ExecutionEnvironment &executionEnvironment,
T *Program::createBuiltInFromGenBinary(
Context *context,
const ClDeviceVector &deviceVector,
const void *binary,
size_t size,
bool isBuiltIn,
cl_int *errcodeRet,
Device *device) {
cl_int *errcodeRet) {
cl_int retVal = CL_SUCCESS;
T *program = nullptr;
@ -129,11 +124,12 @@ T *Program::createFromGenBinary(
if (CL_SUCCESS == retVal) {
ClDeviceVector deviceVector;
deviceVector.push_back(device->getSpecializedDevice<ClDevice>());
program = new T(context, isBuiltIn, deviceVector);
program->numDevices = 1;
program->replaceDeviceBinary(makeCopy(binary, size), size, device->getRootDeviceIndex());
program = new T(context, true, deviceVector);
for (const auto &device : deviceVector) {
if (program->buildInfos[device->getRootDeviceIndex()].packedDeviceBinarySize == 0) {
program->replaceDeviceBinary(makeCopy(binary, size), size, device->getRootDeviceIndex());
}
}
program->isCreatedFromBinary = true;
program->programBinaryType = CL_PROGRAM_BINARY_TYPE_EXECUTABLE;
program->buildStatus = CL_BUILD_SUCCESS;

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

@ -93,29 +93,26 @@ class Program : public BaseObject<_cl_program> {
// Create program from source
template <typename T = Program>
static T *create(
cl_context context,
Context *pContext,
cl_uint count,
const char **strings,
const size_t *lengths,
cl_int &errcodeRet);
template <typename T = Program>
static T *create(
static T *createBuiltInFromSource(
const char *nullTerminatedString,
Context *context,
const ClDeviceVector &deviceVector,
bool isBuiltIn,
cl_int *errcodeRet);
template <typename T = Program>
static T *createFromGenBinary(
ExecutionEnvironment &executionEnvironment,
static T *createBuiltInFromGenBinary(
Context *context,
const ClDeviceVector &deviceVector,
const void *binary,
size_t size,
bool isBuiltIn,
cl_int *errcodeRet,
Device *device);
cl_int *errcodeRet);
template <typename T = Program>
static T *createFromIL(Context *context,

96
opencl/test/unit_test/api/cl_get_program_info_tests.inl
View File

@ -407,4 +407,100 @@ TEST(clGetProgramInfoTest, GivenMultiDeviceProgramCreatedWithBuiltInKernelsWhenG
retVal = clReleaseProgram(pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST(clGetProgramInfoTest, GivenMultiDeviceBuiltInProgramCreatedWithGenBinaryWhenGettingDevicesThenCorrectDevicesAreReturned) {
MockUnrestrictiveContextMultiGPU context;
auto expectedNumDevices = context.getNumDevices();
auto devicesForProgram = std::make_unique<cl_device_id[]>(expectedNumDevices);
for (auto i = 0u; i < expectedNumDevices; i++) {
devicesForProgram[i] = context.getDevice(i);
}
std::unique_ptr<char[]> pBinary = nullptr;
size_t binarySize = 0;
std::string testFile;
retrieveBinaryKernelFilename(testFile, "CopyBuffer_simd16_", ".bin");
pBinary = loadDataFromFile(
testFile.c_str(),
binarySize);
ASSERT_NE(0u, binarySize);
ASSERT_NE(nullptr, pBinary);
cl_program pProgram = nullptr;
cl_int retVal = CL_INVALID_PROGRAM;
pProgram = Program::createBuiltInFromGenBinary(&context, context.getDevices(), pBinary.get(), binarySize, &retVal);
EXPECT_NE(nullptr, pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
verifyDevices(pProgram, expectedNumDevices, devicesForProgram.get());
retVal = clReleaseProgram(pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST(clGetProgramInfoTest, GivenMultiDeviceBuiltInProgramCreatedWithGenBinaryWhenGettingDevicesThenCorrectBinariesAreReturned) {
MockUnrestrictiveContextMultiGPU context;
auto expectedNumDevices = context.getNumDevices();
auto devicesForProgram = std::make_unique<cl_device_id[]>(expectedNumDevices);
for (auto i = 0u; i < expectedNumDevices; i++) {
devicesForProgram[i] = context.getDevice(i);
}
std::unique_ptr<char[]> pBinary = nullptr;
size_t binarySize = 0;
std::string testFile;
retrieveBinaryKernelFilename(testFile, "CopyBuffer_simd16_", ".bin");
pBinary = loadDataFromFile(
testFile.c_str(),
binarySize);
ASSERT_NE(0u, binarySize);
ASSERT_NE(nullptr, pBinary);
cl_program pProgram = nullptr;
cl_int retVal = CL_INVALID_PROGRAM;
pProgram = Program::createBuiltInFromGenBinary(&context, context.getDevices(), pBinary.get(), binarySize, &retVal);
EXPECT_NE(nullptr, pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
auto programBinarySizes = std::make_unique<size_t[]>(expectedNumDevices);
memset(programBinarySizes.get(), 0, expectedNumDevices * sizeof(size_t));
retVal = clGetProgramInfo(pProgram, CL_PROGRAM_BINARY_SIZES, expectedNumDevices * sizeof(size_t), programBinarySizes.get(), nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
for (auto i = 0u; i < expectedNumDevices; i++) {
EXPECT_EQ(binarySize, programBinarySizes[i]);
}
auto programBinaries = std::make_unique<unsigned char *[]>(expectedNumDevices);
auto binariesBuffer = std::make_unique<unsigned char[]>(expectedNumDevices * binarySize);
memset(binariesBuffer.get(), 0, expectedNumDevices * binarySize);
for (auto i = 0u; i < expectedNumDevices; i++) {
programBinaries[i] = ptrOffset(binariesBuffer.get(), i * binarySize);
}
retVal = clGetProgramInfo(pProgram, CL_PROGRAM_BINARIES, expectedNumDevices * sizeof(unsigned char *), programBinaries.get(), nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
for (auto i = 0u; i < expectedNumDevices; i++) {
EXPECT_EQ(0, memcmp(programBinaries[i], pBinary.get(), binarySize));
}
retVal = clReleaseProgram(pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
}
} // namespace ULT

3
opencl/test/unit_test/built_ins/built_in_tests.cpp
View File

@ -2007,8 +2007,7 @@ TEST_F(BuiltInTests, WhenGettingSipKernelThenReturnProgramCreatedFromIsaAcquired
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, pDevice);
auto p = Program::createBuiltInFromGenBinary(pContext, pContext->getDevices(), mockCompilerInterface->sipKernelBinaryOverride.data(), mockCompilerInterface->sipKernelBinaryOverride.size(), &errCode);
ASSERT_EQ(CL_SUCCESS, errCode);
errCode = p->processGenBinary(rootDeviceIndex);
ASSERT_EQ(CL_SUCCESS, errCode);

4
opencl/test/unit_test/command_queue/enqueue_svm_tests.cpp
View File

@ -736,7 +736,7 @@ TEST_F(EnqueueSvmTest, GivenSvmAllocationWhenEnqueingKernelThenSuccessIsReturned
GraphicsAllocation *pSvmAlloc = svmData->gpuAllocations.getGraphicsAllocation(context->getDevice(0)->getRootDeviceIndex());
EXPECT_NE(nullptr, ptrSVM);
std::unique_ptr<Program> program(Program::create("FillBufferBytes", context, context->getDevices(), true, &retVal));
std::unique_ptr<Program> program(Program::createBuiltInFromSource("FillBufferBytes", context, context->getDevices(), &retVal));
cl_device_id device = pClDevice;
program->build(1, &device, nullptr, nullptr, nullptr, false);
std::unique_ptr<MockKernel> kernel(Kernel::create<MockKernel>(program.get(), *program->getKernelInfo("FillBufferBytes"), &retVal));
@ -765,7 +765,7 @@ TEST_F(EnqueueSvmTest, givenEnqueueTaskBlockedOnUserEventWhenItIsEnqueuedThenSur
GraphicsAllocation *pSvmAlloc = svmData->gpuAllocations.getGraphicsAllocation(context->getDevice(0)->getRootDeviceIndex());
EXPECT_NE(nullptr, ptrSVM);
auto program = clUniquePtr(Program::create("FillBufferBytes", context, context->getDevices(), true, &retVal));
auto program = clUniquePtr(Program::createBuiltInFromSource("FillBufferBytes", context, context->getDevices(), &retVal));
cl_device_id device = pClDevice;
program->build(1, &device, nullptr, nullptr, nullptr, false);
auto kernel = clUniquePtr(Kernel::create<MockKernel>(program.get(), *program->getKernelInfo("FillBufferBytes"), &retVal));

2
opencl/test/unit_test/command_queue/get_size_required_image_tests.cpp
View File

@ -115,7 +115,7 @@ HWTEST_F(GetSizeRequiredImageTest, WhenCopyingReadWriteImageThenHeapsAndCommandB
auto usedBeforeIOH = ioh.getUsed();
auto usedBeforeSSH = ssh.getUsed();
std::unique_ptr<Program> program(Program::create("CopyImageToImage3d", context, context->getDevices(), true, nullptr));
std::unique_ptr<Program> program(Program::createBuiltInFromSource("CopyImageToImage3d", context, context->getDevices(), nullptr));
cl_device_id device = pClDevice;
program->build(1, &device, nullptr, nullptr, nullptr, false);
std::unique_ptr<Kernel> kernel(Kernel::create<MockKernel>(program.get(), *program->getKernelInfo("CopyImageToImage3d"), nullptr));

4
opencl/test/unit_test/fixtures/program_fixture.cpp
View File

@ -11,7 +11,7 @@
#include "opencl/test/unit_test/mocks/mock_program.h"
namespace NEO {
void ProgramFixture::CreateProgramWithSource(cl_context context,
void ProgramFixture::CreateProgramWithSource(Context *pContext,
cl_device_id *deviceList,
const std::string &sourceFileName) {
Cleanup();
@ -31,7 +31,7 @@ void ProgramFixture::CreateProgramWithSource(cl_context context,
const char *sources[1] = {knownSource.get()};
pProgram = Program::create<MockProgram>(
context,
pContext,
1,
sources,
&knownSourceSize,

2
opencl/test/unit_test/fixtures/program_fixture.h
View File

@ -29,7 +29,7 @@ class ProgramFixture {
const std::string &binaryFileName,
const std::string &options = "");
void CreateProgramWithSource(cl_context pContext,
void CreateProgramWithSource(Context *pContext,
cl_device_id *pDeviceList,
const std::string &sourceFileName);

6
opencl/test/unit_test/gtpin/gtpin_tests.cpp
View File

@ -1013,7 +1013,7 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenKernelWithoutSSHIsUsedThenK
char binary[1024] = {1, 2, 3, 4, 5, 6, 7, 8, 9, '\0'};
size_t binSize = 10;
MockProgram *pProgram = Program::createFromGenBinary<MockProgram>(*pDevice->getExecutionEnvironment(), pContext, &binary[0], binSize, false, &retVal, &pDevice->getDevice());
MockProgram *pProgram = Program::createBuiltInFromGenBinary<MockProgram>(pContext, pContext->getDevices(), &binary[0], binSize, &retVal);
ASSERT_NE(nullptr, pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -1073,7 +1073,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, GTPinTests, givenInitializedGTPinInterfaceWhenKernel
// Prepare a kernel with fake Execution Environment
char binary[1024] = {1, 2, 3, 4, 5, 6, 7, 8, 9, '\0'};
size_t binSize = 10;
MockProgram *pProgram = Program::createFromGenBinary<MockProgram>(*pDevice->getExecutionEnvironment(), pContext, &binary[0], binSize, false, &retVal, &pDevice->getDevice());
MockProgram *pProgram = Program::createBuiltInFromGenBinary<MockProgram>(pContext, pContext->getDevices(), &binary[0], binSize, &retVal);
ASSERT_NE(nullptr, pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -2096,7 +2096,7 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenLowMemoryConditionOccursThe
char binary[1024] = {1, 2, 3, 4, 5, 6, 7, 8, 9, '\0'};
size_t binSize = 10;
MockProgram *pProgram = Program::createFromGenBinary<MockProgram>(*pDevice->getExecutionEnvironment(), pContext, &binary[0], binSize, false, &retVal, &pDevice->getDevice());
MockProgram *pProgram = Program::createBuiltInFromGenBinary<MockProgram>(pContext, pContext->getDevices(), &binary[0], binSize, &retVal);
ASSERT_NE(nullptr, pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);

2
opencl/test/unit_test/kernel/kernel_is_patched_tests.cpp
View File

@ -20,7 +20,7 @@ class PatchedKernelTest : public ::testing::Test {
void SetUp() override {
device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
context.reset(new MockContext(device.get()));
program.reset(Program::create("FillBufferBytes", context.get(), context->getDevices(), true, &retVal));
program.reset(Program::createBuiltInFromSource("FillBufferBytes", context.get(), context->getDevices(), &retVal));
EXPECT_EQ(CL_SUCCESS, retVal);
cl_device_id clDevice = device.get();
program->build(1, &clDevice, nullptr, nullptr, nullptr, false);

52
opencl/test/unit_test/program/program_tests.cpp
View File

@ -1646,7 +1646,7 @@ TEST(ProgramFromBinaryTests, givenBinaryWithInvalidICBEThenErrorIsReturned) {
{
// whatever method we choose CL_INVALID_BINARY is always returned
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr, mockRootDeviceIndex));
std::unique_ptr<Program> pProgram(Program::createFromGenBinary(*device->getExecutionEnvironment(), nullptr, &binHeader, binSize, false, &retVal, &device->getDevice()));
std::unique_ptr<Program> pProgram(Program::createBuiltInFromGenBinary(nullptr, toClDeviceVector(*device), &binHeader, binSize, &retVal));
ASSERT_NE(nullptr, pProgram.get());
EXPECT_EQ(CL_SUCCESS, retVal);
@ -1670,7 +1670,7 @@ TEST(ProgramFromBinaryTests, givenEmptyProgramThenErrorIsReturned) {
size_t binSize = sizeof(SProgramBinaryHeader);
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr, mockRootDeviceIndex));
std::unique_ptr<MockProgram> pProgram(MockProgram::createFromGenBinary<MockProgram>(*device->getExecutionEnvironment(), nullptr, &binHeader, binSize, false, &retVal, &device->getDevice()));
std::unique_ptr<MockProgram> pProgram(MockProgram::createBuiltInFromGenBinary<MockProgram>(nullptr, toClDeviceVector(*device), &binHeader, binSize, &retVal));
ASSERT_NE(nullptr, pProgram.get());
EXPECT_EQ(CL_SUCCESS, retVal);
@ -1841,7 +1841,7 @@ TEST_F(ProgramTests, Given32bitSupportWhenProgramIsCreatedThenGreaterThan4gbBuff
auto defaultSetting = DebugManager.flags.DisableStatelessToStatefulOptimization.get();
DebugManager.flags.DisableStatelessToStatefulOptimization.set(false);
std::unique_ptr<MockProgram> program{Program::create<MockProgram>("", pContext, pContext->getDevices(), true, nullptr)};
std::unique_ptr<MockProgram> program{Program::createBuiltInFromSource<MockProgram>("", pContext, pContext->getDevices(), nullptr)};
if ((false == pDevice->areSharedSystemAllocationsAllowed()) && (false == is32bit)) {
EXPECT_FALSE(CompilerOptions::contains(program->getInternalOptions(), NEO::CompilerOptions::greaterThan4gbBuffersRequired)) << program->getInternalOptions();
} else {
@ -1854,13 +1854,13 @@ TEST_F(ProgramTests, GivenStatelessToStatefulIsDisabledWhenProgramIsCreatedThenG
auto defaultSetting = DebugManager.flags.DisableStatelessToStatefulOptimization.get();
DebugManager.flags.DisableStatelessToStatefulOptimization.set(true);
std::unique_ptr<MockProgram> program{Program::create<MockProgram>("", pContext, pContext->getDevices(), true, nullptr)};
std::unique_ptr<MockProgram> program{Program::createBuiltInFromSource<MockProgram>("", pContext, pContext->getDevices(), nullptr)};
EXPECT_TRUE(CompilerOptions::contains(program->getInternalOptions(), NEO::CompilerOptions::greaterThan4gbBuffersRequired)) << program->getInternalOptions();
DebugManager.flags.DisableStatelessToStatefulOptimization.set(defaultSetting);
}
TEST_F(ProgramTests, givenProgramWhenItIsCompiledThenItAlwaysHavePreserveVec3TypeInternalOptionSet) {
std::unique_ptr<MockProgram> program(Program::create<MockProgram>("", pContext, pContext->getDevices(), true, nullptr));
std::unique_ptr<MockProgram> program(Program::createBuiltInFromSource<MockProgram>("", pContext, pContext->getDevices(), nullptr));
EXPECT_TRUE(CompilerOptions::contains(program->getInternalOptions(), CompilerOptions::preserveVec3Type)) << program->getInternalOptions();
}
@ -1869,7 +1869,7 @@ TEST_F(ProgramTests, Force32BitAddressessWhenProgramIsCreatedThenGreaterThan4gbB
DebugManager.flags.DisableStatelessToStatefulOptimization.set(false);
const_cast<DeviceInfo *>(&pDevice->getDeviceInfo())->force32BitAddressess = true;
std::unique_ptr<MockProgram> program{Program::create<MockProgram>("", pContext, pContext->getDevices(), true, nullptr)};
std::unique_ptr<MockProgram> program{Program::createBuiltInFromSource<MockProgram>("", pContext, pContext->getDevices(), nullptr)};
if (is32bit) {
EXPECT_TRUE(CompilerOptions::contains(program->getInternalOptions(), CompilerOptions::greaterThan4gbBuffersRequired)) << program->getInternalOptions();
} else {
@ -1924,9 +1924,9 @@ TEST_F(ProgramTests, GivenContextWhenCreateProgramFromSourceThenIncrementContext
auto initialApiRefCount = pContext->getReference();
auto initialInternalRefCount = pContext->getRefInternalCount();
auto tempProgram = Program::create("", nullptr, pContext->getDevices(), false, nullptr);
auto tempProgram = new Program(nullptr, false, pContext->getDevices());
EXPECT_FALSE(tempProgram->getIsBuiltIn());
auto program = Program::create("", pContext, pContext->getDevices(), false, nullptr);
auto program = new Program(pContext, false, pContext->getDevices());
EXPECT_FALSE(program->getIsBuiltIn());
EXPECT_EQ(pContext->getReference(), initialApiRefCount);
@ -1943,9 +1943,9 @@ TEST_F(ProgramTests, GivenContextWhenCreateBuiltInProgramFromSourceThenDontIncre
auto initialApiRefCount = pContext->getReference();
auto initialInternalRefCount = pContext->getRefInternalCount();
auto tempProgram = Program::create("", nullptr, pContext->getDevices(), true, nullptr);
auto tempProgram = new Program(nullptr, true, pContext->getDevices());
EXPECT_TRUE(tempProgram->getIsBuiltIn());
auto program = Program::create("", pContext, pContext->getDevices(), true, nullptr);
auto program = new Program(pContext, true, pContext->getDevices());
EXPECT_TRUE(program->getIsBuiltIn());
EXPECT_EQ(pContext->getReference(), initialApiRefCount);
@ -1960,19 +1960,19 @@ TEST_F(ProgramTests, GivenContextWhenCreateBuiltInProgramFromSourceThenDontIncre
TEST_F(ProgramTests, WhenBuildingProgramThenPointerToProgramIsReturned) {
cl_int retVal = CL_DEVICE_NOT_FOUND;
Program *pProgram = Program::create("", pContext, pContext->getDevices(), false, &retVal);
Program *pProgram = Program::createBuiltInFromSource("", pContext, pContext->getDevices(), &retVal);
EXPECT_NE(nullptr, pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
delete pProgram;
pProgram = Program::create("", pContext, pContext->getDevices(), false, nullptr);
pProgram = Program::createBuiltInFromSource("", pContext, pContext->getDevices(), nullptr);
EXPECT_NE(nullptr, pProgram);
delete pProgram;
}
TEST_F(ProgramTests, GivenNullBinaryWhenCreatingProgramFromGenBinaryThenInvalidValueErrorIsReturned) {
cl_int retVal = CL_SUCCESS;
Program *pProgram = Program::createFromGenBinary(*pDevice->getExecutionEnvironment(), pContext, nullptr, 0, false, &retVal, pDevice);
Program *pProgram = Program::createBuiltInFromGenBinary(pContext, pContext->getDevices(), nullptr, 0, &retVal);
EXPECT_EQ(nullptr, pProgram);
EXPECT_NE(CL_SUCCESS, retVal);
}
@ -1982,12 +1982,12 @@ TEST_F(ProgramTests, WhenCreatingProgramFromGenBinaryThenSuccessIsReturned) {
char binary[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, '\0'};
size_t size = 10;
Program *pProgram = Program::createFromGenBinary(*pDevice->getExecutionEnvironment(), pContext, binary, size, false, &retVal, pDevice);
Program *pProgram = Program::createBuiltInFromGenBinary(pContext, pContext->getDevices(), binary, size, &retVal);
EXPECT_NE(nullptr, pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ((uint32_t)CL_PROGRAM_BINARY_TYPE_EXECUTABLE, (uint32_t)pProgram->getProgramBinaryType());
EXPECT_FALSE(pProgram->getIsBuiltIn());
EXPECT_TRUE(pProgram->getIsBuiltIn());
cl_device_id deviceId = pContext->getDevice(0);
cl_build_status status = 0;
@ -1998,25 +1998,11 @@ TEST_F(ProgramTests, WhenCreatingProgramFromGenBinaryThenSuccessIsReturned) {
delete pProgram;
}
TEST_F(ProgramTests, GivenBuiltInFlagSetWhenCreatingProgramFromGenBinaryThenBuiltInIsCreated) {
cl_int retVal = CL_INVALID_BINARY;
char binary[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, '\0'};
size_t size = 10;
Program *pProgram = Program::createFromGenBinary(*pDevice->getExecutionEnvironment(), pContext, binary, size, true, &retVal, pDevice);
EXPECT_NE(nullptr, pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_TRUE(pProgram->getIsBuiltIn());
delete pProgram;
}
TEST_F(ProgramTests, GivenRetValNullPointerWhenCreatingProgramFromGenBinaryThenSuccessIsReturned) {
char binary[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, '\0'};
size_t size = 10;
Program *pProgram = Program::createFromGenBinary(*pDevice->getExecutionEnvironment(), pContext, binary, size, false, nullptr, pDevice);
Program *pProgram = Program::createBuiltInFromGenBinary(pContext, pContext->getDevices(), binary, size, nullptr);
EXPECT_NE(nullptr, pProgram);
EXPECT_EQ((uint32_t)CL_PROGRAM_BINARY_TYPE_EXECUTABLE, (uint32_t)pProgram->getProgramBinaryType());
@ -2034,7 +2020,7 @@ TEST_F(ProgramTests, GivenNullContextWhenCreatingProgramFromGenBinaryThenSuccess
char binary[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, '\0'};
size_t size = 10;
Program *pProgram = Program::createFromGenBinary(*pDevice->getExecutionEnvironment(), nullptr, binary, size, false, &retVal, pDevice);
Program *pProgram = Program::createBuiltInFromGenBinary(nullptr, toClDeviceVector(*pClDevice), binary, size, &retVal);
EXPECT_NE(nullptr, pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ((uint32_t)CL_PROGRAM_BINARY_TYPE_EXECUTABLE, (uint32_t)pProgram->getProgramBinaryType());
@ -2745,7 +2731,7 @@ TEST(CreateProgramFromBinaryTests, givenBinaryProgramWhenKernelRebulildIsForcedT
PatchTokensTestData::ValidEmptyProgram programTokens;
auto clDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
std::unique_ptr<MockProgram> pProgram(Program::createFromGenBinary<MockProgram>(*clDevice->getExecutionEnvironment(), nullptr, programTokens.storage.data(), programTokens.storage.size(), false, &retVal, &clDevice->getDevice()));
std::unique_ptr<MockProgram> pProgram(Program::createBuiltInFromGenBinary<MockProgram>(nullptr, toClDeviceVector(*clDevice), programTokens.storage.data(), programTokens.storage.size(), &retVal));
pProgram->pDevice = &clDevice->getDevice();
ASSERT_NE(nullptr, pProgram.get());
EXPECT_EQ(CL_SUCCESS, retVal);
@ -2765,7 +2751,7 @@ TEST(CreateProgramFromBinaryTests, givenBinaryProgramWhenKernelRebulildIsNotForc
PatchTokensTestData::ValidEmptyProgram programTokens;
auto clDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
std::unique_ptr<MockProgram> pProgram(Program::createFromGenBinary<MockProgram>(*clDevice->getExecutionEnvironment(), nullptr, programTokens.storage.data(), programTokens.storage.size(), false, &retVal, &clDevice->getDevice()));
std::unique_ptr<MockProgram> pProgram(Program::createBuiltInFromGenBinary<MockProgram>(nullptr, toClDeviceVector(*clDevice), programTokens.storage.data(), programTokens.storage.size(), &retVal));
pProgram->pDevice = &clDevice->getDevice();
ASSERT_NE(nullptr, pProgram.get());
EXPECT_EQ(CL_SUCCESS, retVal);