Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[21/n] Remove Instruction Heap from enqueue path. 

- This removes Instruction Heap allocation from enqueue path
- Blocked path is handled as well
- Heap is no longer allocated on demand it is bind to kernelInfo.

Change-Id: I54545beceed3404ee0330a8bac2b0934944cac30
This commit is contained in:
Mrozek, Michal 2018-03-28 19:21:07 +02:00
parent f2b96fa508
commit 2be5934096
21 changed files with 49 additions and 277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
runtime/command_queue/dispatch_walker.h
View File

@ -438,7 +438,7 @@ void dispatchWalker(
unsigned int commandType = 0) {
OCLRT::LinearStream *commandStream = nullptr;
OCLRT::IndirectHeap *dsh = nullptr, *ish = nullptr, *ioh = nullptr, *ssh = nullptr;
OCLRT::IndirectHeap *dsh = nullptr, *ioh = nullptr, *ssh = nullptr;
bool executionModelKernel = multiDispatchInfo.begin()->getKernel()->isParentKernel;
for (auto &dispatchInfo : multiDispatchInfo) {
@ -450,7 +450,6 @@ void dispatchWalker(
}
// Allocate command stream and indirect heaps
size_t cmdQInstructionHeapReservedBlockSize = 0;
if (blockQueue) {
using KCH = KernelCommandsHelper<GfxFamily>;
commandStream = new LinearStream(alignedMalloc(MemoryConstants::pageSize, MemoryConstants::pageSize), MemoryConstants::pageSize);
@ -465,13 +464,10 @@ void dispatchWalker(
dsh = allocateIndirectHeap([&multiDispatchInfo] { return KCH::getTotalSizeRequiredDSH(multiDispatchInfo); });
ioh = allocateIndirectHeap([&multiDispatchInfo] { return KCH::getTotalSizeRequiredIOH(multiDispatchInfo); });
}
ish = allocateIndirectHeap([&multiDispatchInfo] { return KCH::getTotalSizeRequiredIH(multiDispatchInfo); });
cmdQInstructionHeapReservedBlockSize = commandQueue.getInstructionHeapReservedBlockSize();
ssh = allocateIndirectHeap([&multiDispatchInfo] { return KCH::getTotalSizeRequiredSSH(multiDispatchInfo); });
using UniqueIH = std::unique_ptr<IndirectHeap>;
*blockedCommandsData = new KernelOperation(std::unique_ptr<LinearStream>(commandStream), UniqueIH(dsh),
UniqueIH(ish), UniqueIH(ioh), UniqueIH(ssh));
*blockedCommandsData = new KernelOperation(std::unique_ptr<LinearStream>(commandStream), UniqueIH(dsh), UniqueIH(ioh), UniqueIH(ssh));
if (executionModelKernel) {
(*blockedCommandsData)->doNotFreeISH = true;
}
@ -481,7 +477,6 @@ void dispatchWalker(
commandQueue.releaseIndirectHeap(IndirectHeap::SURFACE_STATE);
}
dsh = &getIndirectHeap<GfxFamily, IndirectHeap::DYNAMIC_STATE>(commandQueue, multiDispatchInfo);
ish = &getIndirectHeap<GfxFamily, IndirectHeap::INSTRUCTION>(commandQueue, multiDispatchInfo);
ioh = &getIndirectHeap<GfxFamily, IndirectHeap::INDIRECT_OBJECT>(commandQueue, multiDispatchInfo);
ssh = &getIndirectHeap<GfxFamily, IndirectHeap::SURFACE_STATE>(commandQueue, multiDispatchInfo);
}
@ -680,13 +675,12 @@ void dispatchScheduler(
using MI_BATCH_BUFFER_START = typename GfxFamily::MI_BATCH_BUFFER_START;
OCLRT::LinearStream *commandStream = nullptr;
OCLRT::IndirectHeap *dsh = nullptr, *ish = nullptr, *ioh = nullptr, *ssh = nullptr;
OCLRT::IndirectHeap *dsh = nullptr, *ioh = nullptr, *ssh = nullptr;
commandStream = &commandQueue.getCS(0);
// note : below code assumes that caller to dispatchScheduler "preallocated" memory
// required for execution model in below heap managers
dsh = devQueueHw.getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
ish = &commandQueue.getIndirectHeap(IndirectHeap::INSTRUCTION);
ssh = &commandQueue.getIndirectHeap(IndirectHeap::SURFACE_STATE);
bool dcFlush = false;
@ -919,14 +913,13 @@ IndirectHeap &getIndirectHeap(CommandQueue &commandQueue, const MultiDispatchInf
// clang-format off
switch(heapType) {
case IndirectHeap::DYNAMIC_STATE: expectedSize = KernelCommandsHelper<GfxFamily>::getTotalSizeRequiredDSH(multiDispatchInfo); break;
case IndirectHeap::INSTRUCTION: expectedSize = KernelCommandsHelper<GfxFamily>::getTotalSizeRequiredIH( multiDispatchInfo); break;
case IndirectHeap::INDIRECT_OBJECT: expectedSize = KernelCommandsHelper<GfxFamily>::getTotalSizeRequiredIOH(multiDispatchInfo); break;
case IndirectHeap::SURFACE_STATE: expectedSize = KernelCommandsHelper<GfxFamily>::getTotalSizeRequiredSSH(multiDispatchInfo); break;
}
// clang-format on
if (multiDispatchInfo.begin()->getKernel()->isParentKernel) {
if (heapType == IndirectHeap::INSTRUCTION || heapType == IndirectHeap::SURFACE_STATE) {
if (heapType == IndirectHeap::SURFACE_STATE) {
expectedSize += KernelCommandsHelper<GfxFamily>::template getSizeRequiredForExecutionModel<heapType>(const_cast<const Kernel &>(*(multiDispatchInfo.begin()->getKernel())));
} else //if (heapType == IndirectHeap::DYNAMIC_STATE || heapType == IndirectHeap::INDIRECT_OBJECT)
{

6
runtime/command_queue/enqueue_common.h
View File

@ -271,12 +271,10 @@ void CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
CompletionStamp completionStamp;
if (!blockQueue) {
if (executionModelKernel) {
size_t minSizeISHForEM = KernelCommandsHelper<GfxFamily>::template getSizeRequiredForExecutionModel<IndirectHeap::INSTRUCTION>(const_cast<const Kernel &>(*(multiDispatchInfo.begin()->getKernel())));
size_t minSizeSSHForEM = KernelCommandsHelper<GfxFamily>::template getSizeRequiredForExecutionModel<IndirectHeap::SURFACE_STATE>(const_cast<const Kernel &>(*(multiDispatchInfo.begin()->getKernel())));
uint32_t taskCount = commandStreamReceiver.peekTaskCount() + 1;
devQueueHw->setupExecutionModelDispatch(getIndirectHeap(IndirectHeap::INSTRUCTION, minSizeISHForEM),
getIndirectHeap(IndirectHeap::SURFACE_STATE, minSizeSSHForEM),
devQueueHw->setupExecutionModelDispatch(getIndirectHeap(IndirectHeap::SURFACE_STATE, minSizeSSHForEM),
multiDispatchInfo.begin()->getKernel(),
(uint32_t)multiDispatchInfo.size(),
taskCount,
@ -385,9 +383,7 @@ void CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
if (blockQueue) {
if (executionModelKernel) {
size_t minSizeISHForEM = KernelCommandsHelper<GfxFamily>::template getSizeRequiredForExecutionModel<IndirectHeap::INSTRUCTION>(const_cast<const Kernel &>(*(multiDispatchInfo.begin()->getKernel())));
size_t minSizeSSHForEM = KernelCommandsHelper<GfxFamily>::template getSizeRequiredForExecutionModel<IndirectHeap::SURFACE_STATE>(const_cast<const Kernel &>(*(multiDispatchInfo.begin()->getKernel())));
blockedCommandsData->instructionHeapSizeEM = minSizeISHForEM;
blockedCommandsData->surfaceStateHeapSizeEM = minSizeSSHForEM;
}

6
runtime/device_queue/device_queue.cpp
View File

@ -156,12 +156,12 @@ void DeviceQueue::initDeviceQueue() {
igilEventPool->m_size = caps.maxOnDeviceEvents;
}
void DeviceQueue::setupExecutionModelDispatch(IndirectHeap &instructionHeap, IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentCount, uint32_t taskCount, HwTimeStamps *hwTimeStamp) {
setupIndirectState(instructionHeap, surfaceStateHeap, parentKernel, parentCount);
void DeviceQueue::setupExecutionModelDispatch(IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentCount, uint32_t taskCount, HwTimeStamps *hwTimeStamp) {
setupIndirectState(surfaceStateHeap, parentKernel, parentCount);
addExecutionModelCleanUpSection(parentKernel, hwTimeStamp, taskCount);
}
void DeviceQueue::setupIndirectState(IndirectHeap &instructionHeap, IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentIDCount) {
void DeviceQueue::setupIndirectState(IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentIDCount) {
return;
}

4
runtime/device_queue/device_queue.h
View File

@ -81,9 +81,9 @@ class DeviceQueue : public BaseObject<_device_queue> {
size_t paramValueSize, void *paramValue,
size_t *paramValueSizeRet);
void setupExecutionModelDispatch(IndirectHeap &instructionHeap, IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentCount, uint32_t taskCount, HwTimeStamps *hwTimeStamp);
void setupExecutionModelDispatch(IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentCount, uint32_t taskCount, HwTimeStamps *hwTimeStamp);
virtual void setupIndirectState(IndirectHeap &instructionHeap, IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentIDCount);
virtual void setupIndirectState(IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentIDCount);
virtual void addExecutionModelCleanUpSection(Kernel *parentKernel, HwTimeStamps *hwTimeStamp, uint32_t taskCount);
MOCKABLE_VIRTUAL bool isEMCriticalSectionFree() {

2
runtime/device_queue/device_queue_hw.h
View File

@ -72,7 +72,7 @@ class DeviceQueueHw : public DeviceQueue {
size_t setSchedulerCrossThreadData(SchedulerKernel &scheduler);
void setupIndirectState(IndirectHeap &instructionHeap, IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentIDCount) override;
void setupIndirectState(IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentIDCount) override;
void addExecutionModelCleanUpSection(Kernel *parentKernel, HwTimeStamps *hwTimeStamp, uint32_t taskCount) override;
void resetDeviceQueue() override;

2
runtime/device_queue/device_queue_hw.inl
View File

@ -291,7 +291,7 @@ IndirectHeap *DeviceQueueHw<GfxFamily>::getIndirectHeap(IndirectHeap::Type type)
}
template <typename GfxFamily>
void DeviceQueueHw<GfxFamily>::setupIndirectState(IndirectHeap &instructionHeap, IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentIDCount) {
void DeviceQueueHw<GfxFamily>::setupIndirectState(IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentIDCount) {
void *pDSH = dshBuffer->getUnderlyingBuffer();
// Heap and dshBuffer shoud be the same if heap is created

57
runtime/helpers/kernel_commands.h
View File

@ -105,8 +105,6 @@ struct KernelCommandsHelper : public PerThreadDataHelper {
static bool isPipeControlWArequired();
static size_t getSizeRequiredDSH(
const Kernel &kernel);
static size_t getSizeRequiredIH(
const Kernel &kernel);
static size_t getSizeRequiredIOH(
const Kernel &kernel,
size_t localWorkSize = 256);
@ -115,8 +113,6 @@ struct KernelCommandsHelper : public PerThreadDataHelper {
static size_t getTotalSizeRequiredDSH(
const MultiDispatchInfo &multiDispatchInfo);
static size_t getTotalSizeRequiredIH(
const MultiDispatchInfo &multiDispatchInfo);
static size_t getTotalSizeRequiredIOH(
const MultiDispatchInfo &multiDispatchInfo);
static size_t getTotalSizeRequiredSSH(
@ -127,46 +123,33 @@ struct KernelCommandsHelper : public PerThreadDataHelper {
typedef typename GfxFamily::BINDING_TABLE_STATE BINDING_TABLE_STATE;
size_t totalSize = 0;
if (kernel.isParentKernel) {
BlockKernelManager *blockManager = kernel.getProgram()->getBlockKernelManager();
uint32_t blockCount = static_cast<uint32_t>(blockManager->getCount());
uint32_t maxBindingTableCount = 0;
BlockKernelManager *blockManager = kernel.getProgram()->getBlockKernelManager();
uint32_t blockCount = static_cast<uint32_t>(blockManager->getCount());
uint32_t maxBindingTableCount = 0;
if (heapType == IndirectHeap::SURFACE_STATE || heapType == IndirectHeap::INSTRUCTION) {
if (heapType == IndirectHeap::SURFACE_STATE) {
totalSize = BINDING_TABLE_STATE::SURFACESTATEPOINTER_ALIGN_SIZE - 1;
} else {
totalSize = Kernel::kernelBinaryAlignement - 1;
}
if (heapType == IndirectHeap::SURFACE_STATE) {
totalSize = BINDING_TABLE_STATE::SURFACESTATEPOINTER_ALIGN_SIZE - 1;
for (uint32_t i = 0; i < blockCount; i++) {
const KernelInfo *pBlockInfo = blockManager->getBlockKernelInfo(i);
if (heapType == IndirectHeap::SURFACE_STATE) {
totalSize += pBlockInfo->heapInfo.pKernelHeader->SurfaceStateHeapSize;
totalSize = alignUp(totalSize, BINDING_TABLE_STATE::SURFACESTATEPOINTER_ALIGN_SIZE);
for (uint32_t i = 0; i < blockCount; i++) {
const KernelInfo *pBlockInfo = blockManager->getBlockKernelInfo(i);
totalSize += pBlockInfo->heapInfo.pKernelHeader->SurfaceStateHeapSize;
totalSize = alignUp(totalSize, BINDING_TABLE_STATE::SURFACESTATEPOINTER_ALIGN_SIZE);
maxBindingTableCount = std::max(maxBindingTableCount, pBlockInfo->patchInfo.bindingTableState->Count);
} else {
totalSize += pBlockInfo->heapInfo.pKernelHeader->KernelHeapSize;
totalSize = alignUp(totalSize, Kernel::kernelBinaryAlignement);
}
}
maxBindingTableCount = std::max(maxBindingTableCount, pBlockInfo->patchInfo.bindingTableState->Count);
}
}
if (heapType == IndirectHeap::INSTRUCTION || heapType == IndirectHeap::INDIRECT_OBJECT || heapType == IndirectHeap::SURFACE_STATE) {
BuiltIns &builtIns = BuiltIns::getInstance();
SchedulerKernel &scheduler = builtIns.getSchedulerKernel(kernel.getContext());
if (heapType == IndirectHeap::INDIRECT_OBJECT || heapType == IndirectHeap::SURFACE_STATE) {
BuiltIns &builtIns = BuiltIns::getInstance();
SchedulerKernel &scheduler = builtIns.getSchedulerKernel(kernel.getContext());
if (heapType == IndirectHeap::INSTRUCTION) {
totalSize += getSizeRequiredIH(scheduler);
} else if (heapType == IndirectHeap::INDIRECT_OBJECT) {
totalSize += getSizeRequiredIOH(scheduler);
} else {
totalSize += getSizeRequiredSSH(scheduler);
if (heapType == IndirectHeap::INDIRECT_OBJECT) {
totalSize += getSizeRequiredIOH(scheduler);
} else {
totalSize += getSizeRequiredSSH(scheduler);
totalSize += maxBindingTableCount * sizeof(BINDING_TABLE_STATE) * DeviceQueue::interfaceDescriptorEntries;
totalSize = alignUp(totalSize, BINDING_TABLE_STATE::SURFACESTATEPOINTER_ALIGN_SIZE);
}
totalSize += maxBindingTableCount * sizeof(BINDING_TABLE_STATE) * DeviceQueue::interfaceDescriptorEntries;
totalSize = alignUp(totalSize, BINDING_TABLE_STATE::SURFACESTATEPOINTER_ALIGN_SIZE);
}
}
return totalSize;

13
runtime/helpers/kernel_commands.inl
View File

@ -93,13 +93,6 @@ size_t KernelCommandsHelper<GfxFamily>::getSizeRequiredIOH(
GPGPU_WALKER::INDIRECTDATASTARTADDRESS_ALIGN_SIZE);
}
template <typename GfxFamily>
size_t KernelCommandsHelper<GfxFamily>::getSizeRequiredIH(
const Kernel &kernel) {
typedef typename GfxFamily::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;
return kernel.getKernelHeapSize() + INTERFACE_DESCRIPTOR_DATA::KERNELSTARTPOINTER_ALIGN_SIZE;
}
template <typename GfxFamily>
size_t KernelCommandsHelper<GfxFamily>::getSizeRequiredSSH(
const Kernel &kernel) {
@ -126,12 +119,6 @@ size_t KernelCommandsHelper<GfxFamily>::getTotalSizeRequiredDSH(
return getSizeRequired(multiDispatchInfo, [](const DispatchInfo &dispatchInfo) { return getSizeRequiredDSH(*dispatchInfo.getKernel()); });
}
template <typename GfxFamily>
size_t KernelCommandsHelper<GfxFamily>::getTotalSizeRequiredIH(
const MultiDispatchInfo &multiDispatchInfo) {
return getSizeRequired(multiDispatchInfo, [](const DispatchInfo &dispatchInfo) { return getSizeRequiredIH(*dispatchInfo.getKernel()); });
}
template <typename GfxFamily>
size_t KernelCommandsHelper<GfxFamily>::getTotalSizeRequiredIOH(
const MultiDispatchInfo &multiDispatchInfo) {

12
runtime/helpers/task_information.cpp
View File

@ -36,7 +36,6 @@
namespace OCLRT {
KernelOperation::~KernelOperation() {
alignedFree(dsh->getCpuBase());
alignedFree(ish->getCpuBase());
if (doNotFreeISH) {
ioh.release();
} else {
@ -165,7 +164,6 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate
memcpy_s(pDst, commandsSize, commandStream.getCpuBase(), commandsSize);
size_t requestedDshSize = kernelOperation->dsh->getUsed();
size_t requestedIshSize = kernelOperation->ish->getUsed() + kernelOperation->instructionHeapSizeEM;
size_t requestedIohSize = kernelOperation->ioh->getUsed();
size_t requestedSshSize = kernelOperation->ssh->getUsed() + kernelOperation->surfaceStateHeapSizeEM;
@ -180,10 +178,6 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate
}
}
if (commandQueue.getIndirectHeap(IndirectHeap::INSTRUCTION, 0).getUsed() > commandQueue.getInstructionHeapReservedBlockSize()) {
commandQueue.releaseIndirectHeap(IndirectHeap::INSTRUCTION);
}
if (executionModelKernel) {
dsh = devQueue->getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
// In ExecutionModel IOH is the same as DSH to eliminate StateBaseAddress reprogramming for scheduler kernel and blocks.
@ -202,12 +196,8 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate
ioh->getSpace(requestedIohSize);
}
IndirectHeap &ish = commandQueue.getIndirectHeap(IndirectHeap::INSTRUCTION, requestedIshSize);
IndirectHeap &ssh = commandQueue.getIndirectHeap(IndirectHeap::SURFACE_STATE, requestedSshSize);
memcpy_s(ptrOffset(ish.getCpuBase(), commandQueue.getInstructionHeapReservedBlockSize()), requestedIshSize, kernelOperation->ish->getCpuBase(), kernelOperation->ish->getUsed());
ish.getSpace(kernelOperation->ish->getUsed());
memcpy_s(ssh.getCpuBase(), requestedSshSize, kernelOperation->ssh->getCpuBase(), kernelOperation->ssh->getUsed());
ssh.getSpace(kernelOperation->ssh->getUsed());
@ -224,7 +214,7 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate
if (executionModelKernel) {
uint32_t taskCount = commandStreamReceiver.peekTaskCount() + 1;
devQueue->setupExecutionModelDispatch(ish, ssh, kernel, kernelCount, taskCount, timestamp);
devQueue->setupExecutionModelDispatch(ssh, kernel, kernelCount, taskCount, timestamp);
BuiltIns &builtIns = BuiltIns::getInstance();
SchedulerKernel &scheduler = builtIns.getSchedulerKernel(commandQueue.getContext());

9
runtime/helpers/task_information.h
View File

@ -77,22 +77,19 @@ class CommandMapUnmap : public Command {
};
struct KernelOperation {
KernelOperation(std::unique_ptr<LinearStream> commandStream, std::unique_ptr<IndirectHeap> dsh, std::unique_ptr<IndirectHeap> ish,
std::unique_ptr<IndirectHeap> ioh, std::unique_ptr<IndirectHeap> ssh)
KernelOperation(std::unique_ptr<LinearStream> commandStream, std::unique_ptr<IndirectHeap> dsh, std::unique_ptr<IndirectHeap> ioh, std::unique_ptr<IndirectHeap> ssh)
: commandStream(std::move(commandStream)), dsh(std::move(dsh)),
ish(std::move(ish)), ioh(std::move(ioh)), ssh(std::move(ssh)),
instructionHeapSizeEM(0), surfaceStateHeapSizeEM(0), doNotFreeISH(false) {
ioh(std::move(ioh)), ssh(std::move(ssh)),
surfaceStateHeapSizeEM(0), doNotFreeISH(false) {
}
~KernelOperation();
std::unique_ptr<LinearStream> commandStream;
std::unique_ptr<IndirectHeap> dsh;
std::unique_ptr<IndirectHeap> ish;
std::unique_ptr<IndirectHeap> ioh;
std::unique_ptr<IndirectHeap> ssh;
size_t instructionHeapSizeEM;
size_t surfaceStateHeapSizeEM;
bool doNotFreeISH;
};

17
unit_tests/command_queue/command_queue_hw_tests.cpp
View File

@ -413,8 +413,7 @@ HWTEST_F(BlockedCommandQueueTest, givenCommandQueueWhichHasSomeUsedHeapsWhenBloc
mockKernelWithInternals.kernelHeader.KernelHeapSize = sizeof(mockKernelWithInternals.kernelIsa);
auto mockKernel = mockKernelWithInternals.mockKernel;
IndirectHeap::Type heaps[] = {IndirectHeap::INSTRUCTION, IndirectHeap::INDIRECT_OBJECT,
IndirectHeap::DYNAMIC_STATE, IndirectHeap::SURFACE_STATE};
IndirectHeap::Type heaps[] = {IndirectHeap::INDIRECT_OBJECT, IndirectHeap::DYNAMIC_STATE, IndirectHeap::SURFACE_STATE};
size_t prealocatedHeapSize = 2 * 64 * KB;
for (auto heapType : heaps) {
@ -428,14 +427,8 @@ HWTEST_F(BlockedCommandQueueTest, givenCommandQueueWhichHasSomeUsedHeapsWhenBloc
DebugManager.flags.DisableResourceRecycling.set(false);
std::set<void *> reusableHeaps;
for (unsigned int i = 0; i < 5; ++i) {
for (unsigned int i = 0; i < 4; ++i) {
auto allocSize = prealocatedHeapSize;
//make sure that one of those allocations is larger so ISH can be recycled.
if (i == 4) {
allocSize = optimalInstructionHeapSize;
}
void *mem = alignedMalloc(allocSize, 64);
reusableHeaps.insert(mem);
memset(mem, 0, allocSize);
@ -452,7 +445,6 @@ HWTEST_F(BlockedCommandQueueTest, givenCommandQueueWhichHasSomeUsedHeapsWhenBloc
userEvent.setStatus(CL_COMPLETE);
// make sure used heaps are from preallocated pool
EXPECT_NE(reusableHeaps.end(), reusableHeaps.find(pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION, 0).getCpuBase()));
EXPECT_NE(reusableHeaps.end(), reusableHeaps.find(pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT, 0).getCpuBase()));
EXPECT_NE(reusableHeaps.end(), reusableHeaps.find(pCmdQ->getIndirectHeap(IndirectHeap::DYNAMIC_STATE, 0).getCpuBase()));
EXPECT_NE(reusableHeaps.end(), reusableHeaps.find(pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE, 0).getCpuBase()));
@ -479,8 +471,6 @@ HWTEST_F(BlockedCommandQueueTest, givenCommandQueueWhichHasSomeUsedHeapsWhenBloc
}
// expecting blocked command to be programmed indentically to a non-blocked counterpart
EXPECT_THAT(nonblockedCommandHeaps[static_cast<int>(IndirectHeap::INSTRUCTION)],
testing::ContainerEq(blockedCommandHeaps[static_cast<int>(IndirectHeap::INSTRUCTION)]));
EXPECT_THAT(nonblockedCommandHeaps[static_cast<int>(IndirectHeap::INDIRECT_OBJECT)],
testing::ContainerEq(blockedCommandHeaps[static_cast<int>(IndirectHeap::INDIRECT_OBJECT)]));
EXPECT_THAT(nonblockedCommandHeaps[static_cast<int>(IndirectHeap::DYNAMIC_STATE)],
@ -506,12 +496,10 @@ HWTEST_F(BlockedCommandQueueTest, givenCommandQueueWhichHasSomeUnusedHeapsWhenBl
cl_event blockedEvent = &userEvent;
auto &ish = pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION, 4096u);
auto &ioh = pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT, 4096u);
auto &dsh = pCmdQ->getIndirectHeap(IndirectHeap::DYNAMIC_STATE, 4096u);
auto &ssh = pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE, 4096u);
auto ishBase = ish.getCpuBase();
auto iohBase = ioh.getCpuBase();
auto dshBase = dsh.getCpuBase();
auto sshBase = ssh.getCpuBase();
@ -519,7 +507,6 @@ HWTEST_F(BlockedCommandQueueTest, givenCommandQueueWhichHasSomeUnusedHeapsWhenBl
pCmdQ->enqueueKernel(mockKernel, 1, &offset, &size, &size, 1, &blockedEvent, nullptr);
userEvent.setStatus(CL_COMPLETE);
EXPECT_EQ(ishBase, ish.getCpuBase());
EXPECT_EQ(iohBase, ioh.getCpuBase());
EXPECT_EQ(dshBase, dsh.getCpuBase());
EXPECT_EQ(sshBase, ssh.getCpuBase());

5
unit_tests/command_queue/dispatch_walker_tests.cpp
View File

@ -651,7 +651,6 @@ HWTEST_F(DispatchWalkerTest, dispatchWalkerDoesntConsumeCommandStreamWhenQueueIs
EXPECT_NE(nullptr, blockedCommandsData);
EXPECT_NE(nullptr, blockedCommandsData->commandStream);
EXPECT_NE(nullptr, blockedCommandsData->dsh);
EXPECT_NE(nullptr, blockedCommandsData->ish);
EXPECT_NE(nullptr, blockedCommandsData->ioh);
EXPECT_NE(nullptr, blockedCommandsData->ssh);
@ -691,13 +690,11 @@ HWTEST_F(DispatchWalkerTest, dispatchWalkerShouldGetRequiredHeapSizesFromKernelW
auto expectedSizeCS = MemoryConstants::pageSize; //can get estimated more precisely
auto expectedSizeDSH = KernelCommandsHelper<FamilyType>::getSizeRequiredDSH(kernel);
auto expectedSizeISH = KernelCommandsHelper<FamilyType>::getSizeRequiredIH(kernel);
auto expectedSizeIOH = KernelCommandsHelper<FamilyType>::getSizeRequiredIOH(kernel, Math::computeTotalElementsCount(localWorkgroupSize));
auto expectedSizeSSH = KernelCommandsHelper<FamilyType>::getSizeRequiredSSH(kernel);
EXPECT_EQ(expectedSizeCS, blockedCommandsData->commandStream->getMaxAvailableSpace());
EXPECT_EQ(expectedSizeDSH, blockedCommandsData->dsh->getMaxAvailableSpace());
EXPECT_EQ(expectedSizeISH, blockedCommandsData->ish->getMaxAvailableSpace());
EXPECT_EQ(expectedSizeIOH, blockedCommandsData->ioh->getMaxAvailableSpace());
EXPECT_EQ(expectedSizeSSH, blockedCommandsData->ssh->getMaxAvailableSpace());
@ -728,13 +725,11 @@ HWTEST_F(DispatchWalkerTest, dispatchWalkerShouldGetRequiredHeapSizesFromMdiWhen
auto expectedSizeCS = MemoryConstants::pageSize; //can get estimated more precisely
auto expectedSizeDSH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredDSH(multiDispatchInfo);
auto expectedSizeISH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredIH(multiDispatchInfo);
auto expectedSizeIOH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredIOH(multiDispatchInfo);
auto expectedSizeSSH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredSSH(multiDispatchInfo);
EXPECT_EQ(expectedSizeCS, blockedCommandsData->commandStream->getMaxAvailableSpace());
EXPECT_EQ(expectedSizeDSH, blockedCommandsData->dsh->getMaxAvailableSpace());
EXPECT_EQ(expectedSizeISH, blockedCommandsData->ish->getMaxAvailableSpace());
EXPECT_EQ(expectedSizeIOH, blockedCommandsData->ioh->getMaxAvailableSpace());
EXPECT_EQ(expectedSizeSSH, blockedCommandsData->ssh->getMaxAvailableSpace());

30
unit_tests/command_queue/get_size_required_buffer_tests.cpp
View File

@ -84,11 +84,9 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueFillBuffer) {
auto &commandStream = pCmdQ->getCS();
auto usedBeforeCS = commandStream.getUsed();
auto &dsh = pCmdQ->getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
auto &ih = pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION);
auto &ioh = pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT);
auto &ssh = pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE);
auto usedBeforeDSH = dsh.getUsed();
auto usedBeforeIH = ih.getUsed();
auto usedBeforeIOH = ioh.getUsed();
auto usedBeforeSSH = ssh.getUsed();
@ -112,13 +110,11 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueFillBuffer) {
auto usedAfterCS = commandStream.getUsed();
auto usedAfterDSH = dsh.getUsed();
auto usedAfterIH = ih.getUsed();
auto usedAfterIOH = ioh.getUsed();
auto usedAfterSSH = ssh.getUsed();
auto expectedSizeCS = EnqueueOperation<FamilyType, CL_COMMAND_FILL_BUFFER>::getTotalSizeRequiredCS(false, false, *pCmdQ, multiDispatchInfo);
auto expectedSizeDSH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredDSH(multiDispatchInfo);
auto expectedSizeIH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredIH(multiDispatchInfo);
auto expectedSizeIOH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredIOH(multiDispatchInfo);
auto expectedSizeSSH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredSSH(multiDispatchInfo);
@ -131,7 +127,6 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueFillBuffer) {
EXPECT_EQ(expectedSizeCS, usedAfterCS - usedBeforeCS);
EXPECT_GE(expectedSizeDSH, usedAfterDSH - usedBeforeDSH);
EXPECT_GE(expectedSizeIH, usedAfterIH - usedBeforeIH);
EXPECT_GE(expectedSizeIOH, usedAfterIOH - usedBeforeIOH);
EXPECT_GE(expectedSizeSSH, usedAfterSSH - usedBeforeSSH);
}
@ -141,11 +136,9 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueCopyBuffer) {
auto &commandStream = pCmdQ->getCS();
auto usedBeforeCS = commandStream.getUsed();
auto &dsh = pCmdQ->getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
auto &ih = pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION);
auto &ioh = pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT);
auto &ssh = pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE);
auto usedBeforeDSH = dsh.getUsed();
auto usedBeforeIH = ih.getUsed();
auto usedBeforeIOH = ioh.getUsed();
auto usedBeforeSSH = ssh.getUsed();
@ -168,13 +161,11 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueCopyBuffer) {
auto usedAfterCS = commandStream.getUsed();
auto usedAfterDSH = dsh.getUsed();
auto usedAfterIH = ih.getUsed();
auto usedAfterIOH = ioh.getUsed();
auto usedAfterSSH = ssh.getUsed();
auto expectedSizeCS = EnqueueOperation<FamilyType, CL_COMMAND_COPY_BUFFER>::getTotalSizeRequiredCS(false, false, *pCmdQ, multiDispatchInfo);
auto expectedSizeDSH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredDSH(multiDispatchInfo);
auto expectedSizeIH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredIH(multiDispatchInfo);
auto expectedSizeIOH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredIOH(multiDispatchInfo);
auto expectedSizeSSH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredSSH(multiDispatchInfo);
@ -187,7 +178,6 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueCopyBuffer) {
EXPECT_EQ(expectedSizeCS, usedAfterCS - usedBeforeCS);
EXPECT_GE(expectedSizeDSH, usedAfterDSH - usedBeforeDSH);
EXPECT_GE(expectedSizeIH, usedAfterIH - usedBeforeIH);
EXPECT_GE(expectedSizeIOH, usedAfterIOH - usedBeforeIOH);
EXPECT_GE(expectedSizeSSH, usedAfterSSH - usedBeforeSSH);
}
@ -197,11 +187,9 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueReadBufferNonBlocking) {
auto &commandStream = pCmdQ->getCS();
auto usedBeforeCS = commandStream.getUsed();
auto &dsh = pCmdQ->getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
auto &ih = pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION);
auto &ioh = pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT);
auto &ssh = pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE);
auto usedBeforeDSH = dsh.getUsed();
auto usedBeforeIH = ih.getUsed();
auto usedBeforeIOH = ioh.getUsed();
auto usedBeforeSSH = ssh.getUsed();
@ -225,13 +213,11 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueReadBufferNonBlocking) {
auto usedAfterCS = commandStream.getUsed();
auto usedAfterDSH = dsh.getUsed();
auto usedAfterIH = ih.getUsed();
auto usedAfterIOH = ioh.getUsed();
auto usedAfterSSH = ssh.getUsed();
auto expectedSizeCS = EnqueueOperation<FamilyType, CL_COMMAND_READ_BUFFER>::getTotalSizeRequiredCS(false, false, *pCmdQ, multiDispatchInfo);
auto expectedSizeDSH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredDSH(multiDispatchInfo);
auto expectedSizeIH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredIH(multiDispatchInfo);
auto expectedSizeIOH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredIOH(multiDispatchInfo);
auto expectedSizeSSH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredSSH(multiDispatchInfo);
@ -244,7 +230,6 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueReadBufferNonBlocking) {
EXPECT_EQ(expectedSizeCS, usedAfterCS - usedBeforeCS);
EXPECT_GE(expectedSizeDSH, usedAfterDSH - usedBeforeDSH);
EXPECT_GE(expectedSizeIH, usedAfterIH - usedBeforeIH);
EXPECT_GE(expectedSizeIOH, usedAfterIOH - usedBeforeIOH);
EXPECT_GE(expectedSizeSSH, usedAfterSSH - usedBeforeSSH);
}
@ -254,11 +239,9 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueReadBufferBlocking) {
auto &commandStream = pCmdQ->getCS();
auto usedBeforeCS = commandStream.getUsed();
auto &dsh = pCmdQ->getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
auto &ih = pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION);
auto &ioh = pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT);
auto &ssh = pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE);
auto usedBeforeDSH = dsh.getUsed();
auto usedBeforeIH = ih.getUsed();
auto usedBeforeIOH = ioh.getUsed();
auto usedBeforeSSH = ssh.getUsed();
@ -283,13 +266,11 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueReadBufferBlocking) {
auto usedAfterCS = commandStream.getUsed();
auto usedAfterDSH = dsh.getUsed();
auto usedAfterIH = ih.getUsed();
auto usedAfterIOH = ioh.getUsed();
auto usedAfterSSH = ssh.getUsed();
auto expectedSizeCS = EnqueueOperation<FamilyType, CL_COMMAND_READ_BUFFER>::getTotalSizeRequiredCS(false, false, *pCmdQ, multiDispatchInfo);
auto expectedSizeDSH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredDSH(multiDispatchInfo);
auto expectedSizeIH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredIH(multiDispatchInfo);
auto expectedSizeIOH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredIOH(multiDispatchInfo);
auto expectedSizeSSH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredSSH(multiDispatchInfo);
@ -302,7 +283,6 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueReadBufferBlocking) {
EXPECT_EQ(expectedSizeCS, usedAfterCS - usedBeforeCS);
EXPECT_GE(expectedSizeDSH, usedAfterDSH - usedBeforeDSH);
EXPECT_GE(expectedSizeIH, usedAfterIH - usedBeforeIH);
EXPECT_GE(expectedSizeIOH, usedAfterIOH - usedBeforeIOH);
EXPECT_GE(expectedSizeSSH, usedAfterSSH - usedBeforeSSH);
}
@ -312,11 +292,9 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueWriteBufferNonBlocking) {
auto &commandStream = pCmdQ->getCS();
auto usedBeforeCS = commandStream.getUsed();
auto &dsh = pCmdQ->getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
auto &ih = pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION);
auto &ioh = pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT);
auto &ssh = pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE);
auto usedBeforeDSH = dsh.getUsed();
auto usedBeforeIH = ih.getUsed();
auto usedBeforeIOH = ioh.getUsed();
auto usedBeforeSSH = ssh.getUsed();
@ -341,13 +319,11 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueWriteBufferNonBlocking) {
auto usedAfterCS = commandStream.getUsed();
auto usedAfterDSH = dsh.getUsed();
auto usedAfterIH = ih.getUsed();
auto usedAfterIOH = ioh.getUsed();
auto usedAfterSSH = ssh.getUsed();
auto expectedSizeCS = EnqueueOperation<FamilyType, CL_COMMAND_WRITE_BUFFER>::getTotalSizeRequiredCS(false, false, *pCmdQ, multiDispatchInfo);
auto expectedSizeDSH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredDSH(multiDispatchInfo);
auto expectedSizeIH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredIH(multiDispatchInfo);
auto expectedSizeIOH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredIOH(multiDispatchInfo);
auto expectedSizeSSH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredSSH(multiDispatchInfo);
@ -357,7 +333,6 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueWriteBufferNonBlocking) {
EXPECT_EQ(expectedSizeCS, usedAfterCS - usedBeforeCS);
EXPECT_GE(expectedSizeDSH, usedAfterDSH - usedBeforeDSH);
EXPECT_GE(expectedSizeIH, usedAfterIH - usedBeforeIH);
EXPECT_GE(expectedSizeIOH, usedAfterIOH - usedBeforeIOH);
EXPECT_GE(expectedSizeSSH, usedAfterSSH - usedBeforeSSH);
}
@ -366,11 +341,9 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueWriteBufferBlocking) {
auto &commandStream = pCmdQ->getCS();
auto usedBeforeCS = commandStream.getUsed();
auto &dsh = pCmdQ->getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
auto &ih = pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION);
auto &ioh = pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT);
auto &ssh = pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE);
auto usedBeforeDSH = dsh.getUsed();
auto usedBeforeIH = ih.getUsed();
auto usedBeforeIOH = ioh.getUsed();
auto usedBeforeSSH = ssh.getUsed();
@ -396,13 +369,11 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueWriteBufferBlocking) {
auto usedAfterCS = commandStream.getUsed();
auto usedAfterDSH = dsh.getUsed();
auto usedAfterIH = ih.getUsed();
auto usedAfterIOH = ioh.getUsed();
auto usedAfterSSH = ssh.getUsed();
auto expectedSizeCS = EnqueueOperation<FamilyType, CL_COMMAND_WRITE_BUFFER>::getTotalSizeRequiredCS(false, false, *pCmdQ, multiDispatchInfo);
auto expectedSizeDSH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredDSH(multiDispatchInfo);
auto expectedSizeIH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredIH(multiDispatchInfo);
auto expectedSizeIOH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredIOH(multiDispatchInfo);
auto expectedSizeSSH = KernelCommandsHelper<FamilyType>::getTotalSizeRequiredSSH(multiDispatchInfo);
@ -412,7 +383,6 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueWriteBufferBlocking) {
EXPECT_EQ(expectedSizeCS, usedAfterCS - usedBeforeCS);
EXPECT_GE(expectedSizeDSH, usedAfterDSH - usedBeforeDSH);
EXPECT_GE(expectedSizeIH, usedAfterIH - usedBeforeIH);
EXPECT_GE(expectedSizeIOH, usedAfterIOH - usedBeforeIOH);
EXPECT_GE(expectedSizeSSH, usedAfterSSH - usedBeforeSSH);
}

30
unit_tests/command_queue/get_size_required_image_tests.cpp
View File

@ -75,11 +75,9 @@ HWTEST_F(GetSizeRequiredImageTest, enqueueCopyImage) {
auto &commandStream = pCmdQ->getCS();
auto usedBeforeCS = commandStream.getUsed();
auto &dsh = pCmdQ->getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
auto &ih = pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION);
auto &ioh = pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT);
auto &ssh = pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE);
auto usedBeforeDSH = dsh.getUsed();
auto usedBeforeIH = ih.getUsed();
auto usedBeforeIOH = ioh.getUsed();
auto usedBeforeSSH = ssh.getUsed();
@ -105,13 +103,11 @@ HWTEST_F(GetSizeRequiredImageTest, enqueueCopyImage) {
auto usedAfterCS = commandStream.getUsed();
auto usedAfterDSH = dsh.getUsed();
auto usedAfterIH = ih.getUsed();
auto usedAfterIOH = ioh.getUsed();
auto usedAfterSSH = ssh.getUsed();
auto expectedSizeCS = EnqueueOperation<FamilyType, CL_COMMAND_COPY_IMAGE>::getSizeRequiredCS(false, false, *pCmdQ, kernel);
auto expectedSizeDSH = KernelCommandsHelper<FamilyType>::getSizeRequiredDSH(*kernel);
auto expectedSizeIH = KernelCommandsHelper<FamilyType>::getSizeRequiredIH(*kernel);
auto expectedSizeIOH = KernelCommandsHelper<FamilyType>::getSizeRequiredIOH(*kernel);
auto expectedSizeSSH = KernelCommandsHelper<FamilyType>::getSizeRequiredSSH(*kernel);
@ -121,7 +117,6 @@ HWTEST_F(GetSizeRequiredImageTest, enqueueCopyImage) {
EXPECT_EQ(expectedSizeCS, usedAfterCS - usedBeforeCS);
EXPECT_GE(expectedSizeDSH, usedAfterDSH - usedBeforeDSH);
EXPECT_GE(expectedSizeIH, usedAfterIH - usedBeforeIH);
EXPECT_GE(expectedSizeIOH, usedAfterIOH - usedBeforeIOH);
EXPECT_GE(expectedSizeSSH, usedAfterSSH - usedBeforeSSH);
}
@ -130,11 +125,9 @@ HWTEST_F(GetSizeRequiredImageTest, enqueueCopyReadAndWriteImage) {
auto &commandStream = pCmdQ->getCS();
auto usedBeforeCS = commandStream.getUsed();
auto &dsh = pCmdQ->getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
auto &ih = pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION);
auto &ioh = pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT);
auto &ssh = pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE);
auto usedBeforeDSH = dsh.getUsed();
auto usedBeforeIH = ih.getUsed();
auto usedBeforeIOH = ioh.getUsed();
auto usedBeforeSSH = ssh.getUsed();
@ -158,13 +151,11 @@ HWTEST_F(GetSizeRequiredImageTest, enqueueCopyReadAndWriteImage) {
auto usedAfterCS = commandStream.getUsed();
auto usedAfterDSH = dsh.getUsed();
auto usedAfterIH = ih.getUsed();
auto usedAfterIOH = ioh.getUsed();
auto usedAfterSSH = ssh.getUsed();
auto expectedSizeCS = EnqueueOperation<FamilyType, CL_COMMAND_COPY_IMAGE>::getSizeRequiredCS(false, false, *pCmdQ, kernel.get());
auto expectedSizeDSH = KernelCommandsHelper<FamilyType>::getSizeRequiredDSH(*kernel.get());
auto expectedSizeIH = KernelCommandsHelper<FamilyType>::getSizeRequiredIH(*kernel.get());
auto expectedSizeIOH = KernelCommandsHelper<FamilyType>::getSizeRequiredIOH(*kernel.get());
auto expectedSizeSSH = KernelCommandsHelper<FamilyType>::getSizeRequiredSSH(*kernel.get());
@ -176,7 +167,6 @@ HWTEST_F(GetSizeRequiredImageTest, enqueueCopyReadAndWriteImage) {
EXPECT_EQ(expectedSizeCS, usedAfterCS - usedBeforeCS);
EXPECT_GE(expectedSizeDSH, usedAfterDSH - usedBeforeDSH);
EXPECT_GE(expectedSizeIH, usedAfterIH - usedBeforeIH);
EXPECT_GE(expectedSizeIOH, usedAfterIOH - usedBeforeIOH);
EXPECT_GE(expectedSizeSSH, usedAfterSSH - usedBeforeSSH);
}
@ -185,11 +175,9 @@ HWTEST_F(GetSizeRequiredImageTest, enqueueReadImageNonBlocking) {
auto &commandStream = pCmdQ->getCS();
auto usedBeforeCS = commandStream.getUsed();
auto &dsh = pCmdQ->getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
auto &ih = pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION);
auto &ioh = pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT);
auto &ssh = pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE);
auto usedBeforeDSH = dsh.getUsed();
auto usedBeforeIH = ih.getUsed();
auto usedBeforeIOH = ioh.getUsed();
auto usedBeforeSSH = ssh.getUsed();
@ -219,13 +207,11 @@ HWTEST_F(GetSizeRequiredImageTest, enqueueReadImageNonBlocking) {
auto usedAfterCS = commandStream.getUsed();
auto usedAfterDSH = dsh.getUsed();
auto usedAfterIH = ih.getUsed();
auto usedAfterIOH = ioh.getUsed();
auto usedAfterSSH = ssh.getUsed();
auto expectedSizeCS = EnqueueOperation<FamilyType, CL_COMMAND_READ_IMAGE>::getSizeRequiredCS(false, false, *pCmdQ, kernel);
auto expectedSizeDSH = KernelCommandsHelper<FamilyType>::getSizeRequiredDSH(*kernel);
auto expectedSizeIH = KernelCommandsHelper<FamilyType>::getSizeRequiredIH(*kernel);
auto expectedSizeIOH = KernelCommandsHelper<FamilyType>::getSizeRequiredIOH(*kernel);
auto expectedSizeSSH = KernelCommandsHelper<FamilyType>::getSizeRequiredSSH(*kernel);
@ -235,7 +221,6 @@ HWTEST_F(GetSizeRequiredImageTest, enqueueReadImageNonBlocking) {
EXPECT_EQ(expectedSizeCS, usedAfterCS - usedBeforeCS);
EXPECT_GE(expectedSizeDSH, usedAfterDSH - usedBeforeDSH);
EXPECT_GE(expectedSizeIH, usedAfterIH - usedBeforeIH);
EXPECT_GE(expectedSizeIOH, usedAfterIOH - usedBeforeIOH);
EXPECT_GE(expectedSizeSSH, usedAfterSSH - usedBeforeSSH);
}
@ -244,11 +229,9 @@ HWTEST_F(GetSizeRequiredImageTest, enqueueReadImageBlocking) {
auto &commandStream = pCmdQ->getCS();
auto usedBeforeCS = commandStream.getUsed();
auto &dsh = pCmdQ->getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
auto &ih = pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION);
auto &ioh = pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT);
auto &ssh = pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE);
auto usedBeforeDSH = dsh.getUsed();
auto usedBeforeIH = ih.getUsed();
auto usedBeforeIOH = ioh.getUsed();
auto usedBeforeSSH = ssh.getUsed();
@ -278,13 +261,11 @@ HWTEST_F(GetSizeRequiredImageTest, enqueueReadImageBlocking) {
auto usedAfterCS = commandStream.getUsed();
auto usedAfterDSH = dsh.getUsed();
auto usedAfterIH = ih.getUsed();
auto usedAfterIOH = ioh.getUsed();
auto usedAfterSSH = ssh.getUsed();
auto expectedSizeCS = EnqueueOperation<FamilyType, CL_COMMAND_READ_IMAGE>::getSizeRequiredCS(false, false, *pCmdQ, kernel);
auto expectedSizeDSH = KernelCommandsHelper<FamilyType>::getSizeRequiredDSH(*kernel);
auto expectedSizeIH = KernelCommandsHelper<FamilyType>::getSizeRequiredIH(*kernel);
auto expectedSizeIOH = KernelCommandsHelper<FamilyType>::getSizeRequiredIOH(*kernel);
auto expectedSizeSSH = KernelCommandsHelper<FamilyType>::getSizeRequiredSSH(*kernel);
@ -294,7 +275,6 @@ HWTEST_F(GetSizeRequiredImageTest, enqueueReadImageBlocking) {
EXPECT_EQ(expectedSizeCS, usedAfterCS - usedBeforeCS);
EXPECT_GE(expectedSizeDSH, usedAfterDSH - usedBeforeDSH);
EXPECT_GE(expectedSizeIH, usedAfterIH - usedBeforeIH);
EXPECT_GE(expectedSizeIOH, usedAfterIOH - usedBeforeIOH);
EXPECT_GE(expectedSizeSSH, usedAfterSSH - usedBeforeSSH);
}
@ -303,11 +283,9 @@ HWTEST_F(GetSizeRequiredImageTest, enqueueWriteImageNonBlocking) {
auto &commandStream = pCmdQ->getCS();
auto usedBeforeCS = commandStream.getUsed();
auto &dsh = pCmdQ->getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
auto &ih = pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION);
auto &ioh = pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT);
auto &ssh = pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE);
auto usedBeforeDSH = dsh.getUsed();
auto usedBeforeIH = ih.getUsed();
auto usedBeforeIOH = ioh.getUsed();
auto usedBeforeSSH = ssh.getUsed();
@ -337,13 +315,11 @@ HWTEST_F(GetSizeRequiredImageTest, enqueueWriteImageNonBlocking) {
auto usedAfterCS = commandStream.getUsed();
auto usedAfterDSH = dsh.getUsed();
auto usedAfterIH = ih.getUsed();
auto usedAfterIOH = ioh.getUsed();
auto usedAfterSSH = ssh.getUsed();
auto expectedSizeCS = EnqueueOperation<FamilyType, CL_COMMAND_WRITE_IMAGE>::getSizeRequiredCS(false, false, *pCmdQ, kernel);
auto expectedSizeDSH = KernelCommandsHelper<FamilyType>::getSizeRequiredDSH(*kernel);
auto expectedSizeIH = KernelCommandsHelper<FamilyType>::getSizeRequiredIH(*kernel);
auto expectedSizeIOH = KernelCommandsHelper<FamilyType>::getSizeRequiredIOH(*kernel);
auto expectedSizeSSH = KernelCommandsHelper<FamilyType>::getSizeRequiredSSH(*kernel);
@ -353,7 +329,6 @@ HWTEST_F(GetSizeRequiredImageTest, enqueueWriteImageNonBlocking) {
EXPECT_EQ(expectedSizeCS, usedAfterCS - usedBeforeCS);
EXPECT_GE(expectedSizeDSH, usedAfterDSH - usedBeforeDSH);
EXPECT_GE(expectedSizeIH, usedAfterIH - usedBeforeIH);
EXPECT_GE(expectedSizeIOH, usedAfterIOH - usedBeforeIOH);
EXPECT_GE(expectedSizeSSH, usedAfterSSH - usedBeforeSSH);
}
@ -362,11 +337,9 @@ HWTEST_F(GetSizeRequiredImageTest, enqueueWriteImageBlocking) {
auto &commandStream = pCmdQ->getCS();
auto usedBeforeCS = commandStream.getUsed();
auto &dsh = pCmdQ->getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
auto &ih = pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION);
auto &ioh = pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT);
auto &ssh = pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE);
auto usedBeforeDSH = dsh.getUsed();
auto usedBeforeIH = ih.getUsed();
auto usedBeforeIOH = ioh.getUsed();
auto usedBeforeSSH = ssh.getUsed();
@ -396,13 +369,11 @@ HWTEST_F(GetSizeRequiredImageTest, enqueueWriteImageBlocking) {
auto usedAfterCS = commandStream.getUsed();
auto usedAfterDSH = dsh.getUsed();
auto usedAfterIH = ih.getUsed();
auto usedAfterIOH = ioh.getUsed();
auto usedAfterSSH = ssh.getUsed();
auto expectedSizeCS = EnqueueOperation<FamilyType, CL_COMMAND_WRITE_IMAGE>::getSizeRequiredCS(false, false, *pCmdQ, kernel);
auto expectedSizeDSH = KernelCommandsHelper<FamilyType>::getSizeRequiredDSH(*kernel);
auto expectedSizeIH = KernelCommandsHelper<FamilyType>::getSizeRequiredIH(*kernel);
auto expectedSizeIOH = KernelCommandsHelper<FamilyType>::getSizeRequiredIOH(*kernel);
auto expectedSizeSSH = KernelCommandsHelper<FamilyType>::getSizeRequiredSSH(*kernel);
@ -412,7 +383,6 @@ HWTEST_F(GetSizeRequiredImageTest, enqueueWriteImageBlocking) {
EXPECT_EQ(expectedSizeCS, usedAfterCS - usedBeforeCS);
EXPECT_GE(expectedSizeDSH, usedAfterDSH - usedBeforeDSH);
EXPECT_GE(expectedSizeIH, usedAfterIH - usedBeforeIH);
EXPECT_GE(expectedSizeIOH, usedAfterIOH - usedBeforeIOH);
EXPECT_GE(expectedSizeSSH, usedAfterSSH - usedBeforeSSH);
}

22
unit_tests/device_queue/device_queue_hw_tests.cpp
View File

@ -528,29 +528,21 @@ HWTEST_P(DeviceQueueHwWithKernel, setupIndirectState) {
auto dsh = devQueueHw->getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
ASSERT_NE(nullptr, dsh);
size_t instructionHeapSize = pKernel->getInstructionHeapSizeForExecutionModel();
size_t surfaceStateHeapSize = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::SURFACE_STATE>(const_cast<const Kernel &>(*pKernel));
auto ish = new IndirectHeap(alignedMalloc(instructionHeapSize, MemoryConstants::pageSize), instructionHeapSize);
auto ssh = new IndirectHeap(alignedMalloc(surfaceStateHeapSize, MemoryConstants::pageSize), surfaceStateHeapSize);
ASSERT_NE(nullptr, ish);
auto usedBeforeISH = ish->getUsed();
auto usedBeforeSSH = ssh->getUsed();
auto usedBeforeDSH = dsh->getUsed();
devQueueHw->setupIndirectState(*ish, *ssh, pKernel, 1);
auto usedAfterISH = ish->getUsed();
devQueueHw->setupIndirectState(*ssh, pKernel, 1);
auto usedAfterSSH = ssh->getUsed();
auto usedAfterDSH = dsh->getUsed();
EXPECT_GE(instructionHeapSize, usedAfterISH - usedBeforeISH);
EXPECT_GE(surfaceStateHeapSize, usedAfterSSH - usedBeforeSSH);
EXPECT_EQ(0u, usedAfterDSH - usedBeforeDSH);
alignedFree(ish->getCpuBase());
alignedFree(ssh->getCpuBase());
delete ish;
delete ssh;
}
}
@ -566,22 +558,18 @@ HWTEST_P(DeviceQueueHwWithKernel, setupIndirectStateSetsCorrectStartBlockID) {
auto dsh = devQueueHw->getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
ASSERT_NE(nullptr, dsh);
size_t instructionHeapSize = pKernel->getInstructionHeapSizeForExecutionModel();
size_t surfaceStateHeapSize = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::SURFACE_STATE>(const_cast<const Kernel &>(*pKernel));
auto ish = new IndirectHeap(alignedMalloc(instructionHeapSize, MemoryConstants::pageSize), instructionHeapSize);
auto ssh = new IndirectHeap(alignedMalloc(surfaceStateHeapSize, MemoryConstants::pageSize), surfaceStateHeapSize);
uint32_t parentCount = 4;
devQueueHw->setupIndirectState(*ish, *ssh, pKernel, parentCount);
devQueueHw->setupIndirectState(*ssh, pKernel, parentCount);
auto *igilQueue = reinterpret_cast<IGIL_CommandQueue *>(devQueueHw->getQueueBuffer()->getUnderlyingBuffer());
EXPECT_EQ(parentCount, igilQueue->m_controls.m_StartBlockID);
alignedFree(ish->getCpuBase());
alignedFree(ssh->getCpuBase());
delete ish;
delete ssh;
}
}
@ -600,15 +588,13 @@ HWTEST_P(DeviceQueueHwWithKernel, setupIndirectStateSetsCorrectDSHValues) {
auto dsh = devQueueHw->getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
ASSERT_NE(nullptr, dsh);
size_t instructionHeapSize = pKernel->getInstructionHeapSizeForExecutionModel();
size_t surfaceStateHeapSize = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::SURFACE_STATE>(const_cast<const Kernel &>(*pKernel));
auto ish = new IndirectHeap(alignedMalloc(instructionHeapSize, MemoryConstants::pageSize), instructionHeapSize);
auto ssh = new IndirectHeap(alignedMalloc(surfaceStateHeapSize, MemoryConstants::pageSize), surfaceStateHeapSize);
uint32_t parentCount = 1;
devQueueHw->setupIndirectState(*ish, *ssh, pKernel, parentCount);
devQueueHw->setupIndirectState(*ssh, pKernel, parentCount);
auto *igilQueue = reinterpret_cast<IGIL_CommandQueue *>(devQueueHw->getQueueBuffer()->getUnderlyingBuffer());
EXPECT_EQ(igilQueue->m_controls.m_DynamicHeapStart, devQueueHw->offsetDsh + alignUp((uint32_t)pKernel->getDynamicStateHeapSize(), GPGPU_WALKER::INDIRECTDATASTARTADDRESS_ALIGN_SIZE));
@ -616,9 +602,7 @@ HWTEST_P(DeviceQueueHwWithKernel, setupIndirectStateSetsCorrectDSHValues) {
EXPECT_EQ(igilQueue->m_controls.m_CurrentDSHoffset, devQueueHw->offsetDsh + alignUp((uint32_t)pKernel->getDynamicStateHeapSize(), GPGPU_WALKER::INDIRECTDATASTARTADDRESS_ALIGN_SIZE));
EXPECT_EQ(igilQueue->m_controls.m_ParentDSHOffset, devQueueHw->offsetDsh);
alignedFree(ish->getCpuBase());
alignedFree(ssh->getCpuBase());
delete ish;
delete ssh;
delete devQueueHw;
}

4
unit_tests/device_queue/device_queue_tests.cpp
View File

@ -39,11 +39,9 @@ TEST(DeviceQueueSimpleTest, setupExecutionModelDispatchDoesNothing) {
memset(buffer, 1, 20);
size_t size = 20;
IndirectHeap ih(buffer, size);
IndirectHeap ssh(buffer, size);
devQueue.setupExecutionModelDispatch(ih, ssh, nullptr, 0, 0, 0);
devQueue.setupExecutionModelDispatch(ssh, nullptr, 0, 0, 0);
EXPECT_EQ(0u, ih.getUsed());
EXPECT_EQ(0u, ssh.getUsed());
for (uint32_t i = 0; i < 20; i++) {

18
unit_tests/event/event_tests.cpp
View File

@ -452,7 +452,6 @@ class SurfaceMock : public Surface {
TEST_F(InternalsEventTest, resizeCmdQueueHeapsWhenKernelOparationHeapsAreBigger) {
CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, 0);
IndirectHeap &cmdQueueDsh = pCmdQ->getIndirectHeap(IndirectHeap::DYNAMIC_STATE, 4096);
IndirectHeap &cmdQueueIsh = pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION, 4096);
IndirectHeap &cmdQueueIoh = pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT, 4096);
IndirectHeap &cmdQueueSsh = pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE, 4096);
@ -466,13 +465,12 @@ TEST_F(InternalsEventTest, resizeCmdQueueHeapsWhenKernelOparationHeapsAreBigger)
};
auto dsh = createFullHeap(requestedSize);
auto ish = createFullHeap(requestedSize);
auto ioh = createFullHeap(requestedSize);
auto ssh = createFullHeap(maxSshSize);
using UniqueIH = std::unique_ptr<IndirectHeap>;
auto kernelOperation = new KernelOperation(std::unique_ptr<LinearStream>(cmdStream), UniqueIH(dsh),
UniqueIH(ish), UniqueIH(ioh), UniqueIH(ssh));
UniqueIH(ioh), UniqueIH(ssh));
std::vector<Surface *> v;
SurfaceMock *surface = new SurfaceMock;
v.push_back(surface);
@ -481,14 +479,12 @@ TEST_F(InternalsEventTest, resizeCmdQueueHeapsWhenKernelOparationHeapsAreBigger)
std::unique_ptr<KernelOperation>(kernelOperation), v, false, false, false, nullptr, preemptionMode);
EXPECT_LT(cmdQueueDsh.getMaxAvailableSpace(), dsh->getMaxAvailableSpace());
EXPECT_EQ(requestedSize, ish->getMaxAvailableSpace());
EXPECT_LT(cmdQueueIoh.getMaxAvailableSpace(), ioh->getMaxAvailableSpace());
EXPECT_EQ(maxSshSize, ssh->getMaxAvailableSpace());
cmdComputeKernel->submit(0, false);
EXPECT_GE(cmdQueueDsh.getMaxAvailableSpace(), dsh->getMaxAvailableSpace());
EXPECT_GE(cmdQueueIsh.getMaxAvailableSpace(), ish->getMaxAvailableSpace());
EXPECT_GE(cmdQueueIoh.getMaxAvailableSpace(), ioh->getMaxAvailableSpace());
EXPECT_GE(cmdQueueSsh.getMaxAvailableSpace(), ssh->getMaxAvailableSpace());
@ -502,12 +498,11 @@ TEST_F(InternalsEventTest, processBlockedCommandsKernelOperation) {
auto cmdStream = new LinearStream(alignedMalloc(4096, 4096), 4096);
auto dsh = new IndirectHeap(alignedMalloc(4096, 4096), 4096);
auto ish = new IndirectHeap(alignedMalloc(4096, 4096), 4096);
auto ioh = new IndirectHeap(alignedMalloc(4096, 4096), 4096);
auto ssh = new IndirectHeap(alignedMalloc(4096, 4096), 4096);
using UniqueIH = std::unique_ptr<IndirectHeap>;
auto blockedCommandsData = new KernelOperation(std::unique_ptr<LinearStream>(cmdStream), UniqueIH(dsh),
UniqueIH(ish), UniqueIH(ioh), UniqueIH(ssh));
UniqueIH(ioh), UniqueIH(ssh));
auto &csr = pDevice->getCommandStreamReceiver();
std::vector<Surface *> v;
@ -540,12 +535,11 @@ TEST_F(InternalsEventTest, processBlockedCommandsAbortKernelOperation) {
auto cmdStream = new LinearStream(alignedMalloc(4096, 4096), 4096);
auto dsh = new IndirectHeap(alignedMalloc(4096, 4096), 4096);
auto ish = new IndirectHeap(alignedMalloc(4096, 4096), 4096);
auto ioh = new IndirectHeap(alignedMalloc(4096, 4096), 4096);
auto ssh = new IndirectHeap(alignedMalloc(4096, 4096), 4096);
using UniqueIH = std::unique_ptr<IndirectHeap>;
auto blockedCommandsData = new KernelOperation(std::unique_ptr<LinearStream>(cmdStream), UniqueIH(dsh),
UniqueIH(ish), UniqueIH(ioh), UniqueIH(ssh));
UniqueIH(ioh), UniqueIH(ssh));
auto &csr = pDevice->getCommandStreamReceiver();
std::vector<Surface *> v;
@ -572,12 +566,11 @@ TEST_F(InternalsEventTest, givenBlockedKernelWithPrintfWhenSubmittedThenPrintOut
auto cmdStream = new LinearStream(alignedMalloc(4096, 4096), 4096);
auto dsh = new IndirectHeap(alignedMalloc(4096, 4096), 4096);
auto ish = new IndirectHeap(alignedMalloc(4096, 4096), 4096);
auto ioh = new IndirectHeap(alignedMalloc(4096, 4096), 4096);
auto ssh = new IndirectHeap(alignedMalloc(4096, 4096), 4096);
using UniqueIH = std::unique_ptr<IndirectHeap>;
auto blockedCommandsData = new KernelOperation(std::unique_ptr<LinearStream>(cmdStream), UniqueIH(dsh),
UniqueIH(ish), UniqueIH(ioh), UniqueIH(ssh));
UniqueIH(ioh), UniqueIH(ssh));
SPatchAllocateStatelessPrintfSurface *pPrintfSurface = new SPatchAllocateStatelessPrintfSurface();
pPrintfSurface->DataParamOffset = 0;
@ -1485,12 +1478,11 @@ HWTEST_F(InternalsEventTest, givenAbortedCommandWhenSubmitCalledThenDontUpdateFl
auto cmdStream = new LinearStream(alignedMalloc(4096, 4096), 4096);
auto dsh = new IndirectHeap(alignedMalloc(4096, 4096), 4096);
auto ish = new IndirectHeap(alignedMalloc(4096, 4096), 4096);
auto ioh = new IndirectHeap(alignedMalloc(4096, 4096), 4096);
auto ssh = new IndirectHeap(alignedMalloc(4096, 4096), 4096);
using UniqueIH = std::unique_ptr<IndirectHeap>;
auto blockedCommandsData = new KernelOperation(std::unique_ptr<LinearStream>(cmdStream), UniqueIH(dsh),
UniqueIH(ish), UniqueIH(ioh), UniqueIH(ssh));
UniqueIH(ioh), UniqueIH(ssh));
PreemptionMode preemptionMode = pDevice->getPreemptionMode();
std::vector<Surface *> v;
auto cmd = new CommandComputeKernel(*pCmdQ, csr, std::unique_ptr<KernelOperation>(blockedCommandsData), v, false, false, false, nullptr, preemptionMode);

