Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-10 12:53:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

Remove device enqueue part 6

Browse Source 
- isParentKernel, peekParentKernel, parentKernel
- structs: AUBParentKernelFixture, MockParentKernel,
ParentKernelCommandQueueFixture

Related-To: NEO-6559
Signed-off-by: Katarzyna Cencelewska <katarzyna.cencelewska@intel.com>
This commit is contained in:
Katarzyna Cencelewska
2022-01-13 15:27:58 +00:00
committed by Compute-Runtime-Automation
parent d9aae805c7
commit 59683ec491
27 changed files with 24 additions and 895 deletions
Download Patch File Download Diff File Expand all files Collapse all files

138
opencl/test/unit_test/mocks/mock_kernel.h
View File

@ -409,144 +409,6 @@ class MockKernelWithInternals {
char dshLocal[128];
std::vector<Kernel::SimpleKernelArgInfo> defaultKernelArguments;
};
class MockParentKernel : public Kernel {
public:
struct CreateParams {
bool addChildSimdSize = false;
bool addChildGlobalMemory = false;
bool addChildConstantMemory = false;
bool addPrintfForParent = false;
bool addPrintfForBlock = false;
};
using Kernel::auxTranslationRequired;
using Kernel::kernelInfo;
using Kernel::patchBlocksCurbeWithConstantValues;
using Kernel::pImplicitArgs;
using Kernel::pSshLocal;
using Kernel::sshLocalSize;
static MockParentKernel *create(Context &context) {
CreateParams createParams{};
return create(context, createParams);
}
static MockParentKernel *create(Context &context, const CreateParams &createParams) {
auto clDevice = context.getDevice(0);
auto info = new MockKernelInfo();
const size_t crossThreadSize = 160;
uint32_t crossThreadOffset = 0;
uint32_t crossThreadOffsetBlock = 0;
info->setLocalIds({0, 0, 0});
info->kernelDescriptor.kernelAttributes.bufferAddressingMode = KernelDescriptor::Stateless;
info->kernelDescriptor.kernelAttributes.flags.usesDeviceSideEnqueue = true;
info->kernelDescriptor.kernelAttributes.numGrfRequired = GrfConfig::DefaultGrfNumber;
info->kernelDescriptor.kernelAttributes.simdSize = 32;
info->setDeviceSideEnqueueDefaultQueueSurface(8, crossThreadOffset);
crossThreadOffset += 8;
info->setDeviceSideEnqueueEventPoolSurface(8, crossThreadOffset);
crossThreadOffset += 8;
if (createParams.addPrintfForParent) {
info->setPrintfSurface(8, crossThreadOffset);
crossThreadOffset += 8;
}
ClDeviceVector deviceVector;
deviceVector.push_back(clDevice);
MockProgram *mockProgram = new MockProgram(&context, false, deviceVector);
if (createParams.addChildSimdSize) {
info->childrenKernelsIdOffset.push_back({0, crossThreadOffset});
}
UNRECOVERABLE_IF(crossThreadSize < crossThreadOffset + 8);
info->crossThreadData = new char[crossThreadSize];
auto parent = new MockParentKernel(mockProgram, *info);
parent->crossThreadData = new char[crossThreadSize];
memset(parent->crossThreadData, 0, crossThreadSize);
parent->crossThreadDataSize = crossThreadSize;
parent->mockKernelInfo = info;
auto infoBlock = new MockKernelInfo();
infoBlock->kernelDescriptor.kernelAttributes.bufferAddressingMode = KernelDescriptor::Stateless;
infoBlock->setDeviceSideEnqueueDefaultQueueSurface(8, crossThreadOffsetBlock);
crossThreadOffsetBlock += 8;
infoBlock->setDeviceSideEnqueueEventPoolSurface(8, crossThreadOffset);
crossThreadOffsetBlock += 8;
if (createParams.addPrintfForBlock) {
infoBlock->setPrintfSurface(8, crossThreadOffsetBlock);
crossThreadOffsetBlock += 8;
}
if (createParams.addChildGlobalMemory) {
infoBlock->setGlobalVariablesSurface(8, crossThreadOffsetBlock);
crossThreadOffsetBlock += 8;
}
if (createParams.addChildConstantMemory) {
infoBlock->setGlobalConstantsSurface(8, crossThreadOffsetBlock);
crossThreadOffsetBlock += 8;
}
infoBlock->setLocalIds({0, 0, 0});
infoBlock->kernelDescriptor.kernelAttributes.flags.usesDeviceSideEnqueue = true;
infoBlock->kernelDescriptor.kernelAttributes.numGrfRequired = GrfConfig::DefaultGrfNumber;
infoBlock->kernelDescriptor.kernelAttributes.simdSize = 32;
infoBlock->setDeviceSideEnqueueBlockInterfaceDescriptorOffset(0);
infoBlock->heapInfo.pDsh = (void *)new uint64_t[64];
infoBlock->heapInfo.DynamicStateHeapSize = 64 * sizeof(uint64_t);
size_t crossThreadDataSize = crossThreadOffsetBlock > crossThreadSize ? crossThreadOffsetBlock : crossThreadSize;
infoBlock->crossThreadData = new char[crossThreadDataSize];
infoBlock->setCrossThreadDataSize(static_cast<uint16_t>(crossThreadDataSize));
mockProgram->blockKernelManager->addBlockKernelInfo(infoBlock);
parent->mockProgram = mockProgram;
return parent;
}
MockParentKernel(Program *programArg, const KernelInfo &kernelInfoArg) : Kernel(programArg, kernelInfoArg, *programArg->getDevices()[0]) {
}
~MockParentKernel() override {
delete &kernelInfo;
BlockKernelManager *blockManager = program->getBlockKernelManager();
for (uint32_t i = 0; i < blockManager->getCount(); i++) {
const KernelInfo *blockInfo = blockManager->getBlockKernelInfo(i);
delete[](uint64_t *) blockInfo->heapInfo.pDsh;
}
if (mockProgram) {
mockProgram->decRefInternal();
}
}
Context *getContext() {
return &mockProgram->getContext();
}
void setReflectionSurface(GraphicsAllocation *reflectionSurface) {
kernelReflectionSurface = reflectionSurface;
}
MockProgram *mockProgram;
KernelInfo *mockKernelInfo = nullptr;
};
class MockDebugKernel : public MockKernel {
public:
MockDebugKernel(Program *program, const KernelInfo &kernelInfo, ClDevice &clDeviceArg) : MockKernel(program, kernelInfo, clDeviceArg) {