1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
/*
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/indirect_heap/indirect_heap.h"
#include "shared/source/program/kernel_info.h"
#include "shared/test/common/cmd_parse/hw_parse.h"
namespace NEO {
template <typename FamilyType>
void HardwareParse::findHardwareCommands(IndirectHeap *dsh) {
using GPGPU_WALKER = typename FamilyType::GPGPU_WALKER;
using PIPELINE_SELECT = typename FamilyType::PIPELINE_SELECT;
using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS;
using MEDIA_INTERFACE_DESCRIPTOR_LOAD = typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD;
using MEDIA_VFE_STATE = typename FamilyType::MEDIA_VFE_STATE;
using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START;
using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM;
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
itorWalker = find<GPGPU_WALKER *>(cmdList.begin(), cmdList.end());
if (itorWalker != cmdList.end()) {
cmdWalker = *itorWalker;
}
itorBBStartAfterWalker = find<MI_BATCH_BUFFER_START *>(itorWalker, cmdList.end());
if (itorBBStartAfterWalker != cmdList.end()) {
cmdBBStartAfterWalker = *itorBBStartAfterWalker;
}
for (auto it = cmdList.begin(); it != cmdList.end(); it++) {
auto lri = genCmdCast<MI_LOAD_REGISTER_IMM *>(*it);
if (lri) {
lriList.push_back(*it);
}
}
if (parsePipeControl) {
for (auto it = cmdList.begin(); it != cmdList.end(); it++) {
auto pipeControl = genCmdCast<PIPE_CONTROL *>(*it);
if (pipeControl) {
pipeControlList.push_back(*it);
}
}
}
MEDIA_INTERFACE_DESCRIPTOR_LOAD *cmdMIDL = nullptr;
itorMediaInterfaceDescriptorLoad = find<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(cmdList.begin(), itorWalker);
if (itorMediaInterfaceDescriptorLoad != itorWalker) {
cmdMIDL = (MEDIA_INTERFACE_DESCRIPTOR_LOAD *)*itorMediaInterfaceDescriptorLoad;
cmdMediaInterfaceDescriptorLoad = *itorMediaInterfaceDescriptorLoad;
}
itorPipelineSelect = find<PIPELINE_SELECT *>(cmdList.begin(), itorWalker);
if (itorPipelineSelect != itorWalker) {
cmdPipelineSelect = *itorPipelineSelect;
}
itorMediaVfeState = find<MEDIA_VFE_STATE *>(itorPipelineSelect, itorWalker);
if (itorMediaVfeState != itorWalker) {
cmdMediaVfeState = *itorMediaVfeState;
}
STATE_BASE_ADDRESS *cmdSBA = nullptr;
uint64_t dynamicStateHeap = 0;
itorStateBaseAddress = find<STATE_BASE_ADDRESS *>(cmdList.begin(), itorWalker);
if (itorStateBaseAddress != itorWalker) {
cmdSBA = (STATE_BASE_ADDRESS *)*itorStateBaseAddress;
cmdStateBaseAddress = *itorStateBaseAddress;
// Extract the dynamicStateHeap
dynamicStateHeap = cmdSBA->getDynamicStateBaseAddress();
if (dsh && (dsh->getHeapGpuBase() == dynamicStateHeap)) {
dynamicStateHeap = reinterpret_cast<uint64_t>(dsh->getCpuBase());
}
ASSERT_NE(0u, dynamicStateHeap);
}
// interfaceDescriptorData should be located within dynamicStateHeap
if constexpr (!FamilyType::isHeaplessRequired()) {
using INTERFACE_DESCRIPTOR_DATA = typename FamilyType::INTERFACE_DESCRIPTOR_DATA;
if (cmdMIDL && cmdSBA) {
auto iddStart = cmdMIDL->getInterfaceDescriptorDataStartAddress();
auto iddEnd = iddStart + cmdMIDL->getInterfaceDescriptorTotalLength();
ASSERT_LE(iddEnd, cmdSBA->getDynamicStateBufferSize() * MemoryConstants::pageSize);
// Extract the interfaceDescriptorData
cmdInterfaceDescriptorData = (INTERFACE_DESCRIPTOR_DATA *)(dynamicStateHeap + iddStart);
}
}
}
template <typename FamilyType>
void HardwareParse::findHardwareCommands() {
findHardwareCommands<FamilyType>(nullptr);
}
template <typename FamilyType>
const void *HardwareParse::getStatelessArgumentPointer(const KernelInfo &kernelInfo, uint32_t indexArg, IndirectHeap &ioh, uint32_t rootDeviceIndex) {
typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
auto cmdWalker = (GPGPU_WALKER *)this->cmdWalker;
EXPECT_NE(nullptr, cmdWalker);
auto cmdSBA = (STATE_BASE_ADDRESS *)cmdStateBaseAddress;
EXPECT_NE(nullptr, cmdSBA);
auto offsetCrossThreadData = cmdWalker->getIndirectDataStartAddress();
EXPECT_LT(offsetCrossThreadData, cmdSBA->getIndirectObjectBufferSize() * MemoryConstants::pageSize);
offsetCrossThreadData -= static_cast<uint32_t>(ioh.getGraphicsAllocation()->getGpuAddressToPatch());
// Get the base of cross thread
auto pCrossThreadData = ptrOffset(
reinterpret_cast<const void *>(ioh.getCpuBase()),
offsetCrossThreadData);
// Determine where the argument is
const auto &arg = kernelInfo.getArgDescriptorAt(indexArg);
if (arg.is<ArgDescriptor::argTPointer>() && isValidOffset(arg.as<ArgDescPointer>().stateless)) {
return ptrOffset(pCrossThreadData, arg.as<ArgDescPointer>().stateless);
}
return nullptr;
}
template <typename FamilyType>
const typename FamilyType::RENDER_SURFACE_STATE *HardwareParse::getSurfaceState(IndirectHeap *ssh, uint32_t index) {
if constexpr (!FamilyType::isHeaplessRequired()) {
typedef typename FamilyType::BINDING_TABLE_STATE BINDING_TABLE_STATE;
typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
const auto &interfaceDescriptorData = *(INTERFACE_DESCRIPTOR_DATA *)cmdInterfaceDescriptorData;
auto cmdSBA = (STATE_BASE_ADDRESS *)cmdStateBaseAddress;
auto surfaceStateHeap = cmdSBA->getSurfaceStateBaseAddress();
if (ssh && (ssh->getHeapGpuBase() == surfaceStateHeap)) {
surfaceStateHeap = reinterpret_cast<uint64_t>(ssh->getCpuBase());
}
EXPECT_NE(0u, surfaceStateHeap);
auto bindingTablePointer = interfaceDescriptorData.getBindingTablePointer();
const auto &bindingTableState = reinterpret_cast<BINDING_TABLE_STATE *>(surfaceStateHeap + bindingTablePointer)[index];
auto surfaceStatePointer = bindingTableState.getSurfaceStatePointer();
return (RENDER_SURFACE_STATE *)(surfaceStateHeap + surfaceStatePointer);
} else {
UNRECOVERABLE_IF(true);
return nullptr;
}
}
template <typename FamilyType>
bool HardwareParse::isStallingBarrier(GenCmdList::iterator &iter) {
PIPE_CONTROL *pipeControlCmd = genCmdCast<PIPE_CONTROL *>(*iter);
if (pipeControlCmd == nullptr) {
return false;
}
EXPECT_EQ(pipeControlCmd->getCommandStreamerStallEnable(), true);
EXPECT_EQ(pipeControlCmd->getDcFlushEnable(), false);
EXPECT_EQ(pipeControlCmd->getRenderTargetCacheFlushEnable(), false);
EXPECT_EQ(pipeControlCmd->getInstructionCacheInvalidateEnable(), false);
EXPECT_EQ(pipeControlCmd->getTextureCacheInvalidationEnable(), false);
EXPECT_EQ(pipeControlCmd->getPipeControlFlushEnable(), false);
EXPECT_EQ(pipeControlCmd->getVfCacheInvalidationEnable(), false);
EXPECT_EQ(pipeControlCmd->getConstantCacheInvalidationEnable(), false);
EXPECT_EQ(pipeControlCmd->getStateCacheInvalidationEnable(), false);
return true;
}
} // namespace NEO
|
