| 1 |
/* |
| 2 |
* Copyright (C) 2020-2026 Intel Corporation |
| 3 |
* |
| 4 |
* SPDX-License-Identifier: MIT |
| 5 |
* |
| 6 |
*/ |
| 7 |
|
| 8 |
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h" |
| 9 |
|
| 10 |
#include "shared/test/common/mocks/mock_os_library.h" |
| 11 |
|
| 12 |
#include "level_zero/core/source/device/device.h" |
| 13 |
#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h" |
| 14 |
#include "level_zero/tools/source/metrics/metric_oa_source.h" |
| 15 |
#include "level_zero/tools/source/metrics/metric_oa_streamer_imp.h" |
| 16 |
#include "level_zero/tools/source/metrics/os_interface_metric.h" |
| 17 |
|
| 18 |
using namespace MetricsLibraryApi; |
| 19 |
|
| 20 |
namespace L0 { |
| 21 |
namespace ult { |
| 22 |
|
| 23 |
void MetricContextFixture::setUp() { |
| 24 |
|
| 25 |
debugManager.flags.DisableProgrammableMetricsSupport.set(1); |
| 26 |
|
| 27 |
// Call base class. |
| 28 |
DeviceFixture::setUp(); |
| 29 |
|
| 30 |
// Initialize metric api. |
| 31 |
auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>(); |
| 32 |
metricSource.setInitializationState(ZE_RESULT_SUCCESS); |
| 33 |
|
| 34 |
mockIpSamplingOsInterface = new MockIpSamplingOsInterface(); |
| 35 |
std::unique_ptr<MetricIpSamplingOsInterface> metricIpSamplingOsInterface = |
| 36 |
std::unique_ptr<MetricIpSamplingOsInterface>(mockIpSamplingOsInterface); |
| 37 |
auto &ipMetricSource = device->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>(); |
| 38 |
ipMetricSource.setMetricOsInterface(metricIpSamplingOsInterface); |
| 39 |
device->getMetricDeviceContext().setMetricsCollectionAllowed(true); |
| 40 |
|
| 41 |
// Mock metrics library. |
| 42 |
mockMetricsLibrary = std::unique_ptr<Mock<MetricsLibrary>>(new (std::nothrow) Mock<MetricsLibrary>(metricSource)); |
| 43 |
mockMetricsLibrary->setMockedApi(&mockMetricsLibraryApi); |
| 44 |
mockMetricsLibrary->handle = std::make_unique<MockOsLibrary>(); |
| 45 |
|
| 46 |
// Mock metric enumeration. |
| 47 |
mockMetricEnumeration = std::unique_ptr<Mock<MetricEnumeration>>(new (std::nothrow) Mock<MetricEnumeration>(metricSource)); |
| 48 |
mockMetricEnumeration->setMockedApi(&mockMetricsDiscoveryApi); |
| 49 |
mockMetricEnumeration->hMetricsDiscovery = std::make_unique<MockOsLibrary>(); |
| 50 |
|
| 51 |
// Metrics Discovery device common settings. |
| 52 |
metricsDeviceParams.Version.MajorNumber = MetricEnumeration::requiredMetricsDiscoveryMajorVersion; |
| 53 |
metricsDeviceParams.Version.MinorNumber = MetricEnumeration::requiredMetricsDiscoveryMinorVersion; |
| 54 |
} |
| 55 |
|
| 56 |
void MetricContextFixture::tearDown() { |
| 57 |
|
| 58 |
// Restore original metrics library |
| 59 |
mockMetricsLibrary->setMockedApi(nullptr); |
| 60 |
mockMetricsLibrary.reset(); |
| 61 |
|
| 62 |
// Restore original metric enumeration. |
| 63 |
mockMetricEnumeration->setMockedApi(nullptr); |
| 64 |
mockMetricEnumeration.reset(); |
| 65 |
|
| 66 |
// Call base class. |
| 67 |
DeviceFixture::tearDown(); |
| 68 |
} |
| 69 |
|
| 70 |
void MetricContextFixture::openMetricsAdapter() { |
| 71 |
|
| 72 |
mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&adapterGroup); |
| 73 |
mockMetricEnumeration->getMetricsAdapterResult = &adapter; |
| 74 |
|
| 75 |
adapter.openMetricsDeviceOutDevice = &metricsDevice; |
| 76 |
} |
| 77 |
|
| 78 |
void MetricContextFixture::openMetricsAdapterGroup() { |
| 79 |
|
| 80 |
mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&adapterGroup); |
| 81 |
adapter.openMetricsDeviceOutDevice = &metricsDevice; |
| 82 |
} |
| 83 |
|
| 84 |
void MetricContextFixture::setupDefaultMocksForMetricDevice(Mock<IMetricsDevice_1_13> &metricDevice) { |
| 85 |
metricDevice.GetParamsResult = &metricsDeviceParams; |
| 86 |
} |
| 87 |
|
| 88 |
void MetricMultiDeviceFixture::setUp() { |
| 89 |
debugManager.flags.DisableProgrammableMetricsSupport.set(1); |
| 90 |
debugManager.flags.EnableImplicitScaling.set(1); |
| 91 |
|
| 92 |
MultiDeviceFixture::setUp(); |
| 93 |
|
| 94 |
devices.resize(driverHandle->devices.size()); |
| 95 |
|
| 96 |
for (uint32_t i = 0; i < driverHandle->devices.size(); i++) { |
| 97 |
devices[i] = driverHandle->devices[i]; |
| 98 |
} |
| 99 |
|
| 100 |
// Initialize metric api. |
| 101 |
auto &metricSource = devices[0]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>(); |
| 102 |
metricSource.setInitializationState(ZE_RESULT_SUCCESS); |
| 103 |
devices[0]->getMetricDeviceContext().setMetricsCollectionAllowed(true); |
| 104 |
|
| 105 |
// Mock metrics library. |
| 106 |
mockMetricsLibrary = std::unique_ptr<Mock<MetricsLibrary>>(new (std::nothrow) Mock<MetricsLibrary>(metricSource)); |
| 107 |
mockMetricsLibrary->setMockedApi(&mockMetricsLibraryApi); |
| 108 |
mockMetricsLibrary->handle = std::make_unique<MockOsLibrary>(); |
| 109 |
|
| 110 |
// Mock metric enumeration. |
| 111 |
mockMetricEnumeration = std::unique_ptr<Mock<MetricEnumeration>>(new (std::nothrow) Mock<MetricEnumeration>(metricSource)); |
| 112 |
mockMetricEnumeration->setMockedApi(&mockMetricsDiscoveryApi); |
| 113 |
mockMetricEnumeration->hMetricsDiscovery = std::make_unique<MockOsLibrary>(); |
| 114 |
|
| 115 |
auto &l0Device = *static_cast<Device *>(devices[0]); |
| 116 |
const uint32_t subDeviceCount = static_cast<uint32_t>(l0Device.subDevices.size()); |
| 117 |
mockMetricEnumerationSubDevices.resize(subDeviceCount); |
| 118 |
mockMetricsLibrarySubDevices.resize(subDeviceCount); |
| 119 |
|
| 120 |
for (uint32_t i = 0; i < subDeviceCount; i++) { |
| 121 |
auto &metricsSubDeviceContext = l0Device.subDevices[i]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>(); |
| 122 |
mockMetricEnumerationSubDevices[i] = std::unique_ptr<Mock<MetricEnumeration>>(new (std::nothrow) Mock<MetricEnumeration>(metricsSubDeviceContext)); |
| 123 |
mockMetricEnumerationSubDevices[i]->setMockedApi(&mockMetricsDiscoveryApi); |
| 124 |
mockMetricEnumerationSubDevices[i]->hMetricsDiscovery = std::make_unique<MockOsLibrary>(); |
| 125 |
|
| 126 |
mockMetricsLibrarySubDevices[i] = std::unique_ptr<Mock<MetricsLibrary>>(new (std::nothrow) Mock<MetricsLibrary>(metricsSubDeviceContext)); |
| 127 |
mockMetricsLibrarySubDevices[i]->setMockedApi(&mockMetricsLibraryApi); |
| 128 |
mockMetricsLibrarySubDevices[i]->handle = std::make_unique<MockOsLibrary>(); |
| 129 |
|
| 130 |
metricsSubDeviceContext.setInitializationState(ZE_RESULT_SUCCESS); |
| 131 |
l0Device.subDevices[i]->getMetricDeviceContext().setMetricsCollectionAllowed(true); |
| 132 |
} |
| 133 |
// Metrics Discovery device common settings. |
| 134 |
metricsDeviceParams.Version.MajorNumber = MetricEnumeration::requiredMetricsDiscoveryMajorVersion; |
| 135 |
metricsDeviceParams.Version.MinorNumber = MetricEnumeration::requiredMetricsDiscoveryMinorVersion; |
| 136 |
} |
| 137 |
|
| 138 |
void MetricMultiDeviceFixture::tearDown() { |
| 139 |
|
| 140 |
auto &l0Device = *static_cast<Device *>(devices[0]); |
| 141 |
const uint32_t subDeviceCount = static_cast<uint32_t>(l0Device.subDevices.size()); |
| 142 |
|
| 143 |
for (uint32_t i = 0; i < subDeviceCount; i++) { |
| 144 |
|
| 145 |
mockMetricEnumerationSubDevices[i]->setMockedApi(nullptr); |
| 146 |
mockMetricEnumerationSubDevices[i].reset(); |
| 147 |
|
| 148 |
mockMetricsLibrarySubDevices[i]->setMockedApi(nullptr); |
| 149 |
mockMetricsLibrarySubDevices[i].reset(); |
| 150 |
} |
| 151 |
|
| 152 |
mockMetricEnumerationSubDevices.clear(); |
| 153 |
mockMetricsLibrarySubDevices.clear(); |
| 154 |
|
| 155 |
// Restore original metrics library |
| 156 |
mockMetricsLibrary->setMockedApi(nullptr); |
| 157 |
mockMetricsLibrary.reset(); |
| 158 |
|
| 159 |
// Restore original metric enumeration. |
| 160 |
mockMetricEnumeration->setMockedApi(nullptr); |
| 161 |
mockMetricEnumeration.reset(); |
| 162 |
|
| 163 |
MultiDeviceFixture::tearDown(); |
| 164 |
} |
| 165 |
|
| 166 |
void MetricMultiDeviceFixture::openMetricsAdapter() { |
| 167 |
|
| 168 |
mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&adapterGroup); |
| 169 |
mockMetricEnumeration->getMetricsAdapterResult = &adapter; |
| 170 |
|
| 171 |
adapter.openMetricsSubDeviceOutDevice = &metricsDevice; |
| 172 |
adapter.openMetricsDeviceOutDevice = &metricsDevice; |
| 173 |
} |
| 174 |
|
| 175 |
void MetricMultiDeviceFixture::openMetricsAdapterSubDevice(uint32_t subDeviceIndex) { |
| 176 |
|
| 177 |
mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&adapterGroup); |
| 178 |
|
| 179 |
mockMetricEnumerationSubDevices[subDeviceIndex]->getMetricsAdapterResult = &adapter; |
| 180 |
|
| 181 |
adapter.openMetricsDeviceOutDevice = &metricsDevice; |
| 182 |
} |
| 183 |
|
| 184 |
void MetricMultiDeviceFixture::openMetricsAdapterDeviceAndSubDeviceNoCountVerify(uint32_t subDeviceIndex) { |
| 185 |
|
| 186 |
mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&adapterGroup); |
| 187 |
mockMetricEnumeration->getMetricsAdapterResult = &adapter; |
| 188 |
mockMetricEnumerationSubDevices[subDeviceIndex]->getMetricsAdapterResult = &adapter; |
| 189 |
|
| 190 |
adapter.openMetricsDeviceOutDevice = &metricsDevice; |
| 191 |
adapter.openMetricsSubDeviceOutDevice = &metricsDevice; |
| 192 |
} |
| 193 |
|
| 194 |
void MetricMultiDeviceFixture::openMetricsAdapterGroup() { |
| 195 |
|
| 196 |
mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&adapterGroup); |
| 197 |
adapter.openMetricsDeviceOutDevice = &metricsDevice; |
| 198 |
} |
| 199 |
|
| 200 |
void MetricMultiDeviceFixture::setupDefaultMocksForMetricDevice(Mock<IMetricsDevice_1_13> &metricDevice) { |
| 201 |
metricDevice.GetParamsResult = &metricsDeviceParams; |
| 202 |
} |
| 203 |
|
| 204 |
void MetricStreamerMultiDeviceFixture::cleanup(zet_device_handle_t &hDevice, zet_metric_streamer_handle_t &hStreamer) { |
| 205 |
|
| 206 |
OaMetricStreamerImp *pStreamerImp = static_cast<OaMetricStreamerImp *>(MetricStreamer::fromHandle(hStreamer)); |
| 207 |
auto &l0Device = *static_cast<Device *>(devices[0]); |
| 208 |
|
| 209 |
for (size_t index = 0; index < l0Device.subDevices.size(); index++) { |
| 210 |
zet_metric_streamer_handle_t metricStreamerSubDeviceHandle = pStreamerImp->getMetricStreamers()[index]; |
| 211 |
OaMetricStreamerImp *pStreamerSubDevImp = static_cast<OaMetricStreamerImp *>(MetricStreamer::fromHandle(metricStreamerSubDeviceHandle)); |
| 212 |
auto device = l0Device.subDevices[index]; |
| 213 |
auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>(); |
| 214 |
auto &metricsLibrary = metricSource.getMetricsLibrary(); |
| 215 |
metricSource.setMetricStreamer(nullptr); |
| 216 |
metricsLibrary.release(); |
| 217 |
delete pStreamerSubDevImp; |
| 218 |
} |
| 219 |
auto &metricSource = devices[0]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>(); |
| 220 |
metricSource.setMetricStreamer(nullptr); |
| 221 |
delete pStreamerImp; |
| 222 |
} |
| 223 |
|
| 224 |
Mock<MetricsLibrary>::Mock(::L0::OaMetricSourceImp &metricSource) : MetricsLibrary(metricSource) { |
| 225 |
} |
| 226 |
|
| 227 |
Mock<MetricsLibrary>::~Mock() { |
| 228 |
} |
| 229 |
|
| 230 |
MockMetricsLibraryApi *Mock<MetricsLibrary>::g_mockApi = nullptr; |
| 231 |
|
| 232 |
void Mock<MetricsLibrary>::setMockedApi(MockMetricsLibraryApi *mockedApi) { |
| 233 |
|
| 234 |
if (mockedApi) { |
| 235 |
|
| 236 |
// Mock class used to communicate with metrics library. |
| 237 |
metricsLibrary = &metricSource.getMetricsLibrary(); |
| 238 |
auto &actualMetricsLibrary = metricSource.getMetricsLibraryObject(); |
| 239 |
actualMetricsLibrary.release(); |
| 240 |
actualMetricsLibrary.reset(this); |
| 241 |
|
| 242 |
// Mock metrics library api functions. |
| 243 |
contextCreateFunction = mockedApi->contextCreate; |
| 244 |
contextDeleteFunction = mockedApi->contextDelete; |
| 245 |
|
| 246 |
api.GetParameter = mockedApi->getParameter; |
| 247 |
|
| 248 |
api.CommandBufferGet = mockedApi->commandBufferGet; |
| 249 |
api.CommandBufferGetSize = mockedApi->commandBufferGetSize; |
| 250 |
|
| 251 |
api.QueryCreate = mockedApi->queryCreate; |
| 252 |
api.QueryDelete = mockedApi->queryDelete; |
| 253 |
|
| 254 |
api.OverrideCreate = mockedApi->overrideCreate; |
| 255 |
api.OverrideDelete = mockedApi->overrideDelete; |
| 256 |
|
| 257 |
api.MarkerCreate = mockedApi->markerCreate; |
| 258 |
api.MarkerDelete = mockedApi->markerDelete; |
| 259 |
|
| 260 |
api.ConfigurationCreate = mockedApi->configurationCreate; |
| 261 |
api.ConfigurationActivate = mockedApi->configurationActivate; |
| 262 |
api.ConfigurationDeactivate = mockedApi->configurationDeactivate; |
| 263 |
api.ConfigurationDelete = mockedApi->configurationDelete; |
| 264 |
|
| 265 |
api.GetData = mockedApi->getData; |
| 266 |
|
| 267 |
// Mock metrics library api. |
| 268 |
Mock<MetricsLibrary>::g_mockApi = mockedApi; |
| 269 |
|
| 270 |
} else { |
| 271 |
|
| 272 |
// Restore an original class used to communicate with metrics library. |
| 273 |
auto &actualMetricsLibrary = metricSource.getMetricsLibraryObject(); |
| 274 |
actualMetricsLibrary.release(); |
| 275 |
actualMetricsLibrary.reset(metricsLibrary); |
| 276 |
} |
| 277 |
} |
| 278 |
|
| 279 |
StatusCode MockMetricsLibraryApi::contextCreate(ClientType_1_0 clientType, ContextCreateData_1_0 *createData, ContextHandle_1_0 *handle) { |
| 280 |
return Mock<MetricsLibrary>::g_mockApi->contextCreateImpl(clientType, createData, handle); |
| 281 |
} |
| 282 |
|
| 283 |
StatusCode MockMetricsLibraryApi::contextDelete(const ContextHandle_1_0 handle) { |
| 284 |
return StatusCode::Success; |
| 285 |
} |
| 286 |
|
| 287 |
StatusCode MockMetricsLibraryApi::getParameter(const ParameterType parameter, ValueType *type, TypedValue_1_0 *value) { |
| 288 |
return Mock<MetricsLibrary>::g_mockApi->getParameterImpl(parameter, type, value); |
| 289 |
} |
| 290 |
|
| 291 |
StatusCode MockMetricsLibraryApi::commandBufferGet(const CommandBufferData_1_0 *data) { |
| 292 |
return Mock<MetricsLibrary>::g_mockApi->commandBufferGetImpl(data); |
| 293 |
} |
| 294 |
|
| 295 |
StatusCode MockMetricsLibraryApi::commandBufferGetSize(const CommandBufferData_1_0 *data, CommandBufferSize_1_0 *size) { |
| 296 |
return Mock<MetricsLibrary>::g_mockApi->commandBufferGetSizeImpl(data, size); |
| 297 |
} |
| 298 |
|
| 299 |
StatusCode MockMetricsLibraryApi::queryCreate(const QueryCreateData_1_0 *createData, QueryHandle_1_0 *handle) { |
| 300 |
return Mock<MetricsLibrary>::g_mockApi->queryCreateImpl(createData, handle); |
| 301 |
} |
| 302 |
|
| 303 |
StatusCode MockMetricsLibraryApi::queryDelete(const QueryHandle_1_0 handle) { |
| 304 |
return StatusCode::Success; |
| 305 |
} |
| 306 |
|
| 307 |
StatusCode MockMetricsLibraryApi::overrideCreate(const OverrideCreateData_1_0 *createData, OverrideHandle_1_0 *handle) { |
| 308 |
return StatusCode::Success; |
| 309 |
} |
| 310 |
|
| 311 |
StatusCode MockMetricsLibraryApi::overrideDelete(const OverrideHandle_1_0 handle) { |
| 312 |
return StatusCode::Success; |
| 313 |
} |
| 314 |
|
| 315 |
StatusCode MockMetricsLibraryApi::markerCreate(const MarkerCreateData_1_0 *createData, MarkerHandle_1_0 *handle) { |
| 316 |
return StatusCode::Success; |
| 317 |
} |
| 318 |
|
| 319 |
StatusCode MockMetricsLibraryApi::markerDelete(const MarkerHandle_1_0 handle) { |
| 320 |
return StatusCode::Success; |
| 321 |
} |
| 322 |
|
| 323 |
StatusCode MockMetricsLibraryApi::configurationCreate(const ConfigurationCreateData_1_0 *createData, ConfigurationHandle_1_0 *handle) { |
| 324 |
return Mock<MetricsLibrary>::g_mockApi->configurationCreateImpl(createData, handle); |
| 325 |
} |
| 326 |
|
| 327 |
StatusCode MockMetricsLibraryApi::configurationActivate(const ConfigurationHandle_1_0 handle, const ConfigurationActivateData_1_0 *activateData) { |
| 328 |
return Mock<MetricsLibrary>::g_mockApi->configurationActivateImpl(handle, activateData); |
| 329 |
} |
| 330 |
|
| 331 |
StatusCode MockMetricsLibraryApi::configurationDeactivate(const ConfigurationHandle_1_0 handle) { |
| 332 |
return Mock<MetricsLibrary>::g_mockApi->configurationDeactivateImpl(handle); |
| 333 |
} |
| 334 |
|
| 335 |
StatusCode MockMetricsLibraryApi::configurationDelete(const ConfigurationHandle_1_0 handle) { |
| 336 |
return StatusCode::Success; |
| 337 |
} |
| 338 |
|
| 339 |
StatusCode MockMetricsLibraryApi::getData(GetReportData_1_0 *data) { |
| 340 |
return Mock<MetricsLibrary>::g_mockApi->getDataImpl(data); |
| 341 |
} |
| 342 |
|
| 343 |
Mock<MetricQuery>::Mock() {} |
| 344 |
|
| 345 |
Mock<MetricQuery>::~Mock() {} |
| 346 |
|
| 347 |
Mock<MetricQueryPool>::Mock() {} |
| 348 |
|
| 349 |
Mock<MetricQueryPool>::~Mock() {} |
| 350 |
|
| 351 |
} // namespace ult |
| 352 |
} // namespace L0 |