Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feature: get zet_metric_global_timestamps_resolution_exp_t for OA from MDAPI 

Related-To: NEO-14161

Signed-off-by: shubham kumar <shubham.kumar@intel.com>
This commit is contained in:
shubham kumar 2025-03-07 12:17:51 +00:00 committed by Compute-Runtime-Automation
parent da4a5d0389
commit ec5283bb3b
20 changed files with 153 additions and 173 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
level_zero/tools/source/metrics/linux/os_metric_oa_enumeration_imp_linux.cpp
View File

@ -84,24 +84,4 @@ MetricsDiscovery::IAdapter_1_13 *getDrmMetricsAdapter(MetricEnumeration *metricE
return nullptr;
}
MetricOALinuxImp::MetricOALinuxImp(Device &device) : device(device) {}
ze_result_t MetricOALinuxImp::getMetricsTimerResolution(uint64_t &timerResolution) {
ze_result_t result = ZE_RESULT_SUCCESS;
const auto drm = device.getOsInterface()->getDriverModel()->as<NEO::Drm>();
int32_t timestampFrequency;
int32_t ret = drm->getOaTimestampFrequency(timestampFrequency);
if (ret < 0 || timestampFrequency == 0) {
timerResolution = 0;
result = ZE_RESULT_ERROR_UNKNOWN;
METRICS_LOG_ERR("getOATimestampFrequenc() failed errno = %d | ret = %d", errno, ret);
} else {
timerResolution = static_cast<uint64_t>(timestampFrequency);
}
return result;
}
} // namespace L0

13
level_zero/tools/source/metrics/linux/os_metric_oa_enumeration_imp_linux.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2024 Intel Corporation
* Copyright (C) 2024-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -17,15 +17,4 @@ struct MetricEnumeration;
bool getDrmAdapterId(uint32_t &adapterMajor, uint32_t &adapterMinor, Device &device);
MetricsDiscovery::IAdapter_1_13 *getDrmMetricsAdapter(MetricEnumeration *metricEnumeration);
class MetricOALinuxImp : public MetricOAOsInterface {
public:
MetricOALinuxImp(Device &device);
~MetricOALinuxImp() override = default;
ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) override;
private:
Device &device;
};
} // namespace L0

1
level_zero/tools/source/metrics/metric_oa_enumeration_imp.h
View File

