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