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 clCreateProgramWithBuiltInKernels

Browse Source 
create program for all provided devices
move OCL specific code from shared to opencl

Related-To: NEO-5001
Change-Id: Ic352b4e907ae75426634ae4b3c7048edecaf83e7
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2020-10-22 12:14:54 +02:00
committed by sys_ocldev
parent 8778b5c302
commit a5a5c94097
52 changed files with 387 additions and 354 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
opencl/test/unit_test/api/cl_create_program_with_built_in_kernels_tests.cpp
View File

@ -11,12 +11,12 @@
#include "opencl/source/built_ins/built_in_ops_vme.h"
#include "opencl/source/built_ins/vme_builtin.h"
#include "opencl/source/cl_device/cl_device.h"
#include "opencl/source/context/context.h"
#include "opencl/source/helpers/base_object.h"
#include "opencl/source/kernel/kernel.h"
#include "opencl/source/program/program.h"
#include "opencl/test/unit_test/fixtures/run_kernel_fixture.h"
#include "opencl/test/unit_test/mocks/mock_cl_device.h"
#include "cl_api_tests.h"
@ -31,10 +31,10 @@ struct clCreateProgramWithBuiltInVmeKernelsTests : clCreateProgramWithBuiltInKer
GTEST_SKIP();
}
pDev = &pContext->getDevice(0)->getDevice();
pClDevice = pContext->getDevice(0);
}
Device *pDev;
ClDevice *pClDevice;
};
namespace ULT {
@ -85,10 +85,44 @@ TEST_F(clCreateProgramWithBuiltInKernelsTests, GivenNoKernelsAndNoReturnWhenCrea
EXPECT_EQ(nullptr, program);
}
TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenDeviceNotAssociatedWithContextWhenCreatingProgramWithBuiltInThenInvalidDeviceErrorIsReturned) {
cl_program pProgram = nullptr;
const char *kernelNamesString = {
"block_advanced_motion_estimate_bidirectional_check_intel;"
"block_motion_estimate_intel;"
"block_advanced_motion_estimate_check_intel;"};
MockClDevice invalidDevice(new MockDevice());
cl_device_id devicesForProgram[] = {&invalidDevice};
pProgram = clCreateProgramWithBuiltInKernels(
pContext,
1,
devicesForProgram,
kernelNamesString,
&retVal);
EXPECT_EQ(CL_INVALID_DEVICE, retVal);
EXPECT_EQ(nullptr, pProgram);
retVal = CL_INVALID_PROGRAM;
devicesForProgram[0] = nullptr;
pProgram = clCreateProgramWithBuiltInKernels(
pContext,
1,
devicesForProgram,
kernelNamesString,
&retVal);
EXPECT_EQ(CL_INVALID_DEVICE, retVal);
EXPECT_EQ(nullptr, pProgram);
}
TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenValidMediaKernelsWhenCreatingProgramWithBuiltInKernelsThenProgramIsSuccessfullyCreated) {
cl_int retVal = CL_SUCCESS;
overwriteBuiltInBinaryName(pDev, "media_kernels_frontend");
overwriteBuiltInBinaryName("media_kernels_frontend");
const char *kernelNamesString = {
"block_advanced_motion_estimate_bidirectional_check_intel;"
@ -108,7 +142,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenValidMediaKernelsWhenCrea
kernelNamesString, // kernel_names
&retVal);
restoreBuiltInBinaryName(pDev);
restoreBuiltInBinaryName();
EXPECT_NE(nullptr, program);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -131,7 +165,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenValidMediaKernelsWhenCrea
TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenValidMediaKernelsWithOptionsWhenCreatingProgramWithBuiltInKernelsThenProgramIsSuccessfullyCreatedWithThoseOptions) {
cl_int retVal = CL_SUCCESS;
overwriteBuiltInBinaryName(pDev, "media_kernels_frontend");
overwriteBuiltInBinaryName("media_kernels_frontend");
const char *kernelNamesString = {
"block_motion_estimate_intel;"};
@ -143,7 +177,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenValidMediaKernelsWithOpti
kernelNamesString, // kernel_names
&retVal);
restoreBuiltInBinaryName(pDev);
restoreBuiltInBinaryName();
auto neoProgram = castToObject<Program>(program);
auto builtinOptions = neoProgram->getOptions();
@ -156,11 +190,11 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenValidMediaKernelsWithOpti
TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockMotionEstimateKernelWhenCreatingProgramWithBuiltInKernelsThenCorrectDispatchBuilderAndFrontendKernelIsCreated) {
cl_int retVal = CL_SUCCESS;
overwriteBuiltInBinaryName(pDev, "media_kernels_backend");
Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockMotionEstimateIntel, *pDev);
restoreBuiltInBinaryName(pDev);
overwriteBuiltInBinaryName("media_kernels_backend");
Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockMotionEstimateIntel, *pClDevice);
restoreBuiltInBinaryName();
overwriteBuiltInBinaryName(pDev, "media_kernels_frontend");
overwriteBuiltInBinaryName("media_kernels_frontend");
const char *kernelNamesString = {
"block_motion_estimate_intel;"};
@ -171,7 +205,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockMotionEstimateKer
&testedClDevice, // device_list
kernelNamesString, // kernel_names
&retVal);
restoreBuiltInBinaryName(pDev);
restoreBuiltInBinaryName();
cl_kernel kernel = clCreateKernel(
program,
@ -182,7 +216,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockMotionEstimateKer
EXPECT_NE(nullptr, kernNeo->getKernelInfo().builtinDispatchBuilder);
EXPECT_EQ(6U, kernNeo->getKernelArgsNumber());
auto &vmeBuilder = Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockMotionEstimateIntel, *pDev);
auto &vmeBuilder = Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockMotionEstimateIntel, *pClDevice);
EXPECT_EQ(&vmeBuilder, kernNeo->getKernelInfo().builtinDispatchBuilder);
clReleaseKernel(kernel);
@ -192,11 +226,11 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockMotionEstimateKer
TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockAdvancedMotionEstimateKernelWhenCreatingProgramWithBuiltInKernelsThenCorrectDispatchBuilderAndFrontendKernelIsCreated) {
cl_int retVal = CL_SUCCESS;
overwriteBuiltInBinaryName(pDev, "media_kernels_backend");
Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel, *pDev);
restoreBuiltInBinaryName(pDev);
overwriteBuiltInBinaryName("media_kernels_backend");
Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel, *pClDevice);
restoreBuiltInBinaryName();
overwriteBuiltInBinaryName(pDev, "media_kernels_frontend");
overwriteBuiltInBinaryName("media_kernels_frontend");
const char *kernelNamesString = {
"block_advanced_motion_estimate_check_intel;"};
@ -207,7 +241,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockAdvancedMotionEst
&testedClDevice, // device_list
kernelNamesString, // kernel_names
&retVal);
restoreBuiltInBinaryName(pDev);
restoreBuiltInBinaryName();
cl_kernel kernel = clCreateKernel(
program,
@ -218,7 +252,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockAdvancedMotionEst
EXPECT_NE(nullptr, kernNeo->getKernelInfo().builtinDispatchBuilder);
EXPECT_EQ(15U, kernNeo->getKernelArgsNumber());
auto &vmeBuilder = Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel, *pDev);
auto &vmeBuilder = Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel, *pClDevice);
EXPECT_EQ(&vmeBuilder, kernNeo->getKernelInfo().builtinDispatchBuilder);
clReleaseKernel(kernel);
@ -228,11 +262,11 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockAdvancedMotionEst
TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockAdvancedMotionEstimateBidirectionalCheckKernelWhenCreatingProgramWithBuiltInKernelsThenCorrectDispatchBuilderAndFrontendKernelIsCreated) {
cl_int retVal = CL_SUCCESS;
overwriteBuiltInBinaryName(pDev, "media_kernels_backend");
Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel, *pDev);
restoreBuiltInBinaryName(pDev);
overwriteBuiltInBinaryName("media_kernels_backend");
Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel, *pClDevice);
restoreBuiltInBinaryName();
overwriteBuiltInBinaryName(pDev, "media_kernels_frontend");
overwriteBuiltInBinaryName("media_kernels_frontend");
const char *kernelNamesString = {
"block_advanced_motion_estimate_bidirectional_check_intel;"};
@ -243,7 +277,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockAdvancedMotionEst
&testedClDevice, // device_list
kernelNamesString, // kernel_names
&retVal);
restoreBuiltInBinaryName(pDev);
restoreBuiltInBinaryName();
cl_kernel kernel = clCreateKernel(
program,
@ -255,7 +289,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockAdvancedMotionEst
EXPECT_EQ(20U, kernNeo->getKernelArgsNumber());
auto ctxNeo = castToObject<Context>(pContext);
auto &vmeBuilder = Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel, ctxNeo->getDevice(0)->getDevice());
auto &vmeBuilder = Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel, *ctxNeo->getDevice(0));
EXPECT_EQ(&vmeBuilder, kernNeo->getKernelInfo().builtinDispatchBuilder);
clReleaseKernel(kernel);

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