@ -18,6 +18,7 @@ namespace L0 {
static constexpr std::string_view globalSymbolOaMaxBufferSize = "OABufferMaxSize";
static constexpr std::string_view globalSymbolOaMaxTimestamp = "MaxTimestamp";
static constexpr std::string_view globalSymbolOaGpuTimestampFrequency = "GpuTimestampFrequency";
struct MetricEnumeration {
MetricEnumeration(OaMetricSourceImp &metricSource);

12
level_zero/tools/source/metrics/metric_oa_source.cpp
View File

@ -28,7 +28,6 @@ std::unique_ptr<OaMetricSourceImp> OaMetricSourceImp::create(const MetricDeviceC
OaMetricSourceImp::OaMetricSourceImp(const MetricDeviceContext &metricDeviceContext) : metricDeviceContext(metricDeviceContext),
metricEnumeration(std::unique_ptr<MetricEnumeration>(new(std::nothrow) MetricEnumeration(*this))),
metricsLibrary(std::unique_ptr<MetricsLibrary>(new(std::nothrow) MetricsLibrary(*this))) {
metricOAOsInterface = MetricOAOsInterface::create(metricDeviceContext.getDevice());
activationTracker = std::make_unique<MultiDomainDeferredActivationTracker>(metricDeviceContext.getSubDeviceIndex());
type = MetricSource::metricSourceTypeOa;
}
@ -40,13 +39,12 @@ void OaMetricSourceImp::enable() {
}
ze_result_t OaMetricSourceImp::getTimerResolution(uint64_t &resolution) {
ze_result_t result = getMetricOsInterface()->getMetricsTimerResolution(resolution);
if (result != ZE_RESULT_SUCCESS) {
if (!metricEnumeration->readGlobalSymbol(globalSymbolOaGpuTimestampFrequency.data(), resolution)) {
resolution = 0;
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return result;
return ZE_RESULT_SUCCESS;
}
ze_result_t OaMetricSourceImp::getTimestampValidBits(uint64_t &validBits) {
@ -171,10 +169,6 @@ bool OaMetricSourceImp::isImplicitScalingCapable() const {
return metricDeviceContext.isImplicitScalingCapable();
}
void OaMetricSourceImp::setMetricOsInterface(std::unique_ptr<MetricOAOsInterface> &metricOAOsInterface) {
this->metricOAOsInterface = std::move(metricOAOsInterface);
}
ze_result_t OaMetricSourceImp::activateMetricGroupsPreferDeferred(uint32_t count,
zet_metric_group_handle_t *phMetricGroups) {
activationTracker->activateMetricGroupsDeferred(count, phMetricGroups);

3
level_zero/tools/source/metrics/metric_oa_source.h
View File

@ -51,8 +51,6 @@ class OaMetricSourceImp : public MetricSource {
bool isImplicitScalingCapable() const;
const MetricDeviceContext &getMetricDeviceContext() const { return metricDeviceContext; }
static std::unique_ptr<OaMetricSourceImp> create(const MetricDeviceContext &metricDeviceContext);
void setMetricOsInterface(std::unique_ptr<MetricOAOsInterface> &metricOAOsInterface);
MetricOAOsInterface *getMetricOsInterface() { return metricOAOsInterface.get(); }
ze_result_t metricGroupCreateFromMetric(const char *pName, const char *pDescription,
zet_metric_group_sampling_type_flags_t samplingType, zet_metric_handle_t hMetric,
zet_metric_group_handle_t *phMetricGroup);
@ -81,7 +79,6 @@ class OaMetricSourceImp : public MetricSource {
std::unique_ptr<MetricsLibrary> metricsLibrary;
MetricStreamer *pMetricStreamer = nullptr;
bool useCompute = false;
std::unique_ptr<MetricOAOsInterface> metricOAOsInterface = nullptr;
std::unique_ptr<MultiDomainDeferredActivationTracker> activationTracker{};
ze_result_t getTimerResolution(uint64_t &resolution);
ze_result_t getTimestampValidBits(uint64_t &validBits);

8
level_zero/tools/source/metrics/os_interface_metric.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2024 Intel Corporation
* Copyright (C) 2022-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -40,10 +40,4 @@ class MetricIpSamplingOsInterface : public MetricOsInterface {
uint32_t unitReportSize = 64u;
};
class MetricOAOsInterface : public MetricOsInterface {
public:
~MetricOAOsInterface() override = default;
static std::unique_ptr<MetricOAOsInterface> create(Device &device);
};
} // namespace L0

6
level_zero/tools/source/metrics/os_metric_oa_enumeration_drm.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2024 Intel Corporation
* Copyright (C) 2024-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -19,8 +19,4 @@ MetricsDiscovery::IAdapter_1_13 *MetricEnumeration::getMetricsAdapter() {
return getDrmMetricsAdapter(this);
}
std::unique_ptr<MetricOAOsInterface> MetricOAOsInterface::create(Device &device) {
return std::make_unique<MetricOALinuxImp>(device);
}
} // namespace L0

12
level_zero/tools/source/metrics/os_metric_oa_enumeration_drm_or_wddm.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2024 Intel Corporation
* Copyright (C) 2024-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -35,14 +35,4 @@ MetricsDiscovery::IAdapter_1_13 *MetricEnumeration::getMetricsAdapter() {
else
return getDrmMetricsAdapter(this);
}
std::unique_ptr<MetricOAOsInterface> MetricOAOsInterface::create(Device &device) {
auto osInterface = device.getNEODevice()->getRootDeviceEnvironment().osInterface.get();
if (osInterface && osInterface->getDriverModel()->getDriverModelType() == NEO::DriverModelType::wddm)
return std::make_unique<MetricOAWindowsImp>();
else
return std::make_unique<MetricOALinuxImp>(device);
}
} // namespace L0

6
level_zero/tools/source/metrics/os_metric_oa_enumeration_imp_drm.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2024 Intel Corporation
* Copyright (C) 2024-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -19,8 +19,4 @@ MetricsDiscovery::IAdapter_1_13 *MetricEnumeration::getMetricsAdapter() {
return getDrmMetricsAdapter(this);
}
std::unique_ptr<MetricOAOsInterface> MetricOAOsInterface::create(Device &device) {
return std::make_unique<MetricOALinuxImp>(device);
}
} // namespace L0

6
level_zero/tools/source/metrics/os_metric_oa_enumeration_wddm.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2024 Intel Corporation
* Copyright (C) 2024-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -19,8 +19,4 @@ MetricsDiscovery::IAdapter_1_13 *MetricEnumeration::getMetricsAdapter() {
return getWddmMetricsAdapter(this);
}
std::unique_ptr<MetricOAOsInterface> MetricOAOsInterface::create(Device &device) {
return std::make_unique<MetricOAWindowsImp>();
}
} // namespace L0

5
level_zero/tools/source/metrics/wddm/os_metric_oa_enumeration_imp_wddm.cpp
View File

@ -56,9 +56,4 @@ MetricsDiscovery::IAdapter_1_13 *getWddmMetricsAdapter(MetricEnumeration *metric
return nullptr;
}
ze_result_t MetricOAWindowsImp::getMetricsTimerResolution(uint64_t &timerResolution) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
} // namespace L0

9
level_zero/tools/source/metrics/wddm/os_metric_oa_enumeration_imp_wddm.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2024 Intel Corporation
* Copyright (C) 2024-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -19,11 +19,4 @@ bool getWddmAdapterId(uint32_t &major, uint32_t &minor, Device &device);
MetricsDiscovery::IAdapter_1_13 *getWddmMetricsAdapter(MetricEnumeration *metricEnumeration);
class MetricOAWindowsImp : public MetricOAOsInterface {
public:
MetricOAWindowsImp() = default;
~MetricOAWindowsImp() override = default;
ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) override;
};
} // namespace L0

94
level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_tests.cpp
View File

@ -707,6 +707,97 @@ bool testExportData() {
return true;
}
//////////////////////////
/// metricGetTimestampTest
//////////////////////////
bool metricGetTimestampTest() {
// This test verifies zetMetricGroupGetGlobalTimestampsExp for all devices OR specific device
bool status = true;
zmu::TestMachineConfiguration machineConfig = {};
zmu::getTestMachineConfiguration(machineConfig);
auto metricTimestamp = [](uint32_t deviceId, int32_t subDeviceId, std::string &metricGroupName) {
auto metricGroupGetGlobalTimestamp = [](zet_metric_group_handle_t metricGroup, ze_bool_t synchronizedWithHost) {
uint64_t globalTimestamp = 0;
uint64_t metricTimestamp = 0;
auto status = zetMetricGroupGetGlobalTimestampsExp(metricGroup, synchronizedWithHost, &globalTimestamp, &metricTimestamp);
if (status != ZE_RESULT_SUCCESS) {
return status;
}
if (synchronizedWithHost) {
LOG(zmu::LogLevel::INFO) << "[Host|Metric] timestamp is " << globalTimestamp << " | " << metricTimestamp << std::endl;
} else {
LOG(zmu::LogLevel::INFO) << "[Device|Metric] timestamp is " << globalTimestamp << " | " << metricTimestamp << std::endl;
}
return ZE_RESULT_SUCCESS;
};
auto metricGroupGetExtendedTimestampResolutionProperties = [](zet_metric_group_handle_t metricGroup) {
const zet_metric_group_handle_t metricGroupHandle = metricGroup;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_global_timestamps_resolution_exp_t metricGlobalTimestampsResolution = {};
metricGlobalTimestampsResolution.stype = ZET_STRUCTURE_TYPE_METRIC_GLOBAL_TIMESTAMPS_RESOLUTION_EXP;
metricGroupProperties.pNext = &metricGlobalTimestampsResolution;
auto status = zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties);
if (status != ZE_RESULT_SUCCESS) {
LOG(zmu::LogLevel::DEBUG) << "zetMetricGroupGetProperties status: " << status << std::endl;
return status;
}
LOG(zmu::LogLevel::INFO) << "METRIC GROUP[" << metricGroupProperties.name << "]: "
<< "desc: " << metricGroupProperties.description << "\n";
LOG(zmu::LogLevel::INFO) << "\t -> timerResolution: " << metricGlobalTimestampsResolution.timerResolution << " | "
<< "timestampValidBits: " << metricGlobalTimestampsResolution.timestampValidBits << std::endl;
return ZE_RESULT_SUCCESS;
};
if (!zmu::isDeviceAvailable(deviceId, subDeviceId)) {
return false;
}
LOG(zmu::LogLevel::INFO) << "Running zetMetricGroupGetGlobalTimestampsExp() : Device [" << deviceId << ", " << subDeviceId << " ] : Metric Group :" << metricGroupName.c_str() << "\n";
std::unique_ptr<SingleDeviceSingleQueueExecutionCtxt> executionCtxt =
std::make_unique<SingleDeviceSingleQueueExecutionCtxt>(deviceId, subDeviceId);
auto metricGroup = zmu::findMetricGroup(metricGroupName.c_str(),
static_cast<zet_metric_group_sampling_type_flag_t>(ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED | ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED | ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EXP_TRACER_BASED), // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange), NEO-12901
executionCtxt->getDeviceHandle(0));
ze_result_t status;
status = metricGroupGetGlobalTimestamp(metricGroup, true);
if (status != ZE_RESULT_SUCCESS) {
return false;
}
status = metricGroupGetGlobalTimestamp(metricGroup, false);
if (status != ZE_RESULT_SUCCESS) {
return false;
}
status = metricGroupGetExtendedTimestampResolutionProperties(metricGroup);
return status == ZE_RESULT_SUCCESS;
};
auto testSettings = zmu::TestSettings::get();
if (testSettings->deviceId.get() == -1) {
for (uint32_t deviceId = 0; deviceId < machineConfig.deviceCount; deviceId++) {
// Run for all subdevices
for (uint32_t subDeviceId = 0; subDeviceId < machineConfig.devices[deviceId].subDeviceCount; subDeviceId++) {
status &= metricTimestamp(deviceId, subDeviceId, testSettings->metricGroupName.get());
}
// Run for root device
status &= metricTimestamp(deviceId, -1, testSettings->metricGroupName.get());
}
} else {
// Run for specific device
status &= metricTimestamp(testSettings->deviceId.get(), testSettings->subDeviceId.get(), testSettings->metricGroupName.get());
}
return status;
}
ZELLO_METRICS_ADD_TEST(queryTest)
ZELLO_METRICS_ADD_TEST(streamTest)
ZELLO_METRICS_ADD_TEST(streamMultiMetricDomainTest)
@ -718,4 +809,5 @@ ZELLO_METRICS_ADD_TEST(streamPowerFrequencyTest)
ZELLO_METRICS_ADD_TEST(displayAllMetricGroups)
ZELLO_METRICS_ADD_TEST(queryImmediateCommandListTest)
ZELLO_METRICS_ADD_TEST(collectIndefinitely)
ZELLO_METRICS_ADD_TEST(testExportData)
ZELLO_METRICS_ADD_TEST(testExportData)
ZELLO_METRICS_ADD_TEST(metricGetTimestampTest)

