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

Correct clCreateProgramWithBinary

Browse Source 
store proper devices
validate input devices, lengths and binary
return correct binaries

Related-To: NEO-5001
Change-Id: I3822c291a4430e64afe54f1486b0014f16de3d64
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2020-10-21 10:25:03 +02:00
committed by sys_ocldev
parent 4c2d92890f
commit 8afdb2d981
18 changed files with 383 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1344,16 +1344,32 @@ cl_program CL_API_CALL clCreateProgramWithBinary(cl_context context,
"lengths", lengths,
"binaries", binaries,
"binaryStatus", binaryStatus);
retVal = validateObjects(context, deviceList, *deviceList, binaries, *binaries, lengths, *lengths);
Context *pContext = nullptr;
retVal = validateObjects(WithCastToInternal(context, &pContext), deviceList, numDevices, binaries, lengths);
cl_program program = nullptr;
ClDeviceVector deviceVector;
if (retVal == CL_SUCCESS) {
for (auto i = 0u; i < numDevices; i++) {
auto device = castToObject<ClDevice>(deviceList[i]);
if (!device || !pContext->isDeviceAssociated(*device)) {
retVal = CL_INVALID_DEVICE;
break;
}
if (lengths[i] == 0 || binaries[i] == nullptr) {
retVal = CL_INVALID_VALUE;
break;
}
deviceVector.push_back(device);
}
}
NEO::FileLoggerInstance().dumpBinaryProgram(numDevices, lengths, binaries);
if (CL_SUCCESS == retVal) {
program = Program::create(
context,
numDevices,
deviceList,
pContext,
deviceVector,
lengths,
binaries,
binaryStatus,

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

@ -15,7 +15,7 @@ namespace ProgramFunctions {
CreateFromILFunc createFromIL = Program::createFromIL<Program>;
} // namespace ProgramFunctions
template Program *Program::create<Program>(cl_context, cl_uint, const cl_device_id *, const size_t *, const unsigned char **, cl_int *, cl_int &);
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 *, ClDevice &, bool, cl_int *);
template Program *Program::create<Program>(const char *, Context *, Device &, bool, cl_int *);

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

@ -21,23 +21,23 @@ namespace NEO {
template <typename T>
T *Program::create(
cl_context context,
cl_uint numDevices,
const cl_device_id *deviceList,
Context *pContext,
const ClDeviceVector &deviceVector,
const size_t *lengths,
const unsigned char **binaries,
cl_int *binaryStatus,
cl_int &errcodeRet) {
auto pContext = castToObject<Context>(context);
DEBUG_BREAK_IF(!pContext);
auto device = pContext->getDevice(0);
ClDeviceVector deviceVector;
deviceVector.push_back(device);
auto program = new T(pContext, false, deviceVector);
auto retVal = program->createProgramFromBinary(binaries[0], lengths[0], device->getRootDeviceIndex());
cl_int retVal = CL_INVALID_PROGRAM;
for (auto i = 0u; i < deviceVector.size(); i++) {
auto device = deviceVector[i];
retVal = program->createProgramFromBinary(binaries[i], lengths[i], device->getRootDeviceIndex());
if (retVal != CL_SUCCESS) {
break;
}
}
program->createdFrom = CreatedFrom::BINARY;
if (binaryStatus) {

40
opencl/source/program/get_info.cpp
View File

@ -31,8 +31,8 @@ cl_int Program::getInfo(cl_program_info paramName, size_t paramValueSize,
size_t numKernels;
cl_context clContext = context;
cl_uint clFalse = CL_FALSE;
auto rootDeviceIndex = pDevice->getRootDeviceIndex();
std::vector<cl_device_id> devicesToExpose;
StackVec<size_t, 1> binarySizes;
switch (paramName) {
case CL_PROGRAM_CONTEXT:
@ -40,25 +40,39 @@ cl_int Program::getInfo(cl_program_info paramName, size_t paramValueSize,
retSize = srcSize = sizeof(clContext);
break;
case CL_PROGRAM_BINARIES:
packDeviceBinary(rootDeviceIndex);
pSrc = buildInfos[rootDeviceIndex].packedDeviceBinary.get();
retSize = sizeof(void **);
srcSize = buildInfos[rootDeviceIndex].packedDeviceBinarySize;
if (paramValue != nullptr) {
if (paramValueSize < retSize) {
case CL_PROGRAM_BINARIES: {
auto requiredSize = clDevices.size() * sizeof(const unsigned char **);
if (!paramValue) {
retSize = requiredSize;
srcSize = 0u;
break;
}
if (paramValueSize < requiredSize) {
retVal = CL_INVALID_VALUE;
break;
}
paramValueSize = srcSize;
paramValue = *(void **)paramValue;
auto outputBinaries = reinterpret_cast<unsigned char **>(paramValue);
for (auto i = 0u; i < clDevices.size(); i++) {
if (outputBinaries[i] == nullptr) {
continue;
}
break;
auto rootDeviceIndex = clDevices[i]->getRootDeviceIndex();
auto binarySize = buildInfos[rootDeviceIndex].packedDeviceBinarySize;
memcpy_s(outputBinaries[i], binarySize, buildInfos[rootDeviceIndex].packedDeviceBinary.get(), binarySize);
}
GetInfo::setParamValueReturnSize(paramValueSizeRet, requiredSize, GetInfoStatus::SUCCESS);
return CL_SUCCESS;
} break;
case CL_PROGRAM_BINARY_SIZES:
for (auto i = 0u; i < clDevices.size(); i++) {
auto rootDeviceIndex = clDevices[i]->getRootDeviceIndex();
packDeviceBinary(rootDeviceIndex);
pSrc = &buildInfos[rootDeviceIndex].packedDeviceBinarySize;
retSize = srcSize = sizeof(size_t *);
binarySizes.push_back(buildInfos[rootDeviceIndex].packedDeviceBinarySize);
}
pSrc = binarySizes.data();
retSize = srcSize = binarySizes.size() * sizeof(cl_device_id);
break;
case CL_PROGRAM_KERNEL_NAMES:

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

@ -83,9 +83,8 @@ class Program : public BaseObject<_cl_program> {
// Create program from binary
template <typename T = Program>
static T *create(
cl_context context,
cl_uint numDevices,
const cl_device_id *deviceList,
Context *pContext,
const ClDeviceVector &deviceVector,
const size_t *lengths,
const unsigned char **binaries,
cl_int *binaryStatus,
@ -132,7 +131,7 @@ class Program : public BaseObject<_cl_program> {
size_t length,
cl_int &errcodeRet);
Program(Context *context, bool isBuiltIn, const ClDeviceVector &clDevices);
Program(Context *context, bool isBuiltIn, const ClDeviceVector &clDevicesIn);
~Program() override;
Program(const Program &) = delete;

109
opencl/test/unit_test/api/cl_create_program_with_binary_tests.inl
View File

@ -66,6 +66,115 @@ TEST_F(clCreateProgramWithBinaryTests, GivenCorrectParametersWhenCreatingProgram
EXPECT_EQ(nullptr, pProgram);
}
TEST_F(clCreateProgramWithBinaryTests, GivenInvalidInputWhenCreatingProgramWithBinaryThenInvalidValueErrorIsReturned) {
cl_program pProgram = nullptr;
cl_int binaryStatus = CL_INVALID_VALUE;
size_t binarySize = 0;
std::string testFile;
retrieveBinaryKernelFilename(testFile, "CopyBuffer_simd16_", ".bin");
ASSERT_EQ(true, fileExists(testFile));
auto pBinary = loadDataFromFile(
testFile.c_str(),
binarySize);
ASSERT_NE(0u, binarySize);
ASSERT_NE(nullptr, pBinary);
const unsigned char *validBinaries[] = {reinterpret_cast<const unsigned char *>(pBinary.get()), reinterpret_cast<const unsigned char *>(pBinary.get())};
const unsigned char *invalidBinaries[] = {reinterpret_cast<const unsigned char *>(pBinary.get()), nullptr};
size_t validSizeBinaries[] = {binarySize, binarySize};
size_t invalidSizeBinaries[] = {binarySize, 0};
cl_device_id devicesForProgram[] = {testedClDevice, testedClDevice};
pProgram = clCreateProgramWithBinary(
pContext,
2,
devicesForProgram,
validSizeBinaries,
invalidBinaries,
&binaryStatus,
&retVal);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
EXPECT_EQ(nullptr, pProgram);
retVal = CL_INVALID_PROGRAM;
pProgram = clCreateProgramWithBinary(
pContext,
2,
devicesForProgram,
invalidSizeBinaries,
validBinaries,
&binaryStatus,
&retVal);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
EXPECT_EQ(nullptr, pProgram);
pProgram = clCreateProgramWithBinary(
pContext,
2,
devicesForProgram,
validSizeBinaries,
validBinaries,
&binaryStatus,
&retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, pProgram);
clReleaseProgram(pProgram);
}
TEST_F(clCreateProgramWithBinaryTests, GivenDeviceNotAssociatedWithContextWhenCreatingProgramWithBinaryThenInvalidDeviceErrorIsReturned) {
cl_program pProgram = nullptr;
cl_int binaryStatus = CL_INVALID_VALUE;
size_t binarySize = 0;
std::string testFile;
retrieveBinaryKernelFilename(testFile, "CopyBuffer_simd16_", ".bin");
ASSERT_EQ(true, fileExists(testFile));
auto pBinary = loadDataFromFile(
testFile.c_str(),
binarySize);
ASSERT_NE(0u, binarySize);
ASSERT_NE(nullptr, pBinary);
const unsigned char *binaries[1] = {reinterpret_cast<const unsigned char *>(pBinary.get())};
MockClDevice invalidDevice(new MockDevice());
cl_device_id devicesForProgram[] = {&invalidDevice};
pProgram = clCreateProgramWithBinary(
pContext,
1,
devicesForProgram,
&binarySize,
binaries,
&binaryStatus,
&retVal);
EXPECT_EQ(CL_INVALID_DEVICE, retVal);
EXPECT_EQ(nullptr, pProgram);
retVal = CL_INVALID_PROGRAM;
devicesForProgram[0] = nullptr;
pProgram = clCreateProgramWithBinary(
pContext,
1,
devicesForProgram,
&binarySize,
binaries,
&binaryStatus,
&retVal);
EXPECT_EQ(CL_INVALID_DEVICE, retVal);
EXPECT_EQ(nullptr, pProgram);
}
TEST_F(clCreateProgramWithILTests, GivenInvalidContextWhenCreatingProgramWithIlThenInvalidContextErrorIsReturned) {
const uint32_t spirv[16] = {0x03022307};

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

@ -168,6 +168,157 @@ TEST_F(clGetProgramInfoTests, GivenIlWhenBuildingProgramThenGetProgramInfoReturn
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST(clGetProgramInfoTest, GivenMultiDeviceProgramCreatedWithBinaryWhenGettingDevicesThenCorrectDevicesAreReturned) {
MockUnrestrictiveContextMultiGPU context;
auto numDevicesForProgram = 2u;
cl_device_id devicesForProgram[] = {context.getDevice(1), context.getDevice(3)};
std::unique_ptr<char[]> pBinary0 = nullptr;
std::unique_ptr<char[]> pBinary1 = nullptr;
size_t binarySize0 = 0;
size_t binarySize1 = 0;
std::string testFile;
retrieveBinaryKernelFilename(testFile, "CopyBuffer_simd16_", ".bin");
pBinary0 = loadDataFromFile(
testFile.c_str(),
binarySize0);
retrieveBinaryKernelFilename(testFile, "copy_buffer_to_image_", ".bin");
pBinary1 = loadDataFromFile(
testFile.c_str(),
binarySize1);
ASSERT_NE(0u, binarySize0);
ASSERT_NE(0u, binarySize1);
ASSERT_NE(nullptr, pBinary0);
ASSERT_NE(nullptr, pBinary1);
EXPECT_NE(binarySize0, binarySize1);
const unsigned char *binaries[] = {reinterpret_cast<const unsigned char *>(pBinary0.get()), reinterpret_cast<const unsigned char *>(pBinary1.get())};
size_t sizeBinaries[] = {binarySize0, binarySize1};
cl_program pProgram = nullptr;
cl_int retVal = CL_INVALID_PROGRAM;
cl_int binaryStaus = CL_INVALID_PROGRAM;
pProgram = clCreateProgramWithBinary(
&context,
numDevicesForProgram,
devicesForProgram,
sizeBinaries,
binaries,
&binaryStaus,
&retVal);
EXPECT_NE(nullptr, pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
cl_uint numDevices;
retVal = clGetProgramInfo(pProgram, CL_PROGRAM_NUM_DEVICES, sizeof(numDevices), &numDevices, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(numDevicesForProgram, numDevices);
cl_device_id programDevices[2] = {};
retVal = clGetProgramInfo(pProgram, CL_PROGRAM_DEVICES, numDevices * sizeof(cl_device_id), programDevices, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
for (auto i = 0u; i < numDevices; i++) {
EXPECT_EQ(devicesForProgram[i], programDevices[i]);
}
retVal = clReleaseProgram(pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST(clGetProgramInfoTest, GivenMultiDeviceProgramCreatedWithBinaryWhenGettingBinariesThenCorrectBinariesAreReturned) {
MockUnrestrictiveContextMultiGPU context;
auto numDevicesForProgram = 2u;
cl_device_id devicesForProgram[] = {context.getDevice(1), context.getDevice(3)};
std::unique_ptr<char[]> pBinary0 = nullptr;
std::unique_ptr<char[]> pBinary1 = nullptr;
size_t binarySize0 = 0;
size_t binarySize1 = 0;
std::string testFile;
retrieveBinaryKernelFilename(testFile, "CopyBuffer_simd16_", ".bin");
pBinary0 = loadDataFromFile(
testFile.c_str(),
binarySize0);
retrieveBinaryKernelFilename(testFile, "copy_buffer_to_image_", ".bin");
pBinary1 = loadDataFromFile(
testFile.c_str(),
binarySize1);
ASSERT_NE(0u, binarySize0);
ASSERT_NE(0u, binarySize1);
ASSERT_NE(nullptr, pBinary0);
ASSERT_NE(nullptr, pBinary1);
EXPECT_NE(binarySize0, binarySize1);
const unsigned char *binaries[] = {reinterpret_cast<const unsigned char *>(pBinary0.get()), reinterpret_cast<const unsigned char *>(pBinary1.get())};
size_t sizeBinaries[] = {binarySize0, binarySize1};
cl_program pProgram = nullptr;
cl_int retVal = CL_INVALID_PROGRAM;
cl_int binaryStaus = CL_INVALID_PROGRAM;
pProgram = clCreateProgramWithBinary(
&context,
numDevicesForProgram,
devicesForProgram,
sizeBinaries,
binaries,
&binaryStaus,
&retVal);
EXPECT_NE(nullptr, pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
size_t programBinarySizes[2] = {};
retVal = clGetProgramInfo(pProgram, CL_PROGRAM_BINARY_SIZES, numDevicesForProgram * sizeof(size_t), programBinarySizes, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
for (auto i = 0u; i < numDevicesForProgram; i++) {
EXPECT_EQ(sizeBinaries[i], programBinarySizes[i]);
}
auto programBinary0 = std::make_unique<unsigned char[]>(binarySize0);
memset(programBinary0.get(), 0, binarySize0);
auto programBinary1 = std::make_unique<unsigned char[]>(binarySize1);
memset(programBinary1.get(), 0, binarySize1);
unsigned char *programBinaries[] = {programBinary0.get(), programBinary1.get()};
retVal = clGetProgramInfo(pProgram, CL_PROGRAM_BINARIES, numDevicesForProgram * sizeof(unsigned char *), programBinaries, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
for (auto i = 0u; i < numDevicesForProgram; i++) {
for (auto j = 0u; j < programBinarySizes[i]; j++) {
EXPECT_EQ(programBinaries[i][j], binaries[i][j]);
}
}
memset(programBinary1.get(), 0, binarySize1);
programBinaries[0] = nullptr;
retVal = clGetProgramInfo(pProgram, CL_PROGRAM_BINARIES, numDevicesForProgram * sizeof(unsigned char *), programBinaries, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
for (auto j = 0u; j < programBinarySizes[1]; j++) {
EXPECT_EQ(programBinaries[1][j], binaries[1][j]);
}
retVal = clReleaseProgram(pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clGetProgramInfoTests, GivenSPIRVProgramWhenGettingProgramSourceThenReturnNullString) {
const size_t binarySize = 16;
const uint32_t spirv[binarySize] = {0x03022307};

4
opencl/test/unit_test/aub_tests/fixtures/run_kernel_fixture.h
View File

@ -63,13 +63,11 @@ class RunKernelFixture : public CommandEnqueueAUBFixture {
EXPECT_NE(nullptr, pSource);
Program *pProgram = nullptr;
const cl_device_id device = pClDevice;
const unsigned char *binaries[1] = {reinterpret_cast<const unsigned char *>(pSource.get())};
pProgram = Program::create(
context,
1,
&device,
context->getDevices(),
&sourceSize,
binaries,
nullptr,

6
opencl/test/unit_test/context/driver_diagnostics_tests.h
View File

@ -221,8 +221,8 @@ struct PerformanceHintEnqueueKernelTest : public PerformanceHintEnqueueTest,
void SetUp() override {
PerformanceHintEnqueueTest::SetUp();
cl_device_id device = pPlatform->getClDevice(0);
CreateProgramFromBinary(context, &device, "CopyBuffer_simd32");
CreateProgramFromBinary(context, context->getDevices(), "CopyBuffer_simd32");
cl_device_id device = context->getDevice(0);
retVal = pProgram->build(1, &device, nullptr, nullptr, nullptr, false);
ASSERT_EQ(CL_SUCCESS, retVal);
kernel = Kernel::create<MockKernel>(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal);
@ -258,7 +258,7 @@ struct PerformanceHintEnqueueKernelPrintfTest : public PerformanceHintEnqueueTes
void SetUp() override {
PerformanceHintEnqueueTest::SetUp();
cl_device_id device = pPlatform->getClDevice(0);
CreateProgramFromBinary(context, &device, "printf");
CreateProgramFromBinary(context, context->getDevices(), "printf");
retVal = pProgram->build(1, &device, nullptr, nullptr, nullptr, false);
ASSERT_EQ(CL_SUCCESS, retVal);
kernel = Kernel::create(pProgram, *pProgram->getKernelInfo("test"), &retVal);

10
opencl/test/unit_test/fixtures/hello_world_kernel_fixture.h
View File

@ -43,8 +43,8 @@ struct HelloWorldKernelFixture : public ProgramFixture {
pTestFilename->append(std::to_string(simd));
}
cl_device_id device = pDevice;
pContext = Context::create<MockContext>(nullptr, ClDeviceVector(&device, 1), nullptr, nullptr, retVal);
auto deviceVector = toClDeviceVector(*pDevice);
pContext = Context::create<MockContext>(nullptr, deviceVector, nullptr, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_NE(nullptr, pContext);
@ -56,18 +56,20 @@ struct HelloWorldKernelFixture : public ProgramFixture {
CreateProgramFromBinary(
pContext,
&device,
deviceVector,
*pTestFilename,
optionsToProgram);
} else {
CreateProgramFromBinary(
pContext,
&device,
deviceVector,
*pTestFilename);
}
ASSERT_NE(nullptr, pProgram);
cl_device_id device = pDevice;
retVal = pProgram->build(
1,
&device,

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

@ -41,8 +41,8 @@ void ProgramFixture::CreateProgramWithSource(cl_context context,
ASSERT_EQ(CL_SUCCESS, retVal);
}
void ProgramFixture::CreateProgramFromBinary(cl_context context,
cl_device_id *pDeviceList,
void ProgramFixture::CreateProgramFromBinary(Context *pContext,
const ClDeviceVector &deviceVector,
const std::string &binaryFileName,
cl_int &retVal,
const std::string &options) {
@ -59,24 +59,23 @@ void ProgramFixture::CreateProgramFromBinary(cl_context context,
ASSERT_NE(nullptr, knownSource);
pProgram = Program::create<MockProgram>(
context,
1,
pDeviceList,
pContext,
deviceVector,
&knownSourceSize,
(const unsigned char **)&knownSource,
nullptr,
retVal);
}
void ProgramFixture::CreateProgramFromBinary(cl_context pContext,
cl_device_id *pDeviceList,
void ProgramFixture::CreateProgramFromBinary(Context *pContext,
const ClDeviceVector &deviceVector,
const std::string &binaryFileName,
const std::string &options) {
Cleanup();
cl_int retVal = CL_SUCCESS;
CreateProgramFromBinary(
pContext,
pDeviceList,
deviceVector,
binaryFileName,
retVal,
options);

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

@ -18,14 +18,14 @@ namespace NEO {
class ProgramFixture {
public:
void CreateProgramFromBinary(cl_context context,
cl_device_id *pDeviceList,
void CreateProgramFromBinary(Context *pContext,
const ClDeviceVector &deviceVector,
const std::string &binaryFileName,
cl_int &retVal,
const std::string &options = "");
void CreateProgramFromBinary(cl_context pContext,
cl_device_id *pDeviceList,
void CreateProgramFromBinary(Context *pContext,
const ClDeviceVector &deviceVector,
const std::string &binaryFileName,
const std::string &options = "");

25
opencl/test/unit_test/fixtures/simple_arg_kernel_fixture.h
View File

@ -91,13 +91,14 @@ class SimpleArgKernelFixture : public ProgramFixture {
}
cl_device_id device = pDevice;
pContext = Context::create<MockContext>(nullptr, ClDeviceVector(&device, 1), nullptr, nullptr, retVal);
auto deviceVector = toClDeviceVector(*pDevice);
pContext = Context::create<MockContext>(nullptr, deviceVector, nullptr, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_NE(nullptr, pContext);
CreateProgramFromBinary(
pContext,
&device,
deviceVector,
testFile);
ASSERT_NE(nullptr, pProgram);
@ -145,11 +146,10 @@ class SimpleArgNonUniformKernelFixture : public ProgramFixture {
ProgramFixture::SetUp();
cl_device_id deviceId = device;
cl_context clContext = context;
CreateProgramFromBinary(
clContext,
&deviceId,
context,
context->getDevices(),
"simple_nonuniform",
"-cl-std=CL2.0");
ASSERT_NE(nullptr, pProgram);
@ -193,11 +193,10 @@ class SimpleKernelFixture : public ProgramFixture {
ProgramFixture::SetUp();
cl_device_id deviceId = device;
cl_context clContext = context;
std::string programName("simple_kernels");
CreateProgramFromBinary(
clContext,
&deviceId,
context,
toClDeviceVector(*device),
programName);
ASSERT_NE(nullptr, pProgram);
@ -249,13 +248,12 @@ class SimpleKernelStatelessFixture : public ProgramFixture {
void SetUp(ClDevice *device, Context *context) {
ProgramFixture::SetUp();
cl_device_id deviceId = device;
cl_context clContext = context;
DebugManager.flags.DisableStatelessToStatefulOptimization.set(true);
DebugManager.flags.EnableStatelessToStatefulBufferOffsetOpt.set(false);
CreateProgramFromBinary(
clContext,
&deviceId,
context,
toClDeviceVector(*device),
"stateless_kernel");
ASSERT_NE(nullptr, pProgram);
@ -300,10 +298,9 @@ class BindlessKernelFixture : public ProgramFixture {
void createKernel(const std::string &programName, const std::string &kernelName) {
DebugManager.flags.UseBindlessMode.set(1);
cl_device_id deviceId = deviceCl;
cl_context clContext = contextCl;
CreateProgramFromBinary(
clContext,
&deviceId,
contextCl,
contextCl->getDevices(),
programName);
ASSERT_NE(nullptr, pProgram);

6
opencl/test/unit_test/kernel/kernel_tests.cpp
View File

@ -346,7 +346,7 @@ typedef Test<KernelFromBinaryTest> KernelFromBinaryTests;
TEST_F(KernelFromBinaryTests, GivenKernelNumArgsWhenGettingInfoThenNumberOfKernelArgsIsReturned) {
cl_device_id device = pClDevice;
CreateProgramFromBinary(pContext, &device, "kernel_num_args");
CreateProgramFromBinary(pContext, pContext->getDevices(), "kernel_num_args");
ASSERT_NE(nullptr, pProgram);
retVal = pProgram->build(
@ -389,7 +389,7 @@ TEST_F(KernelFromBinaryTests, GivenKernelNumArgsWhenGettingInfoThenNumberOfKerne
TEST_F(KernelFromBinaryTests, WhenRegularKernelIsCreatedThenItIsNotBuiltIn) {
cl_device_id device = pClDevice;
CreateProgramFromBinary(pContext, &device, "simple_kernels");
CreateProgramFromBinary(pContext, pContext->getDevices(), "simple_kernels");
ASSERT_NE(nullptr, pProgram);
retVal = pProgram->build(
@ -424,7 +424,7 @@ TEST_F(KernelFromBinaryTests, WhenRegularKernelIsCreatedThenItIsNotBuiltIn) {
TEST_F(KernelFromBinaryTests, givenArgumentDeclaredAsConstantWhenKernelIsCreatedThenArgumentIsMarkedAsReadOnly) {
cl_device_id device = pClDevice;
CreateProgramFromBinary(pContext, &device, "simple_kernels");
CreateProgramFromBinary(pContext, pContext->getDevices(), "simple_kernels");
ASSERT_NE(nullptr, pProgram);
retVal = pProgram->build(

4
opencl/test/unit_test/program/program_from_binary.h
View File

@ -39,9 +39,9 @@ class ProgramFromBinaryTest : public ClDeviceFixture,
ProgramFixture::SetUp();
if (options.size())
CreateProgramFromBinary(pContext, &device, BinaryFileName, options);
CreateProgramFromBinary(pContext, pContext->getDevices(), BinaryFileName, options);
else
CreateProgramFromBinary(pContext, &device, BinaryFileName);
CreateProgramFromBinary(pContext, pContext->getDevices(), BinaryFileName);
}
void TearDown() override {

8
opencl/test/unit_test/program/program_nonuniform.cpp
View File

@ -184,8 +184,8 @@ class ProgramNonUniformTest : public ContextFixture,
TEST_F(ProgramNonUniformTest, GivenCl21WhenExecutingKernelWithNonUniformThenEnqueueSucceeds) {
REQUIRE_OCL_21_OR_SKIP(defaultHwInfo);
CreateProgramFromBinary(pContext, &device, "kernel_data_param");
auto mockProgram = (MockProgram *)pProgram;
CreateProgramFromBinary(pContext, pContext->getDevices(), "kernel_data_param");
auto mockProgram = pProgram;
ASSERT_NE(nullptr, mockProgram);
mockProgram->setBuildOptions("-cl-std=CL2.1");
@ -226,7 +226,7 @@ TEST_F(ProgramNonUniformTest, GivenCl21WhenExecutingKernelWithNonUniformThenEnqu
TEST_F(ProgramNonUniformTest, GivenCl20WhenExecutingKernelWithNonUniformThenEnqueueSucceeds) {
REQUIRE_OCL_21_OR_SKIP(defaultHwInfo);
CreateProgramFromBinary(pContext, &device, "kernel_data_param");
CreateProgramFromBinary(pContext, pContext->getDevices(), "kernel_data_param");
auto mockProgram = pProgram;
ASSERT_NE(nullptr, mockProgram);
@ -266,7 +266,7 @@ TEST_F(ProgramNonUniformTest, GivenCl20WhenExecutingKernelWithNonUniformThenEnqu
}
TEST_F(ProgramNonUniformTest, GivenCl12WhenExecutingKernelWithNonUniformThenInvalidWorkGroupSizeIsReturned) {
CreateProgramFromBinary(pContext, &device, "kernel_data_param");
CreateProgramFromBinary(pContext, pContext->getDevices(), "kernel_data_param");
auto mockProgram = pProgram;
ASSERT_NE(nullptr, mockProgram);

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

@ -254,9 +254,8 @@ TEST_P(ProgramFromBinaryTest, GivenProgramWithNoExecutableCodeWhenGettingNumKern
size_t paramValue = 0;
size_t paramValueSize = sizeof(paramValue);
size_t paramValueSizeRet = 0;
cl_device_id device = pClDevice;
CreateProgramFromBinary(pContext, &device, BinaryFileName);
CreateProgramFromBinary(pContext, pContext->getDevices(), BinaryFileName);
MockProgram *p = pProgram;
p->setBuildStatus(CL_BUILD_NONE);
@ -311,9 +310,8 @@ TEST_P(ProgramFromBinaryTest, WhenGettingKernelNamesThenCorrectNameIsReturned) {
TEST_P(ProgramFromBinaryTest, GivenProgramWithNoExecutableCodeWhenGettingKernelNamesThenInvalidProgramExecutableErrorIsReturned) {
size_t paramValueSize = sizeof(size_t *);
size_t paramValueSizeRet = 0;
cl_device_id device = pClDevice;
CreateProgramFromBinary(pContext, &device, BinaryFileName);
CreateProgramFromBinary(pContext, pContext->getDevices(), BinaryFileName);
MockProgram *p = pProgram;
p->setBuildStatus(CL_BUILD_NONE);
@ -371,10 +369,7 @@ TEST_P(ProgramFromBinaryTest, GivenCorruptedDeviceWhenGettingBuildStatusThenInva
size_t paramValueSize = sizeof(buildStatus);
size_t paramValueSizeRet = 0;
cl_device_id device = pClDevice;
CreateProgramFromBinary(pContext, &device, BinaryFileName);
MockProgram *p = pProgram;
p->setDevice(&pClDevice->getDevice());
CreateProgramFromBinary(pContext, pContext->getDevices(), BinaryFileName);
retVal = pProgram->getBuildInfo(
reinterpret_cast<ClDevice *>(pContext),
@ -615,7 +610,7 @@ TEST_P(ProgramFromBinaryTest, GivenGlobalVariableTotalSizeSetWhenGettingBuildGlo
EXPECT_EQ(globalVarSize, 0u);
// Set GlobalVariableTotalSize as 1024
CreateProgramFromBinary(pContext, &device, BinaryFileName);
CreateProgramFromBinary(pContext, pContext->getDevices(), BinaryFileName);
MockProgram *p = pProgram;
ProgramInfo programInfo;
@ -1426,7 +1421,7 @@ class CommandStreamReceiverMock : public UltCommandStreamReceiver<FamilyType> {
HWTEST_F(PatchTokenTests, givenKernelRequiringConstantAllocationWhenMakeResidentIsCalledThenConstantAllocationIsMadeResident) {
cl_device_id device = pClDevice;
CreateProgramFromBinary(pContext, &device, "test_constant_memory");
CreateProgramFromBinary(pContext, pContext->getDevices(), "test_constant_memory");
ASSERT_NE(nullptr, pProgram);
retVal = pProgram->build(
@ -1495,7 +1490,7 @@ HWTEST_F(PatchTokenTests, givenKernelRequiringConstantAllocationWhenMakeResident
TEST_F(PatchTokenTests, WhenBuildingProgramThenGwsIsSet) {
cl_device_id device = pClDevice;
CreateProgramFromBinary(pContext, &device, "kernel_data_param");
CreateProgramFromBinary(pContext, pContext->getDevices(), "kernel_data_param");
ASSERT_NE(nullptr, pProgram);
retVal = pProgram->build(
@ -1519,7 +1514,7 @@ TEST_F(PatchTokenTests, WhenBuildingProgramThenGwsIsSet) {
TEST_F(PatchTokenTests, WhenBuildingProgramThenLwsIsSet) {
cl_device_id device = pClDevice;
CreateProgramFromBinary(pContext, &device, "kernel_data_param");
CreateProgramFromBinary(pContext, pContext->getDevices(), "kernel_data_param");
ASSERT_NE(nullptr, pProgram);
retVal = pProgram->build(
@ -1554,7 +1549,7 @@ TEST_F(PatchTokenTests, WhenBuildingProgramThenConstantKernelArgsAreAvailable) {
// PATCH_TOKEN_STATELESS_CONSTANT_MEMORY_OBJECT_KERNEL_ARGUMENT
cl_device_id device = pClDevice;
CreateProgramFromBinary(pContext, &device, "test_basic_constant");
CreateProgramFromBinary(pContext, pContext->getDevices(), "test_basic_constant");
ASSERT_NE(nullptr, pProgram);
retVal = pProgram->build(
@ -1597,7 +1592,7 @@ TEST_F(PatchTokenTests, GivenVmeKernelWhenBuildingKernelThenArgAvailable) {
// PATCH_TOKEN_INLINE_VME_SAMPLER_INFO token indicates a VME kernel.
cl_device_id device = pClDevice;
CreateProgramFromBinary(pContext, &device, "vme_kernels");
CreateProgramFromBinary(pContext, pContext->getDevices(), "vme_kernels");
ASSERT_NE(nullptr, pProgram);
retVal = pProgram->build(
@ -1652,9 +1647,8 @@ TEST(ProgramFromBinaryTests, givenBinaryWithInvalidICBEThenErrorIsReturned) {
{
const unsigned char *binaries[1] = {reinterpret_cast<const unsigned char *>(&binHeader)};
MockContext context;
cl_device_id deviceId = context.getDevice(0);
std::unique_ptr<Program> pProgram(Program::create<Program>(&context, 0, &deviceId, &binSize, binaries, nullptr, retVal));
std::unique_ptr<Program> pProgram(Program::create<Program>(&context, context.getDevices(), &binSize, binaries, nullptr, retVal));
EXPECT_EQ(nullptr, pProgram.get());
EXPECT_EQ(CL_INVALID_BINARY, retVal);
}
@ -1714,7 +1708,7 @@ using ProgramWithDebugSymbolsTests = Test<ProgramSimpleFixture>;
TEST_F(ProgramWithDebugSymbolsTests, GivenProgramCreatedWithDashGOptionWhenGettingProgramBinariesThenDebugDataIsIncluded) {
cl_device_id device = pClDevice;
CreateProgramFromBinary(pContext, &device, "CopyBuffer_simd16", "-g");
CreateProgramFromBinary(pContext, pContext->getDevices(), "CopyBuffer_simd16", "-g");
ASSERT_NE(nullptr, pProgram);
@ -2369,10 +2363,9 @@ TEST_F(ProgramTests, givenProgramCreatedFromIntermediateBinaryRepresentationWhen
const uint32_t spirv[16] = {0x03022307};
cl_int errCode = 0;
cl_device_id deviceId = pClDevice;
cl_context ctx = pContext;
size_t lengths = sizeof(spirv);
const unsigned char *binaries[1] = {reinterpret_cast<const unsigned char *>(spirv)};
auto prog = Program::create<MockProgram>(ctx, 1U, &deviceId, &lengths, binaries, nullptr, errCode);
auto prog = Program::create<MockProgram>(pContext, pContext->getDevices(), &lengths, binaries, nullptr, errCode);
ASSERT_NE(nullptr, prog);
auto debugVars = NEO::getIgcDebugVars();
debugVars.forceBuildFailure = true;
@ -2911,7 +2904,7 @@ TEST_F(ProgramBinTest, givenPrintProgramBinaryProcessingTimeSetWhenBuildProgramT
testing::internal::CaptureStdout();
cl_device_id device = pClDevice;
CreateProgramFromBinary(pContext, &device, "kernel_data_param");
CreateProgramFromBinary(pContext, pContext->getDevices(), "kernel_data_param");
auto retVal = pProgram->build(
1,

8
opencl/test/unit_test/program/program_with_block_kernels_tests.cpp
View File

@ -52,8 +52,8 @@ class ProgramWithBlockKernelsTest : public ContextFixture,
};
TEST_F(ProgramWithBlockKernelsTest, GivenKernelWithBlockKernelsWhenProgramIsBuildingThenKernelInfosHaveCorrectNames) {
CreateProgramFromBinary(pContext, &device, "simple_block_kernel", "-cl-std=CL2.0");
auto mockProgram = (MockProgram *)pProgram;
CreateProgramFromBinary(pContext, pContext->getDevices(), "simple_block_kernel", "-cl-std=CL2.0");
auto mockProgram = pProgram;
ASSERT_NE(nullptr, mockProgram);
retVal = mockProgram->build(
@ -91,7 +91,7 @@ TEST_F(ProgramWithBlockKernelsTest, GivenKernelWithBlockKernelsWhenProgramIsBuil
}
TEST_F(ProgramWithBlockKernelsTest, GivenKernelWithBlockKernelsWhenProgramIsLinkedThenBlockKernelsAreSeparated) {
CreateProgramFromBinary(pContext, &device, "simple_block_kernel", "-cl-std=CL2.0");
CreateProgramFromBinary(pContext, pContext->getDevices(), "simple_block_kernel", "-cl-std=CL2.0");
const char *buildOptions = "-cl-std=CL2.0";
overwriteBuiltInBinaryName(
@ -101,7 +101,7 @@ TEST_F(ProgramWithBlockKernelsTest, GivenKernelWithBlockKernelsWhenProgramIsLink
ASSERT_NE(nullptr, pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
Program *programLinked = new Program(pContext, false, toClDeviceVector(*pPlatform->getClDevice(0)));
Program *programLinked = new Program(pContext, false, pContext->getDevices());
cl_program program = pProgram;
retVal = pProgram->compile(1, &device, buildOptions, 0, nullptr, nullptr, nullptr, nullptr);