@ -11,6 +11,7 @@
#include "shared/test/unit_test/helpers/test_files.h"
#include "opencl/source/context/context.h"
#include "opencl/test/unit_test/fixtures/run_kernel_fixture.h"
#include "opencl/test/unit_test/helpers/kernel_binary_helper.h"
#include "opencl/test/unit_test/mocks/mock_context.h"
#include "opencl/test/unit_test/test_macros/test_checks_ocl.h"
@ -25,6 +26,24 @@ namespace ULT {
static_assert(CL_PROGRAM_IL == CL_PROGRAM_IL_KHR, "Param values are different");
void verifyDevices(cl_program pProgram, size_t expectedNumDevices, cl_device_id *expectedDevices) {
cl_uint numDevices;
auto retVal = clGetProgramInfo(pProgram, CL_PROGRAM_NUM_DEVICES, sizeof(numDevices), &numDevices, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(expectedNumDevices, numDevices);
auto programDevices = std::make_unique<cl_device_id[]>(expectedNumDevices);
for (auto i = 0u; i < expectedNumDevices; i++) {
programDevices[i] = nullptr;
}
retVal = clGetProgramInfo(pProgram, CL_PROGRAM_DEVICES, expectedNumDevices * sizeof(cl_device_id), programDevices.get(), nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
for (auto i = 0u; i < expectedNumDevices; i++) {
EXPECT_EQ(expectedDevices[i], programDevices[i]);
}
}
TEST_F(clGetProgramInfoTests, GivenSourceWhenBuildingProgramThenGetProgramInfoReturnsCorrectInfo) {
cl_program pProgram = nullptr;
std::unique_ptr<char[]> pSource = nullptr;
@ -128,21 +147,7 @@ TEST(clGetProgramInfoTest, GivenMultiDeviceProgramCreatedWithSourceWhenGettingDe
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(expectedNumDevices, numDevices);
auto programDevices = std::make_unique<cl_device_id[]>(expectedNumDevices);
for (auto i = 0u; i < expectedNumDevices; i++) {
programDevices[i] = nullptr;
}
retVal = clGetProgramInfo(pProgram, CL_PROGRAM_DEVICES, expectedNumDevices * sizeof(cl_device_id), programDevices.get(), nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
for (auto i = 0u; i < expectedNumDevices; i++) {
EXPECT_EQ(devicesForProgram[i], programDevices[i]);
}
verifyDevices(pProgram, expectedNumDevices, devicesForProgram.get());
retVal = clReleaseProgram(pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -217,18 +222,7 @@ TEST(clGetProgramInfoTest, GivenMultiDeviceProgramCreatedWithBinaryWhenGettingDe
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]);
}
verifyDevices(pProgram, numDevicesForProgram, devicesForProgram);
retVal = clReleaseProgram(pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -370,24 +364,47 @@ TEST(clGetProgramInfoTest, GivenMultiDeviceProgramCreatedWithILWhenGettingDevice
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(expectedNumDevices, numDevices);
auto programDevices = std::make_unique<cl_device_id[]>(expectedNumDevices);
for (auto i = 0u; i < expectedNumDevices; i++) {
programDevices[i] = nullptr;
}
retVal = clGetProgramInfo(pProgram, CL_PROGRAM_DEVICES, expectedNumDevices * sizeof(cl_device_id), programDevices.get(), nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
for (auto i = 0u; i < expectedNumDevices; i++) {
EXPECT_EQ(devicesForProgram[i], programDevices[i]);
}
verifyDevices(pProgram, expectedNumDevices, devicesForProgram.get());
retVal = clReleaseProgram(pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST(clGetProgramInfoTest, GivenMultiDeviceProgramCreatedWithBuiltInKernelsWhenGettingDevicesThenCorrectDevicesAreReturned) {
if (!defaultHwInfo->capabilityTable.supportsVme) {
GTEST_SKIP();
}
MockUnrestrictiveContextMultiGPU context;
auto numDevicesForProgram = 2u;
cl_device_id devicesForProgram[] = {context.getDevice(1), context.getDevice(3)};
overwriteBuiltInBinaryName("media_kernels_frontend");
const char *kernelNamesString = {
"block_advanced_motion_estimate_bidirectional_check_intel;"
"block_motion_estimate_intel;"
"block_advanced_motion_estimate_check_intel;"};
cl_program pProgram = nullptr;
cl_int retVal = CL_INVALID_PROGRAM;
pProgram = clCreateProgramWithBuiltInKernels(
&context,
numDevicesForProgram,
devicesForProgram,
kernelNamesString,
&retVal);
EXPECT_NE(nullptr, pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
restoreBuiltInBinaryName();
verifyDevices(pProgram, numDevicesForProgram, devicesForProgram);
retVal = clReleaseProgram(pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
}
} // namespace ULT

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

@ -157,7 +157,7 @@ TEST_F(BuiltInTests, WhenBuildingListOfBuiltinsThenBuiltinsHaveBeenGenerated) {
}
TEST_F(BuiltInTests, GivenCopyBufferToBufferWhenDispatchInfoIsCreatedThenParamsAreCorrect) {
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pClDevice);
MockBuffer *srcPtr = new MockBuffer();
MockBuffer *dstPtr = new MockBuffer();
@ -220,7 +220,7 @@ TEST_F(BuiltInTests, GivenCopyBufferToBufferWhenDispatchInfoIsCreatedThenParamsA
}
HWTEST_F(BuiltInTests, givenInputBufferWhenBuildingNonAuxDispatchInfoForAuxTranslationThenPickAndSetupCorrectKernels) {
BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pClDevice);
auto &builder = static_cast<BuiltInOp<EBuiltInOps::AuxTranslation> &>(baseBuilder);
MemObjsForAuxTranslation memObjsForAuxTranslation;
@ -267,7 +267,7 @@ HWTEST_F(BuiltInTests, givenInputBufferWhenBuildingNonAuxDispatchInfoForAuxTrans
}
HWTEST_F(BuiltInTests, givenInputBufferWhenBuildingAuxDispatchInfoForAuxTranslationThenPickAndSetupCorrectKernels) {
BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pClDevice);
auto &builder = static_cast<BuiltInOp<EBuiltInOps::AuxTranslation> &>(baseBuilder);
MemObjsForAuxTranslation memObjsForAuxTranslation;
@ -314,7 +314,7 @@ HWTEST_F(BuiltInTests, givenInputBufferWhenBuildingAuxDispatchInfoForAuxTranslat
}
HWTEST_F(BuiltInTests, givenInputBufferWhenBuildingAuxTranslationDispatchThenPickDifferentKernelsDependingOnRequest) {
BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pClDevice);
auto &builder = static_cast<BuiltInOp<EBuiltInOps::AuxTranslation> &>(baseBuilder);
MemObjsForAuxTranslation memObjsForAuxTranslation;
@ -349,7 +349,7 @@ HWTEST_F(BuiltInTests, givenInputBufferWhenBuildingAuxTranslationDispatchThenPic
}
HWTEST_F(BuiltInTests, givenInvalidAuxTranslationDirectionWhenBuildingDispatchInfosThenAbort) {
BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pClDevice);
auto &builder = static_cast<BuiltInOp<EBuiltInOps::AuxTranslation> &>(baseBuilder);
MemObjsForAuxTranslation memObjsForAuxTranslation;
@ -375,17 +375,17 @@ class MockAuxBuilInOp : public BuiltInOp<EBuiltInOps::AuxTranslation> {
using BaseClass::resizeKernelInstances;
using BaseClass::usedKernels;
MockAuxBuilInOp(BuiltIns &kernelsLib, Context &context, Device &device) : BaseClass(kernelsLib, device) {}
using BaseClass::BuiltInOp;
};
TEST_F(BuiltInTests, whenAuxBuiltInIsConstructedThenResizeKernelInstancedTo5) {
MockAuxBuilInOp mockAuxBuiltInOp(*pBuiltIns, *pContext, *pDevice);
MockAuxBuilInOp mockAuxBuiltInOp(*pBuiltIns, *pClDevice);
EXPECT_EQ(5u, mockAuxBuiltInOp.convertToAuxKernel.size());
EXPECT_EQ(5u, mockAuxBuiltInOp.convertToNonAuxKernel.size());
}
HWTEST_F(BuiltInTests, givenMoreBuffersForAuxTranslationThanKernelInstancesWhenDispatchingThenResize) {
MockAuxBuilInOp mockAuxBuiltInOp(*pBuiltIns, *pContext, *pDevice);
MockAuxBuilInOp mockAuxBuiltInOp(*pBuiltIns, *pClDevice);
EXPECT_EQ(5u, mockAuxBuiltInOp.convertToAuxKernel.size());
EXPECT_EQ(5u, mockAuxBuiltInOp.convertToNonAuxKernel.size());
@ -407,7 +407,7 @@ HWTEST_F(BuiltInTests, givenMoreBuffersForAuxTranslationThanKernelInstancesWhenD
}
TEST_F(BuiltInTests, givenkAuxBuiltInWhenResizeIsCalledThenCloneAllNewInstancesFromBaseKernel) {
MockAuxBuilInOp mockAuxBuiltInOp(*pBuiltIns, *pContext, *pDevice);
MockAuxBuilInOp mockAuxBuiltInOp(*pBuiltIns, *pClDevice);
size_t newSize = mockAuxBuiltInOp.convertToAuxKernel.size() + 3;
mockAuxBuiltInOp.resizeKernelInstances(newSize);
@ -423,8 +423,8 @@ TEST_F(BuiltInTests, givenkAuxBuiltInWhenResizeIsCalledThenCloneAllNewInstancesF
}
HWTEST_F(BuiltInTests, givenKernelWithAuxTranslationRequiredWhenEnqueueCalledThenLockOnBuiltin) {
BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
auto mockAuxBuiltInOp = new MockAuxBuilInOp(*pBuiltIns, *pContext, *pDevice);
BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pClDevice);
auto mockAuxBuiltInOp = new MockAuxBuilInOp(*pBuiltIns, *pClDevice);
pBuiltIns->BuiltinOpsBuilders[static_cast<uint32_t>(EBuiltInOps::AuxTranslation)].first.reset(mockAuxBuiltInOp);
auto mockProgram = clUniquePtr(new MockProgram(toClDeviceVector(*pClDevice)));
@ -462,7 +462,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, BuiltInTests, givenAuxTranslationKernelWhenSettingKe
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
MockAuxBuilInOp mockAuxBuiltInOp(*pBuiltIns, *pContext, *pDevice);
MockAuxBuilInOp mockAuxBuiltInOp(*pBuiltIns, *pClDevice);
MultiDispatchInfo multiDispatchInfo;
MemObjsForAuxTranslation memObjsForAuxTranslation;
multiDispatchInfo.setMemObjsForAuxTranslation(memObjsForAuxTranslation);
@ -519,7 +519,7 @@ HWTEST_F(BuiltInTests, givenAuxToNonAuxTranslationWhenSettingSurfaceStateThenSet
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using AUXILIARY_SURFACE_MODE = typename RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE;
MockAuxBuilInOp mockAuxBuiltInOp(*pBuiltIns, *pContext, *pDevice);
MockAuxBuilInOp mockAuxBuiltInOp(*pBuiltIns, *pClDevice);
MultiDispatchInfo multiDispatchInfo;
MemObjsForAuxTranslation memObjsForAuxTranslation;
multiDispatchInfo.setMemObjsForAuxTranslation(memObjsForAuxTranslation);
@ -565,7 +565,7 @@ HWTEST_F(BuiltInTests, givenNonAuxToAuxTranslationWhenSettingSurfaceStateThenSet
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
using AUXILIARY_SURFACE_MODE = typename RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE;
MockAuxBuilInOp mockAuxBuiltInOp(*pBuiltIns, *pContext, *pDevice);
MockAuxBuilInOp mockAuxBuiltInOp(*pBuiltIns, *pClDevice);
MultiDispatchInfo multiDispatchInfo;
MemObjsForAuxTranslation memObjsForAuxTranslation;
multiDispatchInfo.setMemObjsForAuxTranslation(memObjsForAuxTranslation);
@ -603,7 +603,7 @@ HWTEST_F(BuiltInTests, givenNonAuxToAuxTranslationWhenSettingSurfaceStateThenSet
}
TEST_F(BuiltInTests, GivenCopyBufferToBufferWhenDispatchInfoIsCreatedThenSizeIsAlignedToCachLineSize) {
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pClDevice);
AlignedBuffer src;
AlignedBuffer dst;
@ -642,7 +642,7 @@ TEST_F(BuiltInTests, givenBigOffsetAndSizeWhenBuilderCopyBufferToBufferStateless
GTEST_SKIP();
}
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBufferStateless, *pDevice);
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBufferStateless, *pClDevice);
uint64_t bigSize = 10ull * MemoryConstants::gigaByte;
uint64_t bigOffset = 4ull * MemoryConstants::gigaByte;
@ -673,7 +673,7 @@ TEST_F(BuiltInTests, givenBigOffsetAndSizeWhenBuilderCopyBufferToBufferRectState
GTEST_SKIP();
}
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferRectStateless, *pDevice);
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferRectStateless, *pClDevice);
uint64_t bigSize = 10ull * MemoryConstants::gigaByte;
uint64_t bigOffset = 4ull * MemoryConstants::gigaByte;
@ -707,7 +707,7 @@ TEST_F(BuiltInTests, givenBigOffsetAndSizeWhenBuilderFillBufferStatelessIsUsedTh
GTEST_SKIP();
}
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBufferStateless, *pDevice);
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBufferStateless, *pClDevice);
uint64_t bigSize = 10ull * MemoryConstants::gigaByte;
uint64_t bigOffset = 4ull * MemoryConstants::gigaByte;
@ -744,7 +744,7 @@ HWTEST_F(BuiltInTests, givenBigOffsetAndSizeWhenBuilderCopyBufferToImageStateles
std ::unique_ptr<Image> pDstImage(Image2dHelper<>::create(pContext));
ASSERT_NE(nullptr, pDstImage.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3dStateless, *pDevice);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3dStateless, *pClDevice);
BuiltinOpParams dc;
dc.srcPtr = &srcBuffer;
@ -780,7 +780,7 @@ HWTEST_F(BuiltInTests, givenBigOffsetAndSizeWhenBuilderCopyImageToBufferStateles
std ::unique_ptr<Image> pSrcImage(Image2dHelper<>::create(pContext));
ASSERT_NE(nullptr, pSrcImage.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBufferStateless, *pDevice);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBufferStateless, *pClDevice);
BuiltinOpParams dc;
dc.srcMemObj = pSrcImage.get();
@ -801,7 +801,7 @@ HWTEST_F(BuiltInTests, givenBigOffsetAndSizeWhenBuilderCopyImageToBufferStateles
}
TEST_F(BuiltInTests, GivenUnalignedCopyBufferToBufferWhenDispatchInfoIsCreatedThenParamsAreCorrect) {
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pClDevice);
AlignedBuffer src;
AlignedBuffer dst;
@ -826,7 +826,7 @@ TEST_F(BuiltInTests, GivenUnalignedCopyBufferToBufferWhenDispatchInfoIsCreatedTh
}
TEST_F(BuiltInTests, GivenReadBufferAlignedWhenDispatchInfoIsCreatedThenParamsAreCorrect) {
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pClDevice);
AlignedBuffer srcMemObj;
auto size = 10 * MemoryConstants::cacheLineSize;
@ -861,7 +861,7 @@ TEST_F(BuiltInTests, GivenReadBufferAlignedWhenDispatchInfoIsCreatedThenParamsAr
}
TEST_F(BuiltInTests, GivenWriteBufferAlignedWhenDispatchInfoIsCreatedThenParamsAreCorrect) {
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pClDevice);
auto size = 10 * MemoryConstants::cacheLineSize;
auto srcPtr = alignedMalloc(size, MemoryConstants::cacheLineSize);
@ -896,8 +896,8 @@ TEST_F(BuiltInTests, GivenWriteBufferAlignedWhenDispatchInfoIsCreatedThenParamsA
}
TEST_F(BuiltInTests, WhenGettingBuilderInfoTwiceThenPointerIsSame) {
BuiltinDispatchInfoBuilder &builder1 = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
BuiltinDispatchInfoBuilder &builder2 = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
BuiltinDispatchInfoBuilder &builder1 = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pClDevice);
BuiltinDispatchInfoBuilder &builder2 = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pClDevice);
EXPECT_EQ(&builder1, &builder2);
}
@ -905,7 +905,7 @@ TEST_F(BuiltInTests, WhenGettingBuilderInfoTwiceThenPointerIsSame) {
TEST_F(BuiltInTests, GivenUnknownBuiltInOpWhenGettingBuilderInfoThenExceptionThrown) {
bool caughtException = false;
try {
BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::COUNT, *pDevice);
BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::COUNT, *pClDevice);
} catch (const std::runtime_error &) {
caughtException = true;
}
@ -970,26 +970,26 @@ TEST_F(BuiltInTests, WhenSettingExplictArgThenTrueIsReturned) {
}
TEST_F(VmeBuiltInTests, GivenVmeBuilderWhenGettingDispatchInfoThenValidPointerIsReturned) {
overwriteBuiltInBinaryName(pDevice, "media_kernels_backend");
overwriteBuiltInBinaryName("media_kernels_backend");
EBuiltInOps::Type vmeOps[] = {EBuiltInOps::VmeBlockMotionEstimateIntel, EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel, EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel};
for (auto op : vmeOps) {
BuiltinDispatchInfoBuilder &builder = Vme::getBuiltinDispatchInfoBuilder(op, *pDevice);
BuiltinDispatchInfoBuilder &builder = Vme::getBuiltinDispatchInfoBuilder(op, *pClDevice);
EXPECT_NE(nullptr, &builder);
}
restoreBuiltInBinaryName(pDevice);
restoreBuiltInBinaryName();
}
TEST_F(VmeBuiltInTests, givenInvalidBuiltInOpWhenGetVmeBuilderInfoThenExceptionIsThrown) {
EXPECT_THROW(Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::COUNT, *pDevice), std::exception);
EXPECT_THROW(Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::COUNT, *pClDevice), std::exception);
}
TEST_F(VmeBuiltInTests, GivenVmeBuilderAndInvalidParamsWhenGettingDispatchInfoThenEmptyKernelIsReturned) {
overwriteBuiltInBinaryName(pDevice, "media_kernels_backend");
overwriteBuiltInBinaryName("media_kernels_backend");
EBuiltInOps::Type vmeOps[] = {EBuiltInOps::VmeBlockMotionEstimateIntel, EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel, EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel};
for (auto op : vmeOps) {
BuiltinDispatchInfoBuilder &builder = Vme::getBuiltinDispatchInfoBuilder(op, *pDevice);
BuiltinDispatchInfoBuilder &builder = Vme::getBuiltinDispatchInfoBuilder(op, *pClDevice);
MultiDispatchInfo outMdi;
Vec3<size_t> gws{352, 288, 0};
@ -999,7 +999,7 @@ TEST_F(VmeBuiltInTests, GivenVmeBuilderAndInvalidParamsWhenGettingDispatchInfoTh
EXPECT_FALSE(ret);
EXPECT_EQ(0U, outMdi.size());
}
restoreBuiltInBinaryName(pDevice);
restoreBuiltInBinaryName();
}
TEST_F(VmeBuiltInTests, GivenVmeBuilderWhenGettingDispatchInfoThenParamsAreCorrect) {
@ -1010,9 +1010,9 @@ TEST_F(VmeBuiltInTests, GivenVmeBuilderWhenGettingDispatchInfoThenParamsAreCorre
mockKernel.kernelInfo.reqdWorkGroupSize[1] = 0;
mockKernel.kernelInfo.reqdWorkGroupSize[2] = 0;
overwriteBuiltInBinaryName(pDevice, "media_kernels_backend");
BuiltinDispatchInfoBuilder &builder = Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockMotionEstimateIntel, *pDevice);
restoreBuiltInBinaryName(pDevice);
overwriteBuiltInBinaryName("media_kernels_backend");
BuiltinDispatchInfoBuilder &builder = Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockMotionEstimateIntel, *pClDevice);
restoreBuiltInBinaryName();
MultiDispatchInfo outMdi;
Vec3<size_t> gws{352, 288, 0};
@ -1077,9 +1077,9 @@ TEST_F(VmeBuiltInTests, GivenAdvancedVmeBuilderWhenGettingDispatchInfoThenParams
EBuiltInOps::Type vmeOps[] = {EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel, EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel};
for (auto op : vmeOps) {
MultiDispatchInfo outMdi;
overwriteBuiltInBinaryName(pDevice, "media_kernels_backend");
BuiltinDispatchInfoBuilder &builder = Vme::getBuiltinDispatchInfoBuilder(op, *pDevice);
restoreBuiltInBinaryName(pDevice);
overwriteBuiltInBinaryName("media_kernels_backend");
BuiltinDispatchInfoBuilder &builder = Vme::getBuiltinDispatchInfoBuilder(op, *pClDevice);
restoreBuiltInBinaryName();
bool ret = builder.setExplicitArg(srcImageArgNum, sizeof(cl_mem), &srcImageArg, err);
EXPECT_FALSE(ret);
@ -1360,7 +1360,7 @@ TEST_F(BuiltInTests, GivenTypeAnyWhenCreatingProgramFromCodeThenValidPointerIsRe
auto builtinsLib = std::unique_ptr<BuiltinsLib>(new BuiltinsLib());
const BuiltinCode bc = builtinsLib->getBuiltinCode(EBuiltInOps::CopyBufferToBuffer, BuiltinCode::ECodeType::Any, *pDevice);
EXPECT_NE(0u, bc.resource.size());
auto program = std::unique_ptr<Program>(BuiltinsLib::createProgramFromCode(bc, *pDevice));
auto program = std::unique_ptr<Program>(BuiltinDispatchInfoBuilder::createProgramFromCode(bc, toClDeviceVector(*pClDevice)));
EXPECT_NE(nullptr, program.get());
}
@ -1368,7 +1368,7 @@ TEST_F(BuiltInTests, GivenTypeSourceWhenCreatingProgramFromCodeThenValidPointerI
auto builtinsLib = std::unique_ptr<BuiltinsLib>(new BuiltinsLib());
const BuiltinCode bc = builtinsLib->getBuiltinCode(EBuiltInOps::CopyBufferToBuffer, BuiltinCode::ECodeType::Source, *pDevice);
EXPECT_NE(0u, bc.resource.size());
auto program = std::unique_ptr<Program>(BuiltinsLib::createProgramFromCode(bc, *pDevice));
auto program = std::unique_ptr<Program>(BuiltinDispatchInfoBuilder::createProgramFromCode(bc, toClDeviceVector(*pClDevice)));
EXPECT_NE(nullptr, program.get());
}
@ -1379,7 +1379,7 @@ TEST_F(BuiltInTests, givenCreateProgramFromSourceWhenDeviceSupportSharedSystemAl
const BuiltinCode bc = builtinsLib->getBuiltinCode(EBuiltInOps::CopyBufferToBuffer, BuiltinCode::ECodeType::Source, *pDevice);
EXPECT_NE(0u, bc.resource.size());
auto program = std::unique_ptr<Program>(BuiltinsLib::createProgramFromCode(bc, *pDevice));
auto program = std::unique_ptr<Program>(BuiltinDispatchInfoBuilder::createProgramFromCode(bc, toClDeviceVector(*pClDevice)));
EXPECT_NE(nullptr, program.get());
EXPECT_THAT(program->getInternalOptions(), testing::HasSubstr(std::string(CompilerOptions::greaterThan4gbBuffersRequired)));
}
@ -1388,7 +1388,7 @@ TEST_F(BuiltInTests, GivenTypeIntermediateWhenCreatingProgramFromCodeThenNullPoi
auto builtinsLib = std::unique_ptr<BuiltinsLib>(new BuiltinsLib());
const BuiltinCode bc = builtinsLib->getBuiltinCode(EBuiltInOps::CopyBufferToBuffer, BuiltinCode::ECodeType::Intermediate, *pDevice);
EXPECT_EQ(0u, bc.resource.size());
auto program = std::unique_ptr<Program>(BuiltinsLib::createProgramFromCode(bc, *pDevice));
auto program = std::unique_ptr<Program>(BuiltinDispatchInfoBuilder::createProgramFromCode(bc, toClDeviceVector(*pClDevice)));
EXPECT_EQ(nullptr, program.get());
}
@ -1396,7 +1396,7 @@ TEST_F(BuiltInTests, GivenTypeBinaryWhenCreatingProgramFromCodeThenValidPointerI
auto builtinsLib = std::unique_ptr<BuiltinsLib>(new BuiltinsLib());
const BuiltinCode bc = builtinsLib->getBuiltinCode(EBuiltInOps::CopyBufferToBuffer, BuiltinCode::ECodeType::Binary, *pDevice);
EXPECT_NE(0u, bc.resource.size());
auto program = std::unique_ptr<Program>(BuiltinsLib::createProgramFromCode(bc, *pDevice));
auto program = std::unique_ptr<Program>(BuiltinDispatchInfoBuilder::createProgramFromCode(bc, toClDeviceVector(*pClDevice)));
EXPECT_NE(nullptr, program.get());
}
@ -1404,7 +1404,7 @@ TEST_F(BuiltInTests, GivenTypeInvalidWhenCreatingProgramFromCodeThenNullPointerI
auto builtinsLib = std::unique_ptr<BuiltinsLib>(new BuiltinsLib());
const BuiltinCode bc = builtinsLib->getBuiltinCode(EBuiltInOps::CopyBufferToBuffer, BuiltinCode::ECodeType::INVALID, *pDevice);
EXPECT_EQ(0u, bc.resource.size());
auto program = std::unique_ptr<Program>(BuiltinsLib::createProgramFromCode(bc, *pDevice));
auto program = std::unique_ptr<Program>(BuiltinDispatchInfoBuilder::createProgramFromCode(bc, toClDeviceVector(*pClDevice)));
EXPECT_EQ(nullptr, program.get());
}
@ -1412,7 +1412,7 @@ TEST_F(BuiltInTests, GivenInvalidBuiltinWhenCreatingProgramFromCodeThenNullPoint
auto builtinsLib = std::unique_ptr<BuiltinsLib>(new BuiltinsLib());
const BuiltinCode bc = builtinsLib->getBuiltinCode(EBuiltInOps::COUNT, BuiltinCode::ECodeType::Any, *pDevice);
EXPECT_EQ(0u, bc.resource.size());
auto program = std::unique_ptr<Program>(BuiltinsLib::createProgramFromCode(bc, *pDevice));
auto program = std::unique_ptr<Program>(BuiltinDispatchInfoBuilder::createProgramFromCode(bc, toClDeviceVector(*pClDevice)));
EXPECT_EQ(nullptr, program.get());
}
@ -1423,7 +1423,7 @@ TEST_F(BuiltInTests, GivenForce32bitWhenCreatingProgramThenCorrectKernelIsCreate
auto builtinsLib = std::unique_ptr<BuiltinsLib>(new BuiltinsLib());
const BuiltinCode bc = builtinsLib->getBuiltinCode(EBuiltInOps::CopyBufferToBuffer, BuiltinCode::ECodeType::Source, *pDevice);
ASSERT_NE(0u, bc.resource.size());
auto program = std::unique_ptr<Program>(BuiltinsLib::createProgramFromCode(bc, *pDevice));
auto program = std::unique_ptr<Program>(BuiltinDispatchInfoBuilder::createProgramFromCode(bc, toClDeviceVector(*pClDevice)));
ASSERT_NE(nullptr, program.get());
auto builtinInternalOptions = program->getInternalOptions();
@ -1452,9 +1452,9 @@ TEST_F(BuiltInTests, GivenVmeKernelWhenGettingDeviceInfoThenCorrectVmeVersionIsR
TEST_F(VmeBuiltInTests, WhenVmeKernelIsCreatedThenParamsAreCorrect) {
this->pBuiltIns->setCacheingEnableState(false);
overwriteBuiltInBinaryName(pDevice, "media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel> vmeBuilder(*this->pBuiltIns, *this->pDevice);
restoreBuiltInBinaryName(pDevice);
overwriteBuiltInBinaryName("media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel> vmeBuilder(*this->pBuiltIns, *pClDevice);
restoreBuiltInBinaryName();
cl_int err;
@ -1512,10 +1512,10 @@ TEST_F(VmeBuiltInTests, WhenVmeKernelIsCreatedThenParamsAreCorrect) {
TEST_F(VmeBuiltInTests, WhenVmeKernelIsCreatedThenDispatchIsBidirectional) {
this->pBuiltIns->setCacheingEnableState(false);
overwriteBuiltInBinaryName(pDevice, "media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel> avmeBuilder(*this->pBuiltIns, *this->pDevice);
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel> avmeBidirBuilder(*this->pBuiltIns, *this->pDevice);
restoreBuiltInBinaryName(pDevice);
overwriteBuiltInBinaryName("media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel> avmeBuilder(*this->pBuiltIns, *pClDevice);
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel> avmeBidirBuilder(*this->pBuiltIns, *pClDevice);
restoreBuiltInBinaryName();
EXPECT_FALSE(avmeBuilder.isBidirKernel());
EXPECT_TRUE(avmeBidirBuilder.isBidirKernel());
@ -1560,9 +1560,9 @@ const cl_image_format ImageVmeInvalidChannelOrder::imageFormat = {
TEST_F(VmeBuiltInTests, WhenValidatingImagesThenCorrectResponses) {
this->pBuiltIns->setCacheingEnableState(false);
overwriteBuiltInBinaryName(pDevice, "media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockMotionEstimateIntel> vmeBuilder(*this->pBuiltIns, *this->pDevice);
restoreBuiltInBinaryName(pDevice);
overwriteBuiltInBinaryName("media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockMotionEstimateIntel> vmeBuilder(*this->pBuiltIns, *pClDevice);
restoreBuiltInBinaryName();
uint32_t srcImgArgNum = 1;
uint32_t refImgArgNum = 2;
@ -1638,9 +1638,9 @@ TEST_F(VmeBuiltInTests, WhenValidatingImagesThenCorrectResponses) {
TEST_F(VmeBuiltInTests, WhenValidatingFlagsThenValidFlagCombinationsReturnTrue) {
this->pBuiltIns->setCacheingEnableState(false);
overwriteBuiltInBinaryName(pDevice, "media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel> vmeBuilder(*this->pBuiltIns, *this->pDevice);
restoreBuiltInBinaryName(pDevice);
overwriteBuiltInBinaryName("media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel> vmeBuilder(*this->pBuiltIns, *pClDevice);
restoreBuiltInBinaryName();
uint32_t defaultSkipBlockVal = 8192;
uint32_t flagsArgNum = 3;
@ -1668,10 +1668,10 @@ TEST_F(VmeBuiltInTests, WhenValidatingFlagsThenValidFlagCombinationsReturnTrue)
TEST_F(VmeBuiltInTests, WhenValidatingSkipBlockTypeThenCorrectResponses) {
this->pBuiltIns->setCacheingEnableState(false);
overwriteBuiltInBinaryName(pDevice, "media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel> avmeBidirectionalBuilder(*this->pBuiltIns, *this->pDevice);
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel> avmeBuilder(*this->pBuiltIns, *this->pDevice);
restoreBuiltInBinaryName(pDevice);
overwriteBuiltInBinaryName("media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel> avmeBidirectionalBuilder(*this->pBuiltIns, *pClDevice);
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel> avmeBuilder(*this->pBuiltIns, *pClDevice);
restoreBuiltInBinaryName();
cl_int err;
uint32_t skipBlockTypeArgNum = 4;
@ -1703,10 +1703,10 @@ TEST_F(VmeBuiltInTests, WhenValidatingSkipBlockTypeThenCorrectResponses) {
TEST_F(VmeBuiltInTests, GivenAcceleratorWhenExplicitlySettingArgThenFalseIsReturned) {
this->pBuiltIns->setCacheingEnableState(false);
overwriteBuiltInBinaryName(pDevice, "media_kernels_backend");
overwriteBuiltInBinaryName("media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel> vmeBuilder(*this->pBuiltIns, *this->pDevice);
restoreBuiltInBinaryName(pDevice);
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel> vmeBuilder(*this->pBuiltIns, *pClDevice);
restoreBuiltInBinaryName();
cl_int err;
uint32_t aceleratorArgNum = 0;
@ -1729,11 +1729,9 @@ TEST_F(VmeBuiltInTests, GivenAcceleratorWhenExplicitlySettingArgThenFalseIsRetur
TEST_F(VmeBuiltInTests, WhenValidatingDispatchThenCorrectReturns) {
this->pBuiltIns->setCacheingEnableState(false);
overwriteBuiltInBinaryName(pDevice, "media_kernels_backend");
overwriteBuiltInBinaryName("media_kernels_backend");
struct MockVmeBuilder : BuiltInOp<EBuiltInOps::VmeBlockMotionEstimateIntel> {
MockVmeBuilder(BuiltIns &kernelsLib, Context &context, Device &device)
: BuiltInOp<EBuiltInOps::VmeBlockMotionEstimateIntel>(kernelsLib, device) {
}
using BuiltInOp<EBuiltInOps::VmeBlockMotionEstimateIntel>::BuiltInOp;
cl_int validateVmeDispatch(Vec3<size_t> inputRegion, Vec3<size_t> offset, size_t blkNum, size_t blkMul) const override {
receivedInputRegion = inputRegion;
@ -1753,8 +1751,8 @@ TEST_F(VmeBuiltInTests, WhenValidatingDispatchThenCorrectReturns) {
};
uint32_t aaceleratorArgNum = 0;
MockVmeBuilder vmeBuilder(*this->pBuiltIns, *pContext, *this->pDevice);
restoreBuiltInBinaryName(pDevice);
MockVmeBuilder vmeBuilder(*this->pBuiltIns, *pClDevice);
restoreBuiltInBinaryName();
cl_int ret = vmeBuilder.validateDispatch(nullptr, 1, Vec3<size_t>{16, 16, 0}, Vec3<size_t>{16, 1, 0}, Vec3<size_t>{0, 0, 0});
EXPECT_EQ(CL_INVALID_WORK_DIMENSION, ret);
@ -1834,9 +1832,9 @@ TEST_F(VmeBuiltInTests, WhenValidatingDispatchThenCorrectReturns) {
TEST_F(VmeBuiltInTests, WhenValidatingVmeDispatchThenCorrectReturns) {
this->pBuiltIns->setCacheingEnableState(false);
overwriteBuiltInBinaryName(pDevice, "media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockMotionEstimateIntel> vmeBuilder(*this->pBuiltIns, *this->pDevice);
restoreBuiltInBinaryName(pDevice);
overwriteBuiltInBinaryName("media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockMotionEstimateIntel> vmeBuilder(*this->pBuiltIns, *pClDevice);
restoreBuiltInBinaryName();
cl_int err;
@ -1872,9 +1870,9 @@ TEST_F(VmeBuiltInTests, WhenValidatingVmeDispatchThenCorrectReturns) {
TEST_F(VmeBuiltInTests, GivenAdvancedVmeWhenValidatingVmeDispatchThenCorrectReturns) {
this->pBuiltIns->setCacheingEnableState(false);
overwriteBuiltInBinaryName(pDevice, "media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel> avmeBuilder(*this->pBuiltIns, *this->pDevice);
restoreBuiltInBinaryName(pDevice);
overwriteBuiltInBinaryName("media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel> avmeBuilder(*this->pBuiltIns, *pClDevice);
restoreBuiltInBinaryName();
cl_int err;
// images not set
@ -1932,9 +1930,9 @@ TEST_F(VmeBuiltInTests, GivenAdvancedVmeWhenValidatingVmeDispatchThenCorrectRetu
TEST_F(VmeBuiltInTests, GivenAdvancedBidirectionalVmeWhenValidatingVmeDispatchThenCorrectReturns) {
this->pBuiltIns->setCacheingEnableState(false);
overwriteBuiltInBinaryName(pDevice, "media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel> avmeBuilder(*this->pBuiltIns, *this->pDevice);
restoreBuiltInBinaryName(pDevice);
overwriteBuiltInBinaryName("media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel> avmeBuilder(*this->pBuiltIns, *pClDevice);
restoreBuiltInBinaryName();
cl_int err;
uint32_t srcImgArgNum = 1;
@ -1980,9 +1978,9 @@ TEST_F(VmeBuiltInTests, GivenAdvancedBidirectionalVmeWhenValidatingVmeDispatchTh
TEST_F(VmeBuiltInTests, GivenAdvancedVmeWhenGettingSkipResidualsBuffExpSizeThenDefaultSizeIsReturned) {
this->pBuiltIns->setCacheingEnableState(false);
overwriteBuiltInBinaryName(pDevice, "media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel> vmeBuilder(*this->pBuiltIns, *this->pDevice);
restoreBuiltInBinaryName(pDevice);
overwriteBuiltInBinaryName("media_kernels_backend");
BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel> vmeBuilder(*this->pBuiltIns, *pClDevice);
restoreBuiltInBinaryName();
auto size16x16 = vmeBuilder.getSkipResidualsBuffExpSize(CL_ME_MB_TYPE_16x16_INTEL, 4);
auto sizeDefault = vmeBuilder.getSkipResidualsBuffExpSize(8192, 4);
@ -1995,7 +1993,7 @@ TEST_F(BuiltInTests, createBuiltInProgramForInvalidBuiltinKernelName) {
cl_program program = Vme::createBuiltInProgram(
*pContext,
*pDevice,
pContext->getDevices(),
kernelNames,
retVal);
@ -2065,7 +2063,7 @@ TEST_F(BuiltInTests, givenDebugFlagForceUseSourceWhenArgIsAnyThenReturnBuiltinCo
using BuiltInOwnershipWrapperTests = BuiltInTests;
TEST_F(BuiltInOwnershipWrapperTests, givenBuiltinWhenConstructedThenLockAndUnlockOnDestruction) {
MockAuxBuilInOp mockAuxBuiltInOp(*pBuiltIns, *pContext, *pDevice);
MockAuxBuilInOp mockAuxBuiltInOp(*pBuiltIns, *pClDevice);
MockContext mockContext;
{
@ -2077,7 +2075,7 @@ TEST_F(BuiltInOwnershipWrapperTests, givenBuiltinWhenConstructedThenLockAndUnloc
}
TEST_F(BuiltInOwnershipWrapperTests, givenLockWithoutParametersWhenConstructingThenLockOnlyWhenRequested) {
MockAuxBuilInOp mockAuxBuiltInOp(*pBuiltIns, *pContext, *pDevice);
MockAuxBuilInOp mockAuxBuiltInOp(*pBuiltIns, *pClDevice);
MockContext mockContext;
{
@ -2090,8 +2088,8 @@ TEST_F(BuiltInOwnershipWrapperTests, givenLockWithoutParametersWhenConstructingT
}
TEST_F(BuiltInOwnershipWrapperTests, givenLockWithAcquiredOwnershipWhenTakeOwnershipCalledThenAbort) {
MockAuxBuilInOp mockAuxBuiltInOp1(*pBuiltIns, *pContext, *pDevice);
MockAuxBuilInOp mockAuxBuiltInOp2(*pBuiltIns, *pContext, *pDevice);
MockAuxBuilInOp mockAuxBuiltInOp1(*pBuiltIns, *pClDevice);
MockAuxBuilInOp mockAuxBuiltInOp2(*pBuiltIns, *pClDevice);
BuiltInOwnershipWrapper lock(mockAuxBuiltInOp1, pContext);
EXPECT_THROW(lock.takeOwnership(mockAuxBuiltInOp1, pContext), std::exception);

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

@ -780,7 +780,7 @@ struct BuiltinParamsCommandQueueHwTests : public CommandQueueHwTest {
mockBuilder = static_cast<MockBuilder *>(&BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
operation,
*pDevice));
*pClDevice));
}
MockBuilder *mockBuilder;

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

@ -1242,7 +1242,7 @@ TEST(DispatchWalker, WhenCalculatingDispatchDimensionsThenCorrectValuesAreReturn
}
HWTEST_F(DispatchWalkerTest, givenKernelWhenAuxToNonAuxWhenTranslationRequiredThenPipeControlWithStallAndDCFlushAdded) {
BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pClDevice);
auto &builder = static_cast<BuiltInOp<EBuiltInOps::AuxTranslation> &>(baseBuilder);
MockKernel kernel(program.get(), kernelInfo, *pClDevice);
@ -1295,7 +1295,7 @@ HWTEST_F(DispatchWalkerTest, givenKernelWhenAuxToNonAuxWhenTranslationRequiredTh
}
HWTEST_F(DispatchWalkerTest, givenKernelWhenNonAuxToAuxWhenTranslationRequiredThenPipeControlWithStallAdded) {
BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pClDevice);
auto &builder = static_cast<BuiltInOp<EBuiltInOps::AuxTranslation> &>(baseBuilder);
MockKernel kernel(program.get(), kernelInfo, *pClDevice);

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

@ -160,7 +160,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, WhenCopyingBufferRect2DTh
// Extract the kernel used
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferRect,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -191,7 +191,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, WhenCopyingBufferRect2DTh
HWTEST_F(EnqueueCopyBufferRectTest, WhenCopyingBufferRectStatelessThenStatelessKernelIsUsed) {
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferRectStateless,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

8
opencl/test/unit_test/command_queue/enqueue_copy_buffer_tests.cpp
View File

@ -136,7 +136,7 @@ HWTEST_F(EnqueueCopyBufferTest, WhenCopyingBufferThenIndirectDataGetsAdded) {
enqueueCopyBuffer();
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -165,7 +165,7 @@ HWTEST_F(EnqueueCopyBufferTest, WhenCopyingBufferStatelessThenStatelessKernelIsU
auto dstBuffer = std::unique_ptr<Buffer>(BufferHelper<>::create());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBufferStateless,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -261,7 +261,7 @@ HWTEST_F(EnqueueCopyBufferTest, WhenCopyingBufferThenArgumentZeroMatchesSourceAd
// Extract the kernel used
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -289,7 +289,7 @@ HWTEST_F(EnqueueCopyBufferTest, WhenCopyingBufferThenArgumentOneMatchesDestinati
// Extract the kernel used
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

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

@ -201,7 +201,7 @@ HWTEST_P(MipMapCopyBufferToImageTest, GivenImageWithMipLevelNonZeroWhenCopyBuffe
pCmdQ->getDevice().getExecutionEnvironment()->rootDeviceEnvironments[pCmdQ->getDevice().getRootDeviceIndex()]->builtins.reset(builtIns);
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getDevice());
pCmdQ->getClDevice());
// substitute original builder with mock builder
auto oldBuilder = builtIns->setBuiltinDispatchInfoBuilder(
@ -260,7 +260,7 @@ HWTEST_P(MipMapCopyBufferToImageTest, GivenImageWithMipLevelNonZeroWhenCopyBuffe
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getDevice()));
pCmdQ->getClDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(expectedMipLevel, params->dstMipLevel);

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

@ -210,7 +210,7 @@ HWTEST_P(MipMapCopyImageTest, GivenImagesWithNonZeroMipLevelsWhenCopyImageIsCall
pCmdQ->getDevice().getExecutionEnvironment()->rootDeviceEnvironments[pCmdQ->getDevice().getRootDeviceIndex()]->builtins.reset(builtIns);
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImageToImage3d,
pCmdQ->getDevice());
pCmdQ->getClDevice());
// substitute original builder with mock builder
auto oldBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImageToImage3d,
@ -303,7 +303,7 @@ HWTEST_P(MipMapCopyImageTest, GivenImagesWithNonZeroMipLevelsWhenCopyImageIsCall
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
pCmdQ->getDevice()));
pCmdQ->getClDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(expectedSrcMipLevel, params->srcMipLevel);

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

@ -202,7 +202,7 @@ HWTEST_P(MipMapCopyImageToBufferTest, GivenImageWithMipLevelNonZeroWhenCopyImage
pCmdQ->getDevice().getExecutionEnvironment()->rootDeviceEnvironments[pCmdQ->getDevice().getRootDeviceIndex()]->builtins.reset(builtIns);
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
// substitute original builder with mock builder
auto oldBuilder = builtIns->setBuiltinDispatchInfoBuilder(
@ -260,7 +260,7 @@ HWTEST_P(MipMapCopyImageToBufferTest, GivenImageWithMipLevelNonZeroWhenCopyImage
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getDevice()));
pCmdQ->getClDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(expectedMipLevel, params->srcMipLevel);

16
opencl/test/unit_test/command_queue/enqueue_fill_buffer_tests.cpp
View File

@ -98,7 +98,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, WhenFillingBufferThenIndirectDataGetsAdded)
EnqueueFillBufferHelper<>::enqueueFillBuffer(pCmdQ, buffer);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -130,7 +130,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, FillBufferRightLeftover) {
EnqueueFillBufferHelper<>::enqueueFillBuffer(pCmdQ, buffer);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -157,7 +157,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, FillBufferMiddle) {
EnqueueFillBufferHelper<>::enqueueFillBuffer(pCmdQ, buffer);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -184,7 +184,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, FillBufferLeftLeftover) {
EnqueueFillBufferHelper<>::enqueueFillBuffer(pCmdQ, buffer);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -283,7 +283,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, WhenFillingBufferThenArgumentZeroShouldMatch
// Extract the kernel used
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -319,7 +319,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, DISABLED_WhenFillingBufferThenArgumentOneSho
// Extract the kernel used
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -352,7 +352,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, WhenFillingBufferThenArgumentTwoShouldMatchP
// Extract the kernel used
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -382,7 +382,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, WhenFillingBufferStatelessThenStatelessKerne
// Extract the kernel used
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBufferStateless,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

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

@ -173,7 +173,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferRectTest, WhenReadingBufferThenIndi
// Extract the kernel used
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferRect,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

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

@ -141,7 +141,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, addsIndirectData) {
EnqueueReadBufferHelper<>::enqueueReadBuffer(pCmdQ, srcBuffer.get(), CL_TRUE);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

8
opencl/test/unit_test/command_queue/enqueue_read_image_tests.cpp
View File

@ -251,7 +251,7 @@ HWTEST_F(EnqueueReadImageTest, GivenImage1DarrayWhenReadImageIsCalledThenRowPitc
EBuiltInOps::Type copyBuiltIn = EBuiltInOps::CopyImage3dToBuffer;
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
copyBuiltIn,
pCmdQ->getDevice());
pCmdQ->getClDevice());
// substitute original builder with mock builder
auto oldBuilder = builtIns->setBuiltinDispatchInfoBuilder(
@ -270,7 +270,7 @@ HWTEST_F(EnqueueReadImageTest, GivenImage1DarrayWhenReadImageIsCalledThenRowPitc
EnqueueReadImageHelper<>::enqueueReadImage(pCmdQ, srcImage, CL_TRUE, origin, region, rowPitch, slicePitch);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(copyBuiltIn,
pCmdQ->getDevice()));
pCmdQ->getClDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(params->srcRowPitch, slicePitch);
@ -499,7 +499,7 @@ HWTEST_P(MipMapReadImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalled
auto image_type = (cl_mem_object_type)GetParam();
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
// substitute original builder with mock builder
auto oldBuilder = builtIns->setBuiltinDispatchInfoBuilder(
@ -561,7 +561,7 @@ HWTEST_P(MipMapReadImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalled
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getDevice()));
pCmdQ->getClDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(expectedMipLevel, params->srcMipLevel);

12
opencl/test/unit_test/command_queue/enqueue_svm_mem_copy_tests.cpp
View File

@ -77,7 +77,7 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
// retrieve original builder
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &origBuilder);
// substitute original builder with mock builder
@ -111,7 +111,7 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
// check if original builder is restored correctly
auto &restoredBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
EXPECT_EQ(&origBuilder, &restoredBuilder);
// use mock builder to validate builder's input / output
@ -154,7 +154,7 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
// retrieve original builder
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &origBuilder);
// substitute original builder with mock builder
@ -188,7 +188,7 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
// check if original builder is restored correctly
auto &restoredBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
EXPECT_EQ(&origBuilder, &restoredBuilder);
auto &ultCsr = pDevice->getUltCommandStreamReceiver<FamilyType>();
@ -236,7 +236,7 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
// retrieve original builder
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &origBuilder);
// substitute original builder with mock builder
@ -270,7 +270,7 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
// check if original builder is restored correctly
auto &restoredBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
EXPECT_EQ(&origBuilder, &restoredBuilder);
auto &ultCsr = pDevice->getUltCommandStreamReceiver<FamilyType>();

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

@ -78,7 +78,7 @@ HWTEST_P(EnqueueSvmMemFillTest, givenEnqueueSVMMemFillWhenUsingFillBufferBuilder
// retrieve original builder
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &origBuilder);
// substitute original builder with mock builder
@ -112,7 +112,7 @@ HWTEST_P(EnqueueSvmMemFillTest, givenEnqueueSVMMemFillWhenUsingFillBufferBuilder
// check if original builder is restored correctly
auto &restoredBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
EXPECT_EQ(&origBuilder, &restoredBuilder);
// use mock builder to validate builder's input / output

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, *pClDevice, true, &retVal));
std::unique_ptr<Program> program(Program::create("FillBufferBytes", context, context->getDevices(), true, &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, *pClDevice, true, &retVal));
auto program = clUniquePtr(Program::create("FillBufferBytes", context, context->getDevices(), true, &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/enqueue_write_buffer_rect_tests.cpp
View File

@ -147,7 +147,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferRectTest, WhenWritingBufferThenInd
enqueueWriteBufferRect2D<FamilyType>();
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferRect,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

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

@ -139,7 +139,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, WhenWritingBufferThenIndirectDataIsAdded) {
EnqueueWriteBufferHelper<>::enqueueWriteBuffer(pCmdQ, srcBuffer.get(), EnqueueWriteBufferTraits::blocking);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

8
opencl/test/unit_test/command_queue/enqueue_write_image_tests.cpp
View File

@ -232,7 +232,7 @@ HWTEST_F(EnqueueWriteImageTest, GivenImage1DarrayWhenWriteImageIsCalledThenRowPi
EBuiltInOps::Type copyBuiltIn = EBuiltInOps::CopyBufferToImage3d;
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
copyBuiltIn,
pCmdQ->getDevice());
pCmdQ->getClDevice());
// substitute original builder with mock builder
auto oldBuilder = builtIns->setBuiltinDispatchInfoBuilder(
@ -252,7 +252,7 @@ HWTEST_F(EnqueueWriteImageTest, GivenImage1DarrayWhenWriteImageIsCalledThenRowPi
EnqueueWriteImageHelper<>::enqueueWriteImage(pCmdQ, destImage, CL_FALSE, origin, region, rowPitch, slicePitch);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(copyBuiltIn,
pCmdQ->getDevice()));
pCmdQ->getClDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(params->dstRowPitch, slicePitch);
@ -427,7 +427,7 @@ HWTEST_P(MipMapWriteImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalle
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getDevice());
pCmdQ->getClDevice());
// substitute original builder with mock builder
auto oldBuilder = builtIns->setBuiltinDispatchInfoBuilder(
@ -492,7 +492,7 @@ HWTEST_P(MipMapWriteImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalle
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getDevice()));
pCmdQ->getClDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(expectedMipLevel, params->dstMipLevel);

14
opencl/test/unit_test/command_queue/get_size_required_buffer_tests.cpp
View File

@ -77,7 +77,7 @@ HWTEST_F(GetSizeRequiredBufferTest, WhenFillingBufferThenHeapsAndCommandBufferCo
EXPECT_EQ(CL_SUCCESS, retVal);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -131,7 +131,7 @@ HWTEST_F(GetSizeRequiredBufferTest, WhenCopyingBufferThenHeapsAndCommandBufferCo
EXPECT_EQ(CL_SUCCESS, retVal);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -186,7 +186,7 @@ HWTEST_F(GetSizeRequiredBufferTest, WhenReadingBufferNonBlockingThenHeapsAndComm
CL_FALSE);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -241,7 +241,7 @@ HWTEST_F(GetSizeRequiredBufferTest, WhenReadingBufferBlockingThenThenHeapsAndCom
CL_TRUE);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -296,7 +296,7 @@ HWTEST_F(GetSizeRequiredBufferTest, WhenWritingBufferNonBlockingThenHeapsAndComm
EXPECT_EQ(CL_SUCCESS, retVal);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -348,7 +348,7 @@ HWTEST_F(GetSizeRequiredBufferTest, WhenWritingBufferBlockingThenHeapsAndCommand
EXPECT_EQ(CL_SUCCESS, retVal);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -384,7 +384,7 @@ HWTEST_F(GetSizeRequiredBufferTest, WhenWritingBufferBlockingThenHeapsAndCommand
HWTEST_F(GetSizeRequiredBufferTest, givenMultipleKernelRequiringSshWhenTotalSizeIsComputedThenItIsProperlyAligned) {
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

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

@ -68,7 +68,7 @@ HWTEST_F(GetSizeRequiredImageTest, WhenCopyingImageThenHeapsAndCommandBufferCons
EXPECT_EQ(CL_SUCCESS, retVal);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -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, *pClDevice, true, nullptr));
std::unique_ptr<Program> program(Program::create("CopyImageToImage3d", context, context->getDevices(), true, 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));
@ -172,7 +172,7 @@ HWTEST_F(GetSizeRequiredImageTest, WhenReadingImageNonBlockingThenHeapsAndComman
EXPECT_EQ(CL_SUCCESS, retVal);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -227,7 +227,7 @@ HWTEST_F(GetSizeRequiredImageTest, WhenReadingImageBlockingThenHeapsAndCommandBu
EXPECT_EQ(CL_SUCCESS, retVal);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -282,7 +282,7 @@ HWTEST_F(GetSizeRequiredImageTest, WhenWritingImageNonBlockingThenHeapsAndComman
EXPECT_EQ(CL_SUCCESS, retVal);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -337,7 +337,7 @@ HWTEST_F(GetSizeRequiredImageTest, WhenWritingImageBlockingThenHeapsAndCommandBu
EXPECT_EQ(CL_SUCCESS, retVal);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getDevice());
pCmdQ->getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

3
opencl/test/unit_test/fixtures/run_kernel_fixture.h
View File

@ -17,7 +17,6 @@ struct CommandStreamFixture;
// helper functions to enforce MockCompiler input files
inline void overwriteBuiltInBinaryName(
Device *pDevice,
const std::string &filename,
bool appendOptionsToFileName = false) {
// set mock compiler to return expected kernel...
@ -34,7 +33,7 @@ inline void overwriteBuiltInBinaryName(
gEnvironment->igcPushDebugVars(igcDebugVars);
}
inline void restoreBuiltInBinaryName(Device *pDevice) {
inline void restoreBuiltInBinaryName() {
gEnvironment->igcPopDebugVars();
gEnvironment->fclPopDebugVars();
}

10
opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp
View File

@ -68,7 +68,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, WhenProgramInterfaceDescriptor
ASSERT_NE(nullptr, dstImage.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
cmdQ.getDevice());
cmdQ.getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -141,7 +141,7 @@ HWTEST_F(HardwareCommandsTest, WhenCrossThreadDataIsCreatedThenOnlyRequiredSpace
ASSERT_NE(nullptr, dstImage.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
cmdQ.getDevice());
cmdQ.getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -290,7 +290,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, WhenAllocatingIndirectStateRes
ASSERT_NE(nullptr, dstImage.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
cmdQ.getDevice());
cmdQ.getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@ -509,7 +509,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, whenSendingIndirectStateThenKe
std::unique_ptr<Image> img(Image2dHelper<>::create(pContext));
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
cmdQ.getDevice());
cmdQ.getClDevice());
BuiltinOpParams dc;
dc.srcMemObj = img.get();
@ -592,7 +592,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, WhenSendingIndirectStateThenBi
ASSERT_NE(nullptr, dstImage.get());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
cmdQ.getDevice());
cmdQ.getClDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

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(), *device.get(), true, &retVal));
program.reset(Program::create("FillBufferBytes", context.get(), context->getDevices(), true, &retVal));
EXPECT_EQ(CL_SUCCESS, retVal);
cl_device_id clDevice = device.get();
program->build(1, &clDevice, nullptr, nullptr, nullptr, false);

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

@ -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, *pClDevice, true, nullptr)};
std::unique_ptr<MockProgram> program{Program::create<MockProgram>("", pContext, pContext->getDevices(), true, 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, *pClDevice, true, nullptr)};
std::unique_ptr<MockProgram> program{Program::create<MockProgram>("", pContext, pContext->getDevices(), true, 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, *pClDevice, true, nullptr));
std::unique_ptr<MockProgram> program(Program::create<MockProgram>("", pContext, pContext->getDevices(), true, 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, *pClDevice, true, nullptr)};
std::unique_ptr<MockProgram> program{Program::create<MockProgram>("", pContext, pContext->getDevices(), true, nullptr)};
if (is32bit) {
EXPECT_TRUE(CompilerOptions::contains(program->getInternalOptions(), CompilerOptions::greaterThan4gbBuffersRequired)) << program->getInternalOptions();
} else {
@ -1911,7 +1911,7 @@ TEST_F(ProgramTests, GivenContextWhenCreateProgramThenIncrementContextRefCount)
auto initialApiRefCount = pContext->getReference();
auto initialInternalRefCount = pContext->getRefInternalCount();
MockProgram *program = new MockProgram(pContext, false, toClDeviceVector(*pClDevice));
MockProgram *program = new MockProgram(pContext, false, pContext->getDevices());
EXPECT_EQ(pContext->getReference(), initialApiRefCount);
EXPECT_EQ(pContext->getRefInternalCount(), initialInternalRefCount + 1);
@ -1924,9 +1924,9 @@ TEST_F(ProgramTests, GivenContextWhenCreateProgramFromSourceThenIncrementContext
auto initialApiRefCount = pContext->getReference();
auto initialInternalRefCount = pContext->getRefInternalCount();
auto tempProgram = Program::create("", nullptr, *pClDevice, false, nullptr);
auto tempProgram = Program::create("", nullptr, pContext->getDevices(), false, nullptr);
EXPECT_FALSE(tempProgram->getIsBuiltIn());
auto program = Program::create("", pContext, *pClDevice, false, nullptr);
auto program = Program::create("", pContext, pContext->getDevices(), false, nullptr);
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, *pClDevice, true, nullptr);
auto tempProgram = Program::create("", nullptr, pContext->getDevices(), true, nullptr);
EXPECT_TRUE(tempProgram->getIsBuiltIn());
auto program = Program::create("", pContext, *pClDevice, true, nullptr);
auto program = Program::create("", pContext, pContext->getDevices(), true, nullptr);
EXPECT_TRUE(program->getIsBuiltIn());
EXPECT_EQ(pContext->getReference(), initialApiRefCount);
@ -1960,12 +1960,12 @@ TEST_F(ProgramTests, GivenContextWhenCreateBuiltInProgramFromSourceThenDontIncre
TEST_F(ProgramTests, WhenBuildingProgramThenPointerToProgramIsReturned) {
cl_int retVal = CL_DEVICE_NOT_FOUND;
Program *pProgram = Program::create("", pContext, *pClDevice, false, &retVal);
Program *pProgram = Program::create("", pContext, pContext->getDevices(), false, &retVal);
EXPECT_NE(nullptr, pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
delete pProgram;
pProgram = Program::create("", pContext, *pClDevice, false, nullptr);
pProgram = Program::create("", pContext, pContext->getDevices(), false, nullptr);
EXPECT_NE(nullptr, pProgram);
delete pProgram;
}

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

@ -94,9 +94,7 @@ TEST_F(ProgramWithBlockKernelsTest, GivenKernelWithBlockKernelsWhenProgramIsLink
CreateProgramFromBinary(pContext, pContext->getDevices(), "simple_block_kernel", "-cl-std=CL2.0");
const char *buildOptions = "-cl-std=CL2.0";
overwriteBuiltInBinaryName(
&pPlatform->getClDevice(0)->getDevice(),
"simple_block_kernel", true);
overwriteBuiltInBinaryName("simple_block_kernel", true);
ASSERT_NE(nullptr, pProgram);
@ -121,7 +119,7 @@ TEST_F(ProgramWithBlockKernelsTest, GivenKernelWithBlockKernelsWhenProgramIsLink
break;
}
}
restoreBuiltInBinaryName(nullptr);
restoreBuiltInBinaryName();
delete programLinked;
}