1 /*
2 * Copyright (C) 2019-2021 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "shared/test/common/cmd_parse/hw_parse.h"
9 #include "shared/test/common/test_macros/test.h"
10
11 #include "opencl/test/unit_test/helpers/cmd_buffer_validator.h"
12
13 using HwParseTest = ::testing::Test;
14
15 using namespace NEO;
16
HWTEST_F(HwParseTest,WhenEmptyBufferThenDontExpectCommands)17 HWTEST_F(HwParseTest, WhenEmptyBufferThenDontExpectCommands) {
18 using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
19 bool cmdBuffOk = false;
20
21 GenCmdList::iterator beg, end;
22 end = beg;
23 cmdBuffOk = expectCmdBuff<FamilyType>(beg, end,
24 std::vector<MatchCmd *>{});
25 EXPECT_TRUE(cmdBuffOk);
26
27 cmdBuffOk = expectCmdBuff<FamilyType>(beg, end,
28 std::vector<MatchCmd *>{
29 new MatchHwCmd<FamilyType, PIPE_CONTROL>(0),
30 });
31 EXPECT_TRUE(cmdBuffOk);
32
33 cmdBuffOk = expectCmdBuff<FamilyType>(beg, end,
34 std::vector<MatchCmd *>{
35 new MatchHwCmd<FamilyType, PIPE_CONTROL>(AnyNumber),
36 });
37 EXPECT_TRUE(cmdBuffOk);
38
39 cmdBuffOk = expectCmdBuff<FamilyType>(beg, end,
40 std::vector<MatchCmd *>{
41 new MatchHwCmd<FamilyType, PIPE_CONTROL>(AtLeastOne),
42 });
43 EXPECT_FALSE(cmdBuffOk);
44
45 cmdBuffOk = expectCmdBuff<FamilyType>(beg, end,
46 std::vector<MatchCmd *>{
47 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1),
48 });
49 EXPECT_FALSE(cmdBuffOk);
50 }
51
HWTEST_F(HwParseTest,WhenExpectingAnyCommandThenAllCommandsAreValidAsLongAsTheCountMatches)52 HWTEST_F(HwParseTest, WhenExpectingAnyCommandThenAllCommandsAreValidAsLongAsTheCountMatches) {
53 using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
54 using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS;
55 bool cmdBuffOk = false;
56 char buffer[8192];
57 LinearStream stream{alignUp(buffer, 4096), 4096};
58 *stream.getSpaceForCmd<PIPE_CONTROL>() = FamilyType::cmdInitPipeControl;
59 *stream.getSpaceForCmd<STATE_BASE_ADDRESS>() = FamilyType::cmdInitStateBaseAddress;
60 *stream.getSpaceForCmd<PIPE_CONTROL>() = FamilyType::cmdInitPipeControl;
61
62 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
63 std::vector<MatchCmd *>{
64 new MatchAnyCmd(1),
65 new MatchAnyCmd(1),
66 new MatchAnyCmd(1)});
67 EXPECT_TRUE(cmdBuffOk);
68
69 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
70 std::vector<MatchCmd *>{
71 new MatchAnyCmd(AtLeastOne),
72 });
73 EXPECT_TRUE(cmdBuffOk);
74
75 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
76 std::vector<MatchCmd *>{
77 new MatchAnyCmd(AnyNumber),
78 });
79 EXPECT_TRUE(cmdBuffOk);
80
81 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
82 std::vector<MatchCmd *>{
83 new MatchAnyCmd(1),
84 new MatchAnyCmd(1),
85 new MatchAnyCmd(1),
86 new MatchAnyCmd(1)});
87 EXPECT_FALSE(cmdBuffOk);
88
89 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
90 std::vector<MatchCmd *>{
91 new MatchAnyCmd(1),
92 new MatchAnyCmd(1),
93 new MatchAnyCmd(1),
94 new MatchAnyCmd(AtLeastOne)});
95 EXPECT_FALSE(cmdBuffOk);
96
97 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
98 std::vector<MatchCmd *>{
99 new MatchAnyCmd(1),
100 new MatchAnyCmd(1),
101 new MatchAnyCmd(1),
102 new MatchAnyCmd(AnyNumber)});
103 EXPECT_TRUE(cmdBuffOk);
104
105 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
106 std::vector<MatchCmd *>{
107 new MatchAnyCmd(AtLeastOne),
108 new MatchAnyCmd(1)});
109 EXPECT_FALSE(cmdBuffOk);
110
111 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
112 std::vector<MatchCmd *>{
113 new MatchAnyCmd(AnyNumber),
114 new MatchAnyCmd(1)});
115 EXPECT_FALSE(cmdBuffOk);
116
117 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
118 std::vector<MatchCmd *>{
119 new MatchAnyCmd(1),
120 new MatchAnyCmd(1),
121 });
122 EXPECT_FALSE(cmdBuffOk);
123
124 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
125 std::vector<MatchCmd *>{
126 new MatchAnyCmd(1)});
127 EXPECT_FALSE(cmdBuffOk);
128 }
129
HWTEST_F(HwParseTest,WhenExpectingSpecificSetOfCommandsThenNoOtherCommandBufferIsValid)130 HWTEST_F(HwParseTest, WhenExpectingSpecificSetOfCommandsThenNoOtherCommandBufferIsValid) {
131 using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
132 using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS;
133 bool cmdBuffOk = false;
134 char buffer[8192];
135 LinearStream stream{alignUp(buffer, 4096), 4096};
136 *stream.getSpaceForCmd<PIPE_CONTROL>() = FamilyType::cmdInitPipeControl;
137 *stream.getSpaceForCmd<STATE_BASE_ADDRESS>() = FamilyType::cmdInitStateBaseAddress;
138 *stream.getSpaceForCmd<PIPE_CONTROL>() = FamilyType::cmdInitPipeControl;
139
140 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
141 std::vector<MatchCmd *>{
142 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1),
143 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(1),
144 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1)});
145 EXPECT_TRUE(cmdBuffOk);
146
147 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
148 std::vector<MatchCmd *>{
149 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1),
150 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(1),
151 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1),
152 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1)});
153 EXPECT_FALSE(cmdBuffOk);
154
155 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
156 std::vector<MatchCmd *>{
157 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1),
158 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(1),
159 });
160 EXPECT_FALSE(cmdBuffOk);
161
162 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
163 std::vector<MatchCmd *>{
164 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1),
165 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1),
166 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(1),
167 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1)});
168 EXPECT_FALSE(cmdBuffOk);
169
170 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
171 std::vector<MatchCmd *>{
172 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1),
173 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1),
174 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1)});
175 EXPECT_FALSE(cmdBuffOk);
176
177 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
178 std::vector<MatchCmd *>{
179 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1),
180 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(1),
181 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(1)});
182 EXPECT_FALSE(cmdBuffOk);
183 }
184
HWTEST_F(HwParseTest,WhenExpectingAnyNumberOfCommandsThenOnlyTypeOfCommandMatters)185 HWTEST_F(HwParseTest, WhenExpectingAnyNumberOfCommandsThenOnlyTypeOfCommandMatters) {
186 using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
187 using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS;
188 bool cmdBuffOk = false;
189 char buffer[8192];
190 LinearStream stream{alignUp(buffer, 4096), 4096};
191 *stream.getSpaceForCmd<PIPE_CONTROL>() = FamilyType::cmdInitPipeControl;
192 *stream.getSpaceForCmd<STATE_BASE_ADDRESS>() = FamilyType::cmdInitStateBaseAddress;
193 *stream.getSpaceForCmd<STATE_BASE_ADDRESS>() = FamilyType::cmdInitStateBaseAddress;
194 *stream.getSpaceForCmd<STATE_BASE_ADDRESS>() = FamilyType::cmdInitStateBaseAddress;
195 *stream.getSpaceForCmd<STATE_BASE_ADDRESS>() = FamilyType::cmdInitStateBaseAddress;
196 *stream.getSpaceForCmd<PIPE_CONTROL>() = FamilyType::cmdInitPipeControl;
197
198 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
199 std::vector<MatchCmd *>{
200 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1),
201 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(1),
202 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(1),
203 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(1),
204 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(1),
205 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1)});
206 EXPECT_TRUE(cmdBuffOk);
207
208 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
209 std::vector<MatchCmd *>{
210 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1),
211 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(1),
212 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1)});
213 EXPECT_FALSE(cmdBuffOk);
214
215 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
216 std::vector<MatchCmd *>{
217 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1),
218 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(AnyNumber),
219 new MatchHwCmd<FamilyType, PIPE_CONTROL>(1)});
220 EXPECT_TRUE(cmdBuffOk);
221
222 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
223 std::vector<MatchCmd *>{
224 new MatchHwCmd<FamilyType, PIPE_CONTROL>(AnyNumber),
225 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(AnyNumber),
226 new MatchHwCmd<FamilyType, PIPE_CONTROL>(AnyNumber)});
227 EXPECT_TRUE(cmdBuffOk);
228
229 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
230 std::vector<MatchCmd *>{
231 new MatchHwCmd<FamilyType, PIPE_CONTROL>(AtLeastOne),
232 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(AtLeastOne),
233 new MatchHwCmd<FamilyType, PIPE_CONTROL>(AtLeastOne)});
234 EXPECT_TRUE(cmdBuffOk);
235
236 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
237 std::vector<MatchCmd *>{
238 new MatchHwCmd<FamilyType, PIPE_CONTROL>(AtLeastOne),
239 new MatchHwCmd<FamilyType, PIPE_CONTROL>(AtLeastOne),
240 new MatchHwCmd<FamilyType, PIPE_CONTROL>(AtLeastOne),
241 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(AtLeastOne),
242 new MatchHwCmd<FamilyType, PIPE_CONTROL>(AtLeastOne),
243 });
244 EXPECT_FALSE(cmdBuffOk);
245
246 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
247 std::vector<MatchCmd *>{
248 new MatchHwCmd<FamilyType, PIPE_CONTROL>(AnyNumber),
249 new MatchHwCmd<FamilyType, PIPE_CONTROL>(0),
250 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(AnyNumber),
251 new MatchHwCmd<FamilyType, PIPE_CONTROL>(AnyNumber),
252 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(0)});
253 EXPECT_TRUE(cmdBuffOk);
254 }
255
HWTEST_F(HwParseTest,WhenCommandMemberValidatorFailsThenCommandBufferValidationFails)256 HWTEST_F(HwParseTest, WhenCommandMemberValidatorFailsThenCommandBufferValidationFails) {
257 using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
258 using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS;
259 bool cmdBuffOk = false;
260 char buffer[8192];
261 LinearStream stream{alignUp(buffer, 4096), 4096};
262 *stream.getSpaceForCmd<PIPE_CONTROL>() = FamilyType::cmdInitPipeControl;
263 auto sba = stream.getSpaceForCmd<STATE_BASE_ADDRESS>();
264 *sba = FamilyType::cmdInitStateBaseAddress;
265 sba->setGeneralStateBaseAddressModifyEnable(true);
266 *stream.getSpaceForCmd<PIPE_CONTROL>() = FamilyType::cmdInitPipeControl;
267
268 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
269 std::vector<MatchCmd *>{
270 new MatchHwCmd<FamilyType, PIPE_CONTROL>(AnyNumber),
271 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(AnyNumber, Expects{EXPECT_MEMBER(STATE_BASE_ADDRESS, getGeneralStateBaseAddressModifyEnable, true)}),
272 new MatchHwCmd<FamilyType, PIPE_CONTROL>(AnyNumber)});
273 EXPECT_TRUE(cmdBuffOk);
274
275 cmdBuffOk = expectCmdBuff<FamilyType>(stream, 0,
276 std::vector<MatchCmd *>{
277 new MatchHwCmd<FamilyType, PIPE_CONTROL>(AnyNumber),
278 new MatchHwCmd<FamilyType, STATE_BASE_ADDRESS>(AnyNumber, Expects{EXPECT_MEMBER(STATE_BASE_ADDRESS, getGeneralStateBaseAddressModifyEnable, false)}),
279 new MatchHwCmd<FamilyType, PIPE_CONTROL>(AnyNumber)});
280 EXPECT_FALSE(cmdBuffOk);
281 }
282