10
level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_util.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2024 Intel Corporation
* Copyright (C) 2022-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -24,12 +24,14 @@ void createL0() {
ze_driver_handle_t getDriver() {
uint32_t driverCount = 0;
ze_driver_handle_t driverHandle = {};
std::vector<ze_driver_handle_t> driverHandles = {};
// Obtain driver.
VALIDATECALL(zeDriverGet(&driverCount, nullptr));
EXPECT(driverCount > 0);
VALIDATECALL(zeDriverGet(&driverCount, &driverHandle));
return driverHandle;
driverHandles.resize(driverCount);
VALIDATECALL(zeDriverGet(&driverCount, driverHandles.data()));
return driverHandles[0];
}
ze_context_handle_t createContext(ze_driver_handle_t &driverHandle) {

26
level_zero/tools/test/unit_tests/sources/metrics/linux/test_metric_oa_query_pool_linux.cpp
View File

@ -257,32 +257,6 @@ class MetricEnumerationTestLinux : public MetricContextFixture,
}
};
TEST_F(MetricEnumerationTestLinux, givenCorrectLinuxDrmAdapterWhenGettingOATimerResolutionThenReturnSuccess) {
std::unique_ptr<MetricOAOsInterface> oaOsInterface = MetricOAOsInterface::create(*device);
uint64_t timerResolution;
oaOsInterface->getMetricsTimerResolution(timerResolution);
EXPECT_EQ(oaOsInterface->getMetricsTimerResolution(timerResolution), ZE_RESULT_SUCCESS);
EXPECT_EQ(timerResolution, 123456UL);
}
TEST_F(MetricEnumerationTestLinux, givenDrmFailureWhenGettingOATimerResolutionThenReturnError) {
std::unique_ptr<MetricOAOsInterface> oaOsInterface = MetricOAOsInterface::create(*device);
uint64_t timerResolution;
oaOsInterface->getMetricsTimerResolution(timerResolution);
auto drm = static_cast<DrmMock *>(device->getOsInterface()->getDriverModel()->as<NEO::Drm>());
drm->storedRetVal = -1;
EXPECT_EQ(oaOsInterface->getMetricsTimerResolution(timerResolution), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(timerResolution, 0UL);
drm->storedRetVal = 0;
drm->storedOaTimestampFrequency = 0;
EXPECT_EQ(oaOsInterface->getMetricsTimerResolution(timerResolution), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(timerResolution, 0UL);
}
TEST_F(MetricEnumerationTestLinux, givenCorrectLinuxDrmAdapterWhenGetMetricsAdapterThenReturnSuccess) {
auto adapterGroupParams = TAdapterGroupParams_1_6{};

6
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2024 Intel Corporation
* Copyright (C) 2020-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -28,11 +28,7 @@ void MetricContextFixture::setUp() {
DeviceFixture::setUp();
// Initialize metric api.
mockOAOsInterface = new MockOAOsInterface();
std::unique_ptr<MetricOAOsInterface> metricOAOsInterface =
std::unique_ptr<MetricOAOsInterface>(mockOAOsInterface);
auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
metricSource.setMetricOsInterface(metricOAOsInterface);
metricSource.setInitializationState(ZE_RESULT_SUCCESS);
mockIpSamplingOsInterface = new MockIpSamplingOsInterface();

22
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2024 Intel Corporation
* Copyright (C) 2020-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -239,25 +239,6 @@ class MockIpSamplingOsInterface : public MetricIpSamplingOsInterface {
return getMetricsTimerResolutionReturn;
}
};
class MockOAOsInterface : public MetricOAOsInterface {
public:
~MockOAOsInterface() override = default;
ze_result_t getMetricsTimerResolutionReturn = ZE_RESULT_SUCCESS;
uint8_t failGetResolutionOnCall = 0;
uint8_t getResolutionCallCount = 0;
ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) override {
ze_result_t retVal;
getResolutionCallCount++;
if ((failGetResolutionOnCall) && (getResolutionCallCount >= failGetResolutionOnCall)) {
timerResolution = 0UL;
retVal = getMetricsTimerResolutionReturn;
} else {
timerResolution = 25000000UL; // PVC as reference
retVal = ZE_RESULT_SUCCESS;
}
return retVal;
}
};
class MetricContextFixture : public DeviceFixture {
@ -284,7 +265,6 @@ class MetricContextFixture : public DeviceFixture {
MetricsDiscovery::TMetricsDeviceParams_1_2 metricsDeviceParams = {};
MetricsDiscovery::TTypedValue_1_0 defaultMaximumOaBufferSize = {};
void setupDefaultMocksForMetricDevice(Mock<IMetricsDevice_1_13> &metricDevice);
MockOAOsInterface *mockOAOsInterface;
MockIpSamplingOsInterface *mockIpSamplingOsInterface;
};

26
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2024 Intel Corporation
* Copyright (C) 2020-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -134,6 +134,9 @@ class Mock<IMetricsDevice_1_13> : public IMetricsDevice_1_13 {
MetricsDiscovery::TTypedValue_1_0 symbolValue = {};
bool forceGetSymbolByNameFail = false;
bool forceGetGpuCpuTimestampsFail = false;
bool forceGetMaxTimestampFail = false;
uint32_t failGetGpuTimestampFrequencyOnCall = 0;
uint32_t getGpuTimestampFrequencyCallCount = 0;
TTypedValue_1_0 *GetGlobalSymbolValueByName(const char *name) override {
bool found = false;
if (forceGetSymbolByNameFail) {
@ -143,8 +146,19 @@ class Mock<IMetricsDevice_1_13> : public IMetricsDevice_1_13 {
symbolValue.ValueUInt32 = 1024;
found = true;
} else if (std::strcmp(name, "MaxTimestamp") == 0) {
if (forceGetMaxTimestampFail) {
return nullptr;
}
symbolValue.ValueType = MetricsDiscovery::TValueType::VALUE_TYPE_UINT64;
symbolValue.ValueUInt64 = 171798691800UL; // PVC as refference
symbolValue.ValueUInt64 = 171798691800UL; // PVC as reference
found = true;
} else if (std::strcmp(name, "GpuTimestampFrequency") == 0) {
getGpuTimestampFrequencyCallCount++;
if (failGetGpuTimestampFrequencyOnCall && (getGpuTimestampFrequencyCallCount >= failGetGpuTimestampFrequencyOnCall)) {
return nullptr;
}
symbolValue.ValueType = MetricsDiscovery::TValueType::VALUE_TYPE_UINT64;
symbolValue.ValueUInt64 = 25000000UL; // PVC as reference
found = true;
}
if (found) {
@ -168,6 +182,14 @@ class Mock<IMetricsDevice_1_13> : public IMetricsDevice_1_13 {
return MetricsDiscovery::CC_OK;
}
void resetMockVars() {
forceGetSymbolByNameFail = false;
forceGetGpuCpuTimestampsFail = false;
forceGetMaxTimestampFail = false;
failGetGpuTimestampFrequencyOnCall = 0;
getGpuTimestampFrequencyCallCount = 0;
}
std::vector<IConcurrentGroup_1_13 *> getConcurrentGroupResults;
};

34
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp
View File

@ -757,23 +757,17 @@ TEST_F(MetricEnumerationTest, GivenValidMetricGroupWhenReadingFrequencyAndIntern
EXPECT_NE(metricGroupHandle, nullptr);
// Metric group properties.
mockOAOsInterface->getMetricsTimerResolutionReturn = ZE_RESULT_ERROR_UNKNOWN;
mockOAOsInterface->failGetResolutionOnCall = 1;
EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupProperties.domain, 0u);
EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED);
EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
EXPECT_EQ(metricTimestampProperties.timerResolution, 0UL);
EXPECT_EQ(metricTimestampProperties.timestampValidBits, 0UL);
EXPECT_NE(metricTimestampProperties.timerResolution, 0UL);
EXPECT_NE(metricTimestampProperties.timestampValidBits, 0UL);
mockOAOsInterface->getMetricsTimerResolutionReturn = ZE_RESULT_SUCCESS;
mockOAOsInterface->failGetResolutionOnCall = 0;
metricsDevice.forceGetSymbolByNameFail = true;
metricsDevice.failGetGpuTimestampFrequencyOnCall = true;
EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_ERROR_NOT_AVAILABLE);
EXPECT_EQ(metricGroupProperties.domain, 0u);
@ -785,13 +779,10 @@ TEST_F(MetricEnumerationTest, GivenValidMetricGroupWhenReadingFrequencyAndIntern
EXPECT_EQ(metricTimestampProperties.timerResolution, 0UL);
EXPECT_EQ(metricTimestampProperties.timestampValidBits, 0UL);
metricsDevice.forceGetSymbolByNameFail = false;
metricsDevice.resetMockVars();
metricsDevice.forceGetMaxTimestampFail = true;
mockOAOsInterface->getMetricsTimerResolutionReturn = ZE_RESULT_ERROR_UNKNOWN;
mockOAOsInterface->getResolutionCallCount = 0;
mockOAOsInterface->failGetResolutionOnCall = 2; // getTimestampValidBits() also calls getTimerResolution()
EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_ERROR_NOT_AVAILABLE);
EXPECT_EQ(metricGroupProperties.domain, 0u);
EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED);
EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
@ -801,8 +792,15 @@ TEST_F(MetricEnumerationTest, GivenValidMetricGroupWhenReadingFrequencyAndIntern
EXPECT_EQ(metricTimestampProperties.timerResolution, 0UL);
EXPECT_EQ(metricTimestampProperties.timestampValidBits, 0UL);
mockOAOsInterface->getMetricsTimerResolutionReturn = ZE_RESULT_SUCCESS;
mockOAOsInterface->failGetResolutionOnCall = 0;
metricsDevice.resetMockVars();
metricsDevice.failGetGpuTimestampFrequencyOnCall = 2;
EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_ERROR_NOT_AVAILABLE);
EXPECT_EQ(metricGroupProperties.domain, 0u);
EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED);
EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
}
TEST_F(MetricEnumerationTest, GivenEnumerationIsSuccessfulWhenReadingMetricsFrequencyThenValuesAreUpdated) {

7
level_zero/tools/test/unit_tests/sources/metrics/wddm/test_metric_oa_enumeration_wddm.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2024 Intel Corporation
* Copyright (C) 2024-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -39,8 +39,6 @@ TEST_F(MetricEnumerationTestWddm, givenCorrectWddmAdapterWhenGetMetricsAdapterTh
setupDefaultMocksForMetricDevice(metricsDevice);
std::unique_ptr<MetricOAOsInterface> oaOsInterface = MetricOAOsInterface::create(*device);
adapterGroup.GetParamsResult = &adapterGroupParams;
adapterGroup.GetAdapterResult = &adapter;
adapter.GetParamsResult = &adapterParams;
@ -51,9 +49,6 @@ TEST_F(MetricEnumerationTestWddm, givenCorrectWddmAdapterWhenGetMetricsAdapterTh
mockMetricEnumeration->getMetricsAdapterResult = &adapter;
EXPECT_EQ(mockMetricEnumeration->openMetricsDiscovery(), ZE_RESULT_SUCCESS);
uint64_t timerResolution;
EXPECT_EQ(oaOsInterface->getMetricsTimerResolution(timerResolution), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
} // namespace ult
} // namespace L0