Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Improve KernelInfo handling:

Browse Source 
Remove wrapper for KernelInfo constructor
Switch to unique pointer where possible

Change-Id: Ib3f323e34836e1d189d836fd539ab45518609610
This commit is contained in:
Cetnerowski
2018-08-16 14:28:58 +02:00
committed by sys_ocldev
parent ff683ebdc1
commit 8647e0c349
36 changed files with 155 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
runtime/program/kernel_info.cpp
View File

@ -209,10 +209,6 @@ void WorkSizeInfo::checkRatio(const size_t workItems[3]) {
}
}
KernelInfo *KernelInfo::create() {
return new KernelInfo();
}
KernelInfo::~KernelInfo() {
kernelArgInfo.clear();

1
runtime/program/kernel_info.h
View File

@ -128,7 +128,6 @@ struct DebugData {
struct KernelInfo {
public:
static KernelInfo *create();
KernelInfo() {
heapInfo = {};
patchInfo = {};

3
runtime/program/process_gen_binary.cpp
View File

@ -80,7 +80,7 @@ size_t Program::processKernel(
size_t sizeProcessed = 0;
do {
auto pKernelInfo = KernelInfo::create();
auto pKernelInfo = new KernelInfo();
if (!pKernelInfo) {
retVal = CL_OUT_OF_HOST_MEMORY;
break;
@ -113,7 +113,6 @@ size_t Program::processKernel(
retVal = parsePatchList(*pKernelInfo);
if (retVal != CL_SUCCESS) {
delete pKernelInfo;
sizeProcessed = ptrDiff(pCurKernelPtr, pKernelBlob);
break;
}

7
unit_tests/accelerators/media_image_arg_tests.cpp
View File

@ -47,7 +47,8 @@ class MediaImageSetArgTest : public DeviceFixture,
protected:
void SetUp() override {
DeviceFixture::SetUp();
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
kernelHeader.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
@ -82,7 +83,7 @@ class MediaImageSetArgTest : public DeviceFixture,
void TearDown() override {
delete srcImage;
delete pKernel;
delete pKernelInfo;
delete context;
DeviceFixture::TearDown();
}
@ -92,7 +93,7 @@ class MediaImageSetArgTest : public DeviceFixture,
std::unique_ptr<MockProgram> program;
MockKernel *pKernel = nullptr;
SKernelBinaryHeaderCommon kernelHeader;
KernelInfo *pKernelInfo = nullptr;
std::unique_ptr<KernelInfo> pKernelInfo;
char surfaceStateHeap[0x80];
Image *srcImage = nullptr;
};

4
unit_tests/api/cl_create_kernel_tests.inl
View File

@ -89,7 +89,7 @@ TEST_F(clCreateKernelTests, returnsSuccess) {
TEST_F(clCreateKernelTests, givenInvalidKernelWhenCreatingNewKernelThenReturnClInvalidProgramExecutable) {
cl_kernel kernel = nullptr;
KernelInfo *pKernelInfo = KernelInfo::create();
KernelInfo *pKernelInfo = new KernelInfo();
pKernelInfo->isValid = false;
std::unique_ptr<MockProgram> pMockProg = std::make_unique<MockProgram>(*pPlatform->peekExecutionEnvironment(), pContext, false);
@ -170,7 +170,7 @@ TEST_F(clCreateKernelTests, nullProgram) {
TEST_F(clCreateKernelTests, givenNullKernelNameWhenCreatingNewKernelThenReturnClInvalidValue) {
cl_kernel kernel = nullptr;
KernelInfo *pKernelInfo = KernelInfo::create();
KernelInfo *pKernelInfo = new KernelInfo();
pKernelInfo->isValid = true;
std::unique_ptr<MockProgram> pMockProg = std::make_unique<MockProgram>(*pPlatform->peekExecutionEnvironment(), pContext, false);

5
unit_tests/api/cl_set_kernel_arg_svm_pointer_tests.inl
View File

@ -40,7 +40,7 @@ class KernelArgSvmFixture : public api_fixture, public DeviceFixture {
DeviceFixture::SetUp();
// define kernel info
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
// setup kernel arg offsets
KernelArgPatchInfo kernelArgPatchInfo;
@ -66,7 +66,6 @@ class KernelArgSvmFixture : public api_fixture, public DeviceFixture {
void TearDown() override {
delete pMockKernel;
delete pKernelInfo;
DeviceFixture::TearDown();
api_fixture::TearDown();
@ -74,7 +73,7 @@ class KernelArgSvmFixture : public api_fixture, public DeviceFixture {
cl_int retVal = CL_SUCCESS;
MockKernel *pMockKernel = nullptr;
KernelInfo *pKernelInfo = nullptr;
std::unique_ptr<KernelInfo> pKernelInfo;
SKernelBinaryHeaderCommon kernelHeader;
char pSshLocal[64];
char pCrossThreadData[64];

5
unit_tests/api/cl_set_kernel_exec_info_tests.inl
View File

@ -31,7 +31,7 @@ class KernelExecInfoFixture : public api_fixture {
void SetUp() override {
api_fixture::SetUp();
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
pMockKernel = new MockKernel(pProgram, *pKernelInfo, *pPlatform->getDevice(0));
ASSERT_EQ(CL_SUCCESS, pMockKernel->initialize());
@ -48,14 +48,13 @@ class KernelExecInfoFixture : public api_fixture {
}
delete pMockKernel;
delete pKernelInfo;
api_fixture::TearDown();
}
cl_int retVal = CL_SUCCESS;
MockKernel *pMockKernel = nullptr;
KernelInfo *pKernelInfo = nullptr;
std::unique_ptr<KernelInfo> pKernelInfo;
void *ptrSvm = nullptr;
cl_device_svm_capabilities svmCapabilities = 0;
};

3
unit_tests/fixtures/kernel_arg_fixture.cpp
View File

@ -21,6 +21,7 @@
*/
#include "unit_tests/fixtures/kernel_arg_fixture.h"
#include "runtime/program/kernel_info.h"
#include "unit_tests/fixtures/image_fixture.h"
#include "unit_tests/mocks/mock_context.h"
@ -31,7 +32,7 @@
KernelImageArgTest::~KernelImageArgTest() = default;
void KernelImageArgTest::SetUp() {
pKernelInfo.reset(OCLRT::KernelInfo::create());
pKernelInfo = std::make_unique<OCLRT::KernelInfo>();
KernelArgPatchInfo kernelArgPatchInfo;
kernelHeader.reset(new iOpenCL::SKernelBinaryHeaderCommon{});

2
unit_tests/fixtures/preemption_fixture.cpp
View File

@ -49,7 +49,7 @@ void DevicePreemptionTests::SetUp() {
dbgRestore.reset(new DebugManagerStateRestore());
}
const cl_queue_properties properties[3] = {CL_QUEUE_PROPERTIES, 0, 0};
kernelInfo.reset(KernelInfo::create());
kernelInfo = std::make_unique<KernelInfo>();
device.reset(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
context.reset(new MockContext(device.get()));
cmdQ.reset(new MockCommandQueue(context.get(), device.get(), properties));

2
unit_tests/gtpin/gtpin_tests.cpp
View File

@ -2257,7 +2257,7 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenOnKernelSubitIsCalledThenCo
std::unique_ptr<MockContext> context(new MockContext(pDevice));
EXPECT_EQ(CL_SUCCESS, retVal);
std::unique_ptr<KernelInfo> pKernelInfo(KernelInfo::create());
auto pKernelInfo = std::make_unique<KernelInfo>();
kernelHeader.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
pKernelInfo->heapInfo.pKernelHeader = &kernelHeader;

5
unit_tests/helpers/dispatch_info_builder_tests.cpp
View File

@ -45,7 +45,7 @@ class DispatchInfoBuilderFixture : public ContextFixture, public DeviceFixture {
DeviceFixture::SetUp();
cl_device_id device = pDevice;
ContextFixture::SetUp(1, &device);
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
pMediaVFEstate = new SPatchMediaVFEState();
pMediaVFEstate->PerThreadScratchSpace = 1024;
@ -96,13 +96,12 @@ class DispatchInfoBuilderFixture : public ContextFixture, public DeviceFixture {
delete pExecutionEnvironment;
delete pMediaVFEstate;
delete pProgram;
delete pKernelInfo;
ContextFixture::TearDown();
DeviceFixture::TearDown();
}
KernelInfo *pKernelInfo = nullptr;
std::unique_ptr<KernelInfo> pKernelInfo;
SPatchMediaVFEState *pMediaVFEstate = nullptr;
SPatchExecutionEnvironment *pExecutionEnvironment;
SPatchAllocateStatelessPrintfSurface *pPrintfSurface = nullptr;

5
unit_tests/helpers/dispatch_info_tests.cpp
View File

@ -43,7 +43,7 @@ class DispatchInfoFixture : public ContextFixture, public DeviceFixture {
DeviceFixture::SetUp();
cl_device_id device = pDevice;
ContextFixture::SetUp(1, &device);
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
pMediaVFEstate = new SPatchMediaVFEState();
pMediaVFEstate->PerThreadScratchSpace = 1024;
@ -61,13 +61,12 @@ class DispatchInfoFixture : public ContextFixture, public DeviceFixture {
delete pPrintfSurface;
delete pMediaVFEstate;
delete pProgram;
delete pKernelInfo;
ContextFixture::TearDown();
DeviceFixture::TearDown();
}
KernelInfo *pKernelInfo = nullptr;
std::unique_ptr<KernelInfo> pKernelInfo;
SPatchMediaVFEState *pMediaVFEstate = nullptr;
SPatchAllocateStatelessPrintfSurface *pPrintfSurface = nullptr;
MockProgram *pProgram = nullptr;

17
unit_tests/helpers/kernel_commands_tests.cpp
View File

@ -183,8 +183,10 @@ HWTEST_F(KernelCommandsTest, givenSendCrossThreadDataWhenWhenAddPatchInfoComment
CommandQueueHw<FamilyType> cmdQ(pContext, pDevice, 0);
MockContext context;
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
std::unique_ptr<KernelInfo> kernelInfo(KernelInfo::create());
auto kernelInfo = std::make_unique<KernelInfo>();
std::unique_ptr<MockKernel> kernel(new MockKernel(&program, *kernelInfo, *pDevice));
auto &indirectHeap = cmdQ.getIndirectHeap(IndirectHeap::INDIRECT_OBJECT, 8192);
@ -238,8 +240,10 @@ HWTEST_F(KernelCommandsTest, givenSendCrossThreadDataWhenWhenAddPatchInfoComment
CommandQueueHw<FamilyType> cmdQ(pContext, pDevice, 0);
MockContext context;
MockProgram program(*pDevice->getExecutionEnvironment(), &context, false);
std::unique_ptr<KernelInfo> kernelInfo(KernelInfo::create());
auto kernelInfo = std::make_unique<KernelInfo>();
std::unique_ptr<MockKernel> kernel(new MockKernel(&program, *kernelInfo, *pDevice));
auto &indirectHeap = cmdQ.getIndirectHeap(IndirectHeap::INDIRECT_OBJECT, 8192);
@ -588,7 +592,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, KernelCommandsTest, usedBindingTableStatePointersFor
using INTERFACE_DESCRIPTOR_DATA = typename FamilyType::INTERFACE_DESCRIPTOR_DATA;
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchExecutionEnvironment tokenEE;
tokenEE.CompiledSIMD8 = false;
@ -748,13 +752,12 @@ HWCMDTEST_F(IGFX_GEN8_CORE, KernelCommandsTest, usedBindingTableStatePointersFor
}
alignedFree(surfaceStateHeap);
delete pKernel;
delete pKernelInfo;
}
HWTEST_F(KernelCommandsTest, setBindingTableStatesForKernelWithBuffersNotRequiringSSHDoesNotTouchSSH) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
// create program with valid context
MockContext context;
@ -807,13 +810,12 @@ HWTEST_F(KernelCommandsTest, setBindingTableStatesForKernelWithBuffersNotRequiri
EXPECT_EQ(usedAfter, ssh.getUsed());
delete pKernel;
delete pKernelInfo;
}
HWTEST_F(KernelCommandsTest, setBindingTableStatesForNoSurfaces) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
// create program with valid context
MockContext context;
@ -863,7 +865,6 @@ HWTEST_F(KernelCommandsTest, setBindingTableStatesForNoSurfaces) {
pKernelInfo->patchInfo.bindingTableState = nullptr;
delete pKernel;
delete pKernelInfo;
}
HWTEST_F(KernelCommandsTest, slmValueScenarios) {

6
unit_tests/kernel/clone_kernel_tests.cpp
View File

@ -57,7 +57,7 @@ class CloneKernelFixture : public ContextFixture, public DeviceFixture {
ContextFixture::SetUp(1, &device);
// define kernel info
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
// setup kernel arg offsets
KernelArgPatchInfo kernelArgPatchInfo;
@ -110,7 +110,7 @@ class CloneKernelFixture : public ContextFixture, public DeviceFixture {
void TearDown() override {
delete pSourceKernel;
delete pClonedKernel;
delete pKernelInfo;
delete pProgram;
ContextFixture::TearDown();
DeviceFixture::TearDown();
@ -120,7 +120,7 @@ class CloneKernelFixture : public ContextFixture, public DeviceFixture {
MockProgram *pProgram = nullptr;
MockKernel *pSourceKernel = nullptr;
MockKernel *pClonedKernel = nullptr;
KernelInfo *pKernelInfo = nullptr;
std::unique_ptr<KernelInfo> pKernelInfo;
SKernelBinaryHeaderCommon kernelHeader;
char surfaceStateHeap[128];
};

2
unit_tests/kernel/image_transformer_tests.cpp
View File

@ -31,7 +31,7 @@ class ImageTransformerTest : public ::testing::Test {
public:
void SetUp() override {
using SimpleKernelArgInfo = Kernel::SimpleKernelArgInfo;
pKernelInfo.reset(KernelInfo::create());
pKernelInfo = std::make_unique<KernelInfo>();
pKernelInfo->kernelArgInfo.resize(2);
pKernelInfo->kernelArgInfo[0].isTransformable = true;
pKernelInfo->kernelArgInfo[0].offsetHeap = firstImageOffset;

6
unit_tests/kernel/kernel_accelerator_arg_tests.cpp
View File

@ -59,7 +59,7 @@ class KernelArgAcceleratorFixture : public ContextFixture, public DeviceFixture
cl_device_id device = pDevice;
ContextFixture::SetUp(1, &device);
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
KernelArgPatchInfo kernelArgPatchInfo;
pKernelInfo->kernelArgInfo.resize(1);
@ -91,7 +91,7 @@ class KernelArgAcceleratorFixture : public ContextFixture, public DeviceFixture
void TearDown() override {
delete pKernel;
delete pKernelInfo;
delete pProgram;
ContextFixture::TearDown();
DeviceFixture::TearDown();
@ -100,7 +100,7 @@ class KernelArgAcceleratorFixture : public ContextFixture, public DeviceFixture
cl_motion_estimation_desc_intel desc;
MockProgram *pProgram = nullptr;
MockKernel *pKernel = nullptr;
KernelInfo *pKernelInfo = nullptr;
std::unique_ptr<KernelInfo> pKernelInfo;
char pCrossThreadData[64];
};

4
unit_tests/kernel/kernel_arg_buffer_fixture.cpp
View File

@ -43,7 +43,7 @@ void KernelArgBufferFixture::SetUp() {
ContextFixture::SetUp(1, &device);
// define kernel info
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
// setup kernel arg offsets
KernelArgPatchInfo kernelArgPatchInfo;
@ -71,7 +71,7 @@ void KernelArgBufferFixture::SetUp() {
void KernelArgBufferFixture::TearDown() {
delete pKernel;
delete pKernelInfo;
delete pProgram;
ContextFixture::TearDown();
DeviceFixture::TearDown();

2
unit_tests/kernel/kernel_arg_buffer_fixture.h
View File

@ -52,7 +52,7 @@ class KernelArgBufferFixture : public ContextFixture, public DeviceFixture {
cl_int retVal;
MockProgram *pProgram;
MockKernel *pKernel;
KernelInfo *pKernelInfo;
std::unique_ptr<KernelInfo> pKernelInfo;
SKernelBinaryHeaderCommon kernelHeader;
char pSshLocal[64];
char pCrossThreadData[64];

6
unit_tests/kernel/kernel_arg_dev_queue_tests.cpp
View File

@ -38,7 +38,7 @@ struct KernelArgDevQueueTest : public DeviceFixture,
pDeviceQueue = createQueueObject();
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
pKernelInfo->kernelArgInfo.resize(1);
pKernelInfo->kernelArgInfo[0].isDeviceQueue = true;
@ -59,7 +59,7 @@ struct KernelArgDevQueueTest : public DeviceFixture,
void TearDown() override {
delete pKernel;
delete pKernelInfo;
delete pDeviceQueue;
DeviceHostQueueFixture<DeviceQueue>::TearDown();
@ -82,7 +82,7 @@ struct KernelArgDevQueueTest : public DeviceFixture,
std::unique_ptr<MockProgram> program;
DeviceQueue *pDeviceQueue = nullptr;
MockKernel *pKernel = nullptr;
KernelInfo *pKernelInfo = nullptr;
std::unique_ptr<KernelInfo> pKernelInfo;
KernelArgPatchInfo kernelArgPatchInfo;
};

6
unit_tests/kernel/kernel_arg_pipe_tests.cpp
View File

@ -52,7 +52,7 @@ class KernelArgPipeFixture : public ContextFixture, public DeviceFixture {
ContextFixture::SetUp(1, &device);
// define kernel info
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
// setup kernel arg offsets
KernelArgPatchInfo kernelArgPatchInfo;
@ -80,7 +80,7 @@ class KernelArgPipeFixture : public ContextFixture, public DeviceFixture {
void TearDown() override {
delete pKernel;
delete pKernelInfo;
delete pProgram;
ContextFixture::TearDown();
DeviceFixture::TearDown();
@ -89,7 +89,7 @@ class KernelArgPipeFixture : public ContextFixture, public DeviceFixture {
cl_int retVal = CL_SUCCESS;
MockProgram *pProgram = nullptr;
MockKernel *pKernel = nullptr;
KernelInfo *pKernelInfo = nullptr;
std::unique_ptr<KernelInfo> pKernelInfo;
SKernelBinaryHeaderCommon kernelHeader;
char pSshLocal[64];
char pCrossThreadData[64];

6
unit_tests/kernel/kernel_arg_svm_tests.cpp
View File

@ -51,7 +51,7 @@ class KernelArgSvmFixture_ : public ContextFixture, public DeviceFixture {
ContextFixture::SetUp(1, &device);
// define kernel info
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
// setup kernel arg offsets
KernelArgPatchInfo kernelArgPatchInfo;
@ -77,7 +77,7 @@ class KernelArgSvmFixture_ : public ContextFixture, public DeviceFixture {
void TearDown() override {
delete pKernel;
delete pKernelInfo;
delete pProgram;
ContextFixture::TearDown();
DeviceFixture::TearDown();
@ -86,7 +86,7 @@ class KernelArgSvmFixture_ : public ContextFixture, public DeviceFixture {
cl_int retVal = CL_SUCCESS;
MockProgram *pProgram = nullptr;
MockKernel *pKernel = nullptr;
KernelInfo *pKernelInfo = nullptr;
std::unique_ptr<KernelInfo> pKernelInfo;
SKernelBinaryHeaderCommon kernelHeader;
char pSshLocal[64];
char pCrossThreadData[64];

6
unit_tests/kernel/kernel_immediate_arg_tests.cpp
View File

@ -44,7 +44,7 @@ class KernelArgImmediateTest : public Test<DeviceFixture> {
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
// define kernel info
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
// setup kernel arg offsets
KernelArgPatchInfo kernelArgPatchInfo;
@ -83,14 +83,14 @@ class KernelArgImmediateTest : public Test<DeviceFixture> {
void TearDown() override {
delete pKernel;
delete pKernelInfo;
DeviceFixture::TearDown();
}
cl_int retVal = CL_SUCCESS;
std::unique_ptr<MockProgram> program;
MockKernel *pKernel = nullptr;
KernelInfo *pKernelInfo;
std::unique_ptr<KernelInfo> pKernelInfo;
char pCrossThreadData[0x60];
};

6
unit_tests/kernel/kernel_slm_arg_tests.cpp
View File

@ -36,7 +36,7 @@ class KernelSlmArgTest : public Test<DeviceFixture> {
protected:
void SetUp() override {
DeviceFixture::SetUp();
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
KernelArgPatchInfo kernelArgPatchInfo;
pKernelInfo->kernelArgInfo.resize(3);
@ -67,14 +67,14 @@ class KernelSlmArgTest : public Test<DeviceFixture> {
void TearDown() override {
delete pKernel;
delete pKernelInfo;
DeviceFixture::TearDown();
}
cl_int retVal = CL_SUCCESS;
std::unique_ptr<MockProgram> program;
MockKernel *pKernel = nullptr;
KernelInfo *pKernelInfo;
std::unique_ptr<KernelInfo> pKernelInfo;
static const size_t slmSize0 = 0x200;
static const size_t slmSize2 = 0x30;

111
unit_tests/kernel/kernel_tests.cpp
View File

@ -473,7 +473,7 @@ TEST_F(KernelPrivateSurfaceTest, testPrivateSurface) {
ASSERT_NE(nullptr, pDevice);
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
// setup private memory
SPatchAllocateStatelessPrivateSurface tokenSPS;
@ -513,11 +513,10 @@ TEST_F(KernelPrivateSurfaceTest, testPrivateSurface) {
EXPECT_EQ(0u, csr->residency.size());
delete pKernel;
delete pKernelInfo;
}
TEST_F(KernelPrivateSurfaceTest, givenKernelWithPrivateSurfaceThatIsInUseByGpuWhenKernelIsBeingDestroyedThenAllocationIsAddedToDefferedFreeList) {
std::unique_ptr<KernelInfo> pKernelInfo(KernelInfo::create());
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchAllocateStatelessPrivateSurface tokenSPS;
tokenSPS.SurfaceStateHeapOffset = 64;
tokenSPS.DataParamOffset = 40;
@ -556,7 +555,7 @@ TEST_F(KernelPrivateSurfaceTest, testPrivateSurfaceAllocationFailure) {
ASSERT_NE(nullptr, pDevice);
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
// setup private memory
SPatchAllocateStatelessPrivateSurface tokenSPS;
@ -594,8 +593,6 @@ TEST_F(KernelPrivateSurfaceTest, testPrivateSurfaceAllocationFailure) {
f->injectFailures(method);
f->TearDown();
delete f;
delete pKernelInfo;
}
TEST_F(KernelPrivateSurfaceTest, given32BitDeviceWhenKernelIsCreatedThenPrivateSurfaceIs32BitAllocation) {
@ -603,7 +600,7 @@ TEST_F(KernelPrivateSurfaceTest, given32BitDeviceWhenKernelIsCreatedThenPrivateS
pDevice->getMemoryManager()->setForce32BitAllocations(true);
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
// setup private memory
SPatchAllocateStatelessPrivateSurface tokenSPS;
@ -633,14 +630,13 @@ TEST_F(KernelPrivateSurfaceTest, given32BitDeviceWhenKernelIsCreatedThenPrivateS
EXPECT_TRUE(pKernel->getPrivateSurface()->is32BitAllocation);
delete pKernel;
delete pKernelInfo;
}
}
HWTEST_F(KernelPrivateSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenPrivateMemorySurfaceStateIsPatchedWithCpuAddress) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchExecutionEnvironment tokenEE;
tokenEE.CompiledSIMD8 = false;
@ -690,13 +686,12 @@ HWTEST_F(KernelPrivateSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenPri
EXPECT_EQ(bufferAddress, surfaceAddress);
delete pKernel;
delete pKernelInfo;
}
TEST_F(KernelPrivateSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenPrivateMemorySurfaceStateIsNotPatched) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchExecutionEnvironment tokenEE;
tokenEE.CompiledSIMD8 = false;
@ -725,27 +720,22 @@ TEST_F(KernelPrivateSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenPriv
program.setConstantSurface(nullptr);
delete pKernel;
delete pKernelInfo;
}
TEST_F(KernelPrivateSurfaceTest, givenNullDataParameterStreamGetConstantBufferSizeReturnsZero) {
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
EXPECT_EQ(0u, pKernelInfo->getConstantBufferSize());
delete pKernelInfo;
}
TEST_F(KernelPrivateSurfaceTest, givenNonNullDataParameterStreamGetConstantBufferSizeReturnsCorrectSize) {
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchDataParameterStream tokenDPS;
tokenDPS.DataParameterStreamSize = 64;
pKernelInfo->patchInfo.dataParameterStream = &tokenDPS;
EXPECT_EQ(64u, pKernelInfo->getConstantBufferSize());
delete pKernelInfo;
}
TEST_F(KernelPrivateSurfaceTest, GivenKernelWhenPrivateSurfaceTooBigAndGpuPointerSize4ThenReturnOutOfResources) {
@ -753,7 +743,7 @@ TEST_F(KernelPrivateSurfaceTest, GivenKernelWhenPrivateSurfaceTooBigAndGpuPointe
pAllocateStatelessPrivateSurface->PerThreadPrivateMemorySize = std::numeric_limits<uint32_t>::max();
auto executionEnvironment = std::unique_ptr<SPatchExecutionEnvironment>(new SPatchExecutionEnvironment());
executionEnvironment->CompiledSIMD32 = 32;
std::unique_ptr<KernelInfo> pKernelInfo(KernelInfo::create());
auto pKernelInfo = std::make_unique<KernelInfo>();
pKernelInfo->patchInfo.pAllocateStatelessPrivateSurface = pAllocateStatelessPrivateSurface.get();
pKernelInfo->patchInfo.executionEnvironment = executionEnvironment.get();
MockContext context;
@ -771,7 +761,7 @@ TEST_F(KernelPrivateSurfaceTest, GivenKernelWhenPrivateSurfaceTooBigAndGpuPointe
pAllocateStatelessPrivateSurface->PerThreadPrivateMemorySize = std::numeric_limits<uint32_t>::max();
auto executionEnvironment = std::unique_ptr<SPatchExecutionEnvironment>(new SPatchExecutionEnvironment());
executionEnvironment->CompiledSIMD32 = 32;
std::unique_ptr<KernelInfo> pKernelInfo(KernelInfo::create());
auto pKernelInfo = std::make_unique<KernelInfo>();
pKernelInfo->patchInfo.pAllocateStatelessPrivateSurface = pAllocateStatelessPrivateSurface.get();
pKernelInfo->patchInfo.executionEnvironment = executionEnvironment.get();
MockContext context;
@ -789,7 +779,7 @@ TEST_F(KernelPrivateSurfaceTest, GivenKernelWhenPrivateSurfaceTooBigAndGpuPointe
pAllocateStatelessPrivateSurface->PerThreadPrivateMemorySize = std::numeric_limits<uint32_t>::max();
auto executionEnvironment = std::unique_ptr<SPatchExecutionEnvironment>(new SPatchExecutionEnvironment());
executionEnvironment->CompiledSIMD32 = 32;
std::unique_ptr<KernelInfo> pKernelInfo(KernelInfo::create());
auto pKernelInfo = std::make_unique<KernelInfo>();
pKernelInfo->patchInfo.pAllocateStatelessPrivateSurface = pAllocateStatelessPrivateSurface.get();
pKernelInfo->patchInfo.executionEnvironment = executionEnvironment.get();
MockContext context;
@ -805,7 +795,7 @@ TEST_F(KernelPrivateSurfaceTest, GivenKernelWhenPrivateSurfaceTooBigAndGpuPointe
TEST_F(KernelGlobalSurfaceTest, givenBuiltInKernelWhenKernelIsCreatedThenGlobalSurfaceIsPatchedWithCpuAddress) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
// setup global memory
SPatchAllocateStatelessGlobalMemorySurfaceWithInitialization AllocateStatelessGlobalMemorySurfaceWithInitialization;
@ -843,13 +833,12 @@ TEST_F(KernelGlobalSurfaceTest, givenBuiltInKernelWhenKernelIsCreatedThenGlobalS
program.setGlobalSurface(nullptr);
delete pKernel;
delete pKernelInfo;
}
TEST_F(KernelGlobalSurfaceTest, givenNDRangeKernelWhenKernelIsCreatedThenGlobalSurfaceIsPatchedWithBaseAddressOffset) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
// setup global memory
SPatchAllocateStatelessGlobalMemorySurfaceWithInitialization AllocateStatelessGlobalMemorySurfaceWithInitialization;
@ -885,13 +874,12 @@ TEST_F(KernelGlobalSurfaceTest, givenNDRangeKernelWhenKernelIsCreatedThenGlobalS
program.setGlobalSurface(nullptr);
delete pKernel;
delete pKernelInfo;
}
HWTEST_F(KernelGlobalSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenGlobalMemorySurfaceStateIsPatchedWithCpuAddress) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchExecutionEnvironment tokenEE;
tokenEE.CompiledSIMD8 = false;
@ -944,13 +932,12 @@ HWTEST_F(KernelGlobalSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenGlob
program.setGlobalSurface(nullptr);
delete pKernel;
delete pKernelInfo;
}
TEST_F(KernelGlobalSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenGlobalMemorySurfaceStateIsNotPatched) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchExecutionEnvironment tokenEE;
tokenEE.CompiledSIMD8 = false;
@ -978,13 +965,12 @@ TEST_F(KernelGlobalSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenGloba
program.setGlobalSurface(nullptr);
delete pKernel;
delete pKernelInfo;
}
TEST_F(KernelConstantSurfaceTest, givenBuiltInKernelWhenKernelIsCreatedThenConstantSurfaceIsPatchedWithCpuAddress) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
// setup constant memory
SPatchAllocateStatelessConstantMemorySurfaceWithInitialization AllocateStatelessConstantMemorySurfaceWithInitialization;
@ -1021,13 +1007,12 @@ TEST_F(KernelConstantSurfaceTest, givenBuiltInKernelWhenKernelIsCreatedThenConst
program.setConstantSurface(nullptr);
delete pKernel;
delete pKernelInfo;
}
TEST_F(KernelConstantSurfaceTest, givenNDRangeKernelWhenKernelIsCreatedThenConstantSurfaceIsPatchedWithBaseAddressOffset) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
// setup constant memory
SPatchAllocateStatelessConstantMemorySurfaceWithInitialization AllocateStatelessConstantMemorySurfaceWithInitialization;
@ -1063,13 +1048,12 @@ TEST_F(KernelConstantSurfaceTest, givenNDRangeKernelWhenKernelIsCreatedThenConst
program.setConstantSurface(nullptr);
delete pKernel;
delete pKernelInfo;
}
HWTEST_F(KernelConstantSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenConstantMemorySurfaceStateIsPatchedWithCpuAddress) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchExecutionEnvironment tokenEE;
tokenEE.CompiledSIMD8 = false;
@ -1122,13 +1106,12 @@ HWTEST_F(KernelConstantSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenCo
program.setConstantSurface(nullptr);
delete pKernel;
delete pKernelInfo;
}
TEST_F(KernelConstantSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenConstantMemorySurfaceStateIsNotPatched) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchExecutionEnvironment tokenEE;
tokenEE.CompiledSIMD8 = false;
@ -1156,13 +1139,12 @@ TEST_F(KernelConstantSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenCon
program.setConstantSurface(nullptr);
delete pKernel;
delete pKernelInfo;
}
HWTEST_F(KernelEventPoolSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenEventPoolSurfaceStateIsPatchedWithNullSurface) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchExecutionEnvironment tokenEE;
tokenEE.CompiledSIMD8 = false;
@ -1209,13 +1191,12 @@ HWTEST_F(KernelEventPoolSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenE
EXPECT_EQ(RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_NULL, surfaceType);
delete pKernel;
delete pKernelInfo;
}
HWTEST_F(KernelEventPoolSurfaceTest, givenStatefulKernelWhenEventPoolIsPatchedThenEventPoolSurfaceStateIsProgrammed) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchExecutionEnvironment tokenEE;
tokenEE.CompiledSIMD8 = false;
@ -1262,13 +1243,12 @@ HWTEST_F(KernelEventPoolSurfaceTest, givenStatefulKernelWhenEventPoolIsPatchedTh
EXPECT_EQ(RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_BUFFER, surfaceType);
delete pKernel;
delete pKernelInfo;
}
HWTEST_F(KernelEventPoolSurfaceTest, givenKernelWithNullEventPoolInKernelInfoWhenEventPoolIsPatchedThenAddressIsNotPatched) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchExecutionEnvironment tokenEE;
tokenEE.CompiledSIMD8 = false;
@ -1295,13 +1275,12 @@ HWTEST_F(KernelEventPoolSurfaceTest, givenKernelWithNullEventPoolInKernelInfoWhe
EXPECT_EQ(123u, *(uint64_t *)pKernel->getCrossThreadData());
delete pKernel;
delete pKernelInfo;
}
TEST_F(KernelEventPoolSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenEventPoolSurfaceStateIsNotPatched) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchExecutionEnvironment tokenEE;
tokenEE.CompiledSIMD8 = false;
@ -1332,13 +1311,12 @@ TEST_F(KernelEventPoolSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenEv
}
delete pKernel;
delete pKernelInfo;
}
TEST_F(KernelEventPoolSurfaceTest, givenStatelessKernelWhenEventPoolIsPatchedThenCrossThreadDataIsPatched) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchExecutionEnvironment tokenEE;
tokenEE.CompiledSIMD8 = false;
@ -1371,13 +1349,12 @@ TEST_F(KernelEventPoolSurfaceTest, givenStatelessKernelWhenEventPoolIsPatchedThe
EXPECT_EQ(pDevQueue->getEventPoolBuffer()->getGpuAddress(), *(uint64_t *)pKernel->getCrossThreadData());
delete pKernel;
delete pKernelInfo;
}
HWTEST_F(KernelDefaultDeviceQueueSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenDefaultDeviceQueueSurfaceStateIsPatchedWithNullSurface) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchExecutionEnvironment tokenEE;
tokenEE.CompiledSIMD8 = false;
@ -1424,13 +1401,12 @@ HWTEST_F(KernelDefaultDeviceQueueSurfaceTest, givenStatefulKernelWhenKernelIsCre
EXPECT_EQ(RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_NULL, surfaceType);
delete pKernel;
delete pKernelInfo;
}
HWTEST_F(KernelDefaultDeviceQueueSurfaceTest, givenStatefulKernelWhenDefaultDeviceQueueIsPatchedThenSurfaceStateIsCorrectlyProgrammed) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchExecutionEnvironment tokenEE;
tokenEE.CompiledSIMD8 = false;
@ -1479,13 +1455,12 @@ HWTEST_F(KernelDefaultDeviceQueueSurfaceTest, givenStatefulKernelWhenDefaultDevi
EXPECT_EQ(RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_BUFFER, surfaceType);
delete pKernel;
delete pKernelInfo;
}
TEST_F(KernelDefaultDeviceQueueSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenDefaultDeviceQueueSurfaceStateIsNotPatched) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchExecutionEnvironment tokenEE;
tokenEE.CompiledSIMD8 = false;
@ -1514,13 +1489,12 @@ TEST_F(KernelDefaultDeviceQueueSurfaceTest, givenStatelessKernelWhenKernelIsCrea
EXPECT_EQ(0u, pKernel->getSurfaceStateHeapSize());
delete pKernel;
delete pKernelInfo;
}
TEST_F(KernelDefaultDeviceQueueSurfaceTest, givenKernelWithNullDeviceQueueKernelInfoWhenDefaultDeviceQueueIsPatchedThenAddressIsNotPatched) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchExecutionEnvironment tokenEE;
tokenEE.CompiledSIMD8 = false;
@ -1547,13 +1521,12 @@ TEST_F(KernelDefaultDeviceQueueSurfaceTest, givenKernelWithNullDeviceQueueKernel
EXPECT_EQ(123u, *(uint64_t *)pKernel->getCrossThreadData());
delete pKernel;
delete pKernelInfo;
}
TEST_F(KernelDefaultDeviceQueueSurfaceTest, givenStatelessKernelWhenDefaultDeviceQueueIsPatchedThenCrossThreadDataIsPatched) {
// define kernel info
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchExecutionEnvironment tokenEE;
tokenEE.CompiledSIMD8 = false;
@ -1586,7 +1559,6 @@ TEST_F(KernelDefaultDeviceQueueSurfaceTest, givenStatelessKernelWhenDefaultDevic
EXPECT_EQ(pDevQueue->getQueueBuffer()->getGpuAddress(), *(uint64_t *)pKernel->getCrossThreadData());
delete pKernel;
delete pKernelInfo;
}
typedef Test<DeviceFixture> KernelResidencyTest;
@ -1596,7 +1568,7 @@ HWTEST_F(KernelResidencyTest, givenKernelWhenMakeResidentIsCalledThenKernelIsaIs
char pCrossThreadData[64];
// define kernel info
std::unique_ptr<KernelInfo> pKernelInfo(KernelInfo::create());
auto pKernelInfo = std::make_unique<KernelInfo>();
auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver<FamilyType>();
commandStreamReceiver.storeMakeResidentAllocations = true;
@ -1630,7 +1602,7 @@ HWTEST_F(KernelResidencyTest, givenKernelWhenMakeResidentIsCalledThenKernelIsaIs
TEST(KernelImageDetectionTests, givenKernelWithImagesOnlyWhenItIsAskedIfItHasImagesOnlyThenTrueIsReturned) {
auto device = std::make_unique<MockDevice>(*platformDevices[0]);
std::unique_ptr<KernelInfo> pKernelInfo(KernelInfo::create());
auto pKernelInfo = std::make_unique<KernelInfo>();
pKernelInfo->kernelArgInfo.resize(3);
pKernelInfo->kernelArgInfo[2].isImage = true;
@ -1646,7 +1618,7 @@ TEST(KernelImageDetectionTests, givenKernelWithImagesOnlyWhenItIsAskedIfItHasIma
TEST(KernelImageDetectionTests, givenKernelWithImagesAndBuffersWhenItIsAskedIfItHasImagesOnlyThenFalseIsReturned) {
auto device = std::make_unique<MockDevice>(*platformDevices[0]);
std::unique_ptr<KernelInfo> pKernelInfo(KernelInfo::create());
auto pKernelInfo = std::make_unique<KernelInfo>();
pKernelInfo->kernelArgInfo.resize(3);
pKernelInfo->kernelArgInfo[2].isImage = true;
@ -1662,7 +1634,7 @@ TEST(KernelImageDetectionTests, givenKernelWithImagesAndBuffersWhenItIsAskedIfIt
TEST(KernelImageDetectionTests, givenKernelWithNoImagesWhenItIsAskedIfItHasImagesOnlyThenFalseIsReturned) {
auto device = std::make_unique<MockDevice>(*platformDevices[0]);
std::unique_ptr<KernelInfo> pKernelInfo(KernelInfo::create());
auto pKernelInfo = std::make_unique<KernelInfo>();
pKernelInfo->kernelArgInfo.resize(1);
pKernelInfo->kernelArgInfo[0].isBuffer = true;
@ -1708,7 +1680,7 @@ HWTEST_F(KernelResidencyTest, test_MakeArgsResidentCheckImageFromImage) {
std::unique_ptr<OCLRT::Image> imageY(Image::create(&context, flags, surfaceFormat, &imageDesc, nullptr, retVal));
EXPECT_EQ(imageY->getMediaPlaneType(), 0u);
std::unique_ptr<KernelInfo> pKernelInfo(KernelInfo::create());
auto pKernelInfo = std::make_unique<KernelInfo>();
KernelArgInfo kernelArgInfo;
kernelArgInfo.isImage = true;
@ -1731,8 +1703,9 @@ HWTEST_F(KernelResidencyTest, test_MakeArgsResidentCheckImageFromImage) {
struct KernelExecutionEnvironmentTest : public Test<DeviceFixture> {
void SetUp() override {
DeviceFixture::SetUp();
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
pKernelInfo->patchInfo.executionEnvironment = &executionEnvironment;
pKernel = new MockKernel(program.get(), *pKernelInfo, *pDevice);
@ -1741,13 +1714,13 @@ struct KernelExecutionEnvironmentTest : public Test<DeviceFixture> {
void TearDown() override {
delete pKernel;
delete pKernelInfo;
DeviceFixture::TearDown();
}
MockKernel *pKernel;
std::unique_ptr<MockProgram> program;
KernelInfo *pKernelInfo;
std::unique_ptr<KernelInfo> pKernelInfo;
SPatchExecutionEnvironment executionEnvironment;
};
@ -1860,19 +1833,19 @@ struct KernelCrossThreadTests : Test<DeviceFixture> {
program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());
patchDataParameterStream.DataParameterStreamSize = 64 * sizeof(uint8_t);
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
ASSERT_NE(nullptr, pKernelInfo);
pKernelInfo->patchInfo.dataParameterStream = &patchDataParameterStream;
pKernelInfo->patchInfo.executionEnvironment = &executionEnvironment;
}
void TearDown() override {
delete pKernelInfo;
DeviceFixture::TearDown();
}
std::unique_ptr<MockProgram> program;
KernelInfo *pKernelInfo = nullptr;
std::unique_ptr<KernelInfo> pKernelInfo;
SPatchDataParameterStream patchDataParameterStream;
SPatchExecutionEnvironment executionEnvironment;
};
@ -2079,7 +2052,7 @@ TEST_F(KernelCrossThreadTests, patchBlocksSimdSize) {
kernel->kernelInfo.childrenKernelsIdOffset.push_back({0, crossThreadOffset});
// add a new block kernel to program
KernelInfo *infoBlock = new KernelInfo();
auto infoBlock = new KernelInfo();
kernel->executionEnvironmentBlock.CompiledSIMD8 = 0;
kernel->executionEnvironmentBlock.CompiledSIMD16 = 1;
kernel->executionEnvironmentBlock.CompiledSIMD32 = 0;

2
unit_tests/kernel/kernel_transformable_tests.cpp
View File

@ -36,7 +36,7 @@ using namespace OCLRT;
class KernelTransformableTest : public ::testing::Test {
public:
void SetUp() override {
pKernelInfo.reset(KernelInfo::create());
pKernelInfo = std::make_unique<KernelInfo>();
KernelArgPatchInfo kernelArgPatchInfo;
kernelHeader.SurfaceStateHeapSize = sizeof(surfaceStateHeap);

2
unit_tests/kernel/parent_kernel_tests.cpp
View File

@ -130,7 +130,7 @@ TEST(ParentKernelTest, initializeOnParentKernelAllocatesPrivateMemoryForBlocks)
uint32_t crossThreadOffsetBlock = 0;
KernelInfo *infoBlock = new KernelInfo();
auto infoBlock = new KernelInfo();
SPatchAllocateStatelessDefaultDeviceQueueSurface *allocateDeviceQueueBlock = new SPatchAllocateStatelessDefaultDeviceQueueSurface;
allocateDeviceQueueBlock->DataParamOffset = crossThreadOffsetBlock;
allocateDeviceQueueBlock->DataParamSize = 8;

6
unit_tests/mem_obj/buffer_set_arg_tests.cpp
View File

@ -53,7 +53,7 @@ class BufferSetArgTest : public ContextFixture,
DeviceFixture::SetUp();
cl_device_id device = pDevice;
ContextFixture::SetUp(1, &device);
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
ASSERT_NE(nullptr, pKernelInfo);
// define kernel info
@ -99,7 +99,7 @@ class BufferSetArgTest : public ContextFixture,
delete buffer;
delete BufferDefaults::context;
delete pKernel;
delete pKernelInfo;
delete pProgram;
ContextFixture::TearDown();
DeviceFixture::TearDown();
@ -108,7 +108,7 @@ class BufferSetArgTest : public ContextFixture,
cl_int retVal = CL_SUCCESS;
MockProgram *pProgram;
MockKernel *pKernel = nullptr;
KernelInfo *pKernelInfo = nullptr;
std::unique_ptr<KernelInfo> pKernelInfo;
SKernelBinaryHeaderCommon kernelHeader;
char surfaceStateHeap[0x80];
char pCrossThreadData[64];

8
unit_tests/mem_obj/image_set_arg_tests.cpp
View File

@ -79,7 +79,7 @@ class ImageSetArgTest : public DeviceFixture,
void SetUp() override {
DeviceFixture::SetUp();
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
// define kernel info
kernelHeader.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
@ -114,7 +114,7 @@ class ImageSetArgTest : public DeviceFixture,
void TearDown() override {
delete srcImage;
delete pKernel;
delete pKernelInfo;
delete context;
DeviceFixture::TearDown();
}
@ -124,7 +124,7 @@ class ImageSetArgTest : public DeviceFixture,
std::unique_ptr<MockProgram> program;
MockKernel *pKernel = nullptr;
SKernelBinaryHeaderCommon kernelHeader;
KernelInfo *pKernelInfo = nullptr;
std::unique_ptr<KernelInfo> pKernelInfo;
char surfaceStateHeap[0x80];
Image *srcImage = nullptr;
int expectedChannelRed;
@ -754,7 +754,7 @@ class ImageMediaBlockSetArgTest : public ImageSetArgTest {
protected:
void SetUp() override {
DeviceFixture::SetUp();
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
// define kernel info
kernelHeader.SurfaceStateHeapSize = sizeof(surfaceStateHeap);

6
unit_tests/mocks/mock_kernel.h
View File

@ -109,7 +109,7 @@ class MockKernel : public Kernel {
template <typename KernelType = MockKernel>
static KernelType *create(Device &device, Program *program) {
KernelInfo *info = new KernelInfo();
auto info = new KernelInfo();
const size_t crossThreadSize = 160;
SKernelBinaryHeaderCommon *header = new SKernelBinaryHeaderCommon;
@ -313,7 +313,7 @@ class MockParentKernel : public Kernel {
static MockParentKernel *create(Context &context, bool addChildSimdSize = false, bool addChildGlobalMemory = false, bool addChildConstantMemory = false, bool addPrintfForParent = true, bool addPrintfForBlock = true) {
Device &device = *context.getDevice(0);
KernelInfo *info = new KernelInfo();
auto info = new KernelInfo();
const size_t crossThreadSize = 160;
uint32_t crossThreadOffset = 0;
uint32_t crossThreadOffsetBlock = 0;
@ -390,7 +390,7 @@ class MockParentKernel : public Kernel {
parent->crossThreadDataSize = crossThreadSize;
parent->mockKernelInfo = info;
KernelInfo *infoBlock = new KernelInfo();
auto infoBlock = new KernelInfo();
SPatchAllocateStatelessDefaultDeviceQueueSurface *allocateDeviceQueueBlock = new SPatchAllocateStatelessDefaultDeviceQueueSurface;
allocateDeviceQueueBlock->DataParamOffset = crossThreadOffsetBlock;
allocateDeviceQueueBlock->DataParamSize = 8;

26
unit_tests/os_interface/debug_settings_manager_tests.cpp
View File

@ -425,7 +425,8 @@ TEST(DebugSettingsManager, WithDebugFunctionalityDontDumpKernelArgsForNullMdi) {
}
TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsForMdi) {
auto kernelInfo = unique_ptr<KernelInfo>(KernelInfo::create());
auto kernelInfo = std::make_unique<KernelInfo>();
auto device = unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
auto kernel = unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
@ -467,7 +468,8 @@ TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelNullKernel) {
}
TEST(DebugSettingsManager, WithDebugFunctionalityAndEmptyKernelDontDumpKernelArgs) {
auto kernelInfo = unique_ptr<KernelInfo>(KernelInfo::create());
auto kernelInfo = std::make_unique<KernelInfo>();
auto device = unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
auto kernel = unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
@ -481,7 +483,8 @@ TEST(DebugSettingsManager, WithDebugFunctionalityAndEmptyKernelDontDumpKernelArg
}
TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsImmediate) {
auto kernelInfo = unique_ptr<KernelInfo>(KernelInfo::create());
auto kernelInfo = std::make_unique<KernelInfo>();
auto device = unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
auto kernel = unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
@ -512,7 +515,8 @@ TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsImmediate) {
}
TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsImmediateZeroSize) {
auto kernelInfo = unique_ptr<KernelInfo>(KernelInfo::create());
auto kernelInfo = std::make_unique<KernelInfo>();
auto device = unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
auto kernel = unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
@ -540,7 +544,8 @@ TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsImmediateZeroSize
}
TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsLocalBuffer) {
auto kernelInfo = unique_ptr<KernelInfo>(KernelInfo::create());
auto kernelInfo = std::make_unique<KernelInfo>();
auto device = unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
auto kernel = unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
@ -561,7 +566,8 @@ TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsLocalBuffer) {
}
TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsBufferNotSet) {
auto kernelInfo = unique_ptr<KernelInfo>(KernelInfo::create());
auto kernelInfo = std::make_unique<KernelInfo>();
auto device = unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
auto kernel = unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
@ -592,7 +598,7 @@ TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsBuffer) {
auto buffer = BufferHelper<>::create(&context);
cl_mem clObj = buffer;
auto kernelInfo = unique_ptr<KernelInfo>(KernelInfo::create());
auto kernelInfo = std::make_unique<KernelInfo>();
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));
@ -626,7 +632,8 @@ TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsBuffer) {
}
TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsSampler) {
auto kernelInfo = unique_ptr<KernelInfo>(KernelInfo::create());
auto kernelInfo = std::make_unique<KernelInfo>();
auto device = unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
auto kernel = unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
@ -649,7 +656,8 @@ TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsSampler) {
}
TEST(DebugSettingsManager, WithDebugFunctionalityDumpKernelArgsImageNotSet) {
auto kernelInfo = unique_ptr<KernelInfo>(KernelInfo::create());
auto kernelInfo = std::make_unique<KernelInfo>();
auto device = unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
MockProgram program(*device->getExecutionEnvironment());
auto kernel = unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));

34
unit_tests/program/kernel_info_tests.cpp
View File

@ -39,15 +39,14 @@ TEST(KernelInfo, NonAssignable) {
}
TEST(KernelInfo, defaultBehavior) {
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
EXPECT_FALSE(pKernelInfo->usesSsh);
EXPECT_FALSE(pKernelInfo->isValid);
delete pKernelInfo;
}
TEST(KernelInfo, decodeConstantMemoryKernelArgument) {
uint32_t argumentNumber = 0;
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchStatelessConstantMemoryObjectKernelArgument arg;
arg.Token = 0xa;
arg.Size = 0x20;
@ -67,13 +66,11 @@ TEST(KernelInfo, decodeConstantMemoryKernelArgument) {
const auto &patchInfo = pKernelInfo->patchInfo;
EXPECT_EQ(1u, patchInfo.statelessGlobalMemObjKernelArgs.size());
delete pKernelInfo;
}
TEST(KernelInfo, decodeGlobalMemoryKernelArgument) {
uint32_t argumentNumber = 1;
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchStatelessGlobalMemoryObjectKernelArgument arg;
arg.Token = 0xb;
arg.Size = 0x30;
@ -93,13 +90,11 @@ TEST(KernelInfo, decodeGlobalMemoryKernelArgument) {
const auto &patchInfo = pKernelInfo->patchInfo;
EXPECT_EQ(1u, patchInfo.statelessGlobalMemObjKernelArgs.size());
delete pKernelInfo;
}
TEST(KernelInfo, decodeImageKernelArgument) {
uint32_t argumentNumber = 1;
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchImageMemoryObjectKernelArgument arg;
arg.Token = 0xc;
arg.Size = 0x20;
@ -121,8 +116,6 @@ TEST(KernelInfo, decodeImageKernelArgument) {
//EXPECT_EQ(CL_KERNEL_ARG_ACCESS_READ_WRITE, argInfo.accessQualifier);
//EXPECT_EQ(CL_KERNEL_ARG_ADDRESS_, argInfo.addressQualifier);
//EXPECT_EQ(CL_KERNEL_ARG_TYPE_NONE, argInfo.typeQualifier);
delete pKernelInfo;
}
TEST(KernelInfoTest, givenKernelInfoWhenCreateKernelAllocationThenCopyWholeKernelHeapToKernelAllocation) {
@ -163,7 +156,7 @@ TEST(KernelInfoTest, givenKernelInfoWhenCreateKernelAllocationAndCannotAllocateM
TEST(KernelInfo, decodeGlobalMemObjectKernelArgument) {
uint32_t argumentNumber = 1;
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchGlobalMemoryObjectKernelArgument arg;
arg.Token = 0xb;
arg.Size = 0x10;
@ -178,13 +171,11 @@ TEST(KernelInfo, decodeGlobalMemObjectKernelArgument) {
const auto &argInfo = pKernelInfo->kernelArgInfo[argumentNumber];
EXPECT_EQ(arg.Offset, argInfo.offsetHeap);
EXPECT_TRUE(argInfo.isBuffer);
delete pKernelInfo;
}
TEST(KernelInfo, decodeSamplerKernelArgument) {
uint32_t argumentNumber = 1;
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
SPatchSamplerKernelArgument arg;
arg.ArgumentNumber = argumentNumber;
@ -204,12 +195,11 @@ TEST(KernelInfo, decodeSamplerKernelArgument) {
EXPECT_FALSE(argInfo.isImage);
EXPECT_TRUE(argInfo.isSampler);
EXPECT_TRUE(pKernelInfo->usesSsh);
delete pKernelInfo;
}
typedef KernelInfo KernelInfo_resolveKernelInfo;
TEST(KernelInfo_resolveKernelInfo, basicArgument) {
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
pKernelInfo->kernelArgInfo.resize(1);
auto &kernelArgInfo = pKernelInfo->kernelArgInfo[0];
@ -223,12 +213,10 @@ TEST(KernelInfo_resolveKernelInfo, basicArgument) {
EXPECT_EQ(static_cast<cl_kernel_arg_access_qualifier>(CL_KERNEL_ARG_ACCESS_READ_ONLY), kernelArgInfo.accessQualifier);
EXPECT_EQ(static_cast<cl_kernel_arg_address_qualifier>(CL_KERNEL_ARG_ADDRESS_GLOBAL), kernelArgInfo.addressQualifier);
EXPECT_EQ(static_cast<cl_kernel_arg_type_qualifier>(CL_KERNEL_ARG_TYPE_RESTRICT), kernelArgInfo.typeQualifier);
delete pKernelInfo;
}
TEST(KernelInfo_resolveKernelInfo, complexArgumentType) {
KernelInfo *pKernelInfo = KernelInfo::create();
auto pKernelInfo = std::make_unique<KernelInfo>();
pKernelInfo->kernelArgInfo.resize(1);
auto &kernelArgInfo = pKernelInfo->kernelArgInfo[0];
@ -242,13 +230,11 @@ TEST(KernelInfo_resolveKernelInfo, complexArgumentType) {
EXPECT_EQ(static_cast<cl_kernel_arg_access_qualifier>(CL_KERNEL_ARG_ACCESS_READ_ONLY), kernelArgInfo.accessQualifier);
EXPECT_EQ(static_cast<cl_kernel_arg_address_qualifier>(CL_KERNEL_ARG_ADDRESS_GLOBAL), kernelArgInfo.addressQualifier);
EXPECT_EQ(static_cast<cl_kernel_arg_type_qualifier>(CL_KERNEL_ARG_TYPE_RESTRICT | CL_KERNEL_ARG_TYPE_CONST), kernelArgInfo.typeQualifier);
delete pKernelInfo;
}
TEST(KernelInfo, givenKernelInfoWhenStoreTransformableArgThenArgInfoIsTransformable) {
uint32_t argumentNumber = 1;
std::unique_ptr<KernelInfo> kernelInfo(KernelInfo::create());
auto kernelInfo = std::make_unique<KernelInfo>();
SPatchImageMemoryObjectKernelArgument arg;
arg.ArgumentNumber = argumentNumber;
arg.Transformable = true;
@ -260,7 +246,7 @@ TEST(KernelInfo, givenKernelInfoWhenStoreTransformableArgThenArgInfoIsTransforma
TEST(KernelInfo, givenKernelInfoWhenStoreNonTransformableArgThenArgInfoIsNotTransformable) {
uint32_t argumentNumber = 1;
std::unique_ptr<KernelInfo> kernelInfo(KernelInfo::create());
auto kernelInfo = std::make_unique<KernelInfo>();
SPatchImageMemoryObjectKernelArgument arg;
arg.ArgumentNumber = argumentNumber;
arg.Transformable = false;

8
unit_tests/program/printf_handler_tests.cpp
View File

@ -39,7 +39,7 @@ TEST(PrintfHandlerTest, givenNotPreparedPrintfHandlerWhenGetSurfaceIsCalledThenR
pPrintfSurface->DataParamOffset = 0;
pPrintfSurface->DataParamSize = 8;
KernelInfo *pKernelInfo = new KernelInfo();
auto pKernelInfo = std::make_unique<KernelInfo>();
pKernelInfo->patchInfo.pAllocateStatelessPrintfSurface = pPrintfSurface;
MockProgram *pProgram = new MockProgram(*device->getExecutionEnvironment(), &context, false);
@ -53,7 +53,7 @@ TEST(PrintfHandlerTest, givenNotPreparedPrintfHandlerWhenGetSurfaceIsCalledThenR
delete printfHandler;
delete pPrintfSurface;
delete pKernel;
delete pKernelInfo;
delete pProgram;
delete device;
}
@ -65,7 +65,7 @@ TEST(PrintfHandlerTest, givenPreparedPrintfHandlerWhenGetSurfaceIsCalledThenResu
pPrintfSurface->DataParamOffset = 0;
pPrintfSurface->DataParamSize = 8;
KernelInfo *pKernelInfo = new KernelInfo();
auto pKernelInfo = std::make_unique<KernelInfo>();
pKernelInfo->patchInfo.pAllocateStatelessPrintfSurface = pPrintfSurface;
MockProgram *pProgram = new MockProgram(*device->getExecutionEnvironment(), &context, false);
@ -82,7 +82,7 @@ TEST(PrintfHandlerTest, givenPreparedPrintfHandlerWhenGetSurfaceIsCalledThenResu
delete printfHandler;
delete pPrintfSurface;
delete pKernel;
delete pKernelInfo;
delete pProgram;
delete device;
}

5
unit_tests/program/printf_helper_tests.cpp
View File

@ -45,7 +45,7 @@ class PrintFormatterTest : public testing::Test {
MockGraphicsAllocation *data;
MockKernel *kernel;
std::unique_ptr<MockProgram> program;
KernelInfo *kernelInfo;
std::unique_ptr<KernelInfo> kernelInfo;
Device *device;
uint8_t underlyingBuffer[PrintFormatter::maxPrintfOutputLength];
@ -59,7 +59,7 @@ class PrintFormatterTest : public testing::Test {
maxStringIndex = 0;
data = new MockGraphicsAllocation(underlyingBuffer, PrintFormatter::maxPrintfOutputLength);
kernelInfo = KernelInfo::create();
kernelInfo = std::make_unique<KernelInfo>();
device = MockDevice::createWithNewExecutionEnvironment<Device>(nullptr);
program = std::make_unique<MockProgram>(*device->getExecutionEnvironment());
kernel = new MockKernel(program.get(), *kernelInfo, *device);
@ -76,7 +76,6 @@ class PrintFormatterTest : public testing::Test {
delete printFormatter;
delete data;
delete kernel;
delete kernelInfo;
delete device;
}

4
unit_tests/program/process_debug_data_tests.cpp
View File

@ -38,9 +38,9 @@ TEST_F(ProgramTests, GivenProgramWithDebugDataForTwoKernelsWhenPorcessedThenDebu
size_t debugDataSize = sizeof(SProgramDebugDataHeaderIGC) + 2 * (sizeof(SKernelDebugDataHeaderIGC) + kernelNameSize + genIsaSize + visaSize);
std::unique_ptr<char[]> debugData(new char[debugDataSize]);
KernelInfo *kernelInfo1 = new KernelInfo();
auto kernelInfo1 = new KernelInfo();
kernelInfo1->name = kernelName1;
KernelInfo *kernelInfo2 = new KernelInfo();
auto kernelInfo2 = new KernelInfo();
kernelInfo2->name = kernelName2;
auto program = std::make_unique<MockProgram>(*pDevice->getExecutionEnvironment());

20
unit_tests/program/program_tests.cpp
View File

@ -2693,11 +2693,11 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenNoParentAndSubgroupKernelsThen
TEST_F(ProgramTests, givenSeparateBlockKernelsWhenRegularKernelsThenSeparateNoneKernel) {
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
auto pRegularKernel1Info = KernelInfo::create();
auto pRegularKernel1Info = new KernelInfo();
pRegularKernel1Info->name = "regular_kernel_1";
program.getKernelInfoArray().push_back(pRegularKernel1Info);
auto pRegularKernel2Info = KernelInfo::create();
auto pRegularKernel2Info = new KernelInfo();
pRegularKernel2Info->name = "regular_kernel_2";
program.getKernelInfoArray().push_back(pRegularKernel2Info);
@ -2715,12 +2715,12 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenRegularKernelsThenSeparateNone
TEST_F(ProgramTests, givenSeparateBlockKernelsWhenChildLikeKernelWithoutParentKernelThenSeparateNoneKernel) {
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
auto pParentKernelInfo = KernelInfo::create();
auto pParentKernelInfo = new KernelInfo();
pParentKernelInfo->name = "another_parent_kernel";
program.getKernelInfoArray().push_back(pParentKernelInfo);
program.getParentKernelInfoArray().push_back(pParentKernelInfo);
auto pChildKernelInfo = KernelInfo::create();
auto pChildKernelInfo = new KernelInfo();
pChildKernelInfo->name = "childlike_kernel_dispatch_0";
program.getKernelInfoArray().push_back(pChildKernelInfo);
@ -2739,12 +2739,12 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenChildLikeKernelWithoutParentKe
TEST_F(ProgramTests, givenSeparateBlockKernelsWhenChildLikeKernelWithoutSubgroupKernelThenSeparateNoneKernel) {
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
auto pSubgroupKernelInfo = KernelInfo::create();
auto pSubgroupKernelInfo = new KernelInfo();
pSubgroupKernelInfo->name = "another_subgroup_kernel";
program.getKernelInfoArray().push_back(pSubgroupKernelInfo);
program.getSubgroupKernelInfoArray().push_back(pSubgroupKernelInfo);
auto pChildKernelInfo = KernelInfo::create();
auto pChildKernelInfo = new KernelInfo();
pChildKernelInfo->name = "childlike_kernel_dispatch_0";
program.getKernelInfoArray().push_back(pChildKernelInfo);
@ -2763,12 +2763,12 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenChildLikeKernelWithoutSubgroup
TEST_F(ProgramTests, givenSeparateBlockKernelsWhenParentKernelWithChildKernelThenSeparateChildKernel) {
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
auto pParentKernelInfo = KernelInfo::create();
auto pParentKernelInfo = new KernelInfo();
pParentKernelInfo->name = "parent_kernel";
program.getKernelInfoArray().push_back(pParentKernelInfo);
program.getParentKernelInfoArray().push_back(pParentKernelInfo);
auto pChildKernelInfo = KernelInfo::create();
auto pChildKernelInfo = new KernelInfo();
pChildKernelInfo->name = "parent_kernel_dispatch_0";
program.getKernelInfoArray().push_back(pChildKernelInfo);
@ -2787,12 +2787,12 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenParentKernelWithChildKernelThe
TEST_F(ProgramTests, givenSeparateBlockKernelsWhenSubgroupKernelWithChildKernelThenSeparateChildKernel) {
MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false);
auto pSubgroupKernelInfo = KernelInfo::create();
auto pSubgroupKernelInfo = new KernelInfo();
pSubgroupKernelInfo->name = "subgroup_kernel";
program.getKernelInfoArray().push_back(pSubgroupKernelInfo);
program.getSubgroupKernelInfoArray().push_back(pSubgroupKernelInfo);
auto pChildKernelInfo = KernelInfo::create();
auto pChildKernelInfo = new KernelInfo();
pChildKernelInfo->name = "subgroup_kernel_dispatch_0";
program.getKernelInfoArray().push_back(pChildKernelInfo);

6
unit_tests/sampler/sampler_set_arg_tests.cpp
View File

@ -50,7 +50,7 @@ class SamplerSetArgFixture : public DeviceFixture {
protected:
void SetUp() {
DeviceFixture::SetUp();
pKernelInfo = KernelInfo::create();
pKernelInfo = std::make_unique<KernelInfo>();
// define kernel info
kernelHeader.DynamicStateHeapSize = sizeof(samplerStateHeap);
@ -86,7 +86,7 @@ class SamplerSetArgFixture : public DeviceFixture {
void TearDown() {
delete pKernel;
delete pKernelInfo;
delete sampler;
delete context;
DeviceFixture::TearDown();
@ -117,7 +117,7 @@ class SamplerSetArgFixture : public DeviceFixture {
std::unique_ptr<MockProgram> program;
MockKernel *pKernel = nullptr;
SKernelBinaryHeaderCommon kernelHeader;
KernelInfo *pKernelInfo = nullptr;
std::unique_ptr<KernelInfo> pKernelInfo;
char samplerStateHeap[0x80];
MockContext *context;
Sampler *sampler = nullptr;