Skip to content

Commit 2be5934

Browse files
MichalMrozekMichalMrozek
committed
[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
1 parent f2b96fa commit 2be5934

21 files changed

+52
-280
lines changed

‎runtime/command_queue/dispatch_walker.h‎

Lines changed: 4 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -438,7 +438,7 @@ void dispatchWalker(
438438
unsigned int commandType = 0) {
439439

440440
OCLRT::LinearStream *commandStream = nullptr;
441-
OCLRT::IndirectHeap *dsh = nullptr, *ish = nullptr, *ioh = nullptr, *ssh = nullptr;
441+
OCLRT::IndirectHeap *dsh = nullptr, *ioh = nullptr, *ssh = nullptr;
442442
bool executionModelKernel = multiDispatchInfo.begin()->getKernel()->isParentKernel;
443443

444444
for (auto &dispatchInfo : multiDispatchInfo) {
@@ -450,7 +450,6 @@ void dispatchWalker(
450450
}
451451

452452
// Allocate command stream and indirect heaps
453-
size_t cmdQInstructionHeapReservedBlockSize = 0;
454453
if (blockQueue) {
455454
using KCH = KernelCommandsHelper<GfxFamily>;
456455
commandStream = new LinearStream(alignedMalloc(MemoryConstants::pageSize, MemoryConstants::pageSize), MemoryConstants::pageSize);
@@ -465,13 +464,10 @@ void dispatchWalker(
465464
dsh = allocateIndirectHeap([&multiDispatchInfo] { return KCH::getTotalSizeRequiredDSH(multiDispatchInfo); });
466465
ioh = allocateIndirectHeap([&multiDispatchInfo] { return KCH::getTotalSizeRequiredIOH(multiDispatchInfo); });
467466
}
468-
ish = allocateIndirectHeap([&multiDispatchInfo] { return KCH::getTotalSizeRequiredIH(multiDispatchInfo); });
469-
cmdQInstructionHeapReservedBlockSize = commandQueue.getInstructionHeapReservedBlockSize();
470467

471468
ssh = allocateIndirectHeap([&multiDispatchInfo] { return KCH::getTotalSizeRequiredSSH(multiDispatchInfo); });
472469
using UniqueIH = std::unique_ptr<IndirectHeap>;
473-
*blockedCommandsData = new KernelOperation(std::unique_ptr<LinearStream>(commandStream), UniqueIH(dsh),
474-
UniqueIH(ish), UniqueIH(ioh), UniqueIH(ssh));
470+
*blockedCommandsData = new KernelOperation(std::unique_ptr<LinearStream>(commandStream), UniqueIH(dsh), UniqueIH(ioh), UniqueIH(ssh));
475471
if (executionModelKernel) {
476472
(*blockedCommandsData)->doNotFreeISH = true;
477473
}
@@ -481,7 +477,6 @@ void dispatchWalker(
481477
commandQueue.releaseIndirectHeap(IndirectHeap::SURFACE_STATE);
482478
}
483479
dsh = &getIndirectHeap<GfxFamily, IndirectHeap::DYNAMIC_STATE>(commandQueue, multiDispatchInfo);
484-
ish = &getIndirectHeap<GfxFamily, IndirectHeap::INSTRUCTION>(commandQueue, multiDispatchInfo);
485480
ioh = &getIndirectHeap<GfxFamily, IndirectHeap::INDIRECT_OBJECT>(commandQueue, multiDispatchInfo);
486481
ssh = &getIndirectHeap<GfxFamily, IndirectHeap::SURFACE_STATE>(commandQueue, multiDispatchInfo);
487482
}
@@ -680,13 +675,12 @@ void dispatchScheduler(
680675
using MI_BATCH_BUFFER_START = typename GfxFamily::MI_BATCH_BUFFER_START;
681676

682677
OCLRT::LinearStream *commandStream = nullptr;
683-
OCLRT::IndirectHeap *dsh = nullptr, *ish = nullptr, *ioh = nullptr, *ssh = nullptr;
678+
OCLRT::IndirectHeap *dsh = nullptr, *ioh = nullptr, *ssh = nullptr;
684679

685680
commandStream = &commandQueue.getCS(0);
686681
// note : below code assumes that caller to dispatchScheduler "preallocated" memory
687682
// required for execution model in below heap managers
688683
dsh = devQueueHw.getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
689-
ish = &commandQueue.getIndirectHeap(IndirectHeap::INSTRUCTION);
690684
ssh = &commandQueue.getIndirectHeap(IndirectHeap::SURFACE_STATE);
691685

692686
bool dcFlush = false;
@@ -919,14 +913,13 @@ IndirectHeap &getIndirectHeap(CommandQueue &commandQueue, const MultiDispatchInf
919913
// clang-format off
920914
switch(heapType) {
921915
case IndirectHeap::DYNAMIC_STATE: expectedSize = KernelCommandsHelper<GfxFamily>::getTotalSizeRequiredDSH(multiDispatchInfo); break;
922-
case IndirectHeap::INSTRUCTION: expectedSize = KernelCommandsHelper<GfxFamily>::getTotalSizeRequiredIH( multiDispatchInfo); break;
923916
case IndirectHeap::INDIRECT_OBJECT: expectedSize = KernelCommandsHelper<GfxFamily>::getTotalSizeRequiredIOH(multiDispatchInfo); break;
924917
case IndirectHeap::SURFACE_STATE: expectedSize = KernelCommandsHelper<GfxFamily>::getTotalSizeRequiredSSH(multiDispatchInfo); break;
925918
}
926919
// clang-format on
927920

928921
if (multiDispatchInfo.begin()->getKernel()->isParentKernel) {
929-
if (heapType == IndirectHeap::INSTRUCTION || heapType == IndirectHeap::SURFACE_STATE) {
922+
if (heapType == IndirectHeap::SURFACE_STATE) {
930923
expectedSize += KernelCommandsHelper<GfxFamily>::template getSizeRequiredForExecutionModel<heapType>(const_cast<const Kernel &>(*(multiDispatchInfo.begin()->getKernel())));
931924
} else //if (heapType == IndirectHeap::DYNAMIC_STATE || heapType == IndirectHeap::INDIRECT_OBJECT)
932925
{

‎runtime/command_queue/enqueue_common.h‎

Lines changed: 1 addition & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -271,12 +271,10 @@ void CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
271271
CompletionStamp completionStamp;
272272
if (!blockQueue) {
273273
if (executionModelKernel) {
274-
size_t minSizeISHForEM = KernelCommandsHelper<GfxFamily>::template getSizeRequiredForExecutionModel<IndirectHeap::INSTRUCTION>(const_cast<const Kernel &>(*(multiDispatchInfo.begin()->getKernel())));
275274
size_t minSizeSSHForEM = KernelCommandsHelper<GfxFamily>::template getSizeRequiredForExecutionModel<IndirectHeap::SURFACE_STATE>(const_cast<const Kernel &>(*(multiDispatchInfo.begin()->getKernel())));
276275

277276
uint32_t taskCount = commandStreamReceiver.peekTaskCount() + 1;
278-
devQueueHw->setupExecutionModelDispatch(getIndirectHeap(IndirectHeap::INSTRUCTION, minSizeISHForEM),
279-
getIndirectHeap(IndirectHeap::SURFACE_STATE, minSizeSSHForEM),
277+
devQueueHw->setupExecutionModelDispatch(getIndirectHeap(IndirectHeap::SURFACE_STATE, minSizeSSHForEM),
280278
multiDispatchInfo.begin()->getKernel(),
281279
(uint32_t)multiDispatchInfo.size(),
282280
taskCount,
@@ -385,9 +383,7 @@ void CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
385383

386384
if (blockQueue) {
387385
if (executionModelKernel) {
388-
size_t minSizeISHForEM = KernelCommandsHelper<GfxFamily>::template getSizeRequiredForExecutionModel<IndirectHeap::INSTRUCTION>(const_cast<const Kernel &>(*(multiDispatchInfo.begin()->getKernel())));
389386
size_t minSizeSSHForEM = KernelCommandsHelper<GfxFamily>::template getSizeRequiredForExecutionModel<IndirectHeap::SURFACE_STATE>(const_cast<const Kernel &>(*(multiDispatchInfo.begin()->getKernel())));
390-
blockedCommandsData->instructionHeapSizeEM = minSizeISHForEM;
391387
blockedCommandsData->surfaceStateHeapSizeEM = minSizeSSHForEM;
392388
}
393389

‎runtime/device_queue/device_queue.cpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -156,12 +156,12 @@ void DeviceQueue::initDeviceQueue() {
156156
igilEventPool->m_size = caps.maxOnDeviceEvents;
157157
}
158158

159-
void DeviceQueue::setupExecutionModelDispatch(IndirectHeap &instructionHeap, IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentCount, uint32_t taskCount, HwTimeStamps *hwTimeStamp) {
160-
setupIndirectState(instructionHeap, surfaceStateHeap, parentKernel, parentCount);
159+
void DeviceQueue::setupExecutionModelDispatch(IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentCount, uint32_t taskCount, HwTimeStamps *hwTimeStamp) {
160+
setupIndirectState(surfaceStateHeap, parentKernel, parentCount);
161161
addExecutionModelCleanUpSection(parentKernel, hwTimeStamp, taskCount);
162162
}
163163

164-
void DeviceQueue::setupIndirectState(IndirectHeap &instructionHeap, IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentIDCount) {
164+
void DeviceQueue::setupIndirectState(IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentIDCount) {
165165
return;
166166
}
167167

‎runtime/device_queue/device_queue.h‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -81,9 +81,9 @@ class DeviceQueue : public BaseObject<_device_queue> {
8181
size_t paramValueSize, void *paramValue,
8282
size_t *paramValueSizeRet);
8383

84-
void setupExecutionModelDispatch(IndirectHeap &instructionHeap, IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentCount, uint32_t taskCount, HwTimeStamps *hwTimeStamp);
84+
void setupExecutionModelDispatch(IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentCount, uint32_t taskCount, HwTimeStamps *hwTimeStamp);
8585

86-
virtual void setupIndirectState(IndirectHeap &instructionHeap, IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentIDCount);
86+
virtual void setupIndirectState(IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentIDCount);
8787
virtual void addExecutionModelCleanUpSection(Kernel *parentKernel, HwTimeStamps *hwTimeStamp, uint32_t taskCount);
8888

8989
MOCKABLE_VIRTUAL bool isEMCriticalSectionFree() {

‎runtime/device_queue/device_queue_hw.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -72,7 +72,7 @@ class DeviceQueueHw : public DeviceQueue {
7272

7373
size_t setSchedulerCrossThreadData(SchedulerKernel &scheduler);
7474

75-
void setupIndirectState(IndirectHeap &instructionHeap, IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentIDCount) override;
75+
void setupIndirectState(IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentIDCount) override;
7676

7777
void addExecutionModelCleanUpSection(Kernel *parentKernel, HwTimeStamps *hwTimeStamp, uint32_t taskCount) override;
7878
void resetDeviceQueue() override;

‎runtime/device_queue/device_queue_hw.inl‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -291,7 +291,7 @@ IndirectHeap *DeviceQueueHw<GfxFamily>::getIndirectHeap(IndirectHeap::Type type)
291291
}
292292

293293
template <typename GfxFamily>
294-
void DeviceQueueHw<GfxFamily>::setupIndirectState(IndirectHeap &instructionHeap, IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentIDCount) {
294+
void DeviceQueueHw<GfxFamily>::setupIndirectState(IndirectHeap &surfaceStateHeap, Kernel *parentKernel, uint32_t parentIDCount) {
295295
void *pDSH = dshBuffer->getUnderlyingBuffer();
296296

297297
// Heap and dshBuffer shoud be the same if heap is created

‎runtime/helpers/kernel_commands.h‎

Lines changed: 23 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -105,8 +105,6 @@ struct KernelCommandsHelper : public PerThreadDataHelper {
105105
static bool isPipeControlWArequired();
106106
static size_t getSizeRequiredDSH(
107107
const Kernel &kernel);
108-
static size_t getSizeRequiredIH(
109-
const Kernel &kernel);
110108
static size_t getSizeRequiredIOH(
111109
const Kernel &kernel,
112110
size_t localWorkSize = 256);
@@ -115,8 +113,6 @@ struct KernelCommandsHelper : public PerThreadDataHelper {
115113

116114
static size_t getTotalSizeRequiredDSH(
117115
const MultiDispatchInfo &multiDispatchInfo);
118-
static size_t getTotalSizeRequiredIH(
119-
const MultiDispatchInfo &multiDispatchInfo);
120116
static size_t getTotalSizeRequiredIOH(
121117
const MultiDispatchInfo &multiDispatchInfo);
122118
static size_t getTotalSizeRequiredSSH(
@@ -127,46 +123,33 @@ struct KernelCommandsHelper : public PerThreadDataHelper {
127123
typedef typename GfxFamily::BINDING_TABLE_STATE BINDING_TABLE_STATE;
128124

129125
size_t totalSize = 0;
130-
if (kernel.isParentKernel) {
131-
BlockKernelManager *blockManager = kernel.getProgram()->getBlockKernelManager();
132-
uint32_t blockCount = static_cast<uint32_t>(blockManager->getCount());
133-
uint32_t maxBindingTableCount = 0;
134-
135-
if (heapType == IndirectHeap::SURFACE_STATE || heapType == IndirectHeap::INSTRUCTION) {
136-
if (heapType == IndirectHeap::SURFACE_STATE) {
137-
totalSize = BINDING_TABLE_STATE::SURFACESTATEPOINTER_ALIGN_SIZE - 1;
138-
} else {
139-
totalSize = Kernel::kernelBinaryAlignement - 1;
140-
}
141-
142-
for (uint32_t i = 0; i < blockCount; i++) {
143-
const KernelInfo *pBlockInfo = blockManager->getBlockKernelInfo(i);
144-
if (heapType == IndirectHeap::SURFACE_STATE) {
145-
totalSize += pBlockInfo->heapInfo.pKernelHeader->SurfaceStateHeapSize;
146-
totalSize = alignUp(totalSize, BINDING_TABLE_STATE::SURFACESTATEPOINTER_ALIGN_SIZE);
147-
148-
maxBindingTableCount = std::max(maxBindingTableCount, pBlockInfo->patchInfo.bindingTableState->Count);
149-
} else {
150-
totalSize += pBlockInfo->heapInfo.pKernelHeader->KernelHeapSize;
151-
totalSize = alignUp(totalSize, Kernel::kernelBinaryAlignement);
152-
}
153-
}
126+
BlockKernelManager *blockManager = kernel.getProgram()->getBlockKernelManager();
127+
uint32_t blockCount = static_cast<uint32_t>(blockManager->getCount());
128+
uint32_t maxBindingTableCount = 0;
129+
130+
if (heapType == IndirectHeap::SURFACE_STATE) {
131+
totalSize = BINDING_TABLE_STATE::SURFACESTATEPOINTER_ALIGN_SIZE - 1;
132+
133+
for (uint32_t i = 0; i < blockCount; i++) {
134+
const KernelInfo *pBlockInfo = blockManager->getBlockKernelInfo(i);
135+
totalSize += pBlockInfo->heapInfo.pKernelHeader->SurfaceStateHeapSize;
136+
totalSize = alignUp(totalSize, BINDING_TABLE_STATE::SURFACESTATEPOINTER_ALIGN_SIZE);
137+
138+
maxBindingTableCount = std::max(maxBindingTableCount, pBlockInfo->patchInfo.bindingTableState->Count);
154139
}
140+
}
155141

156-
if (heapType == IndirectHeap::INSTRUCTION || heapType == IndirectHeap::INDIRECT_OBJECT || heapType == IndirectHeap::SURFACE_STATE) {
157-
BuiltIns &builtIns = BuiltIns::getInstance();
158-
SchedulerKernel &scheduler = builtIns.getSchedulerKernel(kernel.getContext());
142+
if (heapType == IndirectHeap::INDIRECT_OBJECT || heapType == IndirectHeap::SURFACE_STATE) {
143+
BuiltIns &builtIns = BuiltIns::getInstance();
144+
SchedulerKernel &scheduler = builtIns.getSchedulerKernel(kernel.getContext());
159145

160-
if (heapType == IndirectHeap::INSTRUCTION) {
161-
totalSize += getSizeRequiredIH(scheduler);
162-
} else if (heapType == IndirectHeap::INDIRECT_OBJECT) {
163-
totalSize += getSizeRequiredIOH(scheduler);
164-
} else {
165-
totalSize += getSizeRequiredSSH(scheduler);
146+
if (heapType == IndirectHeap::INDIRECT_OBJECT) {
147+
totalSize += getSizeRequiredIOH(scheduler);
148+
} else {
149+
totalSize += getSizeRequiredSSH(scheduler);
166150

167-
totalSize += maxBindingTableCount * sizeof(BINDING_TABLE_STATE) * DeviceQueue::interfaceDescriptorEntries;
168-
totalSize = alignUp(totalSize, BINDING_TABLE_STATE::SURFACESTATEPOINTER_ALIGN_SIZE);
169-
}
151+
totalSize += maxBindingTableCount * sizeof(BINDING_TABLE_STATE) * DeviceQueue::interfaceDescriptorEntries;
152+
totalSize = alignUp(totalSize, BINDING_TABLE_STATE::SURFACESTATEPOINTER_ALIGN_SIZE);
170153
}
171154
}
172155
return totalSize;

‎runtime/helpers/kernel_commands.inl‎

Lines changed: 0 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -93,13 +93,6 @@ size_t KernelCommandsHelper<GfxFamily>::getSizeRequiredIOH(
9393
GPGPU_WALKER::INDIRECTDATASTARTADDRESS_ALIGN_SIZE);
9494
}
9595

96-
template <typename GfxFamily>
97-
size_t KernelCommandsHelper<GfxFamily>::getSizeRequiredIH(
98-
const Kernel &kernel) {
99-
typedef typename GfxFamily::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;
100-
return kernel.getKernelHeapSize() + INTERFACE_DESCRIPTOR_DATA::KERNELSTARTPOINTER_ALIGN_SIZE;
101-
}
102-
10396
template <typename GfxFamily>
10497
size_t KernelCommandsHelper<GfxFamily>::getSizeRequiredSSH(
10598
const Kernel &kernel) {
@@ -126,12 +119,6 @@ size_t KernelCommandsHelper<GfxFamily>::getTotalSizeRequiredDSH(
126119
return getSizeRequired(multiDispatchInfo, [](const DispatchInfo &dispatchInfo) { return getSizeRequiredDSH(*dispatchInfo.getKernel()); });
127120
}
128121

129-
template <typename GfxFamily>
130-
size_t KernelCommandsHelper<GfxFamily>::getTotalSizeRequiredIH(
131-
const MultiDispatchInfo &multiDispatchInfo) {
132-
return getSizeRequired(multiDispatchInfo, [](const DispatchInfo &dispatchInfo) { return getSizeRequiredIH(*dispatchInfo.getKernel()); });
133-
}
134-
135122
template <typename GfxFamily>
136123
size_t KernelCommandsHelper<GfxFamily>::getTotalSizeRequiredIOH(
137124
const MultiDispatchInfo &multiDispatchInfo) {

‎runtime/helpers/task_information.cpp‎

Lines changed: 1 addition & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -36,7 +36,6 @@
3636
namespace OCLRT {
3737
KernelOperation::~KernelOperation() {
3838
alignedFree(dsh->getCpuBase());
39-
alignedFree(ish->getCpuBase());
4039
if (doNotFreeISH) {
4140
ioh.release();
4241
} else {
@@ -165,7 +164,6 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate
165164
memcpy_s(pDst, commandsSize, commandStream.getCpuBase(), commandsSize);
166165

167166
size_t requestedDshSize = kernelOperation->dsh->getUsed();
168-
size_t requestedIshSize = kernelOperation->ish->getUsed() + kernelOperation->instructionHeapSizeEM;
169167
size_t requestedIohSize = kernelOperation->ioh->getUsed();
170168
size_t requestedSshSize = kernelOperation->ssh->getUsed() + kernelOperation->surfaceStateHeapSizeEM;
171169

@@ -180,10 +178,6 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate
180178
}
181179
}
182180

183-
if (commandQueue.getIndirectHeap(IndirectHeap::INSTRUCTION, 0).getUsed() > commandQueue.getInstructionHeapReservedBlockSize()) {
184-
commandQueue.releaseIndirectHeap(IndirectHeap::INSTRUCTION);
185-
}
186-
187181
if (executionModelKernel) {
188182
dsh = devQueue->getIndirectHeap(IndirectHeap::DYNAMIC_STATE);
189183
// 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
202196
ioh->getSpace(requestedIohSize);
203197
}
204198

205-
IndirectHeap &ish = commandQueue.getIndirectHeap(IndirectHeap::INSTRUCTION, requestedIshSize);
206199
IndirectHeap &ssh = commandQueue.getIndirectHeap(IndirectHeap::SURFACE_STATE, requestedSshSize);
207200

208-
memcpy_s(ptrOffset(ish.getCpuBase(), commandQueue.getInstructionHeapReservedBlockSize()), requestedIshSize, kernelOperation->ish->getCpuBase(), kernelOperation->ish->getUsed());
209-
ish.getSpace(kernelOperation->ish->getUsed());
210-
211201
memcpy_s(ssh.getCpuBase(), requestedSshSize, kernelOperation->ssh->getCpuBase(), kernelOperation->ssh->getUsed());
212202
ssh.getSpace(kernelOperation->ssh->getUsed());
213203

@@ -224,7 +214,7 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate
224214

225215
if (executionModelKernel) {
226216
uint32_t taskCount = commandStreamReceiver.peekTaskCount() + 1;
227-
devQueue->setupExecutionModelDispatch(ish, ssh, kernel, kernelCount, taskCount, timestamp);
217+
devQueue->setupExecutionModelDispatch(ssh, kernel, kernelCount, taskCount, timestamp);
228218

229219
BuiltIns &builtIns = BuiltIns::getInstance();
230220
SchedulerKernel &scheduler = builtIns.getSchedulerKernel(commandQueue.getContext());

‎runtime/helpers/task_information.h‎

Lines changed: 3 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -77,22 +77,19 @@ class CommandMapUnmap : public Command {
7777
};
7878

7979
struct KernelOperation {
80-
KernelOperation(std::unique_ptr<LinearStream> commandStream, std::unique_ptr<IndirectHeap> dsh, std::unique_ptr<IndirectHeap> ish,
81-
std::unique_ptr<IndirectHeap> ioh, std::unique_ptr<IndirectHeap> ssh)
80+
KernelOperation(std::unique_ptr<LinearStream> commandStream, std::unique_ptr<IndirectHeap> dsh, std::unique_ptr<IndirectHeap> ioh, std::unique_ptr<IndirectHeap> ssh)
8281
: commandStream(std::move(commandStream)), dsh(std::move(dsh)),
83-
ish(std::move(ish)), ioh(std::move(ioh)), ssh(std::move(ssh)),
84-
instructionHeapSizeEM(0), surfaceStateHeapSizeEM(0), doNotFreeISH(false) {
82+
ioh(std::move(ioh)), ssh(std::move(ssh)),
83+
surfaceStateHeapSizeEM(0), doNotFreeISH(false) {
8584
}
8685

8786
~KernelOperation();
8887

8988
std::unique_ptr<LinearStream> commandStream;
9089
std::unique_ptr<IndirectHeap> dsh;
91-
std::unique_ptr<IndirectHeap> ish;
9290
std::unique_ptr<IndirectHeap> ioh;
9391
std::unique_ptr<IndirectHeap> ssh;
9492

95-
size_t instructionHeapSizeEM;
9693
size_t surfaceStateHeapSizeEM;
9794
bool doNotFreeISH;
9895
};

0 commit comments

Comments
 (0)