6
unit_tests/execution_model/scheduler_dispatch_tests.cpp
View File

@ -67,11 +67,9 @@ HWTEST_F(ExecutionModelSchedulerFixture, dispatchScheduler) {
EXPECT_NE(nullptr, executionModelDsh);
size_t minRequiredSizeForSchedulerIH = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::INSTRUCTION>(*parentKernel);
size_t minRequiredSizeForSchedulerSSH = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::SURFACE_STATE>(*parentKernel);
// Setup heaps in pCmdQ
LinearStream &commandStream = getCommandStream<FamilyType, CL_COMMAND_NDRANGE_KERNEL>(*pCmdQ, false, false, &scheduler);
pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION, minRequiredSizeForSchedulerIH);
pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE, minRequiredSizeForSchedulerSSH);
dispatchScheduler<FamilyType>(
@ -185,11 +183,9 @@ HWTEST_F(ExecutionModelSchedulerFixture, dispatchSchedulerDoesNotUseStandardCmdQ
DeviceQueueHw<FamilyType> *pDevQueueHw = castToObject<DeviceQueueHw<FamilyType>>(pDevQueue);
SchedulerKernel &scheduler = BuiltIns::getInstance().getSchedulerKernel(*context);
size_t minRequiredSizeForSchedulerIH = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::INSTRUCTION>(*parentKernel);
size_t minRequiredSizeForSchedulerSSH = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::SURFACE_STATE>(*parentKernel);
// Setup heaps in pCmdQ
getCommandStream<FamilyType, CL_COMMAND_NDRANGE_KERNEL>(*pCmdQ, false, false, &scheduler);
pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION, minRequiredSizeForSchedulerIH);
pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE, minRequiredSizeForSchedulerSSH);
dispatchScheduler<FamilyType>(
@ -218,11 +214,9 @@ HWTEST_F(ParentKernelCommandQueueFixture, dispatchSchedulerWithEarlyReturnSetToF
SchedulerKernel &scheduler = BuiltIns::getInstance().getSchedulerKernel(*context);
size_t minRequiredSizeForSchedulerIH = KernelCommandsHelper<FamilyType>::getSizeRequiredIH(scheduler);
size_t minRequiredSizeForSchedulerSSH = KernelCommandsHelper<FamilyType>::getSizeRequiredSSH(scheduler);
// Setup heaps in pCmdQ
LinearStream &commandStream = getCommandStream<FamilyType, CL_COMMAND_NDRANGE_KERNEL>(*pCmdQ, false, false, &scheduler);
pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION, minRequiredSizeForSchedulerIH);
pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE, minRequiredSizeForSchedulerSSH);
dispatchScheduler<FamilyType>(

25
unit_tests/execution_model/submit_blocked_parent_kernel_tests.cpp
View File

@ -65,9 +65,9 @@ class MockDeviceQueueHwWithCriticalSectionRelease : public DeviceQueueHw<GfxFami
return igilCmdQueue->m_controls.m_CriticalSection == DeviceQueueHw<GfxFamily>::ExecutionModelCriticalSection::Free;
}
void setupIndirectState(IndirectHeap &instructionHeap, IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentIDCount) override {
void setupIndirectState(IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentIDCount) override {
indirectStateSetup = true;
return BaseClass::setupIndirectState(instructionHeap, surfaceStateHeap, parentKernel, parentIDCount);
return BaseClass::setupIndirectState(surfaceStateHeap, parentKernel, parentIDCount);
}
void addExecutionModelCleanUpSection(Kernel *parentKernel, HwTimeStamps *hwTimeStamp, uint32_t taskCount) override {
cleanupSectionAdded = true;
@ -103,16 +103,13 @@ HWTEST_F(ParentKernelCommandQueueFixture, givenLockedEMcritcalSectionWhenParentK
IndirectHeap *dsh = new IndirectHeap(alignedMalloc(dshSize, alignement), dshSize);
dsh->getSpace(mockDevQueue.getDshOffset());
size_t minSizeISHForEM = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::INSTRUCTION>(*parentKernel);
size_t minSizeSSHForEM = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::SURFACE_STATE>(*parentKernel);
KernelOperation *blockedCommandData = new KernelOperation(std::unique_ptr<LinearStream>(new LinearStream()),
std::unique_ptr<IndirectHeap>(dsh),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)));
blockedCommandData->instructionHeapSizeEM = minSizeISHForEM;
blockedCommandData->surfaceStateHeapSizeEM = minSizeSSHForEM;
PreemptionMode preemptionMode = device->getPreemptionMode();
std::vector<Surface *> surfaces;
@ -166,13 +163,10 @@ HWTEST_F(ParentKernelCommandQueueFixture, givenParentKernelWhenCommandIsSubmitte
KernelOperation *blockedCommandData = new KernelOperation(std::unique_ptr<LinearStream>(new LinearStream()),
std::unique_ptr<IndirectHeap>(dsh),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)));
size_t minSizeISHForEM = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::INSTRUCTION>(*parentKernel);
size_t minSizeSSHForEM = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::SURFACE_STATE>(*parentKernel);
blockedCommandData->instructionHeapSizeEM = minSizeISHForEM;
blockedCommandData->surfaceStateHeapSizeEM = minSizeSSHForEM;
PreemptionMode preemptionMode = device->getPreemptionMode();
std::vector<Surface *> surfaces;
@ -211,13 +205,10 @@ HWTEST_F(ParentKernelCommandQueueFixture, givenParentKernelWhenCommandIsSubmitte
KernelOperation *blockedCommandData = new KernelOperation(std::unique_ptr<LinearStream>(new LinearStream()),
std::unique_ptr<IndirectHeap>(dsh),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)));
size_t minSizeISHForEM = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::INSTRUCTION>(*parentKernel);
size_t minSizeSSHForEM = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::SURFACE_STATE>(*parentKernel);
blockedCommandData->instructionHeapSizeEM = minSizeISHForEM;
blockedCommandData->surfaceStateHeapSizeEM = minSizeSSHForEM;
PreemptionMode preemptionMode = device->getPreemptionMode();
std::vector<Surface *> surfaces;
@ -251,13 +242,10 @@ HWTEST_F(ParentKernelCommandQueueFixture, givenBlockedParentKernelWithProfilingW
KernelOperation *blockedCommandData = new KernelOperation(std::unique_ptr<LinearStream>(new LinearStream()),
std::unique_ptr<IndirectHeap>(dsh),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)));
size_t minSizeISHForEM = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::INSTRUCTION>(*parentKernel);
size_t minSizeSSHForEM = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::SURFACE_STATE>(*parentKernel);
blockedCommandData->instructionHeapSizeEM = minSizeISHForEM;
blockedCommandData->surfaceStateHeapSizeEM = minSizeSSHForEM;
PreemptionMode preemptionMode = device->getPreemptionMode();
std::vector<Surface *> surfaces;
@ -294,13 +282,10 @@ HWTEST_F(ParentKernelCommandQueueFixture, givenParentKernelWhenCommandIsSubmitte
KernelOperation *blockedCommandData = new KernelOperation(std::unique_ptr<LinearStream>(new LinearStream()),
std::unique_ptr<IndirectHeap>(dsh),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)));
size_t minSizeISHForEM = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::INSTRUCTION>(*parentKernel);
size_t minSizeSSHForEM = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::SURFACE_STATE>(*parentKernel);
blockedCommandData->instructionHeapSizeEM = minSizeISHForEM;
blockedCommandData->surfaceStateHeapSizeEM = minSizeSSHForEM;
PreemptionMode preemptionMode = device->getPreemptionMode();
std::vector<Surface *> surfaces;
@ -326,7 +311,6 @@ HWTEST_F(ParentKernelCommandQueueFixture, givenUsedSSHWhenParentKernelIsSubmitte
MockCommandQueue cmdQ(context, device, properties);
size_t minSizeISHForEM = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::INSTRUCTION>(*parentKernel);
size_t minSizeSSHForEM = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::SURFACE_STATE>(*parentKernel);
size_t heapSize = 20;
@ -343,10 +327,8 @@ HWTEST_F(ParentKernelCommandQueueFixture, givenUsedSSHWhenParentKernelIsSubmitte
KernelOperation *blockedCommandData = new KernelOperation(std::unique_ptr<LinearStream>(new LinearStream()),
std::unique_ptr<IndirectHeap>(dsh),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)));
blockedCommandData->instructionHeapSizeEM = minSizeISHForEM;
blockedCommandData->surfaceStateHeapSizeEM = minSizeSSHForEM;
PreemptionMode preemptionMode = device->getPreemptionMode();
std::vector<Surface *> surfaces;
@ -370,7 +352,6 @@ HWTEST_F(ParentKernelCommandQueueFixture, givenNotUsedSSHWhenParentKernelIsSubmi
parentKernel->createReflectionSurface();
context->setDefaultDeviceQueue(&mockDevQueue);
size_t minSizeISHForEM = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::INSTRUCTION>(*parentKernel);
size_t minSizeSSHForEM = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::SURFACE_STATE>(*parentKernel);
size_t heapSize = 20;
@ -392,10 +373,8 @@ HWTEST_F(ParentKernelCommandQueueFixture, givenNotUsedSSHWhenParentKernelIsSubmi
KernelOperation *blockedCommandData = new KernelOperation(std::unique_ptr<LinearStream>(new LinearStream()),
std::unique_ptr<IndirectHeap>(dsh),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)),
std::unique_ptr<IndirectHeap>(new IndirectHeap(alignedMalloc(heapSize, alignement), heapSize)),
std::unique_ptr<IndirectHeap>(ssh));
blockedCommandData->instructionHeapSizeEM = minSizeISHForEM;
blockedCommandData->surfaceStateHeapSizeEM = minSizeSSHForEM;
PreemptionMode preemptionMode = device->getPreemptionMode();
std::vector<Surface *> surfaces;

