diff --git a/level_zero/api/extensions/public/ze_exp_ext.h b/level_zero/api/extensions/public/ze_exp_ext.h index ff9a1bb954..e209d6653f 100644 --- a/level_zero/api/extensions/public/ze_exp_ext.h +++ b/level_zero/api/extensions/public/ze_exp_ext.h @@ -56,6 +56,12 @@ ze_result_t zetMetricGroupCalculateMultipleMetricValuesExp( uint32_t *pMetricCounts, zet_typed_value_t *pMetricValues); +ze_result_t zetMetricGroupGetGlobalTimestampsExp( + zet_metric_group_handle_t hMetricGroup, + ze_bool_t synchronizedWithHost, + uint64_t *globalTimestamp, + uint64_t *metricTimestamp); + ze_result_t zeFabricVertexGetExp( ze_driver_handle_t hDriver, uint32_t *pCount, diff --git a/level_zero/api/extensions/public/zet_exp_ext.cpp b/level_zero/api/extensions/public/zet_exp_ext.cpp index 2248e72a19..4b4725149d 100644 --- a/level_zero/api/extensions/public/zet_exp_ext.cpp +++ b/level_zero/api/extensions/public/zet_exp_ext.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2021-2022 Intel Corporation + * Copyright (C) 2021-2023 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -22,6 +22,14 @@ ze_result_t zetMetricGroupCalculateMultipleMetricValuesExp( return L0::MetricGroup::fromHandle(hMetricGroup)->calculateMetricValuesExp(type, rawDataSize, pRawData, pSetCount, pTotalMetricValueCount, pMetricCounts, pMetricValues); } +ze_result_t zetMetricGroupGetGlobalTimestampsExp( + zet_metric_group_handle_t hMetricGroup, + ze_bool_t synchronizedWithHost, + uint64_t *globalTimestamp, + uint64_t *metricTimestamp) { + return L0::MetricGroup::fromHandle(hMetricGroup)->getMetricTimestampsExp(synchronizedWithHost, globalTimestamp, metricTimestamp); +} + } // namespace L0 extern "C" { @@ -39,4 +47,12 @@ zetMetricGroupCalculateMultipleMetricValuesExp( return L0::zetMetricGroupCalculateMultipleMetricValuesExp(hMetricGroup, type, rawDataSize, pRawData, pSetCount, pTotalMetricValueCount, pMetricCounts, pMetricValues); } +ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricGroupGetGlobalTimestampsExp( + zet_metric_group_handle_t hMetricGroup, + ze_bool_t synchronizedWithHost, + uint64_t *globalTimestamp, + uint64_t *metricTimestamp) { + return L0::zetMetricGroupGetGlobalTimestampsExp(hMetricGroup, synchronizedWithHost, globalTimestamp, metricTimestamp); +} + } // extern "C" diff --git a/level_zero/api/tools/ze_tools_loader.cpp b/level_zero/api/tools/ze_tools_loader.cpp index 951fd97ad0..b3d806aa8c 100644 --- a/level_zero/api/tools/ze_tools_loader.cpp +++ b/level_zero/api/tools/ze_tools_loader.cpp @@ -234,6 +234,7 @@ zetGetMetricGroupExpProcAddrTable( ze_result_t result = ZE_RESULT_SUCCESS; pDdiTable->pfnCalculateMultipleMetricValuesExp = L0::zetMetricGroupCalculateMultipleMetricValuesExp; + pDdiTable->pfnGetGlobalTimestampsExp = L0::zetMetricGroupGetGlobalTimestampsExp; return result; } diff --git a/level_zero/core/test/unit_tests/fixtures/device_fixture.h b/level_zero/core/test/unit_tests/fixtures/device_fixture.h index c5cac7e697..7cdde99db9 100644 --- a/level_zero/core/test/unit_tests/fixtures/device_fixture.h +++ b/level_zero/core/test/unit_tests/fixtures/device_fixture.h @@ -8,6 +8,7 @@ #pragma once #include "shared/source/helpers/hw_info.h" +#include "shared/source/os_interface/os_time.h" #include "shared/test/common/helpers/debug_manager_state_restore.h" #include "shared/test/common/mocks/mock_device.h" @@ -174,5 +175,38 @@ struct SingleRootMultiSubDeviceFixtureWithImplicitScaling : public SingleRootMul SingleRootMultiSubDeviceFixtureWithImplicitScaling() : SingleRootMultiSubDeviceFixtureWithImplicitScalingImpl(copyEngineCount, implicitScalingArg){}; }; +class FalseCpuGpuDeviceTime : public NEO::DeviceTime { + public: + bool getCpuGpuTime(TimeStampData *pGpuCpuTime, OSTime *osTime) override { + return false; + } + double getDynamicDeviceTimerResolution(HardwareInfo const &hwInfo) const override { + return NEO::OSTime::getDeviceTimerResolution(hwInfo); + } + uint64_t getDynamicDeviceTimerClock(HardwareInfo const &hwInfo) const override { + return static_cast(1000000000.0 / OSTime::getDeviceTimerResolution(hwInfo)); + } +}; + +class FalseCpuGpuTime : public NEO::OSTime { + public: + FalseCpuGpuTime() { + this->deviceTime = std::make_unique(); + } + + bool getCpuTime(uint64_t *timeStamp) override { + return true; + }; + double getHostTimerResolution() const override { + return 0; + } + uint64_t getCpuRawTimestamp() override { + return 0; + } + static std::unique_ptr create() { + return std::unique_ptr(new FalseCpuGpuTime()); + } +}; + } // namespace ult } // namespace L0 diff --git a/level_zero/core/test/unit_tests/sources/device/test_l0_device.cpp b/level_zero/core/test/unit_tests/sources/device/test_l0_device.cpp index ff168576c0..f48d8115c7 100644 --- a/level_zero/core/test/unit_tests/sources/device/test_l0_device.cpp +++ b/level_zero/core/test/unit_tests/sources/device/test_l0_device.cpp @@ -10,12 +10,10 @@ #include "shared/source/helpers/bit_helpers.h" #include "shared/source/helpers/compiler_product_helper.h" #include "shared/source/helpers/gfx_core_helper.h" -#include "shared/source/helpers/hw_info.h" #include "shared/source/helpers/preamble.h" #include "shared/source/helpers/ray_tracing_helper.h" #include "shared/source/os_interface/os_inc_base.h" #include "shared/source/os_interface/os_interface.h" -#include "shared/source/os_interface/os_time.h" #include "shared/source/os_interface/product_helper.h" #include "shared/source/unified_memory/usm_memory_support.h" #include "shared/test/common/helpers/debug_manager_state_restore.h" @@ -1518,39 +1516,6 @@ TEST_F(DeviceTest, whenGetGlobalTimestampIsCalledThenSuccessIsReturnedAndValuesS EXPECT_NE(0u, deviceTs); } -class FalseCpuGpuDeviceTime : public NEO::DeviceTime { - public: - bool getCpuGpuTime(TimeStampData *pGpuCpuTime, OSTime *osTime) override { - return false; - } - double getDynamicDeviceTimerResolution(HardwareInfo const &hwInfo) const override { - return NEO::OSTime::getDeviceTimerResolution(hwInfo); - } - uint64_t getDynamicDeviceTimerClock(HardwareInfo const &hwInfo) const override { - return static_cast(1000000000.0 / OSTime::getDeviceTimerResolution(hwInfo)); - } -}; - -class FalseCpuGpuTime : public NEO::OSTime { - public: - FalseCpuGpuTime() { - this->deviceTime = std::make_unique(); - } - - bool getCpuTime(uint64_t *timeStamp) override { - return true; - }; - double getHostTimerResolution() const override { - return 0; - } - uint64_t getCpuRawTimestamp() override { - return 0; - } - static std::unique_ptr create() { - return std::unique_ptr(new FalseCpuGpuTime()); - } -}; - struct GlobalTimestampTest : public ::testing::Test { void SetUp() override { DebugManager.flags.CreateMultipleRootDevices.set(numRootDevices); diff --git a/level_zero/tools/source/metrics/linux/os_metric_oa_enumeration_imp_linux.cpp b/level_zero/tools/source/metrics/linux/os_metric_oa_enumeration_imp_linux.cpp index bff85d7fad..7551b07513 100644 --- a/level_zero/tools/source/metrics/linux/os_metric_oa_enumeration_imp_linux.cpp +++ b/level_zero/tools/source/metrics/linux/os_metric_oa_enumeration_imp_linux.cpp @@ -104,7 +104,7 @@ ze_result_t MetricOALinuxImp::getMetricsTimerResolution(uint64_t &timerResolutio const auto drm = device.getOsInterface().getDriverModel()->as(); int32_t timestampFrequency; - int32_t ret = drm->getOATimestampFrequency(timestampFrequency); + int32_t ret = drm->getOaTimestampFrequency(timestampFrequency); if (ret < 0 || timestampFrequency == 0) { timerResolution = 0; result = ZE_RESULT_ERROR_UNKNOWN; diff --git a/level_zero/tools/source/metrics/metric.h b/level_zero/tools/source/metrics/metric.h index 240e5d1c08..88a38f43cd 100644 --- a/level_zero/tools/source/metrics/metric.h +++ b/level_zero/tools/source/metrics/metric.h @@ -41,8 +41,6 @@ class MetricSource { virtual ze_result_t getTimerResolution(uint64_t &resolution) = 0; virtual ze_result_t getTimestampValidBits(uint64_t &validBits) = 0; virtual ~MetricSource() = default; - - private: }; class MetricDeviceContext { @@ -98,6 +96,10 @@ struct MetricGroup : _zet_metric_group_handle_t { const uint8_t *pRawData, uint32_t *pSetCount, uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts, zet_typed_value_t *pMetricValues) = 0; + virtual ze_result_t getMetricTimestampsExp(const ze_bool_t synchronizedWithHost, + uint64_t *globalTimestamp, + uint64_t *metricTimestamp) = 0; + static MetricGroup *fromHandle(zet_metric_group_handle_t handle) { return static_cast(handle); } diff --git a/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp b/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp index 843eff1653..6d06ce6f24 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp @@ -29,7 +29,7 @@ std::unique_ptr IpSamplingMetricSourceImp::create(con } IpSamplingMetricSourceImp::IpSamplingMetricSourceImp(const MetricDeviceContext &metricDeviceContext) : metricDeviceContext(metricDeviceContext) { - metricIPSamplingOsInterface = MetricIpSamplingOsInterface::create(metricDeviceContext.getDevice()); + metricIPSamplingpOsInterface = MetricIpSamplingOsInterface::create(metricDeviceContext.getDevice()); } ze_result_t IpSamplingMetricSourceImp::getTimerResolution(uint64_t &resolution) { @@ -43,7 +43,7 @@ ze_result_t IpSamplingMetricSourceImp::getTimestampValidBits(uint64_t &validBits } void IpSamplingMetricSourceImp::enable() { - isEnabled = metricIPSamplingOsInterface->isDependencyAvailable(); + isEnabled = metricIPSamplingpOsInterface->isDependencyAvailable(); } bool IpSamplingMetricSourceImp::isAvailable() { @@ -144,8 +144,8 @@ ze_result_t IpSamplingMetricSourceImp::appendMetricMemoryBarrier(CommandList &co return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } -void IpSamplingMetricSourceImp::setMetricOsInterface(std::unique_ptr &metricIPSamplingOsInterface) { - this->metricIPSamplingOsInterface = std::move(metricIPSamplingOsInterface); +void IpSamplingMetricSourceImp::setMetricOsInterface(std::unique_ptr &metricIPSamplingpOsInterface) { + this->metricIPSamplingpOsInterface = std::move(metricIPSamplingpOsInterface); } IpSamplingMetricGroupImp::IpSamplingMetricGroupImp(IpSamplingMetricSourceImp &metricSource, @@ -256,6 +256,37 @@ ze_result_t IpSamplingMetricGroupImp::calculateMetricValuesExp(const zet_metric_ return result; } +ze_result_t getDeviceTimestamps(DeviceImp *deviceImp, const ze_bool_t synchronizedWithHost, + uint64_t *globalTimestamp, uint64_t *metricTimestamp) { + + ze_result_t result; + uint64_t hostTimestamp; + uint64_t deviceTimestamp; + + result = deviceImp->getGlobalTimestamps(&hostTimestamp, &deviceTimestamp); + if (result != ZE_RESULT_SUCCESS) { + *globalTimestamp = 0; + *metricTimestamp = 0; + } else { + if (synchronizedWithHost) { + *globalTimestamp = hostTimestamp; + } else { + *globalTimestamp = deviceTimestamp; + } + *metricTimestamp = deviceTimestamp; + result = ZE_RESULT_SUCCESS; + } + + return result; +} + +ze_result_t IpSamplingMetricGroupImp::getMetricTimestampsExp(const ze_bool_t synchronizedWithHost, + uint64_t *globalTimestamp, + uint64_t *metricTimestamp) { + DeviceImp *deviceImp = static_cast(&getMetricSource().getMetricDeviceContext().getDevice()); + return getDeviceTimestamps(deviceImp, synchronizedWithHost, globalTimestamp, metricTimestamp); +} + ze_result_t IpSamplingMetricGroupImp::getCalculatedMetricCount(const size_t rawDataSize, uint32_t &metricValueCount) { @@ -559,6 +590,13 @@ void MultiDeviceIpSamplingMetricGroupImp::closeSubDeviceStreamers(std::vector(&subDeviceMetricGroup[0]->getMetricSource().getMetricDeviceContext().getDevice()); + return getDeviceTimestamps(deviceImp, synchronizedWithHost, globalTimestamp, metricTimestamp); +} + std::unique_ptr MultiDeviceIpSamplingMetricGroupImp::create( std::vector &subDeviceMetricGroup) { UNRECOVERABLE_IF(subDeviceMetricGroup.size() == 0); diff --git a/level_zero/tools/source/metrics/metric_ip_sampling_source.h b/level_zero/tools/source/metrics/metric_ip_sampling_source.h index 03c668dce1..4b7429fc03 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.h +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.h @@ -25,9 +25,9 @@ class IpSamplingMetricSourceImp : public MetricSource { bool isAvailable() override; ze_result_t metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) override; ze_result_t appendMetricMemoryBarrier(CommandList &commandList) override; - void setMetricOsInterface(std::unique_ptr &metricIPSamplingOsInterface); + void setMetricOsInterface(std::unique_ptr &metricIPSamplingpOsInterface); static std::unique_ptr create(const MetricDeviceContext &metricDeviceContext); - MetricIpSamplingOsInterface *getMetricOsInterface() { return metricIPSamplingOsInterface.get(); } + MetricIpSamplingOsInterface *getMetricOsInterface() { return metricIPSamplingpOsInterface.get(); } IpSamplingMetricStreamerImp *pActiveStreamer = nullptr; const MetricDeviceContext &getMetricDeviceContext() const { return metricDeviceContext; } ze_result_t getTimerResolution(uint64_t &resolution) override; @@ -38,7 +38,7 @@ class IpSamplingMetricSourceImp : public MetricSource { bool isEnabled = false; const MetricDeviceContext &metricDeviceContext; - std::unique_ptr metricIPSamplingOsInterface = nullptr; + std::unique_ptr metricIPSamplingpOsInterface = nullptr; std::unique_ptr cachedMetricGroup = nullptr; }; @@ -80,6 +80,9 @@ struct IpSamplingMetricGroupImp : public IpSamplingMetricGroupBase { const uint8_t *pRawData, uint32_t *pSetCount, uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts, zet_typed_value_t *pMetricValues) override; + ze_result_t getMetricTimestampsExp(const ze_bool_t synchronizedWithHost, + uint64_t *globalTimestamp, + uint64_t *metricTimestamp) override; zet_metric_group_handle_t getMetricGroupForSubDevice(const uint32_t subDeviceIndex) override; ze_result_t streamerOpen( zet_context_handle_t hContext, @@ -121,6 +124,9 @@ struct MultiDeviceIpSamplingMetricGroupImp : public IpSamplingMetricGroupBase { const uint8_t *pRawData, uint32_t *pSetCount, uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts, zet_typed_value_t *pMetricValues) override; + ze_result_t getMetricTimestampsExp(const ze_bool_t synchronizedWithHost, + uint64_t *globalTimestamp, + uint64_t *metricTimestamp) override; zet_metric_group_handle_t getMetricGroupForSubDevice(const uint32_t subDeviceIndex) override; ze_result_t streamerOpen( zet_context_handle_t hContext, diff --git a/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp b/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp index ed1d739d35..b6fc0ffcb9 100644 --- a/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp +++ b/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp @@ -183,6 +183,14 @@ ze_result_t MetricEnumeration::openMetricsDiscovery() { subDeviceMetricEnumeraion.readGlobalSymbol(globalSymbolOaMaxBufferSize.data(), maximumOaBufferSize); } + + pAdapter->OpenMetricsDevice(&pMetricsDevice); + if (pMetricsDevice == nullptr) { + NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "unable to open metrics device %u\n", 0); + cleanupMetricsDiscovery(); + return ZE_RESULT_ERROR_NOT_AVAILABLE; + } + } else { auto &deviceImp = *static_cast(&metricSource.getDevice()); const uint32_t subDeviceIndex = deviceImp.getPhysicalSubDeviceId(); @@ -216,7 +224,9 @@ ze_result_t MetricEnumeration::cleanupMetricsDiscovery() { for (size_t i = 0; i < deviceImp.numSubDevices; i++) { deviceImp.subDevices[i]->getMetricDeviceContext().getMetricSource().getMetricEnumeration().cleanupMetricsDiscovery(); } - } else if (pMetricsDevice) { + } + + if (pMetricsDevice) { // Close metrics device for one sub device or root device. pAdapter->CloseMetricsDevice(pMetricsDevice); @@ -263,6 +273,7 @@ ze_result_t MetricEnumeration::cacheMetricInformation() { // Cache and aggregate all metric groups from all sub devices. for (uint32_t i = 0; i < metricGroupCount; i++) { auto metricGroupRootDevice = new OaMetricGroupImp(); + metricGroupRootDevice->setMetricSource(&metricSource); for (auto subDevice : deviceImp.subDevices) { MetricGroup *metricGroupSubDevice = subDevice->getMetricDeviceContext().getMetricSource().getMetricEnumeration().getMetricGroupByIndex(i); @@ -826,6 +837,46 @@ ze_result_t OaMetricGroupImp::calculateMetricValuesExp(const zet_metric_group_ca return result; } +ze_result_t OaMetricGroupImp::getMetricTimestampsExp(const ze_bool_t synchronizedWithHost, + uint64_t *globalTimestamp, + uint64_t *metricTimestamp) { + ze_result_t result; + OaMetricSourceImp *metricSource = getMetricSource(); + const auto deviceImp = static_cast(&metricSource->getMetricDeviceContext().getDevice()); + + uint64_t hostTimestamp; + uint64_t deviceTimestamp; + + result = deviceImp->getGlobalTimestamps(&hostTimestamp, &deviceTimestamp); + if (result != ZE_RESULT_SUCCESS) { + *globalTimestamp = 0; + *metricTimestamp = 0; + } else { + if (synchronizedWithHost) { + *globalTimestamp = hostTimestamp; + } else { + *globalTimestamp = deviceTimestamp; + } + + uint32_t cpuId; + MetricsDiscovery::ECompletionCode mdapiRetVal; + MetricsDiscovery::IMetricsDevice_1_5 *metricDevice; + metricDevice = getMetricSource()->getMetricEnumeration().getMetricDevice(); + + // MDAPI returns GPU timestamps in nanoseconds + mdapiRetVal = metricDevice->GetGpuCpuTimestamps(metricTimestamp, &hostTimestamp, &cpuId); + if (mdapiRetVal != MetricsDiscovery::CC_OK) { + *globalTimestamp = 0; + *metricTimestamp = 0; + result = ZE_RESULT_ERROR_NOT_AVAILABLE; + } else { + result = ZE_RESULT_SUCCESS; + } + } + + return result; +} + ze_result_t OaMetricGroupImp::getCalculatedMetricCount(const size_t rawDataSize, uint32_t &metricValueCount) { metricValueCount = 0; diff --git a/level_zero/tools/source/metrics/metric_oa_enumeration_imp.h b/level_zero/tools/source/metrics/metric_oa_enumeration_imp.h index 81fee79a32..839970be41 100644 --- a/level_zero/tools/source/metrics/metric_oa_enumeration_imp.h +++ b/level_zero/tools/source/metrics/metric_oa_enumeration_imp.h @@ -35,6 +35,7 @@ struct MetricEnumeration { uint32_t getMaxOaBufferSize() const { return maximumOaBufferSize; } bool readGlobalSymbol(const char *name, uint32_t &symbolValue); bool readGlobalSymbol(const char *name, uint64_t &symbolValue); + MetricsDiscovery::IMetricsDevice_1_5 *getMetricDevice() { return pMetricsDevice; }; protected: ze_result_t initialize(); @@ -92,6 +93,9 @@ struct OaMetricGroupImp : MetricGroup { const uint8_t *pRawData, uint32_t *pSetCount, uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts, zet_typed_value_t *pMetricValues) override; + ze_result_t getMetricTimestampsExp(const ze_bool_t synchronizedWithHost, + uint64_t *globalTimestamp, + uint64_t *metricTimestamp) override; ze_result_t initialize(const zet_metric_group_properties_t &sourceProperties, MetricsDiscovery::IMetricSet_1_5 &metricSet, MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup, @@ -131,6 +135,8 @@ struct OaMetricGroupImp : MetricGroup { MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup, const std::vector &metrics, MetricSource &metricSource); + OaMetricSourceImp *getMetricSource() { return metricSource; } + void setMetricSource(OaMetricSourceImp *inputMetricSource) { metricSource = inputMetricSource; } static ze_result_t getProperties(const zet_metric_group_handle_t handle, zet_metric_group_properties_t *pProperties); uint32_t getRawReportSize(); const MetricEnumeration &getMetricEnumeration() const; diff --git a/level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.cpp b/level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.cpp index ec305bbb8d..ce354a0602 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022 Intel Corporation + * Copyright (C) 2022-2023 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -55,5 +55,24 @@ void MetricIpSamplingFixture::TearDown() { MultiDeviceFixture::tearDown(); } +void MetricIpSamplingTimestampFixture::SetUp() { + DeviceFixture::setUp(); + auto mockMetricIpSamplingOsInterface = new MockMetricIpSamplingOsInterface(); + osInterfaceVector.push_back(mockMetricIpSamplingOsInterface); + std::unique_ptr metricIpSamplingOsInterface = std::unique_ptr(mockMetricIpSamplingOsInterface); + + auto &metricSource = device->getMetricDeviceContext().getMetricSource(); + metricSource.setMetricOsInterface(metricIpSamplingOsInterface); + + auto &metricOaSource = device->getMetricDeviceContext().getMetricSource(); + metricOaSource.setInitializationState(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); + + GlobalDriverHandle = static_cast<_ze_driver_handle_t *>(driverHandle.get()); +} + +void MetricIpSamplingTimestampFixture::TearDown() { + DeviceFixture::tearDown(); +} + } // namespace ult } // namespace L0 diff --git a/level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h b/level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h index 5aadf27b83..7f1e167513 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h +++ b/level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h @@ -64,6 +64,16 @@ class MetricIpSamplingFixture : public MultiDeviceFixture, std::vector testDevices = {}; }; +class MetricIpSamplingTimestampFixture : public DeviceFixture, + public ::testing::Test { + public: + void SetUp(); + void TearDown(); + + DebugManagerStateRestore restorer; + std::vector osInterfaceVector = {}; +}; + class MetricIpSamplingCalculateMetricsFixture : public MetricIpSamplingFixture { public: void addHeader(uint8_t *rawDataOut, size_t rawDataOutSize, uint8_t *rawDataIn, size_t rawDataInSize, uint32_t setIndex) { diff --git a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.cpp b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.cpp index 26cd802d82..079113b72d 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.cpp @@ -218,8 +218,12 @@ void MetricMultiDeviceFixture::openMetricsAdapter() { .Times(2) .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(&metricsDevice), Return(TCompletionCode::CC_OK))); + EXPECT_CALL(adapter, OpenMetricsDevice(_)) + .Times(1) + .WillOnce(DoAll(::testing::SetArgPointee<0>(&metricsDevice), Return(TCompletionCode::CC_OK))); + EXPECT_CALL(adapter, CloseMetricsDevice(_)) - .Times(2) + .Times(3) .WillRepeatedly(Return(TCompletionCode::CC_OK)); EXPECT_CALL(adapterGroup, GetAdapter(_)) diff --git a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.h b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.h index 264567ebc3..03219a0f17 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.h +++ b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.h @@ -112,6 +112,7 @@ class Mock : public IMetricsDevice_1_5 { MetricsDiscovery::TTypedValue_1_0 symbolValue = {}; bool forceGetSymbolByNameFail = false; + bool forceGetGpuCpuTimestampsFail = false; TTypedValue_1_0 *GetGlobalSymbolValueByName(const char *name) override { bool found = false; if (forceGetSymbolByNameFail) { @@ -133,7 +134,20 @@ class Mock : public IMetricsDevice_1_5 { } MOCK_METHOD(TCompletionCode, GetLastError, (), (override)); - MOCK_METHOD(TCompletionCode, GetGpuCpuTimestamps, (uint64_t * gpuTimestampNs, uint64_t *cpuTimestampNs, uint32_t *cpuId), (override)); + + TCompletionCode GetGpuCpuTimestamps(uint64_t *gpuTimestampNs, uint64_t *cpuTimestampNs, uint32_t *cpuId) override { + if (forceGetGpuCpuTimestampsFail) { + *gpuTimestampNs = 0; + *cpuTimestampNs = 0; + *cpuId = 0; + return MetricsDiscovery::CC_ERROR_GENERAL; + } + + *gpuTimestampNs += 10; + *cpuTimestampNs += 10; + *cpuId = 0; + return MetricsDiscovery::CC_OK; + } }; template <> diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp index a959de7e5c..0432e5b0db 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp @@ -228,6 +228,104 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenReadingM } } +TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulOnMulitDeviceWhenReadingMetricsTimestampThenResultIsSuccess) { + + EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); + + for (auto device : testDevices) { + + ze_device_properties_t deviceProps = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2, nullptr}; + device->getProperties(&deviceProps); + + uint32_t metricGroupCount = 0; + zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); + EXPECT_EQ(metricGroupCount, 1u); + + std::vector metricGroups; + metricGroups.resize(metricGroupCount); + + ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); + ASSERT_NE(metricGroups[0], nullptr); + ze_bool_t synchronizedWithHost = true; + uint64_t globalTimestamp = 0; + uint64_t metricTimestamp = 0; + + EXPECT_EQ(L0::zetMetricGroupGetGlobalTimestampsExp(metricGroups[0], synchronizedWithHost, &globalTimestamp, &metricTimestamp), ZE_RESULT_SUCCESS); + } +} + +using MetricIpSamplingTimestampTest = MetricIpSamplingTimestampFixture; + +TEST_F(MetricIpSamplingTimestampTest, GivenEnumerationIsSuccessfulWhenReadingMetricsFrequencyThenValuesAreUpdated) { + + EXPECT_EQ(ZE_RESULT_SUCCESS, device->getMetricDeviceContext().enableMetricApi()); + + ze_device_properties_t deviceProps = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2, nullptr}; + device->getProperties(&deviceProps); + + uint32_t metricGroupCount = 0; + zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); + EXPECT_EQ(metricGroupCount, 1u); + + std::vector metricGroups; + metricGroups.resize(metricGroupCount); + + ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); + ASSERT_NE(metricGroups[0], nullptr); + + ze_bool_t synchronizedWithHost = true; + uint64_t globalTimestamp = 0; + uint64_t metricTimestamp = 0; + + EXPECT_EQ(L0::zetMetricGroupGetGlobalTimestampsExp(metricGroups[0], synchronizedWithHost, &globalTimestamp, &metricTimestamp), ZE_RESULT_SUCCESS); + EXPECT_NE(globalTimestamp, 0UL); + EXPECT_NE(metricTimestamp, 0UL); + + synchronizedWithHost = false; + globalTimestamp = 0; + metricTimestamp = 0; + + EXPECT_EQ(L0::zetMetricGroupGetGlobalTimestampsExp(metricGroups[0], synchronizedWithHost, &globalTimestamp, &metricTimestamp), ZE_RESULT_SUCCESS); + EXPECT_NE(globalTimestamp, 0UL); + EXPECT_NE(metricTimestamp, 0UL); + + DebugManager.flags.EnableImplicitScaling.set(1); + globalTimestamp = 0; + metricTimestamp = 0; + + EXPECT_EQ(L0::zetMetricGroupGetGlobalTimestampsExp(metricGroups[0], synchronizedWithHost, &globalTimestamp, &metricTimestamp), ZE_RESULT_SUCCESS); + EXPECT_NE(globalTimestamp, 0UL); + EXPECT_NE(metricTimestamp, 0UL); +} + +TEST_F(MetricIpSamplingTimestampTest, GivenGetCpuGpuTimeIsFalseWhenReadingMetricsFrequencyThenValuesAreZero) { + + EXPECT_EQ(ZE_RESULT_SUCCESS, device->getMetricDeviceContext().enableMetricApi()); + + neoDevice->setOSTime(new FalseCpuGpuTime()); + + ze_device_properties_t deviceProps = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2, nullptr}; + device->getProperties(&deviceProps); + + uint32_t metricGroupCount = 0; + zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); + EXPECT_EQ(metricGroupCount, 1u); + + std::vector metricGroups; + metricGroups.resize(metricGroupCount); + + ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); + ASSERT_NE(metricGroups[0], nullptr); + + ze_bool_t synchronizedWithHost = true; + uint64_t globalTimestamp = 1; + uint64_t metricTimestamp = 1; + + EXPECT_EQ(L0::zetMetricGroupGetGlobalTimestampsExp(metricGroups[0], synchronizedWithHost, &globalTimestamp, &metricTimestamp), ZE_RESULT_ERROR_DEVICE_LOST); + EXPECT_EQ(globalTimestamp, 0UL); + EXPECT_EQ(metricTimestamp, 0UL); +} + using MetricIpSamplingCalculateMetricsTest = MetricIpSamplingCalculateMetricsFixture; TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMultipleMetricValuesExpIsCalledThenValidDataIsReturned) { diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp index eb4bcf4760..8a1b04d1c4 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp @@ -624,7 +624,7 @@ TEST_F(MetricEnumerationTest, GivenValidMetricGroupWhenReadingFrequencyAndIntern mockOAOsInterface->getMetricsTimerResolutionReturn = ZE_RESULT_ERROR_UNKNOWN; mockOAOsInterface->getResolutionCallCount = 0; - mockOAOsInterface->failGetResolutionOnCall = 2; // getTimestampValidBits() also calls getTimestampValidBits() + mockOAOsInterface->failGetResolutionOnCall = 2; // getTimestampValidBits() also calls getTimerResolution() EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_ERROR_UNKNOWN); EXPECT_EQ(metricGroupProperties.domain, 0u); @@ -640,6 +640,157 @@ TEST_F(MetricEnumerationTest, GivenValidMetricGroupWhenReadingFrequencyAndIntern mockOAOsInterface->failGetResolutionOnCall = 0; } +TEST_F(MetricEnumerationTest, GivenEnumerationIsSuccessfulWhenReadingMetricsFrequencyThenValuesAreUpdated) { + + // Metrics Discovery device. + metricsDeviceParams.ConcurrentGroupsCount = 1; + + // Metrics Discovery concurrent group. + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + metricsConcurrentGroupParams.MetricSetsCount = 1; + metricsConcurrentGroupParams.SymbolName = "OA"; + metricsConcurrentGroupParams.Description = "OA description"; + + // Metrics Discovery:: metric set. + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; + metricsSetParams.MetricsCount = 0; + metricsSetParams.SymbolName = "Metric set name"; + metricsSetParams.ShortName = "Metric set description"; + + // One api: metric group handle. + zet_metric_group_handle_t metricGroupHandle = {}; + + MetricsDiscovery::TTypedValue_1_0 defaultMaxTimestamp = {}; + defaultMaxTimestamp.ValueType = MetricsDiscovery::TValueType::VALUE_TYPE_UINT64; + defaultMaxTimestamp.ValueUInt64 = UINT64_MAX; + + openMetricsAdapter(); + + setupDefaultMocksForMetricDevice(metricsDevice); + + EXPECT_CALL(metricsDevice, GetConcurrentGroup(_)) + .Times(1) + .WillOnce(Return(&metricsConcurrentGroup)); + + EXPECT_CALL(metricsConcurrentGroup, GetParams()) + .Times(1) + .WillRepeatedly(Return(&metricsConcurrentGroupParams)); + + EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_)) + .WillRepeatedly(Return(&metricsSet)); + + EXPECT_CALL(metricsSet, GetParams()) + .WillRepeatedly(Return(&metricsSetParams)); + + EXPECT_CALL(metricsSet, SetApiFiltering(_)) + .WillRepeatedly(Return(TCompletionCode::CC_OK)); + + // Metric group count. + uint32_t metricGroupCount = 0; + EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS); + EXPECT_EQ(metricGroupCount, 1u); + + // Metric group handle. + EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS); + EXPECT_EQ(metricGroupCount, 1u); + EXPECT_NE(metricGroupHandle, nullptr); + + ze_bool_t synchronizedWithHost = true; + uint64_t globalTimestamp = 0; + uint64_t metricTimestamp = 0; + + EXPECT_EQ(L0::zetMetricGroupGetGlobalTimestampsExp(metricGroupHandle, synchronizedWithHost, &globalTimestamp, &metricTimestamp), ZE_RESULT_SUCCESS); + EXPECT_NE(globalTimestamp, 0UL); + EXPECT_NE(metricTimestamp, 0UL); + + synchronizedWithHost = false; + globalTimestamp = 0; + metricTimestamp = 0; + + EXPECT_EQ(L0::zetMetricGroupGetGlobalTimestampsExp(metricGroupHandle, synchronizedWithHost, &globalTimestamp, &metricTimestamp), ZE_RESULT_SUCCESS); + EXPECT_NE(globalTimestamp, 0UL); + EXPECT_NE(metricTimestamp, 0UL); +} + +TEST_F(MetricEnumerationTest, GivenEnumerationIsSuccessfulWhenFailingToReadMetricsOrDeviceTimestampsThenValuesAreZero) { + + // Metrics Discovery device. + metricsDeviceParams.ConcurrentGroupsCount = 1; + + // Metrics Discovery concurrent group. + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + metricsConcurrentGroupParams.MetricSetsCount = 1; + metricsConcurrentGroupParams.SymbolName = "OA"; + metricsConcurrentGroupParams.Description = "OA description"; + + // Metrics Discovery:: metric set. + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; + metricsSetParams.MetricsCount = 0; + metricsSetParams.SymbolName = "Metric set name"; + metricsSetParams.ShortName = "Metric set description"; + + // One api: metric group handle. + zet_metric_group_handle_t metricGroupHandle = {}; + + MetricsDiscovery::TTypedValue_1_0 defaultMaxTimestamp = {}; + defaultMaxTimestamp.ValueType = MetricsDiscovery::TValueType::VALUE_TYPE_UINT64; + defaultMaxTimestamp.ValueUInt64 = UINT64_MAX; + + openMetricsAdapter(); + + setupDefaultMocksForMetricDevice(metricsDevice); + + EXPECT_CALL(metricsDevice, GetConcurrentGroup(_)) + .Times(1) + .WillOnce(Return(&metricsConcurrentGroup)); + + EXPECT_CALL(metricsConcurrentGroup, GetParams()) + .Times(1) + .WillRepeatedly(Return(&metricsConcurrentGroupParams)); + + EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_)) + .WillRepeatedly(Return(&metricsSet)); + + EXPECT_CALL(metricsSet, GetParams()) + .WillRepeatedly(Return(&metricsSetParams)); + + EXPECT_CALL(metricsSet, SetApiFiltering(_)) + .WillRepeatedly(Return(TCompletionCode::CC_OK)); + + // Metric group count. + uint32_t metricGroupCount = 0; + EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS); + EXPECT_EQ(metricGroupCount, 1u); + + // Metric group handle. + EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS); + EXPECT_EQ(metricGroupCount, 1u); + EXPECT_NE(metricGroupHandle, nullptr); + + ze_bool_t synchronizedWithHost = true; + uint64_t globalTimestamp = 1; + uint64_t metricTimestamp = 1; + metricsDevice.forceGetGpuCpuTimestampsFail = true; + + EXPECT_EQ(L0::zetMetricGroupGetGlobalTimestampsExp(metricGroupHandle, synchronizedWithHost, &globalTimestamp, &metricTimestamp), ZE_RESULT_ERROR_NOT_AVAILABLE); + EXPECT_EQ(globalTimestamp, 0UL); + EXPECT_EQ(metricTimestamp, 0UL); + metricsDevice.forceGetGpuCpuTimestampsFail = false; + + globalTimestamp = 1; + metricTimestamp = 1; + neoDevice->setOSTime(new FalseCpuGpuTime()); + EXPECT_EQ(L0::zetMetricGroupGetGlobalTimestampsExp(metricGroupHandle, synchronizedWithHost, &globalTimestamp, &metricTimestamp), ZE_RESULT_ERROR_DEVICE_LOST); + EXPECT_EQ(globalTimestamp, 0UL); + EXPECT_EQ(metricTimestamp, 0UL); +} + TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetIsCalledThenReturnsCorrectMetric) { // Metrics Discovery device. diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_2.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_2.cpp index f386d2e511..6c85904fb9 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_2.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_2.cpp @@ -170,8 +170,12 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa .Times(subDeviceCount) .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(&mockDevice), Return(TCompletionCode::CC_OK))); + EXPECT_CALL(mockAdapter, OpenMetricsDevice(_)) + .Times(1) + .WillOnce(DoAll(::testing::SetArgPointee<0>(&mockDevice), Return(TCompletionCode::CC_OK))); + EXPECT_CALL(mockAdapter, CloseMetricsDevice(_)) - .Times(subDeviceCount) + .Times(subDeviceCount + 1) .WillRepeatedly(Return(TCompletionCode::CC_OK)); setupDefaultMocksForMetricDevice(mockDevice); @@ -310,6 +314,58 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), false); } +TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesAndOpenAdapterOnRootDeviceFailsThenCLeanUpIsDone) { + + // Use first root device. + auto &metricSource = devices[0]->getMetricDeviceContext().getMetricSource(); + auto &deviceImp = *static_cast(devices[0]); + const uint32_t subDeviceCount = static_cast(deviceImp.subDevices.size()); + Mock mockAdapterGroup; + Mock mockAdapter; + Mock mockDevice; + + EXPECT_CALL(*mockMetricsLibrary, load()) + .Times(1) + .WillOnce(Return(true)); + + EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery()) + .Times(1) + .WillOnce(Return(ZE_RESULT_SUCCESS)); + + EXPECT_CALL(*Mock::g_mockApi, MockOpenAdapterGroup(_)) + .Times(1) + .WillOnce(DoAll(::testing::SetArgPointee<0>(&mockAdapterGroup), Return(TCompletionCode::CC_OK))); + + EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter()) + .Times(1) + .WillOnce(Return(&mockAdapter)); + + EXPECT_CALL(mockAdapter, OpenMetricsSubDevice(_, _)) + .Times(subDeviceCount) + .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(&mockDevice), Return(TCompletionCode::CC_OK))); + + EXPECT_CALL(mockAdapter, OpenMetricsDevice(_)) + .Times(1) + .WillOnce(DoAll(::testing::SetArgPointee<0>(nullptr), Return(TCompletionCode::CC_ERROR_GENERAL))); + + EXPECT_CALL(mockAdapter, CloseMetricsDevice(_)) + .Times(subDeviceCount) + .WillRepeatedly(Return(TCompletionCode::CC_OK)); + + setupDefaultMocksForMetricDevice(mockDevice); + + EXPECT_CALL(mockAdapterGroup, Close()) + .Times(1) + .WillOnce(Return(TCompletionCode::CC_OK)); + + // Use root device. + devices[0]->getMetricDeviceContext().setSubDeviceIndex(0); + mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS; + + EXPECT_EQ(metricSource.loadDependencies(), true); + EXPECT_EQ(mockMetricEnumeration->openMetricsDiscovery(), ZE_RESULT_ERROR_NOT_AVAILABLE); +} + TEST_F(MetricEnumerationMultiDeviceTest, givenIncorrectMetricsDiscoveryInterfaceVersionWhenZetGetMetricGroupIsCalledThenReturnsFail) { metricsDeviceParams.Version.MajorNumber = 0; diff --git a/shared/source/os_interface/linux/drm_neo.cpp b/shared/source/os_interface/linux/drm_neo.cpp index c6951fee6c..ef83c84155 100644 --- a/shared/source/os_interface/linux/drm_neo.cpp +++ b/shared/source/os_interface/linux/drm_neo.cpp @@ -817,7 +817,7 @@ int Drm::getTimestampFrequency(int &frequency) { return getParamIoctl(DrmParam::ParamCsTimestampFrequency, &frequency); } -int Drm::getOATimestampFrequency(int &frequency) { +int Drm::getOaTimestampFrequency(int &frequency) { frequency = 0; return getParamIoctl(DrmParam::ParamOATimestampFrequency, &frequency); } diff --git a/shared/source/os_interface/linux/drm_neo.h b/shared/source/os_interface/linux/drm_neo.h index 1f48f9492a..f4d39684e9 100644 --- a/shared/source/os_interface/linux/drm_neo.h +++ b/shared/source/os_interface/linux/drm_neo.h @@ -97,7 +97,7 @@ class Drm : public DriverModel { int getEnabledPooledEu(int &enabled); int getMinEuInPool(int &minEUinPool); int getTimestampFrequency(int &frequency); - int getOATimestampFrequency(int &frequency); + int getOaTimestampFrequency(int &frequency); MOCKABLE_VIRTUAL int queryGttSize(uint64_t >tSizeOutput); bool isPreemptionSupported() const { return preemptionSupported; } diff --git a/shared/test/unit_test/os_interface/linux/drm_tests.cpp b/shared/test/unit_test/os_interface/linux/drm_tests.cpp index a0a2cc8e5e..00ff7dc5bc 100644 --- a/shared/test/unit_test/os_interface/linux/drm_tests.cpp +++ b/shared/test/unit_test/os_interface/linux/drm_tests.cpp @@ -916,7 +916,7 @@ TEST(DrmTest, givenPrintIoctlDebugFlagSetWhenGettingOATimestampFrequencyThenCapt testing::internal::CaptureStdout(); // start capturing - int ret = drm.getOATimestampFrequency(frequency); + int ret = drm.getOaTimestampFrequency(frequency); DebugManager.flags.PrintIoctlEntries.set(false); std::string outputString = testing::internal::GetCapturedStdout(); // stop capturing