Debian Codegraph @

level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h

raw
1 /*
2 * Copyright (C) 2020-2025 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #pragma once
9
10 #include "level_zero/core/source/cmdlist/cmdlist.h"
11 #include "level_zero/tools/source/metrics/metric.h"
12
13 #include <unordered_set>
14
15 namespace L0 {
16 namespace ult {
17
18 class MockMetric : public L0::MetricImp {
19 public:
20 ze_result_t destroyReturn = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
21 ~MockMetric() override = default;
22 MockMetric(MetricSource &metricSource, std::vector<MetricScopeImp *> &scopes)
23 : L0::MetricImp(metricSource, scopes) {}
24 ze_result_t getProperties(zet_metric_properties_t *pProperties) override {
25 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
26 }
27 ze_result_t destroy() override {
28 return destroyReturn;
29 }
30
31 void setPredefined(bool status) {
32 isPredefined = status;
33 }
34
35 void setMultiDevice(bool status) {
36 isMultiDevice = status;
37 }
38
39 void setScopes(const std::vector<zet_intel_metric_scope_exp_handle_t> &hNewScopes) {
40 std::vector<MetricScopeImp *> newMetricScopes;
41 for (auto &hScope : hNewScopes) {
42 newMetricScopes.push_back(static_cast<MetricScopeImp *>(MetricScope::fromHandle(hScope)));
43 }
44 metricScopes = newMetricScopes;
45 }
46 };
47
48 class MockMetricCalcOp : public MetricCalcOpImp {
49 public:
50 ~MockMetricCalcOp() override = default;
51 MockMetricCalcOp(bool multiDevice, const std::vector<MetricScopeImp *> &metricScopes,
52 const std::vector<MetricImp *> &metricsInReport,
53 const std::vector<MetricImp *> &excludedMetrics)
54 : MetricCalcOpImp(multiDevice, metricScopes, metricsInReport, excludedMetrics) {}
55
56 ze_result_t destroy() override {
57 // Remove duplicates before deleting to avoid double-free
58 std::unordered_set<MetricImp *> uniqueMetrics(metricsInReport.begin(), metricsInReport.end());
59 for (auto &metric : uniqueMetrics) {
60 delete metric;
61 }
62 metricsInReport.clear();
63 delete this;
64 return ZE_RESULT_SUCCESS;
65 };
66
67 ze_result_t metricCalculateValues(const size_t rawDataSize, const uint8_t *pRawData,
68 bool, size_t *usedSize,
69 uint32_t *pTotalMetricReportCount,
70 zet_intel_metric_result_exp_t *pMetricResults) override {
71 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
72 };
73 };
74
75 class MockMetricSource : public L0::MetricSource {
76 public:
77 ~MockMetricSource() override = default;
78 void enable() override { enableCallCount++; }
79 bool isAvailable() override { return isAvailableReturn; }
80 ze_result_t appendMetricMemoryBarrier(L0::CommandList &commandList) override { return ZE_RESULT_ERROR_UNKNOWN; }
81 ze_result_t metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) override { return ZE_RESULT_ERROR_UNKNOWN; }
82 ze_result_t handleMetricGroupExtendedProperties(zet_metric_group_handle_t hMetricGroup,
83 zet_metric_group_properties_t *pBaseProperties,
84 void *pNext) override { return ZE_RESULT_ERROR_UNKNOWN; }
85 ze_result_t activateMetricGroupsPreferDeferred(uint32_t count, zet_metric_group_handle_t *phMetricGroups) override { return ZE_RESULT_ERROR_UNKNOWN; }
86 ze_result_t activateMetricGroupsAlreadyDeferred() override { return ZE_RESULT_ERROR_UNKNOWN; }
87 ze_result_t metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) override {
88 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
89 }
90 ze_result_t createMetricGroupsFromMetrics(std::vector<zet_metric_handle_t> &metricList,
91 const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP],
92 const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
93 uint32_t *maxMetricGroupCount,
94 std::vector<zet_metric_group_handle_t> &metricGroupList) override {
95 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
96 }
97 ze_result_t getConcurrentMetricGroups(std::vector<zet_metric_group_handle_t> &hMetricGroups,
98 uint32_t *pConcurrentGroupCount,
99 uint32_t *pCountPerConcurrentGroup) override {
100 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
101 }
102 ze_result_t appendMarker(zet_command_list_handle_t hCommandList, zet_metric_group_handle_t hMetricGroup, uint32_t value) override {
103 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
104 }
105
106 void setType(uint32_t type) {
107 this->type = type;
108 }
109
110 ze_result_t calcOperationCreate(MetricDeviceContext &metricDeviceContext,
111 zet_intel_metric_calculation_exp_desc_t *pCalculationDesc,
112 zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation) override {
113
114 std::vector<MetricScopeImp *> metricScopes;
115 for (uint32_t i = 0; i < pCalculationDesc->metricScopesCount; i++) {
116 metricScopes.push_back(static_cast<MetricScopeImp *>(MetricScope::fromHandle(pCalculationDesc->phMetricScopes[i])));
117 }
118
119 std::vector<MetricImp *> metrics;
120 std::vector<MetricImp *> metricsInReport;
121 std::vector<MetricScopeImp *> metricScopesInReport;
122
123 // Only support metric groups, enough for ULT
124 for (uint32_t i = 0; i < pCalculationDesc->metricGroupCount; i++) {
125 MockMetricSource metricSource{};
126 metrics.push_back(new MockMetric(metricSource, const_cast<std::vector<MetricScopeImp *> &>(metricScopes)));
127 }
128
129 for (uint32_t i = 0; i < pCalculationDesc->metricCount; i++) {
130 MockMetricSource metricSource{};
131 metrics.push_back(new MockMetric(metricSource, const_cast<std::vector<MetricScopeImp *> &>(metricScopes)));
132 }
133
134 // Map each metric scope to all metrics
135 for (uint32_t i = 0; i < metricScopes.size(); i++) {
136 for (uint32_t j = 0; j < metrics.size(); j++) {
137 metricsInReport.push_back(metrics[j]);
138 metricScopesInReport.push_back(metricScopes[i]);
139 }
140 }
141
142 auto calcOp = new MockMetricCalcOp(true, metricScopesInReport, metricsInReport, {});
143 *phCalculationOperation = calcOp->toHandle();
144
145 return ZE_RESULT_SUCCESS;
146 }
147 bool canDisable() override { return false; }
148
149 void initMetricScopes(MetricDeviceContext &metricDeviceContext) override {
150 for (auto index = 0u; index < static_cast<uint32_t>(testMetricScopes.size()); index++) {
151 metricDeviceContext.addMetricScope(testMetricScopes[index].name,
152 testMetricScopes[index].description,
153 testMetricScopes[index].computeSubDeviceIndex);
154 }
155 initComputeMetricScopes(metricDeviceContext);
156 }
157
158 void addTestMetricScope(const std::string &name, const std::string &description, uint32_t computeSubDeviceIndex) {
159 testMetricScopes.emplace_back(TestMetricScope{name, description, computeSubDeviceIndex});
160 }
161
162 void removeTestMetricScope(const std::string &name) {
163 testMetricScopes.erase(std::remove_if(testMetricScopes.begin(), testMetricScopes.end(),
164 [&name](const TestMetricScope &scope) { return scope.name == name; }),
165 testMetricScopes.end());
166 }
167
168 uint32_t enableCallCount = 0;
169 bool isAvailableReturn = false;
170 struct TestMetricScope {
171 std::string name;
172 std::string description;
173 uint32_t computeSubDeviceIndex = 0;
174 };
175
176 std::vector<TestMetricScope> testMetricScopes{};
177 };
178
179 class MockMetricGroup : public L0::MetricGroupImp {
180
181 public:
182 using L0::MetricGroupImp::isMultiDevice;
183
184 ~MockMetricGroup() override = default;
185 MockMetricGroup(MetricSource &metricSource) : L0::MetricGroupImp(metricSource) {}
186 ze_result_t getProperties(zet_metric_group_properties_t *pProperties) override {
187 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
188 }
189 ze_result_t metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) override {
190 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
191 }
192 ze_result_t calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
193 const uint8_t *pRawData, uint32_t *pMetricValueCount,
194 zet_typed_value_t *pMetricValues) override {
195 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
196 }
197 ze_result_t calculateMetricValuesExp(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
198 const uint8_t *pRawData, uint32_t *pSetCount,
199 uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
200 zet_typed_value_t *pMetricValues) override {
201 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
202 }
203 ze_result_t getMetricTimestampsExp(const ze_bool_t synchronizedWithHost,
204 uint64_t *globalTimestamp,
205 uint64_t *metricTimestamp) override {
206 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
207 }
208
209 bool activate() override {
210 return false;
211 }
212 bool deactivate() override {
213 return false;
214 }
215 zet_metric_group_handle_t getMetricGroupForSubDevice(const uint32_t subDeviceIndex) override {
216 return nullptr;
217 }
218 ze_result_t streamerOpen(
219 zet_context_handle_t hContext,
220 zet_device_handle_t hDevice,
221 zet_metric_streamer_desc_t *desc,
222 ze_event_handle_t hNotificationEvent,
223 zet_metric_streamer_handle_t *phMetricStreamer) override {
224 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
225 }
226 ze_result_t metricQueryPoolCreate(
227 zet_context_handle_t hContext,
228 zet_device_handle_t hDevice,
229 const zet_metric_query_pool_desc_t *desc,
230 zet_metric_query_pool_handle_t *phMetricQueryPool) override {
231 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
232 }
233
234 ze_result_t getExportData(const uint8_t *pRawData, size_t rawDataSize, size_t *pExportDataSize,
235 uint8_t *pExportData) override {
236 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
237 }
238 ze_result_t addMetric(zet_metric_handle_t hMetric, size_t *errorStringSize, char *pErrorString) override {
239 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
240 }
241 ze_result_t removeMetric(zet_metric_handle_t hMetric) override {
242 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
243 }
244 ze_result_t close() override {
245 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
246 }
247 ze_result_t destroy() override {
248 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
249 }
250 };
251
252 class MockMetricDeviceContext : public MetricDeviceContext {
253 public:
254 MockMetricDeviceContext(Device &device) : MetricDeviceContext(device) {}
255
256 void clearAllSources() {
257 metricSources.clear();
258 }
259
260 void setMockMetricSource(MockMetricSource *metricSource) {
261 metricSources[MetricSource::metricSourceTypeOa] = std::unique_ptr<MockMetricSource>(metricSource);
262 }
263 void setMockMetricSourceAtIndex(uint32_t index, MockMetricSource *metricSource) {
264 metricSources[index] = std::unique_ptr<MockMetricSource>(metricSource);
265 }
266
267 void setMultiDeviceCapable(bool capable) {
268 multiDeviceCapable = capable;
269 }
270 };
271
272 class MockMetricScope : public MetricScopeImp {
273 public:
274 ~MockMetricScope() override = default;
275 MockMetricScope(zet_intel_metric_scope_properties_exp_t &properties, bool aggregated, uint32_t computeSubDeviceIndex)
276 : MetricScopeImp(properties, aggregated, computeSubDeviceIndex) {}
277 ze_result_t getProperties(zet_intel_metric_scope_properties_exp_t *pProperties) override {
278 return MetricScopeImp::getProperties(pProperties);
279 }
280 };
281
282 } // namespace ult
283 } // namespace L0