2
unit_tests/gen8/scheduler_dispatch_tests.cpp
View File

@ -45,12 +45,10 @@ BDWTEST_F(BdwSchedulerTest, givenCallToDispatchSchedulerWhenPipeControlWithCSSta
DeviceQueueHw<FamilyType> *pDevQueueHw = castToObject<DeviceQueueHw<FamilyType>>(pDevQueue);
SchedulerKernel &scheduler = BuiltIns::getInstance().getSchedulerKernel(*context);
size_t minRequiredSizeForSchedulerIH = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::INSTRUCTION>(*parentKernel);
size_t minRequiredSizeForSchedulerSSH = KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::SURFACE_STATE>(*parentKernel);
// Setup heaps in pCmdQ
LinearStream &commandStream = getCommandStream<FamilyType, CL_COMMAND_NDRANGE_KERNEL>(*pCmdQ, false, false, &scheduler);
pCmdQ->getIndirectHeap(IndirectHeap::INSTRUCTION, minRequiredSizeForSchedulerIH);
pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE, minRequiredSizeForSchedulerSSH);
dispatchScheduler<FamilyType>(

41
unit_tests/helpers/kernel_commands_tests.cpp
View File

@ -800,49 +800,8 @@ HWTEST_F(KernelCommandsTest, GivenKernelWithSamplersWhenIndirectStateIsProgramme
delete[] mockDsh;
}
HWTEST_F(KernelCommandsTest, getSizeRequiredIHForExecutionModelReturnsZeroForNonParentKernel) {
// define kernel info
std::unique_ptr<KernelInfo> pKernelInfo = std::unique_ptr<KernelInfo>(KernelInfo::create());
// create program with valid context
MockContext context;
MockProgram program(&context, false);
// create kernel
std::unique_ptr<MockKernel> pKernel = std::unique_ptr<MockKernel>(new MockKernel(&program, *pKernelInfo.get(), *pDevice));
EXPECT_FALSE(pKernel->isParentKernel);
EXPECT_EQ(0u, KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::INSTRUCTION>(*pKernel.get()));
}
typedef ExecutionModelKernelFixture ParentKernelCommandsFromBinaryTest;
HWTEST_P(ParentKernelCommandsFromBinaryTest, getSizeRequiredForExecutionModelReturnsTotalBlockBinarySizeAndSchedulerBinarySize) {
if (std::string(pPlatform->getDevice(0)->getDeviceInfo().clVersion).find("OpenCL 2.") != std::string::npos) {
EXPECT_TRUE(pKernel->isParentKernel);
size_t totalSize = 0;
BlockKernelManager *blockManager = pKernel->getProgram()->getBlockKernelManager();
uint32_t blockCount = static_cast<uint32_t>(blockManager->getCount());
totalSize = Kernel::kernelBinaryAlignement - 1; // for initial alignment
for (uint32_t i = 0; i < blockCount; i++) {
const KernelInfo *pBlockInfo = blockManager->getBlockKernelInfo(i);
totalSize += pBlockInfo->heapInfo.pKernelHeader->KernelHeapSize;
totalSize = alignUp(totalSize, Kernel::kernelBinaryAlignement);
}
BuiltIns &builtIns = BuiltIns::getInstance();
auto &scheduler = builtIns.getSchedulerKernel(*pContext);
totalSize += KernelCommandsHelper<FamilyType>::getSizeRequiredIH(scheduler);
EXPECT_EQ(totalSize, KernelCommandsHelper<FamilyType>::template getSizeRequiredForExecutionModel<IndirectHeap::INSTRUCTION>(*pKernel));
}
}
HWTEST_P(ParentKernelCommandsFromBinaryTest, getSizeRequiredForExecutionModelForSurfaceStatesReturnsSizeOfBlocksPlusMaxBindingTableSizeForAllIDTEntriesAndSchedulerSSHSize) {
using BINDING_TABLE_STATE = typename FamilyType::BINDING_TABLE_STATE;