intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-21 01:04:57 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add executionEnvironment field to Program

Browse Source 
Change-Id: Id624177aa3f0b5525bac86e2e0a935ebaf53480e
Signed-off-by: Maciej Dziuban <maciej.dziuban@intel.com>
This commit is contained in:
Maciej Dziuban
2018-08-06 09:46:57 +02:00
committed by sys_ocldev
parent 956ee41c71
commit 524737af39
56 changed files with 294 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
runtime/api/api.cpp
View File

@@ -1361,7 +1361,7 @@ cl_program CL_API_CALL clLinkProgram(cl_context context,
pContext = castToObject<Context>(context);
}
if (pContext != nullptr) {
program = new Program(pContext, false);
program = new Program(*pContext->getDevice(0)->getExecutionEnvironment(), pContext, false);
retVal = program->link(numDevices, deviceList, options,
numInputPrograms, inputPrograms,
funcNotify, userData);

10
runtime/program/create.inl
View File

@@ -37,7 +37,7 @@ T *Program::create(
auto pContext = castToObject<Context>(context);
DEBUG_BREAK_IF(!pContext);
auto program = new T(pContext, false);
auto program = new T(*pContext->getDevice(0)->getExecutionEnvironment(), pContext, false);
auto retVal = program->createProgramFromBinary(binaries[0], lengths[0]);
@@ -76,7 +76,7 @@ T *Program::create(
lengths);
if (CL_SUCCESS == retVal) {
program = new T(pContext, false);
program = new T(*pContext->getDevice(0)->getExecutionEnvironment(), pContext, false);
program->sourceCode.swap(combinedString);
}
@@ -99,7 +99,7 @@ T *Program::create(
}
if (retVal == CL_SUCCESS) {
program = new T();
program = new T(*device.getExecutionEnvironment());
program->setSource((char *)nullTerminatedString);
program->context = context;
program->isBuiltIn = isBuiltIn;
@@ -136,7 +136,7 @@ T *Program::createFromGenBinary(
}
if (CL_SUCCESS == retVal) {
program = new T(context, isBuiltIn);
program = new T(executionEnvironment, context, isBuiltIn);
program->numDevices = 1;
program->storeGenBinary(binary, size);
program->isCreatedFromBinary = true;
@@ -164,7 +164,7 @@ T *Program::createFromIL(Context *ctx,
return nullptr;
}
T *program = new T(ctx, false);
T *program = new T(*ctx->getDevice(0)->getExecutionEnvironment(), ctx, false);
errcodeRet = program->createProgramFromBinary(il, length);
if (errcodeRet != CL_SUCCESS) {
delete program;

6
runtime/program/program.cpp
View File

@@ -36,11 +36,13 @@ namespace OCLRT {
const std::string Program::clOptNameClVer("-cl-std=CL");
const std::string Program::clOptNameUniformWgs{"-cl-uniform-work-group-size"};
Program::Program() : Program(nullptr, false) {
Program::Program(ExecutionEnvironment &executionEnvironment) : Program(executionEnvironment, nullptr, false) {
numDevices = 0;
}
Program::Program(Context *context, bool isBuiltIn) : context(context), isBuiltIn(isBuiltIn) {
Program::Program(ExecutionEnvironment &executionEnvironment, Context *context, bool isBuiltIn) : executionEnvironment(executionEnvironment),
context(context),
isBuiltIn(isBuiltIn) {
if (this->context && !this->isBuiltIn) {
this->context->incRefInternal();
}

10
runtime/program/program.h
View File

@@ -41,6 +41,7 @@
namespace OCLRT {
class Context;
class CompilerInterface;
class ExecutionEnvironment;
template <>
struct OpenCLObjectMapper<_cl_program> {
typedef class Program DerivedType;
@@ -95,7 +96,7 @@ class Program : public BaseObject<_cl_program> {
size_t length,
cl_int &errcodeRet);
Program(Context *context, bool isBuiltIn);
Program(ExecutionEnvironment &executionEnvironment, Context *context, bool isBuiltIn);
~Program() override;
Program(const Program &) = delete;
@@ -144,6 +145,10 @@ class Program : public BaseObject<_cl_program> {
return context;
}
ExecutionEnvironment &peekExecutionEnvironment() const {
return executionEnvironment;
}
const Device &getDevice(cl_uint deviceOrdinal) const {
return *pDevice;
}
@@ -240,7 +245,7 @@ class Program : public BaseObject<_cl_program> {
}
protected:
Program();
Program(ExecutionEnvironment &executionEnvironment);
MOCKABLE_VIRTUAL bool isSafeToSkipUnhandledToken(unsigned int token) const;
@@ -322,6 +327,7 @@ class Program : public BaseObject<_cl_program> {
std::map<const Device*, std::string> buildLog;
ExecutionEnvironment& executionEnvironment;
Context* context;
Device* pDevice;
cl_uint numDevices;

2
unit_tests/accelerators/media_image_arg_tests.cpp
View File

@@ -48,7 +48,7 @@ class MediaImageSetArgTest : public DeviceFixture,
void SetUp() override {
DeviceFixture::SetUp();
pKernelInfo = KernelInfo::create();
program = std::make_unique<MockProgram>();
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
kernelHeader.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;

4
unit_tests/api/cl_api_tests.cpp
View File

@@ -47,7 +47,7 @@ void api_fixture::SetUp() {
pCommandQueue = new CommandQueue(pContext, pDevice, 0);
pProgram = new MockProgram(pContext, false);
pProgram = new MockProgram(*pDevice->getExecutionEnvironment(), pContext, false);
pKernel = new MockKernel(pProgram, *pProgram->MockProgram::getKernelInfo(), *pDevice);
ASSERT_NE(nullptr, pKernel);
@@ -76,7 +76,7 @@ void api_fixture_using_aligned_memory_manager::SetUp() {
commandQueue = new CommandQueue(context, devPtr, 0);
program = new MockProgram(ctxPtr, false);
program = new MockProgram(*device->getExecutionEnvironment(), ctxPtr, false);
Program *prgPtr = reinterpret_cast<Program *>(program);
kernel = new MockKernel(prgPtr, *program->MockProgram::getKernelInfo(), *devPtr);

6
unit_tests/api/cl_create_kernel_tests.inl
View File

@@ -92,7 +92,7 @@ TEST_F(clCreateKernelTests, givenInvalidKernelWhenCreatingNewKernelThenReturnClI
KernelInfo *pKernelInfo = KernelInfo::create();
pKernelInfo->isValid = false;
std::unique_ptr<MockProgram> pMockProg = std::make_unique<MockProgram>(pContext, false);
std::unique_ptr<MockProgram> pMockProg = std::make_unique<MockProgram>(*pPlatform->peekExecutionEnvironment(), pContext, false);
pMockProg->addKernelInfo(pKernelInfo);
pMockProg->SetBuildStatus(CL_BUILD_SUCCESS);
@@ -173,7 +173,7 @@ TEST_F(clCreateKernelTests, givenNullKernelNameWhenCreatingNewKernelThenReturnCl
KernelInfo *pKernelInfo = KernelInfo::create();
pKernelInfo->isValid = true;
std::unique_ptr<MockProgram> pMockProg = std::make_unique<MockProgram>(pContext, false);
std::unique_ptr<MockProgram> pMockProg = std::make_unique<MockProgram>(*pPlatform->peekExecutionEnvironment(), pContext, false);
pMockProg->addKernelInfo(pKernelInfo);
kernel = clCreateKernel(
@@ -199,7 +199,7 @@ TEST_F(clCreateKernelTests, invalidProgram) {
TEST_F(clCreateKernelTests, givenProgramWithBuildErrorWhenCreatingNewKernelThenReturnClInvalidProgramExecutable) {
cl_kernel kernel = nullptr;
std::unique_ptr<MockProgram> pMockProg = std::make_unique<MockProgram>(pContext, false);
std::unique_ptr<MockProgram> pMockProg = std::make_unique<MockProgram>(*pPlatform->peekExecutionEnvironment(), pContext, false);
pMockProg->SetBuildStatus(CL_BUILD_ERROR);
kernel = clCreateKernel(

2
unit_tests/built_ins/built_in_tests.cpp
View File

@@ -458,7 +458,7 @@ HWTEST_F(BuiltInTests, givenKernelWithAuxTranslationRequiredWhenEnqueueCalledThe
auto mockAuxBuiltInOp = new MockAuxBuilInOp<FamilyType>(*pBuiltIns, *pContext, *pDevice);
pBuiltIns->BuiltinOpsBuilders[static_cast<uint32_t>(EBuiltInOps::AuxTranslation)].first.reset(mockAuxBuiltInOp);
MockProgram mockProgram;
MockProgram mockProgram(*pDevice->getExecutionEnvironment());
auto mockBuiltinKernel = MockKernel::create(*pDevice, &mockProgram);
mockAuxBuiltInOp->usedKernels.at(0).reset(mockBuiltinKernel);

4
unit_tests/command_queue/command_queue_tests.cpp
View File

@@ -920,7 +920,7 @@ TEST(CommandQueue, givenEnqueueAcquireSharedObjectsCallWhenAcquireFailsThenCorre
HWTEST_F(CommandQueueCommandStreamTest, givenDebugKernelWhenSetupDebugSurfaceIsCalledThenSurfaceStateIsCorrectlySet) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
MockProgram program;
MockProgram program(*pDevice->getExecutionEnvironment());
program.enableKernelDebug();
std::unique_ptr<MockDebugKernel> kernel(MockKernel::create<MockDebugKernel>(*pDevice, &program));
CommandQueue cmdQ(context.get(), pDevice, 0);
@@ -939,7 +939,7 @@ HWTEST_F(CommandQueueCommandStreamTest, givenDebugKernelWhenSetupDebugSurfaceIsC
HWTEST_F(CommandQueueCommandStreamTest, givenCsrWithDebugSurfaceAllocatedWhenSetupDebugSurfaceIsCalledThenDebugSurfaceIsReused) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
MockProgram program;
MockProgram program(*pDevice->getExecutionEnvironment());
program.enableKernelDebug();
std::unique_ptr<MockDebugKernel> kernel(MockKernel::create<MockDebugKernel>(*pDevice, &program));
CommandQueue cmdQ(context.get(), pDevice, 0);

64
unit_tests/command_queue/dispatch_walker_tests.cpp
View File

@@ -46,6 +46,8 @@ struct DispatchWalkerTest : public CommandQueueFixture, public DeviceFixture, pu
DeviceFixture::SetUp();
CommandQueueFixture::SetUp(nullptr, pDevice, 0);
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
memset(&kernelHeader, 0, sizeof(kernelHeader));
kernelHeader.KernelHeapSize = sizeof(kernelIsa);
@@ -88,7 +90,7 @@ struct DispatchWalkerTest : public CommandQueueFixture, public DeviceFixture, pu
DeviceFixture::TearDown();
}
MockProgram program;
std::unique_ptr<MockProgram> program;
SKernelBinaryHeaderCommon kernelHeader;
SPatchDataParameterStream dataParameterStream;
@@ -116,7 +118,7 @@ HWTEST_F(DispatchWalkerTest, computeDimensions) {
}
HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, shouldntChangeCommandStreamMemory) {
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
auto &commandStream = pCmdQ->getCS(4096);
@@ -164,7 +166,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, noLocalIdsShouldntCrash) {
threadPayload.LocalIDZPresent = 0;
threadPayload.UnusedPerThreadConstantPresent = 1;
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
auto &commandStream = pCmdQ->getCS(4096);
@@ -207,7 +209,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, noLocalIdsShouldntCrash) {
}
HWTEST_F(DispatchWalkerTest, dataParameterWorkDimensionswithDefaultLwsAlgorithm) {
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
kernelInfo.workloadInfo.workDimOffset = 0;
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
@@ -237,7 +239,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterWorkDimensionswithSquaredLwsAlgorithm)
DebugManagerStateRestore dbgRestore;
DebugManager.flags.EnableComputeWorkSizeND.set(false);
DebugManager.flags.EnableComputeWorkSizeSquared.set(true);
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
kernelInfo.workloadInfo.workDimOffset = 0;
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
@@ -266,7 +268,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterWorkDimensionswithSquaredLwsAlgorithm)
HWTEST_F(DispatchWalkerTest, dataParameterWorkDimensionswithNDLwsAlgorithm) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.EnableComputeWorkSizeND.set(true);
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
kernelInfo.workloadInfo.workDimOffset = 0;
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
@@ -296,7 +298,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterWorkDimensionswithOldLwsAlgorithm) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.EnableComputeWorkSizeND.set(false);
DebugManager.flags.EnableComputeWorkSizeSquared.set(false);
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
kernelInfo.workloadInfo.workDimOffset = 0;
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
@@ -323,7 +325,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterWorkDimensionswithOldLwsAlgorithm) {
}
HWTEST_F(DispatchWalkerTest, dataParameterNumWorkGroups) {
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
kernelInfo.workloadInfo.numWorkGroupsOffset[0] = 0;
kernelInfo.workloadInfo.numWorkGroupsOffset[1] = 4;
kernelInfo.workloadInfo.numWorkGroupsOffset[2] = 8;
@@ -355,7 +357,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterNumWorkGroups) {
HWTEST_F(DispatchWalkerTest, dataParameterNoLocalWorkSizeWithOutComputeND) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.EnableComputeWorkSizeND.set(false);
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
kernelInfo.workloadInfo.localWorkSizeOffsets[0] = 0;
kernelInfo.workloadInfo.localWorkSizeOffsets[1] = 4;
kernelInfo.workloadInfo.localWorkSizeOffsets[2] = 8;
@@ -386,7 +388,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterNoLocalWorkSizeWithOutComputeND) {
HWTEST_F(DispatchWalkerTest, dataParameterNoLocalWorkSizeWithComputeND) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.EnableComputeWorkSizeND.set(true);
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
kernelInfo.workloadInfo.localWorkSizeOffsets[0] = 0;
kernelInfo.workloadInfo.localWorkSizeOffsets[1] = 4;
kernelInfo.workloadInfo.localWorkSizeOffsets[2] = 8;
@@ -418,7 +420,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterNoLocalWorkSizeWithComputeSquared) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.EnableComputeWorkSizeSquared.set(true);
DebugManager.flags.EnableComputeWorkSizeND.set(false);
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
kernelInfo.workloadInfo.localWorkSizeOffsets[0] = 0;
kernelInfo.workloadInfo.localWorkSizeOffsets[1] = 4;
kernelInfo.workloadInfo.localWorkSizeOffsets[2] = 8;
@@ -450,7 +452,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterNoLocalWorkSizeWithOutComputeSquaredAn
DebugManagerStateRestore dbgRestore;
DebugManager.flags.EnableComputeWorkSizeSquared.set(false);
DebugManager.flags.EnableComputeWorkSizeND.set(false);
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
kernelInfo.workloadInfo.localWorkSizeOffsets[0] = 0;
kernelInfo.workloadInfo.localWorkSizeOffsets[1] = 4;
kernelInfo.workloadInfo.localWorkSizeOffsets[2] = 8;
@@ -479,7 +481,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterNoLocalWorkSizeWithOutComputeSquaredAn
}
HWTEST_F(DispatchWalkerTest, dataParameterLocalWorkSize) {
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
kernelInfo.workloadInfo.localWorkSizeOffsets[0] = 0;
kernelInfo.workloadInfo.localWorkSizeOffsets[1] = 4;
kernelInfo.workloadInfo.localWorkSizeOffsets[2] = 8;
@@ -509,7 +511,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterLocalWorkSize) {
}
HWTEST_F(DispatchWalkerTest, dataParameterLocalWorkSizes) {
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
kernelInfo.workloadInfo.localWorkSizeOffsets[0] = 0;
kernelInfo.workloadInfo.localWorkSizeOffsets[1] = 4;
kernelInfo.workloadInfo.localWorkSizeOffsets[2] = 8;
@@ -545,13 +547,13 @@ HWTEST_F(DispatchWalkerTest, dataParameterLocalWorkSizes) {
}
HWTEST_F(DispatchWalkerTest, dataParameterLocalWorkSizeForSplitKernel) {
MockKernel kernel1(&program, kernelInfo, *pDevice);
MockKernel kernel1(program.get(), kernelInfo, *pDevice);
kernelInfo.workloadInfo.localWorkSizeOffsets[0] = 0;
kernelInfo.workloadInfo.localWorkSizeOffsets[1] = 4;
kernelInfo.workloadInfo.localWorkSizeOffsets[2] = 8;
ASSERT_EQ(CL_SUCCESS, kernel1.initialize());
MockKernel kernel2(&program, kernelInfoWithSampler, *pDevice);
MockKernel kernel2(program.get(), kernelInfoWithSampler, *pDevice);
kernelInfoWithSampler.workloadInfo.localWorkSizeOffsets[0] = 12;
kernelInfoWithSampler.workloadInfo.localWorkSizeOffsets[1] = 16;
kernelInfoWithSampler.workloadInfo.localWorkSizeOffsets[2] = 20;
@@ -591,7 +593,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterLocalWorkSizeForSplitKernel) {
}
HWTEST_F(DispatchWalkerTest, dataParameterLocalWorkSizesForSplitWalker) {
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
kernelInfo.workloadInfo.localWorkSizeOffsets[0] = 0;
kernelInfo.workloadInfo.localWorkSizeOffsets[1] = 4;
kernelInfo.workloadInfo.localWorkSizeOffsets[2] = 8;
@@ -634,7 +636,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterLocalWorkSizesForSplitWalker) {
}
HWTEST_F(DispatchWalkerTest, dispatchWalkerDoesntConsumeCommandStreamWhenQueueIsBlocked) {
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
size_t globalOffsets[3] = {0, 0, 0};
@@ -674,7 +676,7 @@ HWTEST_F(DispatchWalkerTest, dispatchWalkerDoesntConsumeCommandStreamWhenQueueIs
}
HWTEST_F(DispatchWalkerTest, dispatchWalkerShouldGetRequiredHeapSizesFromKernelWhenQueueIsBlocked) {
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
size_t globalOffsets[3] = {0, 0, 0};
@@ -718,7 +720,7 @@ HWTEST_F(DispatchWalkerTest, dispatchWalkerShouldGetRequiredHeapSizesFromKernelW
}
HWTEST_F(DispatchWalkerTest, dispatchWalkerShouldGetRequiredHeapSizesFromMdiWhenQueueIsBlocked) {
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
MockMultiDispatchInfo multiDispatchInfo(&kernel);
@@ -753,9 +755,9 @@ HWTEST_F(DispatchWalkerTest, dispatchWalkerShouldGetRequiredHeapSizesFromMdiWhen
}
HWTEST_F(DispatchWalkerTest, dispatchWalkerWithMultipleDispatchInfo) {
MockKernel kernel1(&program, kernelInfo, *pDevice);
MockKernel kernel1(program.get(), kernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel1.initialize());
MockKernel kernel2(&program, kernelInfo, *pDevice);
MockKernel kernel2(program.get(), kernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel2.initialize());
MockMultiDispatchInfo multiDispatchInfo(std::vector<Kernel *>({&kernel1, &kernel2}));
@@ -788,9 +790,9 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, dispatchWalkerWithMultipleDispat
auto gpuAddress1 = kernelIsaAllocation->getGpuAddressToPatch();
auto gpuAddress2 = kernelIsaWithSamplerAllocation->getGpuAddressToPatch();
MockKernel kernel1(&program, kernelInfo, *pDevice);
MockKernel kernel1(program.get(), kernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel1.initialize());
MockKernel kernel2(&program, kernelInfoWithSampler, *pDevice);
MockKernel kernel2(program.get(), kernelInfoWithSampler, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel2.initialize());
MockMultiDispatchInfo multiDispatchInfo(std::vector<Kernel *>({&kernel1, &kernel2}));
@@ -875,9 +877,9 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, dispatchWalkerWithMultipleDispat
HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, dispatchWalkerWithMultipleDispatchInfoCorrectlyProgramsGpgpuWalkerIDOffset) {
using GPGPU_WALKER = typename FamilyType::GPGPU_WALKER;
MockKernel kernel1(&program, kernelInfo, *pDevice);
MockKernel kernel1(program.get(), kernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel1.initialize());
MockKernel kernel2(&program, kernelInfoWithSampler, *pDevice);
MockKernel kernel2(program.get(), kernelInfoWithSampler, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel2.initialize());
MockMultiDispatchInfo multiDispatchInfo(std::vector<Kernel *>({&kernel1, &kernel2}));
@@ -920,9 +922,9 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, dispatchWalkerWithMultipleDispat
HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, dispatchWalkerWithMultipleDispatchInfoAndDifferentKernelsCorrectlyProgramsGpgpuWalkerThreadGroupIdStartingCoordinates) {
using GPGPU_WALKER = typename FamilyType::GPGPU_WALKER;
MockKernel kernel1(&program, kernelInfo, *pDevice);
MockKernel kernel1(program.get(), kernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel1.initialize());
MockKernel kernel2(&program, kernelInfoWithSampler, *pDevice);
MockKernel kernel2(program.get(), kernelInfoWithSampler, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel2.initialize());
MockMultiDispatchInfo multiDispatchInfo(std::vector<Kernel *>({&kernel1, &kernel2}));
@@ -969,7 +971,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, dispatchWalkerWithMultipleDispat
HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, dispatchWalkerWithMultipleDispatchInfoButSameKernelCorrectlyProgramsGpgpuWalkerThreadGroupIdStartingCoordinates) {
using GPGPU_WALKER = typename FamilyType::GPGPU_WALKER;
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
DispatchInfo di1(&kernel, 1, {100, 1, 1}, {10, 1, 1}, {0, 0, 0}, {100, 1, 1}, {10, 1, 1}, {10, 1, 1}, {10, 1, 1}, {0, 0, 0});
@@ -1024,7 +1026,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, givenMultiDispatchWhenWhiteliste
auto &cmdStream = pCmdQ->getCS(0);
HardwareParse hwParser;
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
DispatchInfo di1(&kernel, 1, Vec3<size_t>(1, 1, 1), Vec3<size_t>(1, 1, 1), Vec3<size_t>(0, 0, 0));
@@ -1060,7 +1062,7 @@ TEST(DispatchWalker, calculateDispatchDim) {
HWTEST_F(DispatchWalkerTest, WhenCallingDefaultWaMethodsThenExpectNothing) {
auto &cmdStream = pCmdQ->getCS(0);
MockKernel kernel(&program, kernelInfo, *pDevice);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
EXPECT_EQ(CL_SUCCESS, kernel.initialize());
GpgpuWalkerHelper<GENX>::applyWADisableLSQCROPERFforOCL(&cmdStream, kernel, false);

4
unit_tests/command_queue/enqueue_debug_kernel_tests.cpp
View File

@@ -135,7 +135,7 @@ class GMockCommandQueueHw : public CommandQueueHw<GfxFamily> {
};
HWTEST_F(EnqueueDebugKernelSimpleTest, givenKernelFromProgramWithDebugEnabledWhenEnqueuedThenDebugSurfaceIsSetup) {
MockProgram program;
MockProgram program(*pDevice->getExecutionEnvironment());
program.enableKernelDebug();
std::unique_ptr<MockDebugKernel> kernel(MockKernel::create<MockDebugKernel>(*pDevice, &program));
std::unique_ptr<GMockCommandQueueHw<FamilyType>> mockCmdQ(new GMockCommandQueueHw<FamilyType>(context, pDevice, 0));
@@ -149,7 +149,7 @@ HWTEST_F(EnqueueDebugKernelSimpleTest, givenKernelFromProgramWithDebugEnabledWhe
}
HWTEST_F(EnqueueDebugKernelSimpleTest, givenKernelFromProgramWithoutDebugEnabledWhenEnqueuedThenDebugSurfaceIsNotSetup) {
MockProgram program;
MockProgram program(*pDevice->getExecutionEnvironment());
std::unique_ptr<MockDebugKernel> kernel(MockKernel::create<MockDebugKernel>(*pDevice, &program));
std::unique_ptr<NiceMock<GMockCommandQueueHw<FamilyType>>> mockCmdQ(new NiceMock<GMockCommandQueueHw<FamilyType>>(context, pDevice, nullptr));

2
unit_tests/command_stream/aub_subcapture_tests.cpp
View File

@@ -35,7 +35,7 @@ struct AubSubCaptureTest : public DeviceFixture,
public ::testing::Test {
void SetUp() override {
DeviceFixture::SetUp();
program = std::make_unique<MockProgram>();
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
kernelInfo.name = "kernel_name";
dbgRestore = new DebugManagerStateRestore();
}

16
unit_tests/compiler_interface/binary_cache_tests.cpp
View File

@@ -323,13 +323,15 @@ TEST_F(BinaryCacheTests, doNotCacheEmpty) {
}
TEST_F(BinaryCacheTests, loadNotFound) {
MockProgram program;
ExecutionEnvironment executionEnvironment;
MockProgram program(executionEnvironment);
bool ret = cache->loadCachedBinary("----do-not-exists----", program);
EXPECT_FALSE(ret);
}
TEST_F(BinaryCacheTests, cacheThenLoad) {
MockProgram program;
ExecutionEnvironment executionEnvironment;
MockProgram program(executionEnvironment);
static const char *hash = "SOME_HASH";
std::unique_ptr<char> data(new char[32]);
for (size_t i = 0; i < 32; i++)
@@ -352,7 +354,7 @@ TEST_F(CompilerInterfaceCachedTests, canInjectCache) {
}
TEST_F(CompilerInterfaceCachedTests, notCachedAndIgcFailed) {
MockContext context(pDevice, true);
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
BinaryCacheMock cache;
TranslationArgs inputArgs;
@@ -383,7 +385,7 @@ TEST_F(CompilerInterfaceCachedTests, notCachedAndIgcFailed) {
TEST_F(CompilerInterfaceCachedTests, wasCached) {
MockContext context(pDevice, true);
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
BinaryCacheMock cache;
TranslationArgs inputArgs;
@@ -414,7 +416,7 @@ TEST_F(CompilerInterfaceCachedTests, wasCached) {
TEST_F(CompilerInterfaceCachedTests, builtThenCached) {
MockContext context(pDevice, true);
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
BinaryCacheMock cache;
TranslationArgs inputArgs;
@@ -444,7 +446,7 @@ TEST_F(CompilerInterfaceCachedTests, builtThenCached) {
TEST_F(CompilerInterfaceCachedTests, givenKernelWithoutIncludesAndBinaryInCacheWhenCompilationRequestedThenFCLIsNotCalled) {
MockContext context(pDevice, true);
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
BinaryCacheMock cache;
TranslationArgs inputArgs;
@@ -478,7 +480,7 @@ TEST_F(CompilerInterfaceCachedTests, givenKernelWithoutIncludesAndBinaryInCacheW
TEST_F(CompilerInterfaceCachedTests, givenKernelWithIncludesAndBinaryInCacheWhenCompilationRequestedThenFCLIsCalled) {
MockContext context(pDevice, true);
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
BinaryCacheMock cache;
TranslationArgs inputArgs;

10
unit_tests/compiler_interface/compiler_interface_tests.cpp
View File

@@ -77,7 +77,7 @@ class CompilerInterfaceTest : public DeviceFixture,
cl_device_id clDevice = pDevice;
pContext = Context::create<MockContext>(nullptr, DeviceVector(&clDevice, 1), nullptr, nullptr, retVal);
pProgram = new Program(pContext, false);
pProgram = new Program(*pDevice->getExecutionEnvironment(), pContext, false);
inputArgs.pInput = (char *)pSource;
inputArgs.InputSize = (uint32_t)sourceSize;
@@ -286,7 +286,7 @@ TEST_F(CompilerInterfaceTest, CompileClToIr) {
}
TEST_F(CompilerInterfaceTest, GivenProgramCreatedFromIrWhenCompileIsCalledThenIrFormatIsPreserved) {
MockProgram prog(pContext, false);
MockProgram prog(*pDevice->getExecutionEnvironment(), pContext, false);
prog.programBinaryType = CL_PROGRAM_BINARY_TYPE_INTERMEDIATE;
prog.isSpirV = true;
retVal = pCompilerInterface->compile(prog, inputArgs);
@@ -498,7 +498,7 @@ TEST_F(CompilerInterfaceTest, igcBuildFailure) {
TEST_F(CompilerInterfaceTest, CompileAndLinkSpirToIsa) {
// compile and link from SPIR binary to gen ISA
MockProgram program(pContext, false);
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
char binary[] = "BC\xc0\xde ";
auto retVal = program.createProgramFromBinary(binary, sizeof(binary));
EXPECT_EQ(CL_SUCCESS, retVal);
@@ -510,7 +510,7 @@ TEST_F(CompilerInterfaceTest, CompileAndLinkSpirToIsa) {
TEST_F(CompilerInterfaceTest, BuildSpirToIsa) {
// build from SPIR binary to gen ISA
MockProgram program(pContext, false);
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
char binary[] = "BC\xc0\xde ";
auto retVal = program.createProgramFromBinary(binary, sizeof(binary));
EXPECT_EQ(CL_SUCCESS, retVal);
@@ -520,7 +520,7 @@ TEST_F(CompilerInterfaceTest, BuildSpirToIsa) {
TEST_F(CompilerInterfaceTest, BuildSpirvToIsa) {
// build from SPIR binary to gen ISA
MockProgram program(pContext, false);
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
uint64_t spirv[16] = {0x03022307};
auto retVal = program.createProgramFromBinary(spirv, sizeof(spirv));
EXPECT_EQ(CL_SUCCESS, retVal);

2
unit_tests/device_queue/device_queue_tests.cpp
View File

@@ -317,7 +317,7 @@ TEST_F(DeviceQueueTest, sizeOfDshBuffer) {
TEST_F(DeviceQueueTest, dispatchScheduler) {
DeviceQueue devQueue;
MockContext context;
MockProgram program;
MockProgram program(*device->getExecutionEnvironment());
CommandQueue cmdQ(nullptr, nullptr, 0);
KernelInfo info;
MockSchedulerKernel *kernel = new MockSchedulerKernel(&program, info, *device);

2
unit_tests/fixtures/kernel_arg_fixture.cpp
View File

@@ -65,7 +65,7 @@ void KernelImageArgTest::SetUp() {
pKernelInfo->kernelArgInfo[0].isImage = true;
DeviceFixture::SetUp();
program.reset(new OCLRT::MockProgram);
program = std::make_unique<OCLRT::MockProgram>(*pDevice->getExecutionEnvironment());
pKernel.reset(new OCLRT::MockKernel(program.get(), *pKernelInfo, *pDevice));
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());

2
unit_tests/fixtures/kernel_data_fixture.h
View File

@@ -64,7 +64,7 @@ class KernelDataTest : public testing::Test {
void SetUp() override {
kernelBinaryHeader.KernelNameSize = kernelNameSize;
pDevice = MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr);
program = std::make_unique<MockProgram>();
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
}
void TearDown() override {

2
unit_tests/fixtures/preemption_fixture.cpp
View File

@@ -56,7 +56,7 @@ void DevicePreemptionTests::SetUp() {
executionEnvironment.reset(new SPatchExecutionEnvironment);
memset(executionEnvironment.get(), 0, sizeof(SPatchExecutionEnvironment));
kernelInfo->patchInfo.executionEnvironment = executionEnvironment.get();
program.reset(new MockProgram);
program = std::make_unique<MockProgram>(*device->getExecutionEnvironment());
kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
dispatchInfo.reset(new DispatchInfo(kernel.get(), 1, Vec3<size_t>(1, 1, 1), Vec3<size_t>(1, 1, 1), Vec3<size_t>(0, 0, 0)));

2
unit_tests/fixtures/scenario_test_fixture.h
View File

@@ -49,7 +49,7 @@ class ScenarioTest : public ::testing::Test,
cl_device_id clDevice = pDevice;
context = Context::create<MockContext>(nullptr, DeviceVector(&clDevice, 1), nullptr, nullptr, retVal);
commandQueue = new MockCommandQueue(context, pDevice, 0);
program = new MockProgram(context, false);
program = new MockProgram(*pDevice->getExecutionEnvironment(), context, false);
kernelInternals = new MockKernelWithInternals(*pDevice, context);
kernel = kernelInternals->mockKernel;

2
unit_tests/gtpin/gtpin_tests.cpp
View File

@@ -2263,7 +2263,7 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenOnKernelSubitIsCalledThenCo
pKernelInfo->heapInfo.pKernelHeader = &kernelHeader;
pKernelInfo->usesSsh = true;
std::unique_ptr<MockProgram> pProgramm(new MockProgram(context.get(), false));
auto pProgramm = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment(), context.get(), false);
std::unique_ptr<MockCommandQueue> cmdQ(new MockCommandQueue(context.get(), pDevice, nullptr));
std::unique_ptr<MockKernel> pKernel(new MockKernel(pProgramm.get(), *pKernelInfo, *pDevice));

22
unit_tests/helpers/base_object_tests.cpp
View File

@@ -100,6 +100,28 @@ class MockObject<Buffer> : public Buffer {
cl_ulong validMagic;
};
template <>
class MockObject<Program> : public Program {
public:
MockObject() : Program(*new ExecutionEnvironment()),
executionEnvironment(&this->peekExecutionEnvironment()) {}
void setInvalidMagic() {
validMagic = this->magic;
this->magic = 0x0101010101010101LL;
}
void setValidMagic() {
this->magic = validMagic;
}
bool isObjectValid() const {
return this->isValid();
}
cl_ulong validMagic;
std::unique_ptr<ExecutionEnvironment> executionEnvironment;
};
typedef ::testing::Types<
Platform,
IntelAccelerator,

2
unit_tests/helpers/dispatch_info_builder_tests.cpp
View File

@@ -79,7 +79,7 @@ class DispatchInfoBuilderFixture : public ContextFixture, public DeviceFixture {
pKernelInfo->kernelArgInfo[2].kernelArgPatchInfoVector[0].crossthreadOffset = 0x50;
pKernelInfo->kernelArgInfo[2].kernelArgPatchInfoVector[0].size = (uint32_t)sizeof(void *);
pProgram = new MockProgram(pContext, false);
pProgram = new MockProgram(*pDevice->getExecutionEnvironment(), pContext, false);
pKernel = new MockKernel(pProgram, *pKernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());

2
unit_tests/helpers/dispatch_info_tests.cpp
View File

@@ -51,7 +51,7 @@ class DispatchInfoFixture : public ContextFixture, public DeviceFixture {
pKernelInfo->patchInfo.mediavfestate = pMediaVFEstate;
pPrintfSurface = new SPatchAllocateStatelessPrintfSurface();
pKernelInfo->patchInfo.pAllocateStatelessPrintfSurface = pPrintfSurface;
pProgram = new MockProgram(pContext, false);
pProgram = new MockProgram(*pDevice->getExecutionEnvironment(), pContext, false);
pKernel = new MockKernel(pProgram, *pKernelInfo, *pDevice);
pKernel->slmTotalSize = 128;

10
unit_tests/helpers/kernel_commands_tests.cpp
View File

@@ -183,7 +183,7 @@ HWTEST_F(KernelCommandsTest, givenSendCrossThreadDataWhenWhenAddPatchInfoComment
CommandQueueHw<FamilyType> cmdQ(pContext, pDevice, 0);
MockContext context;
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
std::unique_ptr<KernelInfo> kernelInfo(KernelInfo::create());
std::unique_ptr<MockKernel> kernel(new MockKernel(&program, *kernelInfo, *pDevice));
@@ -238,7 +238,7 @@ HWTEST_F(KernelCommandsTest, givenSendCrossThreadDataWhenWhenAddPatchInfoComment
CommandQueueHw<FamilyType> cmdQ(pContext, pDevice, 0);
MockContext context;
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
std::unique_ptr<KernelInfo> kernelInfo(KernelInfo::create());
std::unique_ptr<MockKernel> kernel(new MockKernel(&program, *kernelInfo, *pDevice));
@@ -634,7 +634,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, KernelCommandsTest, usedBindingTableStatePointersFor
// create program with valid context
MockContext context;
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
// setup global memory
char globalBuffer[16];
@@ -758,7 +758,7 @@ HWTEST_F(KernelCommandsTest, setBindingTableStatesForKernelWithBuffersNotRequiri
// create program with valid context
MockContext context;
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
// create kernel
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
@@ -817,7 +817,7 @@ HWTEST_F(KernelCommandsTest, setBindingTableStatesForNoSurfaces) {
// create program with valid context
MockContext context;
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
// create kernel
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);

2
unit_tests/kernel/clone_kernel_tests.cpp
View File

@@ -94,7 +94,7 @@ class CloneKernelFixture : public ContextFixture, public DeviceFixture {
pKernelInfo->kernelArgInfo[0].offsetVmeSadAdjustMode = 0x14;
pKernelInfo->kernelArgInfo[0].offsetVmeSearchPathType = 0x1c;
pProgram = new MockProgram(pContext, false);
pProgram = new MockProgram(*pDevice->getExecutionEnvironment(), pContext, false);
pSourceKernel = new MockKernel(pProgram, *pKernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, pSourceKernel->initialize());

8
unit_tests/kernel/debug_kernel_tests.cpp
View File

@@ -32,7 +32,7 @@ using namespace OCLRT;
TEST(DebugKernelTest, givenKernelCompiledForDebuggingWhenGetDebugSurfaceBtiIsCalledThenCorrectValueIsReturned) {
auto device = std::make_unique<MockDevice>(*platformDevices[0]);
MockProgram program;
MockProgram program(*device->getExecutionEnvironment());
program.enableKernelDebug();
std::unique_ptr<MockKernel> kernel(MockKernel::create<MockDebugKernel>(*device.get(), &program));
@@ -41,7 +41,7 @@ TEST(DebugKernelTest, givenKernelCompiledForDebuggingWhenGetDebugSurfaceBtiIsCal
TEST(DebugKernelTest, givenKernelCompiledForDebuggingWhenGetPerThreadSystemThreadSurfaceSizeIsCalledThenCorrectValueIsReturned) {
auto device = std::make_unique<MockDevice>(*platformDevices[0]);
MockProgram program;
MockProgram program(*device->getExecutionEnvironment());
program.enableKernelDebug();
std::unique_ptr<MockDebugKernel> kernel(MockKernel::create<MockDebugKernel>(*device.get(), &program));
@@ -50,7 +50,7 @@ TEST(DebugKernelTest, givenKernelCompiledForDebuggingWhenGetPerThreadSystemThrea
TEST(DebugKernelTest, givenKernelWithoutDebugFlagWhenGetDebugSurfaceBtiIsCalledThenInvalidIndexValueIsReturned) {
auto device = std::make_unique<MockDevice>(*platformDevices[0]);
MockProgram program;
MockProgram program(*device->getExecutionEnvironment());
program.enableKernelDebug();
std::unique_ptr<MockKernel> kernel(MockKernel::create<MockKernel>(*device.get(), &program));
@@ -59,7 +59,7 @@ TEST(DebugKernelTest, givenKernelWithoutDebugFlagWhenGetDebugSurfaceBtiIsCalledT
TEST(DebugKernelTest, givenKernelWithoutDebugFlagWhenGetPerThreadSystemThreadSurfaceSizeIsCalledThenZeroIsReturned) {
auto device = std::make_unique<MockDevice>(*platformDevices[0]);
MockProgram program;
MockProgram program(*device->getExecutionEnvironment());
program.enableKernelDebug();
std::unique_ptr<MockKernel> kernel(MockKernel::create<MockKernel>(*device.get(), &program));

2
unit_tests/kernel/kernel_accelerator_arg_tests.cpp
View File

@@ -75,7 +75,7 @@ class KernelArgAcceleratorFixture : public ContextFixture, public DeviceFixture
pKernelInfo->kernelArgInfo[0].offsetVmeSadAdjustMode = 0x14;
pKernelInfo->kernelArgInfo[0].offsetVmeSearchPathType = 0x1c;
pProgram = new MockProgram(pContext, false);
pProgram = new MockProgram(*pDevice->getExecutionEnvironment(), pContext, false);
pKernel = new MockKernel(pProgram, *pKernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());

2
unit_tests/kernel/kernel_arg_buffer_fixture.cpp
View File

@@ -60,7 +60,7 @@ void KernelArgBufferFixture::SetUp() {
pKernelInfo->kernelArgInfo[0].kernelArgPatchInfoVector[0].crossthreadOffset = 0x30;
pKernelInfo->kernelArgInfo[0].kernelArgPatchInfoVector[0].size = (uint32_t)sizeof(void *);
pProgram = new MockProgram(pContext, false);
pProgram = new MockProgram(*pDevice->getExecutionEnvironment(), pContext, false);
pKernel = new MockKernel(pProgram, *pKernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());

4
unit_tests/kernel/kernel_arg_dev_queue_tests.cpp
View File

@@ -31,8 +31,6 @@ using namespace DeviceHostQueue;
struct KernelArgDevQueueTest : public DeviceFixture,
public DeviceHostQueueFixture<DeviceQueue> {
KernelArgDevQueueTest() : program(), kernelArgPatchInfo() {}
protected:
void SetUp() override {
DeviceFixture::SetUp();
@@ -50,7 +48,7 @@ struct KernelArgDevQueueTest : public DeviceFixture,
pKernelInfo->kernelArgInfo[0].kernelArgPatchInfoVector.push_back(kernelArgPatchInfo);
program = std::make_unique<MockProgram>();
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
pKernel = new MockKernel(program.get(), *pKernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());

2
unit_tests/kernel/kernel_arg_pipe_tests.cpp
View File

@@ -69,7 +69,7 @@ class KernelArgPipeFixture : public ContextFixture, public DeviceFixture {
pKernelInfo->kernelArgInfo[0].kernelArgPatchInfoVector[0].crossthreadOffset = 0x30;
pKernelInfo->kernelArgInfo[0].kernelArgPatchInfoVector[0].size = (uint32_t)sizeof(void *);
pProgram = new MockProgram(pContext, false);
pProgram = new MockProgram(*pDevice->getExecutionEnvironment(), pContext, false);
pKernel = new MockKernel(pProgram, *pKernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());

2
unit_tests/kernel/kernel_arg_svm_tests.cpp
View File

@@ -68,7 +68,7 @@ class KernelArgSvmFixture_ : public ContextFixture, public DeviceFixture {
pKernelInfo->kernelArgInfo[0].kernelArgPatchInfoVector[0].crossthreadOffset = 0x30;
pKernelInfo->kernelArgInfo[0].kernelArgPatchInfoVector[0].size = (uint32_t)sizeof(void *);
pProgram = new MockProgram(pContext, false);
pProgram = new MockProgram(*pDevice->getExecutionEnvironment(), pContext, false);
pKernel = new MockKernel(pProgram, *pKernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());

3
unit_tests/kernel/kernel_immediate_arg_tests.cpp
View File

@@ -41,6 +41,7 @@ class KernelArgImmediateTest : public Test<DeviceFixture> {
void SetUp() override {
DeviceFixture::SetUp();
memset(pCrossThreadData, 0xfe, sizeof(pCrossThreadData));
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
// define kernel info
pKernelInfo = KernelInfo::create();
@@ -69,7 +70,7 @@ class KernelArgImmediateTest : public Test<DeviceFixture> {
pKernelInfo->kernelArgInfo[1].kernelArgPatchInfoVector[0].size = sizeof(T);
pKernelInfo->kernelArgInfo[0].kernelArgPatchInfoVector[0].size = sizeof(T);
program = std::make_unique<MockProgram>();
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
pKernel = new MockKernel(program.get(), *pKernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
pKernel->setCrossThreadData(pCrossThreadData, sizeof(pCrossThreadData));

8
unit_tests/kernel/kernel_reflection_surface_tests.cpp
View File

@@ -620,8 +620,8 @@ TEST_P(KernelReflectionSurfaceTest, getCurbeParamsReturnsTokenMask) {
}
TEST(KernelReflectionSurfaceTestSingle, CreateKernelReflectionSurfaceCalledOnNonParentKernelDoesNotCreateReflectionSurface) {
MockProgram program;
MockDevice device(*platformDevices[0]);
MockProgram program(*device.getExecutionEnvironment());
KernelInfo info;
MockKernel kernel(&program, info, device);
@@ -638,8 +638,8 @@ TEST(KernelReflectionSurfaceTestSingle, CreateKernelReflectionSurfaceCalledOnNon
DebugManagerStateRestore dbgRestorer;
DebugManager.flags.ForceDispatchScheduler.set(true);
MockProgram program;
MockDevice device(*platformDevices[0]);
MockProgram program(*device.getExecutionEnvironment());
KernelInfo info;
MockKernel kernel(&program, info, device);
@@ -653,9 +653,9 @@ TEST(KernelReflectionSurfaceTestSingle, CreateKernelReflectionSurfaceCalledOnNon
}
TEST(KernelReflectionSurfaceTestSingle, ObtainKernelReflectionSurfaceWithoutKernelArgs) {
MockProgram program;
MockContext context;
std::unique_ptr<MockDevice> device(MockDevice::createWithNewExecutionEnvironment<MockDevice>(platformDevices[0]));
MockProgram program(*device->getExecutionEnvironment());
KernelInfo *blockInfo = new KernelInfo;
KernelInfo &info = *blockInfo;
cl_queue_properties properties[1] = {0};
@@ -704,9 +704,9 @@ TEST(KernelReflectionSurfaceTestSingle, ObtainKernelReflectionSurfaceWithoutKern
}
TEST(KernelReflectionSurfaceTestSingle, ObtainKernelReflectionSurfaceWithDeviceQueueKernelArg) {
MockProgram program;
MockContext context;
std::unique_ptr<MockDevice> device(MockDevice::createWithNewExecutionEnvironment<MockDevice>(platformDevices[0]));
MockProgram program(*device->getExecutionEnvironment());
KernelInfo *blockInfo = new KernelInfo;
KernelInfo &info = *blockInfo;

6
unit_tests/kernel/kernel_slm_arg_tests.cpp
View File

@@ -33,10 +33,6 @@
using namespace OCLRT;
class KernelSlmArgTest : public Test<DeviceFixture> {
public:
KernelSlmArgTest() {
}
protected:
void SetUp() override {
DeviceFixture::SetUp();
@@ -56,7 +52,7 @@ class KernelSlmArgTest : public Test<DeviceFixture> {
pKernelInfo->kernelArgInfo[2].slmAlignment = 0x400;
pKernelInfo->workloadInfo.slmStaticSize = 3 * KB;
program = std::make_unique<MockProgram>();
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
pKernel = new MockKernel(program.get(), *pKernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());

2
unit_tests/kernel/kernel_slm_tests.cpp
View File

@@ -36,7 +36,7 @@ struct KernelSLMAndBarrierTest : public DeviceFixture,
public ::testing::TestWithParam<uint32_t> {
void SetUp() override {
DeviceFixture::SetUp();
program = std::make_unique<MockProgram>();
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
memset(&kernelHeader, 0, sizeof(kernelHeader));
kernelHeader.KernelHeapSize = sizeof(kernelIsa);

72
unit_tests/kernel/kernel_tests.cpp
View File

@@ -495,7 +495,7 @@ TEST_F(KernelPrivateSurfaceTest, testPrivateSurface) {
// create kernel
MockContext context;
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
@@ -534,7 +534,7 @@ TEST_F(KernelPrivateSurfaceTest, givenKernelWithPrivateSurfaceThatIsInUseByGpuWh
pKernelInfo->patchInfo.executionEnvironment = &tokenEE;
MockContext context;
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo, *pDevice));
pKernel->initialize();
@@ -578,7 +578,7 @@ TEST_F(KernelPrivateSurfaceTest, testPrivateSurfaceAllocationFailure) {
// create kernel
MockContext context;
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
MemoryManagementFixture::InjectedFunction method = [&](size_t failureIndex) {
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
@@ -625,7 +625,7 @@ TEST_F(KernelPrivateSurfaceTest, given32BitDeviceWhenKernelIsCreatedThenPrivateS
// create kernel
MockContext context;
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
@@ -658,7 +658,7 @@ HWTEST_F(KernelPrivateSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenPri
pKernelInfo->patchInfo.pAllocateStatelessPrivateSurface = &AllocateStatelessPrivateMemorySurface;
MockContext context;
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
// create kernel
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
@@ -709,7 +709,7 @@ TEST_F(KernelPrivateSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenPriv
GraphicsAllocation gfxAlloc(buffer, sizeof(buffer));
MockContext context;
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
program.setConstantSurface(&gfxAlloc);
// create kernel
@@ -757,7 +757,7 @@ TEST_F(KernelPrivateSurfaceTest, GivenKernelWhenPrivateSurfaceTooBigAndGpuPointe
pKernelInfo->patchInfo.pAllocateStatelessPrivateSurface = pAllocateStatelessPrivateSurface.get();
pKernelInfo->patchInfo.executionEnvironment = executionEnvironment.get();
MockContext context;
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo, *pDevice));
pKernelInfo->gpuPointerSize = 4;
pDevice->getMemoryManager()->setForce32BitAllocations(false);
@@ -775,7 +775,7 @@ TEST_F(KernelPrivateSurfaceTest, GivenKernelWhenPrivateSurfaceTooBigAndGpuPointe
pKernelInfo->patchInfo.pAllocateStatelessPrivateSurface = pAllocateStatelessPrivateSurface.get();
pKernelInfo->patchInfo.executionEnvironment = executionEnvironment.get();
MockContext context;
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo, *pDevice));
pKernelInfo->gpuPointerSize = 4;
pDevice->getMemoryManager()->setForce32BitAllocations(true);
@@ -793,7 +793,7 @@ TEST_F(KernelPrivateSurfaceTest, GivenKernelWhenPrivateSurfaceTooBigAndGpuPointe
pKernelInfo->patchInfo.pAllocateStatelessPrivateSurface = pAllocateStatelessPrivateSurface.get();
pKernelInfo->patchInfo.executionEnvironment = executionEnvironment.get();
MockContext context;
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo, *pDevice));
pKernelInfo->gpuPointerSize = 8;
pDevice->getMemoryManager()->setForce32BitAllocations(true);
@@ -831,7 +831,7 @@ TEST_F(KernelGlobalSurfaceTest, givenBuiltInKernelWhenKernelIsCreatedThenGlobalS
// create kernel
MockContext context;
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
program.setGlobalSurface(&gfxAlloc);
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
@@ -874,7 +874,7 @@ TEST_F(KernelGlobalSurfaceTest, givenNDRangeKernelWhenKernelIsCreatedThenGlobalS
uint64_t bufferAddress = gfxAlloc.getGpuAddress();
// create kernel
MockProgram program;
MockProgram program(*pDevice->getExecutionEnvironment());
program.setGlobalSurface(&gfxAlloc);
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
@@ -912,7 +912,7 @@ HWTEST_F(KernelGlobalSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenGlob
void *bufferAddress = gfxAlloc.getUnderlyingBuffer();
MockContext context;
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
program.setGlobalSurface(&gfxAlloc);
// create kernel
@@ -962,7 +962,7 @@ TEST_F(KernelGlobalSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenGloba
char buffer[16];
GraphicsAllocation gfxAlloc(buffer, sizeof(buffer));
MockProgram program;
MockProgram program(*pDevice->getExecutionEnvironment());
program.setGlobalSurface(&gfxAlloc);
// create kernel
@@ -1009,7 +1009,7 @@ TEST_F(KernelConstantSurfaceTest, givenBuiltInKernelWhenKernelIsCreatedThenConst
uint64_t bufferAddress = (uint64_t)gfxAlloc.getUnderlyingBuffer();
// create kernel
MockProgram program;
MockProgram program(*pDevice->getExecutionEnvironment());
program.setConstantSurface(&gfxAlloc);
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
@@ -1052,7 +1052,7 @@ TEST_F(KernelConstantSurfaceTest, givenNDRangeKernelWhenKernelIsCreatedThenConst
uint64_t bufferAddress = gfxAlloc.getGpuAddress();
// create kernel
MockProgram program;
MockProgram program(*pDevice->getExecutionEnvironment());
program.setConstantSurface(&gfxAlloc);
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
@@ -1090,7 +1090,7 @@ HWTEST_F(KernelConstantSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenCo
void *bufferAddress = gfxAlloc.getUnderlyingBuffer();
MockContext context;
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
program.setConstantSurface(&gfxAlloc);
// create kernel
@@ -1140,7 +1140,7 @@ TEST_F(KernelConstantSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenCon
char buffer[16];
GraphicsAllocation gfxAlloc(buffer, sizeof(buffer));
MockProgram program;
MockProgram program(*pDevice->getExecutionEnvironment());
program.setConstantSurface(&gfxAlloc);
// create kernel
@@ -1179,7 +1179,7 @@ HWTEST_F(KernelEventPoolSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenE
pKernelInfo->patchInfo.pAllocateStatelessEventPoolSurface = &AllocateStatelessEventPoolSurface;
// create kernel
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
// setup surface state heap
@@ -1232,7 +1232,7 @@ HWTEST_F(KernelEventPoolSurfaceTest, givenStatefulKernelWhenEventPoolIsPatchedTh
pKernelInfo->patchInfo.pAllocateStatelessEventPoolSurface = &AllocateStatelessEventPoolSurface;
// create kernel
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
// setup surface state heap
@@ -1279,7 +1279,7 @@ HWTEST_F(KernelEventPoolSurfaceTest, givenKernelWithNullEventPoolInKernelInfoWhe
pKernelInfo->patchInfo.pAllocateStatelessEventPoolSurface = nullptr;
// create kernel
MockProgram program;
MockProgram program(*pDevice->getExecutionEnvironment());
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
// define stateful path
@@ -1318,7 +1318,7 @@ TEST_F(KernelEventPoolSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenEv
pKernelInfo->patchInfo.pAllocateStatelessEventPoolSurface = &AllocateStatelessEventPoolSurface;
// create kernel
MockProgram program;
MockProgram program(*pDevice->getExecutionEnvironment());
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
// define stateful path
@@ -1355,7 +1355,7 @@ TEST_F(KernelEventPoolSurfaceTest, givenStatelessKernelWhenEventPoolIsPatchedThe
pKernelInfo->patchInfo.pAllocateStatelessEventPoolSurface = &AllocateStatelessEventPoolSurface;
// create kernel
MockProgram program;
MockProgram program(*pDevice->getExecutionEnvironment());
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
// define stateful path
@@ -1394,7 +1394,7 @@ HWTEST_F(KernelDefaultDeviceQueueSurfaceTest, givenStatefulKernelWhenKernelIsCre
pKernelInfo->patchInfo.pAllocateStatelessDefaultDeviceQueueSurface = &AllocateStatelessDefaultDeviceQueueSurface;
// create kernel
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
// setup surface state heap
@@ -1447,7 +1447,7 @@ HWTEST_F(KernelDefaultDeviceQueueSurfaceTest, givenStatefulKernelWhenDefaultDevi
pKernelInfo->patchInfo.pAllocateStatelessDefaultDeviceQueueSurface = &AllocateStatelessDefaultDeviceQueueSurface;
// create kernel
MockProgram program(&context, false);
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
// setup surface state heap
@@ -1502,7 +1502,7 @@ TEST_F(KernelDefaultDeviceQueueSurfaceTest, givenStatelessKernelWhenKernelIsCrea
pKernelInfo->patchInfo.pAllocateStatelessDefaultDeviceQueueSurface = &AllocateStatelessDefaultDeviceQueueSurface;
// create kernel
MockProgram program;
MockProgram program(*pDevice->getExecutionEnvironment());
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
// define stateful path
@@ -1531,7 +1531,7 @@ TEST_F(KernelDefaultDeviceQueueSurfaceTest, givenKernelWithNullDeviceQueueKernel
pKernelInfo->patchInfo.pAllocateStatelessDefaultDeviceQueueSurface = nullptr;
// create kernel
MockProgram program;
MockProgram program(*pDevice->getExecutionEnvironment());
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
// define stateful path
@@ -1570,7 +1570,7 @@ TEST_F(KernelDefaultDeviceQueueSurfaceTest, givenStatelessKernelWhenDefaultDevic
pKernelInfo->patchInfo.pAllocateStatelessDefaultDeviceQueueSurface = &AllocateStatelessDefaultDeviceQueueSurface;
// create kernel
MockProgram program;
MockProgram program(*pDevice->getExecutionEnvironment());
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pDevice);
// define stateful path
@@ -1615,7 +1615,7 @@ HWTEST_F(KernelResidencyTest, givenKernelWhenMakeResidentIsCalledThenKernelIsaIs
pKernelInfo->kernelArgInfo[1].kernelArgPatchInfoVector[0].crossthreadOffset = 0x20;
pKernelInfo->kernelArgInfo[0].kernelArgPatchInfoVector[0].crossthreadOffset = 0x30;
MockProgram program;
MockProgram program(*pDevice->getExecutionEnvironment());
std::unique_ptr<MockKernel> pKernel(new MockKernel(&program, *pKernelInfo, *pDevice));
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
pKernel->setCrossThreadData(pCrossThreadData, sizeof(pCrossThreadData));
@@ -1637,7 +1637,7 @@ TEST(KernelImageDetectionTests, givenKernelWithImagesOnlyWhenItIsAskedIfItHasIma
pKernelInfo->kernelArgInfo[1].isMediaBlockImage = true;
pKernelInfo->kernelArgInfo[0].isMediaImage = true;
MockProgram program;
MockProgram program(*device->getExecutionEnvironment());
std::unique_ptr<MockKernel> kernel(new MockKernel(&program, *pKernelInfo, *device));
EXPECT_FALSE(kernel->usesOnlyImages());
kernel->initialize();
@@ -1653,7 +1653,7 @@ TEST(KernelImageDetectionTests, givenKernelWithImagesAndBuffersWhenItIsAskedIfIt
pKernelInfo->kernelArgInfo[1].isBuffer = true;
pKernelInfo->kernelArgInfo[0].isMediaImage = true;
MockProgram program;
MockProgram program(*device->getExecutionEnvironment());
std::unique_ptr<MockKernel> kernel(new MockKernel(&program, *pKernelInfo, *device));
EXPECT_FALSE(kernel->usesOnlyImages());
kernel->initialize();
@@ -1667,7 +1667,7 @@ TEST(KernelImageDetectionTests, givenKernelWithNoImagesWhenItIsAskedIfItHasImage
pKernelInfo->kernelArgInfo.resize(1);
pKernelInfo->kernelArgInfo[0].isBuffer = true;
MockProgram program;
MockProgram program(*device->getExecutionEnvironment());
std::unique_ptr<MockKernel> kernel(new MockKernel(&program, *pKernelInfo, *device));
EXPECT_FALSE(kernel->usesOnlyImages());
kernel->initialize();
@@ -1714,7 +1714,7 @@ HWTEST_F(KernelResidencyTest, test_MakeArgsResidentCheckImageFromImage) {
pKernelInfo->kernelArgInfo.push_back(kernelArgInfo);
std::unique_ptr<MockProgram> program(new MockProgram);
auto program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
std::unique_ptr<MockKernel> pKernel(new MockKernel(program.get(), *pKernelInfo, *pDevice));
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
@@ -1731,7 +1731,7 @@ HWTEST_F(KernelResidencyTest, test_MakeArgsResidentCheckImageFromImage) {
struct KernelExecutionEnvironmentTest : public Test<DeviceFixture> {
void SetUp() override {
DeviceFixture::SetUp();
program = std::make_unique<MockProgram>();
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
pKernelInfo = KernelInfo::create();
pKernelInfo->patchInfo.executionEnvironment = &executionEnvironment;
@@ -1857,7 +1857,7 @@ struct KernelCrossThreadTests : Test<DeviceFixture> {
void SetUp() override {
DeviceFixture::SetUp();
program = std::make_unique<MockProgram>();
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
patchDataParameterStream.DataParameterStreamSize = 64 * sizeof(uint8_t);
pKernelInfo = KernelInfo::create();
@@ -2243,8 +2243,8 @@ TEST(KernelTest, givenKernelWithKernelInfoWith32bitPointerSizeThenReport32bit) {
info.gpuPointerSize = 4;
MockContext context;
MockProgram program(&context, false);
std::unique_ptr<MockDevice> device(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockProgram program(*device->getExecutionEnvironment(), &context, false);
std::unique_ptr<MockKernel> kernel(new MockKernel(&program, info, *device.get()));
EXPECT_TRUE(kernel->is32Bit());
@@ -2255,8 +2255,8 @@ TEST(KernelTest, givenKernelWithKernelInfoWith64bitPointerSizeThenReport64bit) {
info.gpuPointerSize = 8;
MockContext context;
MockProgram program(&context, false);
std::unique_ptr<MockDevice> device(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockProgram program(*device->getExecutionEnvironment(), &context, false);
std::unique_ptr<MockKernel> kernel(new MockKernel(&program, info, *device.get()));
EXPECT_FALSE(kernel->is32Bit());

2
unit_tests/kernel/kernel_transformable_tests.cpp
View File

@@ -60,7 +60,7 @@ class KernelTransformableTest : public ::testing::Test {
pKernelInfo->kernelArgInfo[3].isImage = true;
pKernelInfo->argumentsToPatchNum = 4;
program = std::make_unique<MockProgram>();
program = std::make_unique<MockProgram>(*context.getDevice(0)->getExecutionEnvironment());
pKernel.reset(new MockKernel(program.get(), *pKernelInfo, *context.getDevice(0)));
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());

2
unit_tests/kernel/parent_kernel_tests.cpp
View File

@@ -52,7 +52,7 @@ class MockKernelWithArgumentAccess : public Kernel {
TEST(ParentKernelTest, GetObjectCounts) {
KernelInfo info;
MockDevice *device = new MockDevice(*platformDevices[0]);
MockProgram program;
MockProgram program(*device->getExecutionEnvironment());
SPatchExecutionEnvironment environment;
environment.HasDeviceEnqueue = 1;

2
unit_tests/mem_obj/buffer_set_arg_tests.cpp
View File

@@ -80,7 +80,7 @@ class BufferSetArgTest : public ContextFixture,
pKernelInfo->heapInfo.pKernelHeader = &kernelHeader;
pKernelInfo->usesSsh = true;
pProgram = new MockProgram(pContext, false);
pProgram = new MockProgram(*pDevice->getExecutionEnvironment(), pContext, false);
pKernel = new MockKernel(pProgram, *pKernelInfo, *pDevice);
ASSERT_NE(nullptr, pKernel);

4
unit_tests/mem_obj/image_set_arg_tests.cpp
View File

@@ -95,7 +95,7 @@ class ImageSetArgTest : public DeviceFixture,
pKernelInfo->kernelArgInfo[1].isImage = true;
pKernelInfo->kernelArgInfo[0].isImage = true;
program = std::make_unique<MockProgram>();
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
pKernel = new MockKernel(program.get(), *pKernelInfo, *pDevice);
ASSERT_NE(nullptr, pKernel);
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
@@ -773,7 +773,7 @@ class ImageMediaBlockSetArgTest : public ImageSetArgTest {
pKernelInfo->kernelArgInfo[1].isMediaBlockImage = true;
pKernelInfo->kernelArgInfo[0].isMediaBlockImage = true;
program = std::make_unique<MockProgram>();
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
pKernel = new MockKernel(program.get(), *pKernelInfo, *pDevice);
ASSERT_NE(nullptr, pKernel);
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());

4
unit_tests/mocks/mock_kernel.h
View File

@@ -277,7 +277,7 @@ class MockKernelWithInternals {
mockContext = context;
}
mockProgram = new MockProgram(context, false);
mockProgram = new MockProgram(*deviceArg.getExecutionEnvironment(), context, false);
mockKernel = new MockKernel(mockProgram, kernelInfo, deviceArg);
mockKernel->setCrossThreadData(&crossThreadData, sizeof(crossThreadData));
mockKernel->setSshLocal(&sshLocal, sizeof(sshLocal));
@@ -369,7 +369,7 @@ class MockParentKernel : public Kernel {
crossThreadOffset += 8;
}
MockProgram *mockProgram = new MockProgram();
MockProgram *mockProgram = new MockProgram(*device.getExecutionEnvironment());
mockProgram->setContext(&context);
mockProgram->setDevice(&device);

6
unit_tests/mocks/mock_program.h
View File

@@ -56,8 +56,8 @@ class MockProgram : public Program {
using Program::sourceCode;
MockProgram() : Program() {}
MockProgram(Context *context, bool isBuiltinKernel) : Program(context, isBuiltinKernel) {}
MockProgram(ExecutionEnvironment &executionEnvironment) : Program(executionEnvironment) {}
MockProgram(ExecutionEnvironment &executionEnvironment, Context *context, bool isBuiltinKernel) : Program(executionEnvironment, context, isBuiltinKernel) {}
~MockProgram() {
if (contextSet)
context = nullptr;
@@ -146,7 +146,7 @@ class MockProgram : public Program {
class GlobalMockSipProgram : public Program {
public:
using Program::Program;
GlobalMockSipProgram() : Program() {
GlobalMockSipProgram(ExecutionEnvironment &executionEnvironment) : Program(executionEnvironment) {
}
cl_int processGenBinary() override;
cl_int processGenBinaryOnce();

18
unit_tests/os_interface/debug_settings_manager_tests.cpp
View File

@@ -425,9 +425,9 @@ TEST(DebugSettingsManager, WithDebugFunctionalityDontDumpKernelArgsForNullMdi) {
}
TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsForMdi) {
MockProgram program;
auto kernelInfo = unique_ptr<KernelInfo>(KernelInfo::create());
auto device = unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
auto kernel = unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
auto multiDispatchInfo = unique_ptr<MockMultiDispatchInfo>(new MockMultiDispatchInfo(kernel.get()));
@@ -467,9 +467,9 @@ TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelNullKernel) {
}
TEST(DebugSettingsManager, WithDebugFunctionalityAndEmptyKernelDontDumpKernelArgs) {
MockProgram program;
auto kernelInfo = unique_ptr<KernelInfo>(KernelInfo::create());
auto device = unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
auto kernel = unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
FullyEnabledTestDebugManager debugManager;
@@ -481,9 +481,9 @@ TEST(DebugSettingsManager, WithDebugFunctionalityAndEmptyKernelDontDumpKernelArg
}
TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsImmediate) {
MockProgram program;
auto kernelInfo = unique_ptr<KernelInfo>(KernelInfo::create());
auto device = unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
auto kernel = unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
KernelArgPatchInfo kernelArgPatchInfo;
@@ -512,9 +512,9 @@ TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsImmediate) {
}
TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsImmediateZeroSize) {
MockProgram program;
auto kernelInfo = unique_ptr<KernelInfo>(KernelInfo::create());
auto device = unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
auto kernel = unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
KernelArgPatchInfo kernelArgPatchInfo;
@@ -540,9 +540,9 @@ TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsImmediateZeroSize
}
TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsLocalBuffer) {
MockProgram program;
auto kernelInfo = unique_ptr<KernelInfo>(KernelInfo::create());
auto device = unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
auto kernel = unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
KernelArgPatchInfo kernelArgPatchInfo;
@@ -561,9 +561,9 @@ TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsLocalBuffer) {
}
TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsBufferNotSet) {
MockProgram program;
auto kernelInfo = unique_ptr<KernelInfo>(KernelInfo::create());
auto device = unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
auto kernel = unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
KernelArgPatchInfo kernelArgPatchInfo;
@@ -592,9 +592,9 @@ TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsBuffer) {
auto buffer = BufferHelper<>::create(&context);
cl_mem clObj = buffer;
MockProgram program(&context, false);
auto kernelInfo = unique_ptr<KernelInfo>(KernelInfo::create());
auto device = unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
MockProgram program(*device->getExecutionEnvironment(), &context, false);
auto kernel = unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
KernelArgPatchInfo kernelArgPatchInfo;
@@ -626,9 +626,9 @@ TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsBuffer) {
}
TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsSampler) {
MockProgram program;
auto kernelInfo = unique_ptr<KernelInfo>(KernelInfo::create());
auto device = unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
auto kernel = unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
KernelArgPatchInfo kernelArgPatchInfo;
@@ -649,9 +649,9 @@ TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsSampler) {
}
TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsImageNotSet) {
MockProgram program;
auto kernelInfo = unique_ptr<KernelInfo>(KernelInfo::create());
auto device = unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
auto kernel = unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
SKernelBinaryHeaderCommon kernelHeader;

2
unit_tests/profiling/profiling_tests.cpp
View File

@@ -46,7 +46,7 @@ struct ProfilingTests : public CommandEnqueueFixture,
public ::testing::Test {
void SetUp() override {
CommandEnqueueFixture::SetUp(CL_QUEUE_PROFILING_ENABLE);
program = std::make_unique<MockProgram>();
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
memset(&kernelHeader, 0, sizeof(kernelHeader));
kernelHeader.KernelHeapSize = sizeof(kernelIsa);

10
unit_tests/program/evaluate_unhandled_token_tests.cpp
View File

@@ -25,6 +25,8 @@
#include "runtime/program/create.inl"
#include "runtime/program/program.h"
using namespace OCLRT;
extern GFXCORE_FAMILY renderCoreFamily;
template <typename ContainerT, typename TokenT>
@@ -33,11 +35,12 @@ inline void PushBackToken(ContainerT &container, const TokenT &token) {
reinterpret_cast<const typename ContainerT::value_type *>(&token) + sizeof(token));
}
struct MockProgramRecordUnhandledTokens : OCLRT::Program {
struct MockProgramRecordUnhandledTokens : public Program {
bool allowUnhandledTokens;
mutable int lastUnhandledTokenFound;
using Program::Program;
MockProgramRecordUnhandledTokens(ExecutionEnvironment &executionEnvironment) : Program(executionEnvironment) {}
MockProgramRecordUnhandledTokens(ExecutionEnvironment &executionEnvironment, Context *context, bool isBuiltinKernel) : Program(executionEnvironment, context, isBuiltinKernel) {}
bool isSafeToSkipUnhandledToken(unsigned int token) const override {
lastUnhandledTokenFound = static_cast<int>(token);
@@ -131,7 +134,8 @@ inline std::vector<char> CreateBinary(bool addUnhandledProgramScopePatchToken, b
constexpr int32_t unhandledTokenId = iOpenCL::NUM_PATCH_TOKENS;
TEST(EvaluateUnhandledToken, ByDefaultSkippingOfUnhandledTokensInUnitTestsIsSafe) {
MockProgramRecordUnhandledTokens program;
ExecutionEnvironment executionEnvironment;
MockProgramRecordUnhandledTokens program(executionEnvironment);
EXPECT_TRUE(program.getDefaultIsSafeToSkipUnhandledToken());
}

4
unit_tests/program/printf_handler_tests.cpp
View File

@@ -42,7 +42,7 @@ TEST(PrintfHandlerTest, givenNotPreparedPrintfHandlerWhenGetSurfaceIsCalledThenR
KernelInfo *pKernelInfo = new KernelInfo();
pKernelInfo->patchInfo.pAllocateStatelessPrintfSurface = pPrintfSurface;
MockProgram *pProgram = new MockProgram(&context, false);
MockProgram *pProgram = new MockProgram(*device->getExecutionEnvironment(), &context, false);
MockKernel *pKernel = new MockKernel(pProgram, *pKernelInfo, *device);
MockMultiDispatchInfo multiDispatchInfo(pKernel);
@@ -68,7 +68,7 @@ TEST(PrintfHandlerTest, givenPreparedPrintfHandlerWhenGetSurfaceIsCalledThenResu
KernelInfo *pKernelInfo = new KernelInfo();
pKernelInfo->patchInfo.pAllocateStatelessPrintfSurface = pPrintfSurface;
MockProgram *pProgram = new MockProgram(&context, false);
MockProgram *pProgram = new MockProgram(*device->getExecutionEnvironment(), &context, false);
uint64_t crossThread[10];
MockKernel *pKernel = new MockKernel(pProgram, *pKernelInfo, *device);

2
unit_tests/program/printf_helper_tests.cpp
View File

@@ -61,7 +61,7 @@ class PrintFormatterTest : public testing::Test {
kernelInfo = KernelInfo::create();
device = MockDevice::createWithNewExecutionEnvironment<Device>(nullptr);
program = std::make_unique<MockProgram>();
program = std::make_unique<MockProgram>(*device->getExecutionEnvironment());
kernel = new MockKernel(program.get(), *kernelInfo, *device);
printFormatter = new PrintFormatter(*kernel, *data);

4
unit_tests/program/process_debug_data_tests.cpp
View File

@@ -42,7 +42,7 @@ TEST_F(ProgramTests, GivenProgramWithDebugDataForTwoKernelsWhenPorcessedThenDebu
kernelInfo1->name = kernelName1;
KernelInfo *kernelInfo2 = new KernelInfo();
kernelInfo2->name = kernelName2;
std::unique_ptr<MockProgram> program(new MockProgram());
auto program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
SProgramDebugDataHeaderIGC *programDebugHeader = reinterpret_cast<SProgramDebugDataHeaderIGC *>(debugData.get());
programDebugHeader->NumberOfKernels = 2;
@@ -92,4 +92,4 @@ TEST_F(ProgramTests, GivenProgramWithDebugDataForTwoKernelsWhenPorcessedThenDebu
EXPECT_EQ(visaSize, kernelInfo2->debugData.vIsaSize);
EXPECT_EQ(ptrDiff(vIsa2, debugData.get()), ptrDiff(kernelInfo2->debugData.vIsa, program->getDebugDataBinary(programDebugDataSize)));
EXPECT_EQ(ptrDiff(genIsa2, debugData.get()), ptrDiff(kernelInfo2->debugData.genIsa, program->getDebugDataBinary(programDebugDataSize)));
}
}

8
unit_tests/program/process_elf_binary_tests.cpp
View File

@@ -33,9 +33,11 @@ using namespace OCLRT;
class ProcessElfBinaryTests : public ::testing::Test {
public:
void SetUp() override {
program = std::make_unique<MockProgram>();
executionEnvironment = std::make_unique<ExecutionEnvironment>();
program = std::make_unique<MockProgram>(*executionEnvironment);
}
std::unique_ptr<ExecutionEnvironment> executionEnvironment;
std::unique_ptr<MockProgram> program;
};
@@ -138,9 +140,11 @@ unsigned int BinaryTypeValues[] = {
class ProcessElfBinaryTestsWithBinaryType : public ::testing::TestWithParam<unsigned int> {
public:
void SetUp() override {
program = std::make_unique<MockProgram>();
executionEnvironment = std::make_unique<ExecutionEnvironment>();
program = std::make_unique<MockProgram>(*executionEnvironment);
}
std::unique_ptr<ExecutionEnvironment> executionEnvironment;
std::unique_ptr<MockProgram> program;
};

4
unit_tests/program/process_spir_binary_tests.cpp
View File

@@ -32,9 +32,11 @@ using namespace OCLRT;
class ProcessSpirBinaryTests : public ::testing::Test {
public:
void SetUp() override {
program = std::make_unique<MockProgram>();
executionEnvironment = std::make_unique<ExecutionEnvironment>();
program = std::make_unique<MockProgram>(*executionEnvironment);
}
std::unique_ptr<ExecutionEnvironment> executionEnvironment;
std::unique_ptr<MockProgram> program;
};

29
unit_tests/program/program_nonuniform.cpp
View File

@@ -46,8 +46,16 @@
using namespace OCLRT;
class MyMockProgram : public MockProgram {
public:
MyMockProgram() : MockProgram(*new ExecutionEnvironment()), executionEnvironment(&this->peekExecutionEnvironment()) {}
private:
std::unique_ptr<ExecutionEnvironment> executionEnvironment;
};
TEST(ProgramNonUniform, UpdateAllowNonUniform) {
MockProgram pm;
MyMockProgram pm;
EXPECT_FALSE(pm.getAllowNonUniform());
EXPECT_EQ(12u, pm.getProgramOptionVersion());
pm.setBuildOptions(nullptr);
@@ -57,7 +65,7 @@ TEST(ProgramNonUniform, UpdateAllowNonUniform) {
}
TEST(ProgramNonUniform, UpdateAllowNonUniform12) {
MockProgram pm;
MyMockProgram pm;
EXPECT_FALSE(pm.getAllowNonUniform());
EXPECT_EQ(12u, pm.getProgramOptionVersion());
pm.setBuildOptions("-cl-std=CL1.2");
@@ -67,7 +75,7 @@ TEST(ProgramNonUniform, UpdateAllowNonUniform12) {
}
TEST(ProgramNonUniform, UpdateAllowNonUniform20) {
MockProgram pm;
MyMockProgram pm;
EXPECT_FALSE(pm.getAllowNonUniform());
EXPECT_EQ(12u, pm.getProgramOptionVersion());
pm.setBuildOptions("-cl-std=CL2.0");
@@ -77,7 +85,7 @@ TEST(ProgramNonUniform, UpdateAllowNonUniform20) {
}
TEST(ProgramNonUniform, UpdateAllowNonUniform21) {
MockProgram pm;
MyMockProgram pm;
EXPECT_FALSE(pm.getAllowNonUniform());
EXPECT_EQ(12u, pm.getProgramOptionVersion());
pm.setBuildOptions("-cl-std=CL2.1");
@@ -87,7 +95,7 @@ TEST(ProgramNonUniform, UpdateAllowNonUniform21) {
}
TEST(ProgramNonUniform, UpdateAllowNonUniform20UniformFlag) {
MockProgram pm;
MyMockProgram pm;
EXPECT_FALSE(pm.getAllowNonUniform());
EXPECT_EQ(12u, pm.getProgramOptionVersion());
pm.setBuildOptions("-cl-std=CL2.0 -cl-uniform-work-group-size");
@@ -97,7 +105,7 @@ TEST(ProgramNonUniform, UpdateAllowNonUniform20UniformFlag) {
}
TEST(ProgramNonUniform, UpdateAllowNonUniform21UniformFlag) {
MockProgram pm;
MyMockProgram pm;
EXPECT_FALSE(pm.getAllowNonUniform());
EXPECT_EQ(12u, pm.getProgramOptionVersion());
pm.setBuildOptions("-cl-std=CL2.1 -cl-uniform-work-group-size");
@@ -107,9 +115,9 @@ TEST(ProgramNonUniform, UpdateAllowNonUniform21UniformFlag) {
}
TEST(KernelNonUniform, GetAllowNonUniformFlag) {
MockProgram pm;
KernelInfo ki;
MockDevice d(*platformDevices[0]);
MockProgram pm(*d.getExecutionEnvironment());
struct KernelMock : Kernel {
KernelMock(Program *p, KernelInfo &ki, Device &d)
: Kernel(p, ki, d) {
@@ -126,9 +134,10 @@ TEST(KernelNonUniform, GetAllowNonUniformFlag) {
}
TEST(ProgramNonUniform, UpdateAllowNonUniformOutcomeUniformFlag) {
MockProgram pm;
MockProgram pm1;
MockProgram pm2;
ExecutionEnvironment executionEnvironment;
MockProgram pm(executionEnvironment);
MockProgram pm1(executionEnvironment);
MockProgram pm2(executionEnvironment);
const MockProgram *inputPrograms[] = {&pm1, &pm2};
cl_uint numInputPrograms = 2;

100
unit_tests/program/program_tests.cpp
View File

@@ -92,11 +92,13 @@ std::vector<const char *> KernelNames{
class NoCompilerInterfaceProgram : public MockProgram {
public:
NoCompilerInterfaceProgram(ExecutionEnvironment &executionEnvironment) : MockProgram(executionEnvironment) {}
CompilerInterface *getCompilerInterface() const override { return nullptr; }
};
class FailingGenBinaryProgram : public MockProgram {
public:
FailingGenBinaryProgram(ExecutionEnvironment &executionEnvironment) : MockProgram(executionEnvironment) {}
cl_int processGenBinary() override { return CL_INVALID_BINARY; }
};
@@ -714,7 +716,7 @@ TEST_P(ProgramFromSourceTest, CreateWithSource_Build) {
pMockProgram->SetBuildStatus(CL_BUILD_NONE);
// fail build - CompilerInterface cannot be obtained
auto p2 = std::make_unique<NoCompilerInterfaceProgram>();
auto p2 = std::make_unique<NoCompilerInterfaceProgram>(*pPlatform->getDevice(0)->getExecutionEnvironment());
retVal = p2->build(0, nullptr, nullptr, nullptr, nullptr, false);
EXPECT_EQ(CL_OUT_OF_HOST_MEMORY, retVal);
p2.reset(nullptr);
@@ -724,7 +726,7 @@ TEST_P(ProgramFromSourceTest, CreateWithSource_Build) {
EXPECT_EQ(CL_BUILD_PROGRAM_FAILURE, retVal);
// fail build - linked code is corrupted and cannot be postprocessed
auto p3 = std::make_unique<FailingGenBinaryProgram>();
auto p3 = std::make_unique<FailingGenBinaryProgram>(*pPlatform->getDevice(0)->getExecutionEnvironment());
Device *device = pPlatform->getDevice(0);
p3->setDevice(device);
std::string testFile;
@@ -990,7 +992,7 @@ TEST_P(ProgramFromSourceTest, CreateWithSource_Compile) {
delete p3;
// fail compilation - CompilerInterface cannot be obtained
auto p2 = std::make_unique<NoCompilerInterfaceProgram>();
auto p2 = std::make_unique<NoCompilerInterfaceProgram>(*pPlatform->getDevice(0)->getExecutionEnvironment());
retVal = p2->compile(0, nullptr, nullptr, 0, nullptr, nullptr, nullptr, nullptr);
EXPECT_EQ(CL_OUT_OF_HOST_MEMORY, retVal);
p2.reset(nullptr);
@@ -1036,7 +1038,7 @@ TEST_P(ProgramFromSourceTest, CompileProgramWithReraFlag) {
class MyProgram : public Program {
public:
MyProgram() { cip = nullptr; };
MyProgram(ExecutionEnvironment &executionEnvironment) : Program(executionEnvironment), cip(nullptr) {}
~MyProgram() override {
delete cip;
}
@@ -1054,7 +1056,7 @@ TEST_P(ProgramFromSourceTest, CompileProgramWithReraFlag) {
mutable MyCompilerInterface *cip;
};
auto program = std::make_unique<MyProgram>();
auto program = std::make_unique<MyProgram>(*pPlatform->getDevice(0)->getExecutionEnvironment());
EXPECT_NE(nullptr, program);
cl_device_id deviceId = pContext->getDevice(0);
Device *pDevice = castToObject<Device>(deviceId);
@@ -1242,7 +1244,7 @@ TEST_P(ProgramFromSourceTest, CreateWithSource_Link) {
EXPECT_EQ(CL_BUILD_PROGRAM_FAILURE, retVal);
// fail linking - linked code is corrupted and cannot be postprocessed
auto p2 = std::make_unique<FailingGenBinaryProgram>();
auto p2 = std::make_unique<FailingGenBinaryProgram>(*pPlatform->getDevice(0)->getExecutionEnvironment());
Device *device = pPlatform->getDevice(0);
p2->setDevice(device);
retVal = p2->link(0, nullptr, nullptr, 1, &program, nullptr, nullptr);
@@ -1264,7 +1266,7 @@ TEST_P(ProgramFromSourceTest, CreateWithSource_Link) {
// Program::Link (create library)
////////////////////////////////////////////////////////////////////////////////
TEST_P(ProgramFromSourceTest, CreateWithSource_CreateLibrary) {
auto p = std::make_unique<NoCompilerInterfaceProgram>();
auto p = std::make_unique<NoCompilerInterfaceProgram>(*pPlatform->getDevice(0)->getExecutionEnvironment());
cl_program program = pProgram;
// Order of following microtests is important - do not change.
@@ -1575,7 +1577,8 @@ TEST(ProgramFromBinaryTests, givenBinaryWithInvalidICBEThenErrorIsReturned) {
{
const unsigned char *binaries[1] = {reinterpret_cast<const unsigned char *>(&binHeader)};
const cl_device_id deviceId = 0;
std::unique_ptr<Program> pProgram(Program::create<Program>(nullptr, 0, &deviceId, &binSize, binaries, nullptr, retVal));
MockContext context;
std::unique_ptr<Program> pProgram(Program::create<Program>(&context, 0, &deviceId, &binSize, binaries, nullptr, retVal));
EXPECT_EQ(nullptr, pProgram.get());
EXPECT_EQ(CL_INVALID_BINARY, retVal);
}
@@ -1594,7 +1597,7 @@ TEST(ProgramFromBinaryTests, givenBinaryWithInvalidICBEThenErrorIsReturned) {
class FailProgram : public Program {
public:
FailProgram(Context *context, bool isBuiltIn = false) : Program(context, isBuiltIn) {}
FailProgram(ExecutionEnvironment &executionEnvironment, Context *context, bool isBuiltIn = false) : Program(executionEnvironment, context, isBuiltIn) {}
cl_int rebuildProgramFromIr() override {
return CL_INVALID_PROGRAM;
}
@@ -1636,7 +1639,7 @@ TEST(ProgramFromBinaryTests, CreateWithBinary_FailRecompile) {
TEST(ProgramFromBinaryTests, givenEmptyProgramThenErrorIsReturned) {
class TestedProgram : public Program {
public:
TestedProgram(Context *context, bool isBuiltIn) : Program(context, isBuiltIn) {}
TestedProgram(ExecutionEnvironment &executionEnvironment, Context *context, bool isBuiltIn) : Program(executionEnvironment, context, isBuiltIn) {}
char *setGenBinary(char *binary) {
auto res = genBinary;
genBinary = binary;
@@ -1689,7 +1692,7 @@ TEST_F(ProgramTests, ProgramCtorSetsProperInternalOptions) {
DebugManager.flags.DisableStatelessToStatefulOptimization.set(false);
if (pDevice) {
MockProgram program(pContext, false);
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
char paramValue[32];
pDevice->getDeviceInfo(CL_DEVICE_VERSION, 32, paramValue, 0);
if (strstr(paramValue, "2.1")) {
@@ -1712,7 +1715,7 @@ TEST_F(ProgramTests, ProgramCtorSetsProperInternalOptionsForced20) {
pDevice->getMutableDeviceInfo()->clVersion = "OpenCL 2.0 ";
if (pDevice) {
MockProgram program(pContext, false);
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
char paramValue[32];
pDevice->getDeviceInfo(CL_DEVICE_VERSION, 32, paramValue, 0);
ASSERT_EQ(std::string(paramValue), "OpenCL 2.0 ");
@@ -1727,7 +1730,7 @@ TEST_F(ProgramTests, ProgramCtorSetsProperInternalOptionsWhenStatelessToStateful
DebugManager.flags.DisableStatelessToStatefulOptimization.set(true);
if (pDevice) {
MockProgram program(pContext, false);
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
char paramValue[32];
pDevice->getDeviceInfo(CL_DEVICE_VERSION, 32, paramValue, 0);
if (strstr(paramValue, "2.1")) {
@@ -1756,7 +1759,7 @@ TEST_F(ProgramTests, ProgramCtorSetsProperInternalOptionsWhenForcing32BitAddress
DebugManager.flags.DisableStatelessToStatefulOptimization.set(false);
if (pDevice) {
const_cast<DeviceInfo *>(&pDevice->getDeviceInfo())->force32BitAddressess = true;
MockProgram program(pContext, false);
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
char paramValue[32];
pDevice->getDeviceInfo(CL_DEVICE_VERSION, 32, paramValue, 0);
if (strstr(paramValue, "2.1")) {
@@ -1860,16 +1863,15 @@ TEST_F(ProgramTests, givenStatelessToStatefullOptimizationOffWHenProgramIsCreate
TEST_F(ProgramTests, ProgramCtorSetsProperProgramScopePatchListSize) {
MockProgram program(pContext, false);
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
EXPECT_EQ((size_t)0, program.getProgramScopePatchListSize());
}
TEST_F(ProgramTests, GivenContextWhenCreateProgramThenIncrementContextRefCount) {
auto initialApiRefCount = pContext->getReference();
auto initialInternalRefCount = pContext->getRefInternalCount();
MockProgram tempProgram;
MockProgram *program = new MockProgram(pContext, false);
MockProgram *program = new MockProgram(*pDevice->getExecutionEnvironment(), pContext, false);
EXPECT_EQ(pContext->getReference(), initialApiRefCount);
EXPECT_EQ(pContext->getRefInternalCount(), initialInternalRefCount + 1);
@@ -2136,7 +2138,7 @@ TEST_F(ProgramTests, ProgramFromGenBinaryWithPATCH_TOKEN_GTPIN_FREE_GRF_INFO) {
TEST_F(ProgramTests, GetGenBinaryReturnsBinaryStoreInProgram) {
char genBin[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
MockProgram mp;
MockProgram mp(*pDevice->getExecutionEnvironment());
mp.storeGenBinary(genBin, sizeof(genBin));
size_t binarySize = 0;
@@ -2149,7 +2151,7 @@ TEST_F(ProgramTests, ValidBinaryWithIGCVersionEqual0) {
cl_int retVal;
CompilerInterface::getInstance();
auto program = std::make_unique<MockProgram>();
auto program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
EXPECT_NE(nullptr, program);
cl_device_id deviceId = pContext->getDevice(0);
Device *pDevice = castToObject<Device>(deviceId);
@@ -2207,7 +2209,7 @@ TEST_F(ProgramTests, ValidBinaryWithIGCVersionEqual0) {
}
TEST_F(ProgramTests, RebuildBinaryButNoCompilerInterface) {
auto program = std::make_unique<NoCompilerInterfaceProgram>();
auto program = std::make_unique<NoCompilerInterfaceProgram>(*pDevice->getExecutionEnvironment());
EXPECT_NE(nullptr, program);
cl_device_id deviceId = pContext->getDevice(0);
Device *pDevice = castToObject<Device>(deviceId);
@@ -2243,7 +2245,7 @@ TEST_F(ProgramTests, RebuildBinaryWithRebuildError) {
class MyProgram : public MockProgram {
public:
MyProgram() { cip = nullptr; };
MyProgram(ExecutionEnvironment &executionEnvironment) : MockProgram(executionEnvironment), cip(nullptr) {}
~MyProgram() override {
delete cip;
}
@@ -2256,7 +2258,7 @@ TEST_F(ProgramTests, RebuildBinaryWithRebuildError) {
mutable MyCompilerInterface *cip;
};
auto program = std::make_unique<MyProgram>();
auto program = std::make_unique<MyProgram>(*pDevice->getExecutionEnvironment());
EXPECT_NE(nullptr, program);
cl_device_id deviceId = pContext->getDevice(0);
Device *pDevice = castToObject<Device>(deviceId);
@@ -2302,7 +2304,7 @@ TEST_F(ProgramTests, BuildProgramWithReraFlag) {
class MyProgram : public Program {
public:
MyProgram() { cip = nullptr; };
MyProgram(ExecutionEnvironment &executionEnvironment) : Program(executionEnvironment), cip(nullptr) {}
~MyProgram() override {
delete cip;
}
@@ -2320,7 +2322,7 @@ TEST_F(ProgramTests, BuildProgramWithReraFlag) {
mutable MyCompilerInterface *cip;
};
auto program = std::make_unique<MyProgram>();
auto program = std::make_unique<MyProgram>(*pDevice->getExecutionEnvironment());
EXPECT_NE(nullptr, program);
cl_device_id deviceId = pContext->getDevice(0);
Device *pDevice = castToObject<Device>(deviceId);
@@ -2375,7 +2377,7 @@ TEST_F(ProgramTests, RebuildBinaryWithProcessGenBinaryError) {
cl_int retVal;
CompilerInterface::getInstance();
auto program = std::make_unique<FailingGenBinaryProgram>();
auto program = std::make_unique<FailingGenBinaryProgram>(*pDevice->getExecutionEnvironment());
EXPECT_NE(nullptr, program);
cl_device_id deviceId = pContext->getDevice(0);
Device *pDevice = castToObject<Device>(deviceId);
@@ -2402,7 +2404,7 @@ TEST_F(ProgramTests, RebuildBinaryWithProcessGenBinaryError) {
}
TEST_F(ProgramTests, GetProgramCompilerVersion) {
auto program = std::make_unique<MockProgram>();
auto program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
// Create example header of OpenCL Program Binary
cl_device_id deviceId = pContext->getDevice(0);
@@ -2428,7 +2430,7 @@ TEST_F(ProgramTests, GetProgramCompilerVersion) {
}
TEST_F(ProgramTests, GivenZeroPrivateSizeInBlockWhenAllocateBlockProvateSurfacesCalledThenNoSurfaceIsCreated) {
MockProgram *program = new MockProgram(pContext, false);
MockProgram *program = new MockProgram(*pDevice->getExecutionEnvironment(), pContext, false);
uint32_t crossThreadOffsetBlock = 0;
@@ -2454,7 +2456,7 @@ TEST_F(ProgramTests, GivenZeroPrivateSizeInBlockWhenAllocateBlockProvateSurfaces
}
TEST_F(ProgramTests, GivenNonZeroPrivateSizeInBlockWhenAllocateBlockProvateSurfacesCalledThenSurfaceIsCreated) {
MockProgram *program = new MockProgram(pContext, false);
MockProgram *program = new MockProgram(*pDevice->getExecutionEnvironment(), pContext, false);
uint32_t crossThreadOffsetBlock = 0;
@@ -2480,7 +2482,7 @@ TEST_F(ProgramTests, GivenNonZeroPrivateSizeInBlockWhenAllocateBlockProvateSurfa
}
TEST_F(ProgramTests, GivenNonZeroPrivateSizeInBlockWhenAllocateBlockProvateSurfacesCalledThenSecondSurfaceIsNotCreated) {
MockProgram *program = new MockProgram(pContext, false);
MockProgram *program = new MockProgram(*pDevice->getExecutionEnvironment(), pContext, false);
uint32_t crossThreadOffsetBlock = 0;
@@ -2514,7 +2516,7 @@ TEST_F(ProgramTests, GivenNonZeroPrivateSizeInBlockWhenAllocateBlockProvateSurfa
}
TEST_F(ProgramTests, givenProgramWithBlockKernelsWhenfreeBlockResourcesisCalledThenFreeGraphhicsAllocationsFromBlockKernelManagerIsCalled) {
MockProgram *program = new MockProgram(pContext, false);
MockProgram *program = new MockProgram(*pDevice->getExecutionEnvironment(), pContext, false);
uint32_t crossThreadOffsetBlock = 0;
@@ -2555,13 +2557,13 @@ class Program32BitTests : public ProgramTests {
};
TEST_F(Program32BitTests, givenDeviceWithForce32BitAddressingOnWhenBultinIsCreatedThenNoFlagsArePassedAsInternalOptions) {
MockProgram pProgram;
MockProgram pProgram(*pDevice->getExecutionEnvironment());
auto &internalOptions = pProgram.getInternalOptions();
EXPECT_THAT(internalOptions, testing::HasSubstr(std::string("")));
}
TEST_F(Program32BitTests, givenDeviceWithForce32BitAddressingOnWhenProgramIsCreatedThen32bitFlagIsPassedAsInternalOption) {
MockProgram pProgram(pContext, false);
MockProgram pProgram(*pDevice->getExecutionEnvironment(), pContext, false);
auto &internalOptions = pProgram.getInternalOptions();
std::string s1 = internalOptions;
size_t pos = s1.find("-m32");
@@ -2573,7 +2575,7 @@ TEST_F(Program32BitTests, givenDeviceWithForce32BitAddressingOnWhenProgramIsCrea
}
TEST_F(ProgramTests, givenNewProgramTheStatelessToStatefulBufferOffsetOtimizationIsMatchingThePlatformEnablingStatus) {
MockProgram prog(pContext, false);
MockProgram prog(*pDevice->getExecutionEnvironment(), pContext, false);
auto &internalOpts = prog.getInternalOptions();
auto it = internalOpts.find("-cl-intel-has-buffer-offset-arg ");
@@ -2587,10 +2589,9 @@ TEST_F(ProgramTests, givenNewProgramTheStatelessToStatefulBufferOffsetOtimizatio
}
template <int32_t ErrCodeToReturn, bool spirv = true>
struct CreateProgramFromBinaryMock : MockProgram {
using MockProgram::MockProgram;
CreateProgramFromBinaryMock(Context *context, bool isBuiltIn)
: MockProgram(context, isBuiltIn) {
struct CreateProgramFromBinaryMock : public MockProgram {
CreateProgramFromBinaryMock(ExecutionEnvironment &executionEnvironment, Context *context, bool isBuiltIn)
: MockProgram(executionEnvironment, context, isBuiltIn) {
}
cl_int createProgramFromBinary(const void *pBinary,
@@ -2722,7 +2723,7 @@ TEST_F(ProgramTests, linkingTwoValidSpirvProgramsReturnsValidProgram) {
}
TEST_F(ProgramTests, givenSeparateBlockKernelsWhenNoParentAndSubgroupKernelsThenSeparateNoneKernel) {
MockProgram program(pContext, false);
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
EXPECT_EQ(0u, program.getKernelInfoArray().size());
EXPECT_EQ(0u, program.getParentKernelInfoArray().size());
@@ -2735,7 +2736,7 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenNoParentAndSubgroupKernelsThen
}
TEST_F(ProgramTests, givenSeparateBlockKernelsWhenRegularKernelsThenSeparateNoneKernel) {
MockProgram program(pContext, false);
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
auto pRegularKernel1Info = KernelInfo::create();
pRegularKernel1Info->name = "regular_kernel_1";
@@ -2757,7 +2758,7 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenRegularKernelsThenSeparateNone
}
TEST_F(ProgramTests, givenSeparateBlockKernelsWhenChildLikeKernelWithoutParentKernelThenSeparateNoneKernel) {
MockProgram program(pContext, false);
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
auto pParentKernelInfo = KernelInfo::create();
pParentKernelInfo->name = "another_parent_kernel";
@@ -2781,7 +2782,7 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenChildLikeKernelWithoutParentKe
}
TEST_F(ProgramTests, givenSeparateBlockKernelsWhenChildLikeKernelWithoutSubgroupKernelThenSeparateNoneKernel) {
MockProgram program(pContext, false);
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
auto pSubgroupKernelInfo = KernelInfo::create();
pSubgroupKernelInfo->name = "another_subgroup_kernel";
@@ -2805,7 +2806,7 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenChildLikeKernelWithoutSubgroup
}
TEST_F(ProgramTests, givenSeparateBlockKernelsWhenParentKernelWithChildKernelThenSeparateChildKernel) {
MockProgram program(pContext, false);
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
auto pParentKernelInfo = KernelInfo::create();
pParentKernelInfo->name = "parent_kernel";
@@ -2829,7 +2830,7 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenParentKernelWithChildKernelThe
}
TEST_F(ProgramTests, givenSeparateBlockKernelsWhenSubgroupKernelWithChildKernelThenSeparateChildKernel) {
MockProgram program(pContext, false);
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
auto pSubgroupKernelInfo = KernelInfo::create();
pSubgroupKernelInfo->name = "subgroup_kernel";
@@ -2853,7 +2854,8 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenSubgroupKernelWithChildKernelT
}
TEST(SimpleProgramTests, givenDefaultProgramWhenSetDeviceIsCalledThenDeviceIsSet) {
MockProgram pProgram(nullptr, false);
ExecutionEnvironment executionEnvironment;
MockProgram pProgram(executionEnvironment);
EXPECT_EQ(nullptr, pProgram.getDevicePtr());
auto dummyDevice = (Device *)0x1337;
pProgram.SetDevice(dummyDevice);
@@ -2866,7 +2868,7 @@ TEST(ProgramDestructionTests, givenProgramUsingDeviceWhenItIsDestroyedAfterPlatf
platformImpl->initialize();
auto device = platformImpl->getDevice(0);
MockContext *context = new MockContext(device, false);
MockProgram *pProgram = new MockProgram(context, false);
MockProgram *pProgram = new MockProgram(*device->getExecutionEnvironment(), context, false);
auto globalAllocation = device->getMemoryManager()->allocateGraphicsMemory(MemoryConstants::pageSize);
pProgram->setGlobalSurface(globalAllocation);
@@ -2904,20 +2906,20 @@ TEST_F(ProgramTests, givenCompilerInterfaceWhenCompileIsCalledThenProperIntermed
compilerMain->setDefaultCreatorFunc<OCLRT::MockFclOclDeviceCtx>(OCLRT::MockFclOclDeviceCtx::Create);
compilerInterface.useLlvmText = true;
auto programLlvmText = wrapReleasableObjectWithUniquePtr(new MockProgram());
auto programLlvmText = wrapReleasableObjectWithUniquePtr(new MockProgram(*pDevice->getExecutionEnvironment()));
programLlvmText->setDevice(device);
compilerInterface.intermediateRepresentation = IGC::CodeType::spirV;
compilerInterface.compile(*programLlvmText, input);
EXPECT_FALSE(programLlvmText->getIsSpirV());
compilerInterface.useLlvmText = false;
auto programSpirV = wrapReleasableObjectWithUniquePtr(new MockProgram());
auto programSpirV = wrapReleasableObjectWithUniquePtr(new MockProgram(*pDevice->getExecutionEnvironment()));
programSpirV->setDevice(device);
compilerInterface.intermediateRepresentation = IGC::CodeType::spirV;
compilerInterface.compile(*programSpirV, input);
EXPECT_TRUE(programSpirV->getIsSpirV());
auto programLlvmBc = wrapReleasableObjectWithUniquePtr(new MockProgram());
auto programLlvmBc = wrapReleasableObjectWithUniquePtr(new MockProgram(*pDevice->getExecutionEnvironment()));
programLlvmBc->setDevice(device);
compilerInterface.intermediateRepresentation = IGC::CodeType::llvmBc;
compilerInterface.compile(*programLlvmBc, input);
@@ -2943,7 +2945,7 @@ TEST_F(ProgramTests, givenProgramWithSpirvWhenRebuildProgramIsCalledThenSpirvPat
gEnvironment->igcPushDebugVars(debugVars);
std::unique_ptr<void, void (*)(void *)> igcDebugVarsAutoPop{&gEnvironment, [](void *) { gEnvironment->igcPopDebugVars(); }};
auto program = wrapReleasableObjectWithUniquePtr(new MockProgram());
auto program = wrapReleasableObjectWithUniquePtr(new MockProgram(*pDevice->getExecutionEnvironment()));
program->setDevice(device);
uint32_t spirv[16] = {0x03022307, 0x23471113, 0x17192329};
program->storeIrBinary(spirv, sizeof(spirv), true);

2
unit_tests/program/program_with_block_kernels_tests.cpp
View File

@@ -118,7 +118,7 @@ TEST_F(ProgramWithBlockKernelsTest, GivenKernelWithBlockKernelsWhenProgramIsLink
ASSERT_NE(nullptr, pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
Program *programLinked = new Program(pContext, false);
Program *programLinked = new Program(*pPlatform->peekExecutionEnvironment(), pContext, false);
cl_program program = pProgram;
retVal = pProgram->compile(1, &device, buildOptions, 0, nullptr, nullptr, nullptr, nullptr);

4
unit_tests/program/program_with_kernel_debug_tests.cpp
View File

@@ -38,12 +38,12 @@
using namespace OCLRT;
TEST_F(ProgramTests, givenDeafultProgramObjectWhenKernelDebugEnabledIsQueriedThenFalseIsReturned) {
MockProgram program(pContext, false);
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
EXPECT_FALSE(program.isKernelDebugEnabled());
}
TEST_F(ProgramTests, givenProgramObjectWhenEnableKernelDebugIsCalledThenProgramHasKernelDebugEnabled) {
MockProgram program(pContext, false);
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
program.enableKernelDebug();
EXPECT_TRUE(program.isKernelDebugEnabled());
}

2
unit_tests/sampler/sampler_set_arg_tests.cpp
View File

@@ -70,7 +70,7 @@ class SamplerSetArgFixture : public DeviceFixture {
pKernelInfo->kernelArgInfo[1].offsetHeap = 0x40;
pKernelInfo->kernelArgInfo[1].isSampler = true;
program = std::make_unique<MockProgram>();
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
pKernel = new MockKernel(program.get(), *pKernelInfo, *pDevice);
ASSERT_NE(nullptr, pKernel);
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());

26
unit_tests/scheduler/scheduler_kernel_tests.cpp
View File

@@ -70,8 +70,8 @@ class MockSchedulerKernel : public SchedulerKernel {
};
TEST(SchedulerKernelTest, getLws) {
MockProgram program;
auto device = unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
KernelInfo info;
MockSchedulerKernel kernel(&program, info, *device);
@@ -80,8 +80,8 @@ TEST(SchedulerKernelTest, getLws) {
}
TEST(SchedulerKernelTest, getGws) {
MockProgram program;
auto device = unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
KernelInfo info;
MockSchedulerKernel kernel(&program, info, *device);
@@ -96,8 +96,8 @@ TEST(SchedulerKernelTest, getGws) {
}
TEST(SchedulerKernelTest, setGws) {
MockProgram program;
auto device = unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
KernelInfo info;
MockSchedulerKernel kernel(&program, info, *device);
@@ -109,8 +109,8 @@ TEST(SchedulerKernelTest, setGws) {
}
TEST(SchedulerKernelTest, getCurbeSize) {
MockProgram program;
auto device = unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
KernelInfo info;
uint32_t crossTrheadDataSize = 32;
uint32_t dshSize = 48;
@@ -132,7 +132,7 @@ TEST(SchedulerKernelTest, getCurbeSize) {
TEST(SchedulerKernelTest, setArgsForSchedulerKernel) {
auto device = unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockProgram program;
MockProgram program(*device->getExecutionEnvironment());
program.setDevice(device.get());
unique_ptr<KernelInfo> info(nullptr);
KernelInfo *infoPtr = nullptr;
@@ -161,7 +161,7 @@ TEST(SchedulerKernelTest, setArgsForSchedulerKernel) {
TEST(SchedulerKernelTest, setArgsForSchedulerKernelWithNullDebugQueue) {
auto device = unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockProgram program;
MockProgram program(*device->getExecutionEnvironment());
program.setDevice(device.get());
unique_ptr<KernelInfo> info(nullptr);
@@ -194,7 +194,7 @@ TEST(SchedulerKernelTest, createKernelReflectionForForcedSchedulerDispatch) {
DebugManager.flags.ForceDispatchScheduler.set(true);
auto device = unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockProgram program;
MockProgram program(*device->getExecutionEnvironment());
program.setDevice(device.get());
unique_ptr<KernelInfo> info(nullptr);
@@ -212,7 +212,7 @@ TEST(SchedulerKernelTest, createKernelReflectionSecondTimeForForcedSchedulerDisp
DebugManager.flags.ForceDispatchScheduler.set(true);
auto device = unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockProgram program;
MockProgram program(*device->getExecutionEnvironment());
program.setDevice(device.get());
unique_ptr<KernelInfo> info(nullptr);
@@ -234,7 +234,7 @@ TEST(SchedulerKernelTest, createKernelReflectionForSchedulerDoesNothing) {
DebugManager.flags.ForceDispatchScheduler.set(false);
auto device = unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockProgram program;
MockProgram program(*device->getExecutionEnvironment());
program.setDevice(device.get());
unique_ptr<KernelInfo> info(nullptr);
@@ -248,8 +248,8 @@ TEST(SchedulerKernelTest, createKernelReflectionForSchedulerDoesNothing) {
}
TEST(SchedulerKernelTest, getCurbeSizeWithNullKernelInfo) {
MockProgram program;
auto device = unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
KernelInfo info;
info.patchInfo.dataParameterStream = nullptr;
@@ -265,8 +265,8 @@ TEST(SchedulerKernelTest, givenForcedSchedulerGwsByDebugVariableWhenSchedulerKer
DebugManagerStateRestore dbgRestorer;
DebugManager.flags.SchedulerGWS.set(48);
MockProgram program;
auto device = unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
KernelInfo info;
MockSchedulerKernel kernel(&program, info, *device);
@@ -275,13 +275,13 @@ TEST(SchedulerKernelTest, givenForcedSchedulerGwsByDebugVariableWhenSchedulerKer
}
TEST(SchedulerKernelTest, givenSimulationModeWhenSchedulerKernelIsCreatedThenGwsIsSetToOneWorkgroup) {
MockProgram program;
FeatureTable skuTable = *platformDevices[0]->pSkuTable;
skuTable.ftrSimulationMode = true;
HardwareInfo hwInfo = {platformDevices[0]->pPlatform, &skuTable, platformDevices[0]->pWaTable,
platformDevices[0]->pSysInfo, platformDevices[0]->capabilityTable};
auto device = std::unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(&hwInfo));
MockProgram program(*device->getExecutionEnvironment());
KernelInfo info;
MockSchedulerKernel kernel(&program, info, *device);
@@ -293,13 +293,13 @@ TEST(SchedulerKernelTest, givenForcedSchedulerGwsByDebugVariableAndSimulationMod
DebugManagerStateRestore dbgRestorer;
DebugManager.flags.SchedulerGWS.set(48);
MockProgram program;
FeatureTable skuTable = *platformDevices[0]->pSkuTable;
skuTable.ftrSimulationMode = true;
HardwareInfo hwInfo = {platformDevices[0]->pPlatform, &skuTable, platformDevices[0]->pWaTable,
platformDevices[0]->pSysInfo, platformDevices[0]->capabilityTable};
auto device = std::unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(&hwInfo));
MockProgram program(*device->getExecutionEnvironment());
KernelInfo info;
MockSchedulerKernel kernel(&program, info, *device);