Debian Codegraph @

origami/tests/origami_gtest.cpp

raw
1 // Copyright Advanced Micro Devices, Inc., or its affiliates.
2 // SPDX-License-Identifier: MIT
3
4 #include "testing_origami.hpp"
5 #include <cctype>
6 #include <fstream>
7 #include <iostream>
8 #include <vector>
9
10 #ifndef _WIN32
11 #include <unistd.h>
12 #include <limits.h>
13 #else
14 #include <windows.h>
15 #endif
16
17 // Returns the directory path where the current executable resides.
18 // Adds a trailing slash ('/' on Linux, '\' on Windows) for easy file concatenation.
19 std::string getExecutableDir() {
20 #ifndef _WIN32
21 // Linux branch
22
23 char result[PATH_MAX]; // Buffer to store the path
24 ssize_t count = readlink("/proc/self/exe", result, PATH_MAX);
25 // readlink reads the symbolic link /proc/self/exe, which points to the current executable
26
27 if (count == -1) {
28 // If readlink fails, return empty string
29 return "";
30 }
31
32 result[count] = '\0'; // Null-terminate the buffer
33 std::string fullPath(result); // Convert to std::string
34
35 // Find the position of the last slash ('/') in the path
36 // This separates the directory from the binary name
37 size_t pos = fullPath.find_last_of('/');
38
39 // Extract the directory portion
40 std::string dir = (pos != std::string::npos) ? fullPath.substr(0, pos) : fullPath;
41
42 // Ensure the directory string ends with a slash
43 if (!dir.empty() && dir.back() != '/')
44 dir += '/';
45
46 return dir;
47
48 #else
49 // Windows branch
50
51 char path[MAX_PATH]; // Buffer to store the path
52 DWORD length = GetModuleFileNameA(NULL, path, MAX_PATH);
53 // GetModuleFileNameA returns the full path of the current executable
54
55 if (length == 0) {
56 // Failed to get the executable path
57 return "";
58 }
59
60 std::string fullPath(path, length); // Convert to std::string
61
62 // Find the position of the last backslash ('\') or forward slash ('/')
63 size_t pos = fullPath.find_last_of("\\/");
64
65 // Extract the directory portion
66 std::string dir = (pos != std::string::npos) ? fullPath.substr(0, pos) : fullPath;
67
68 // Ensure the directory string ends with a backslash
69 if (!dir.empty() && dir.back() != '\\' && dir.back() != '/')
70 dir += '\\';
71
72 return dir;
73 #endif
74 }
75
76 // Parse origami_gtest.yaml to get the test data
77 std::vector<MyTestData> parseYamlManually(const std::string& filename)
78 {
79 std::string YamlfullPath = getExecutableDir() + filename;
80 std::ifstream file(YamlfullPath);
81 if(!file)
82 {
83 std::cerr << "Failed to open file: " << YamlfullPath << std::endl;
84 return {};
85 }
86
87 std::string line;
88 std::vector<MyTestData> tests;
89 MyTestData current;
90 enum class State
91 {
92 None,
93 Inputs
94 } state
95 = State::None;
96 int line_number = 0;
97
98 while(std::getline(file, line))
99 {
100 line_number++;
101 line.erase(0, line.find_first_not_of(" \t\r\n"));
102 line.erase(line.find_last_not_of(" \t\r\n") + 1);
103
104 if(line.empty() || line[0] == '#')
105 continue;
106
107 if(line.rfind("- name:", 0) == 0)
108 {
109 if(!current.name.empty())
110 tests.push_back(current);
111 current = MyTestData{};
112 current.name = line.substr(7);
113 current.name.erase(0, current.name.find_first_not_of(" \t"));
114 state = State::None;
115 }
116 else if(line.rfind("inputs:", 0) == 0)
117 {
118 state = State::Inputs;
119 }
120 else if(state == State::Inputs && line.rfind("- {", 0) == 0)
121 {
122 std::string inner = line.substr(3);
123 if(!inner.empty() && inner.back() == '}')
124 inner.pop_back();
125
126 std::map<std::string, int> values;
127 std::optional<int> expected;
128 std::optional<int> expected_gt;
129 std::optional<int> expected_lt;
130
131 std::stringstream ss(inner);
132 std::string pair;
133 while(std::getline(ss, pair, ','))
134 {
135 auto colon = pair.find(':');
136 if(colon == std::string::npos)
137 continue;
138
139 std::string key = pair.substr(0, colon);
140 std::string val = pair.substr(colon + 1);
141 key.erase(0, key.find_first_not_of(" \t"));
142 key.erase(key.find_last_not_of(" \t") + 1);
143 val.erase(0, val.find_first_not_of(" \t"));
144 val.erase(val.find_last_not_of(" \t") + 1);
145
146 try
147 {
148 int num = std::stoi(val);
149 if(key == "expected")
150 expected = num;
151 else if(key == "expected_gt")
152 expected_gt = num;
153 else if(key == "expected_lt")
154 expected_lt = num;
155 else
156 values[key] = num;
157 }
158 catch(...)
159 {
160 std::cerr << "Invalid number in line " << line_number << ": " << val
161 << std::endl;
162 }
163 }
164
165 current.inputs.push_back(InputWithExpected{values, expected, expected_gt, expected_lt});
166 }
167 }
168
169 if(!current.name.empty())
170 tests.push_back(current);
171
172 return tests;
173 }
174
175 TEST_P(AnalyticalGtest, DynamicDispatch)
176 {
177 const MyTestData& test = GetParam();
178
179 const std::string gpuArchNumber = std::to_string(test.inputs[0].values.at("gpu_arch"));
180 auto gpuArchEnum = origami::hardware_t::arch_name_to_enum("gfx" + gpuArchNumber);
181
182 //TODO: Hardcoding numbers for gfx942. Future archs could be added here with if else loop.
183 auto gpuInfo = origami::hardware_t(
184 gpuArchEnum, 304, 65536, 8, 1.0, 1.0, 1.0, 4000000, 1.0, 1, std::make_tuple(0, 0.015, 0));
185
186 if(test.name == "ComputeLoads")
187 {
188 for(const auto& input_case : test.inputs)
189 {
190 ComputeLoads(input_case.values.at("M"), input_case.values.at("N"), input_case.values.at("K"), input_case.expected);
191 }
192 }
193 else if(test.name == "EstimateL2Hit")
194 {
195 for(const auto& input_case : test.inputs)
196 {
197 EstimateL2Hit(gpuInfo, input_case.values.at("M"), input_case.values.at("N"), input_case.values.at("K"), input_case.values.at("batch"),
198 input_case.values.at("MT_M"), input_case.values.at("MT_N"), input_case.values.at("MT_K"), input_case.values.at("element_size"),
199 input_case.values.at("splittingFactor"),input_case.expected_gt, input_case.expected_lt);
200 }
201 }
202 else if(test.name == "ComputeNumMatrixInstructions")
203 {
204 for(const auto& input_case : test.inputs)
205 {
206 ComputeNumMatrixInstructions(gpuInfo, input_case.values.at("MT_M"), input_case.values.at("MT_N"), input_case.values.at("MT_K"),
207 input_case.values.at("MI_M"), input_case.values.at("MI_N"), input_case.values.at("MI_K"), input_case.expected);
208 }
209 }
210 else if(test.name == "ComputeMTComputeLatency")
211 {
212 for(const auto& input_case : test.inputs)
213 {
214 ComputeMTComputeLatency(gpuInfo, input_case.values.at("M"), input_case.values.at("N"), input_case.values.at("K"),
215 input_case.values.at("transA"), input_case.values.at("transB"),input_case.values.at("MT_M"), input_case.values.at("MT_N"),
216 input_case.values.at("MT_K"), input_case.values.at("MI_M"), input_case.values.at("MI_N"), input_case.values.at("MI_K"),
217 input_case.values.at("element_size_A"), input_case.values.at("element_size_B"), input_case.expected, input_case.expected_gt);
218 }
219 }
220 else if(test.name == "ComputeMemoryLatency")
221 {
222 for(const auto& input_case : test.inputs)
223 {
224 ComputeMemoryLatency(gpuInfo, input_case.values.at("M"), input_case.values.at("N"), input_case.values.at("K"), input_case.values.at("batch"),
225 input_case.values.at("transA"), input_case.values.at("transB"), input_case.values.at("MT_M"), input_case.values.at("MT_N"),
226 input_case.values.at("MT_K"), input_case.values.at("element_size_A"), input_case.values.at("element_size_B"),
227 input_case.values.at("mx_block_size"), input_case.values.at("wgm"), input_case.values.at("numActiveCUs"), input_case.values.at("splittingFactor"));
228 }
229 }
230 else if(test.name == "ComputeTileLatency")
231 {
232 for(const auto& input_case : test.inputs)
233 {
234 ComputeTileLatency(gpuInfo, input_case.values.at("M"), input_case.values.at("N"), input_case.values.at("K"), input_case.values.at("batch"),
235 input_case.values.at("transA"), input_case.values.at("transB"), input_case.values.at("MT_M"), input_case.values.at("MT_N"),
236 input_case.values.at("MT_K"), input_case.values.at("MI_M"), input_case.values.at("MI_N"), input_case.values.at("MI_K"),
237 input_case.values.at("element_size_A"), input_case.values.at("element_size_B"), input_case.values.at("element_size_out"),
238 input_case.values.at("mx_block_size"), input_case.values.at("wgm"), input_case.values.at("numActiveCUs"), input_case.values.at("splittingFactor"));
239 }
240 }
241 else if(test.name == "ComputeWaveLatency")
242 {
243 for(const auto& input_case : test.inputs)
244 {
245 ComputeWaveLatency(gpuInfo, input_case.values.at("M"), input_case.values.at("N"), input_case.values.at("K"), input_case.values.at("batch"),
246 input_case.values.at("transA"), input_case.values.at("transB"), input_case.values.at("MT_M"), input_case.values.at("MT_N"),
247 input_case.values.at("MT_K"), input_case.values.at("MI_M"), input_case.values.at("MI_N"), input_case.values.at("MI_K"),
248 input_case.values.at("element_size_A"), input_case.values.at("element_size_B"), input_case.values.at("element_size_out"),
249 input_case.values.at("mx_block_size"), input_case.values.at("wgm"), input_case.values.at("numActiveCUs"), input_case.values.at("splittingFactor"));
250 }
251 }
252 else if(test.name == "ComputeTotalLatency")
253 {
254 for(const auto& input_case : test.inputs)
255 {
256 ComputeTotalLatency(gpuInfo, input_case.values.at("M"), input_case.values.at("N"), input_case.values.at("K"), input_case.values.at("batch"),
257 input_case.values.at("transA"), input_case.values.at("transB"), input_case.values.at("MT_M"), input_case.values.at("MT_N"),
258 input_case.values.at("MT_K"), input_case.values.at("MI_M"), input_case.values.at("MI_N"), input_case.values.at("MI_K"),
259 input_case.values.at("element_size_A"), input_case.values.at("element_size_B"), input_case.values.at("element_size_out"),
260 input_case.values.at("mx_block_size"), input_case.values.at("wgm"), input_case.values.at("splittingFactor"));
261 }
262 }
263 else if(test.name == "ComputePerfGflops")
264 {
265 for(const auto& input_case : test.inputs)
266 {
267 ComputePerfGflops(input_case.values.at("M"), input_case.values.at("N"), input_case.values.at("K"), input_case.values.at("batch"),
268 input_case.values.at("transA"), input_case.values.at("transB"), input_case.values.at("MT_M"), input_case.values.at("MT_N"),
269 input_case.values.at("MT_K"), input_case.values.at("MI_M"), input_case.values.at("MI_N"), input_case.values.at("MI_K"),
270 input_case.values.at("element_size_A"), input_case.values.at("element_size_B"), input_case.values.at("element_size_out"),
271 input_case.values.at("WGM"));
272 }
273 }
274 else if(test.name == "EstimateMallHit")
275 {
276 for(const auto& input_case : test.inputs)
277 {
278 EstimateMallHit(gpuInfo, input_case.values.at("M"), input_case.values.at("N"), input_case.values.at("K"), input_case.values.at("batch"),
279 input_case.values.at("MT_M"), input_case.values.at("MT_N"), input_case.values.at("MT_K"), input_case.values.at("numActiveCUs"),
280 input_case.values.at("splittingFactor"), input_case.expected_gt);
281 }
282 }
283 else if(test.name == "CheckLDSCapacity")
284 {
285 for(const auto& input_case : test.inputs)
286 {
287 CheckLDSCapacity(gpuInfo, input_case.values.at("MT_M"), input_case.values.at("MT_N"), input_case.values.at("MT_K"), input_case.values.at("element_size"));
288 }
289 }
290 else if(test.name == "HardwareArchEnum")
291 {
292 for(const auto& input_case : test.inputs)
293 {
294 HardwareArchEnum(std::to_string(test.inputs[0].values.at("gpu_arch")));
295 }
296 }
297 else if(test.name == "BestGridSize")
298 {
299 for(const auto& input_case : test.inputs)
300 {
301 BestGridSize(gpuInfo, input_case.values.at("M"), input_case.values.at("N"), input_case.values.at("K"), input_case.values.at("batch"),
302 input_case.values.at("transA"), input_case.values.at("transB"), input_case.values.at("MT_M"), input_case.values.at("MT_N"),
303 input_case.values.at("MT_K"), input_case.values.at("MI_M"), input_case.values.at("MI_N"), input_case.values.at("MI_K"),
304 input_case.values.at("element_size_A"), input_case.values.at("element_size_B"), input_case.values.at("element_size_out"),
305 input_case.values.at("mx_block_size"), input_case.values.at("H_L2"), input_case.values.at("WGM"),
306 input_case.values.at("biggest_allowable_split"), input_case.expected_gt);
307 }
308 }
309 else if(test.name == "BestMacroTileSize")
310 {
311 for(const auto& input_case : test.inputs)
312 {
313 BestMacroTileSize(gpuInfo, input_case.values.at("M"), input_case.values.at("N"), input_case.values.at("K"), input_case.values.at("batch"),
314 input_case.values.at("transA"), input_case.values.at("transB"), input_case.values.at("element_size_A"),
315 input_case.values.at("element_size_B"), input_case.values.at("element_size_out"), input_case.values.at("mx_block_size"),
316 input_case.values.at("H_L2"), input_case.values.at("WGM"));
317 }
318 }
319 else if(test.name == "BestWGM")
320 {
321 for(const auto& input_case : test.inputs)
322 {
323 BestWGM(gpuInfo, input_case.values.at("M"), input_case.values.at("N"), input_case.values.at("K"), input_case.values.at("batch"),
324 input_case.values.at("MT_M"), input_case.values.at("MT_N"), input_case.values.at("MT_K"), input_case.values.at("MI_M"),
325 input_case.values.at("MI_N"), input_case.values.at("MI_K"), input_case.values.at("element_size"), input_case.values.at("H_L2"));
326 }
327 }
328 else if(test.name == "UtilsTFlopsFromLatency")
329 {
330 for(const auto& input_case : test.inputs)
331 {
332 UtilsTFlopsFromLatency(input_case.values.at("M"), input_case.values.at("N"), input_case.values.at("K"),
333 input_case.values.at("latency_cycles"), input_case.values.at("clock_GHz"));
334 }
335 }
336 else
337 {
338 FAIL() << "Unknown test name: " << test.name;
339 }
340 }
341
342 // Instantiate tests using manual parser
343 INSTANTIATE_TEST_SUITE_P(AnalyticalYamlTests,
344 AnalyticalGtest,
345 ::testing::ValuesIn(parseYamlManually("origami_gtest.yaml")),
346 [](const ::testing::TestParamInfo<MyTestData>& info) {
347 std::string name = info.param.name;
348 for(auto& c : name)
349 if(!std::isalnum(c))
350 c = '_';
351 return name;
352 });
353