intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-25 05:24:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

feature: support metric group type

Browse Source 
Related-To: NEO-12055

Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>
This commit is contained in:
Joshua Santosh Ranjan
2024-08-31 17:26:46 +00:00
committed by Compute-Runtime-Automation
parent eca60f01d1
commit 365b0affc9
11 changed files with 194 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
level_zero/api/driver_experimental/public/zex_metric.h
View File

@@ -14,6 +14,28 @@
#include <level_zero/ze_api.h>
#include <level_zero/zet_api.h>
#define ZET_INTEL_STRUCTURE_TYPE_METRIC_GROUP_TYPE_EXP (static_cast<zet_structure_type_t>(0x00010006))
#define ZET_INTEL_STRUCTURE_TYPE_EXPORT_DMA_EXP_PROPERTIES (static_cast<zet_structure_type_t>(0x00010007))
#define ZET_INTEL_METRIC_TYPE_EXPORT_DMA_BUF (0x7ffffffd)
typedef struct _zet_intel_export_dma_buf_exp_properties_t {
zet_structure_type_t stype;
void *pNext;
int fd; // [out] the file descriptor handle that could be used to import the memory by the host process.
size_t size; // [out] size in bytes of the dma_buf
} zet_intel_export_dma_buf_exp_properties_t;
typedef enum _zet_intel_metric_group_type_exp_flags_t {
ZET_INTEL_METRIC_GROUP_TYPE_EXP_OTHER = ZE_BIT(0),
ZET_INTEL_METRIC_GROUP_TYPE_EXP_EXPORT_DMA_BUF = ZE_BIT(1)
} zet_intel_metric_group_type_exp_flags_t;
typedef struct _zet_intel_metric_group_type_exp_t {
zet_structure_type_t stype;
void *pNext;
zet_intel_metric_group_type_exp_flags_t type; //[out] metric group type
} zet_intel_metric_group_type_exp_t;
namespace L0 {
///////////////////////////////////////////////////////////////////////////////
/// @brief Get sets of metric groups which could be collected concurrently.

32
level_zero/tools/source/metrics/metric.cpp
View File

@@ -299,38 +299,6 @@ ze_result_t metricStreamerOpen(zet_context_handle_t hContext, zet_device_handle_
return MetricGroup::fromHandle(hMetricGroup)->streamerOpen(hContext, hDevice, pDesc, hNotificationEvent, phMetricStreamer);
}
ze_result_t MetricGroup::getMetricGroupExtendedProperties(MetricSource &metricSource, void *pNext) {
ze_result_t retVal = ZE_RESULT_ERROR_INVALID_ARGUMENT;
while (pNext) {
zet_base_desc_t *extendedProperties = reinterpret_cast<zet_base_desc_t *>(pNext);
if (extendedProperties->stype == ZET_STRUCTURE_TYPE_METRIC_GLOBAL_TIMESTAMPS_RESOLUTION_EXP) {
zet_metric_global_timestamps_resolution_exp_t *metricsTimestampProperties =
reinterpret_cast<zet_metric_global_timestamps_resolution_exp_t *>(extendedProperties);
retVal = metricSource.getTimerResolution(metricsTimestampProperties->timerResolution);
if (retVal != ZE_RESULT_SUCCESS) {
metricsTimestampProperties->timerResolution = 0;
metricsTimestampProperties->timestampValidBits = 0;
return retVal;
}
retVal = metricSource.getTimestampValidBits(metricsTimestampProperties->timestampValidBits);
if (retVal != ZE_RESULT_SUCCESS) {
metricsTimestampProperties->timerResolution = 0;
metricsTimestampProperties->timestampValidBits = 0;
return retVal;
}
}
pNext = const_cast<void *>(extendedProperties->pNext);
}
return retVal;
}
bool MultiDomainDeferredActivationTracker::activateMetricGroupsDeferred(uint32_t count, zet_metric_group_handle_t *phMetricGroups) {
// Activation: postpone until zetMetricStreamerOpen or zeCommandQueueExecuteCommandLists

4
level_zero/tools/source/metrics/metric.h
View File

@@ -53,8 +53,6 @@ class MetricSource {
virtual bool isAvailable() = 0;
virtual ze_result_t appendMetricMemoryBarrier(CommandList &commandList) = 0;
virtual ze_result_t metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) = 0;
virtual ze_result_t getTimerResolution(uint64_t &resolution) = 0;
virtual ze_result_t getTimestampValidBits(uint64_t &validBits) = 0;
virtual ze_result_t activateMetricGroupsPreferDeferred(uint32_t count, zet_metric_group_handle_t *phMetricGroups) = 0;
virtual ze_result_t activateMetricGroupsAlreadyDeferred() = 0;
virtual ze_result_t metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) = 0;
@@ -71,6 +69,7 @@ class MetricSource {
uint32_t getType() const {
return type;
}
virtual ze_result_t handleMetricGroupExtendedProperties(void *pNext) = 0;
protected:
uint32_t type = MetricSource::metricSourceTypeUndefined;
@@ -194,7 +193,6 @@ struct MetricGroup : _zet_metric_group_handle_t {
zet_device_handle_t hDevice,
const zet_metric_query_pool_desc_t *desc,
zet_metric_query_pool_handle_t *phMetricQueryPool) = 0;
ze_result_t getMetricGroupExtendedProperties(MetricSource &metricSource, void *pnext);
virtual ze_result_t getExportData(const uint8_t *pRawData, size_t rawDataSize, size_t *pExportDataSize,
uint8_t *pExportData) = 0;
};

30
level_zero/tools/source/metrics/metric_ip_sampling_source.cpp
View File

@@ -12,6 +12,7 @@
#include "shared/source/helpers/hw_info.h"
#include "shared/source/helpers/string.h"
#include "level_zero/api/driver_experimental/public/zex_metric.h"
#include "level_zero/core/source/device/device.h"
#include "level_zero/core/source/device/device_imp.h"
#include "level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h"
@@ -206,6 +207,33 @@ ze_result_t IpSamplingMetricSourceImp::getConcurrentMetricGroups(std::vector<zet
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingMetricSourceImp::handleMetricGroupExtendedProperties(void *pNext) {
ze_result_t retVal = ZE_RESULT_ERROR_INVALID_ARGUMENT;
while (pNext) {
auto extendedProperties = reinterpret_cast<zet_base_properties_t *>(pNext);
if (extendedProperties->stype == ZET_STRUCTURE_TYPE_METRIC_GLOBAL_TIMESTAMPS_RESOLUTION_EXP) {
zet_metric_global_timestamps_resolution_exp_t *metricsTimestampProperties =
reinterpret_cast<zet_metric_global_timestamps_resolution_exp_t *>(extendedProperties);
getTimerResolution(metricsTimestampProperties->timerResolution);
getTimestampValidBits(metricsTimestampProperties->timestampValidBits);
retVal = ZE_RESULT_SUCCESS;
}
if (extendedProperties->stype == ZET_INTEL_STRUCTURE_TYPE_METRIC_GROUP_TYPE_EXP) {
zet_intel_metric_group_type_exp_t *groupType = reinterpret_cast<zet_intel_metric_group_type_exp_t *>(extendedProperties);
groupType->type = ZET_INTEL_METRIC_GROUP_TYPE_EXP_OTHER;
retVal = ZE_RESULT_SUCCESS;
}
pNext = extendedProperties->pNext;
}
return retVal;
}
IpSamplingMetricGroupImp::IpSamplingMetricGroupImp(IpSamplingMetricSourceImp &metricSource,
std::vector<IpSamplingMetricImp> &metrics) : IpSamplingMetricGroupBase(metricSource) {
this->metrics.reserve(metrics.size());
@@ -228,7 +256,7 @@ ze_result_t IpSamplingMetricGroupImp::getProperties(zet_metric_group_properties_
pProperties->pNext = pNext;
if (pNext) {
return getMetricGroupExtendedProperties(metricSource, pNext);
return metricSource.handleMetricGroupExtendedProperties(pNext);
}
return ZE_RESULT_SUCCESS;

5
level_zero/tools/source/metrics/metric_ip_sampling_source.h
View File

@@ -40,8 +40,7 @@ class IpSamplingMetricSourceImp : public MetricSource {
MetricIpSamplingOsInterface *getMetricOsInterface() { return metricIPSamplingpOsInterface.get(); }
IpSamplingMetricStreamerImp *pActiveStreamer = nullptr;
const MetricDeviceContext &getMetricDeviceContext() const { return metricDeviceContext; }
ze_result_t getTimerResolution(uint64_t &resolution) override;
ze_result_t getTimestampValidBits(uint64_t &validBits) override;
ze_result_t handleMetricGroupExtendedProperties(void *pNext) override;
void setActivationTracker(MultiDomainDeferredActivationTracker *inputActivationTracker) {
activationTracker.reset(inputActivationTracker);
}
@@ -55,6 +54,8 @@ class IpSamplingMetricSourceImp : public MetricSource {
std::unique_ptr<MetricIpSamplingOsInterface> metricIPSamplingpOsInterface = nullptr;
std::unique_ptr<MetricGroup> cachedMetricGroup = nullptr;
std::unique_ptr<MultiDomainDeferredActivationTracker> activationTracker{};
ze_result_t getTimerResolution(uint64_t &resolution);
ze_result_t getTimestampValidBits(uint64_t &validBits);
};
struct IpSamplingMetricGroupBase : public MetricGroupImp {

2
level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp
View File

@@ -561,7 +561,7 @@ ze_result_t OaMetricGroupImp::getProperties(zet_metric_group_properties_t *pProp
copyProperties(properties, *pProperties);
pProperties->pNext = pNext;
if (pNext) {
status = getMetricGroupExtendedProperties(metricSource, pNext);
status = metricSource.handleMetricGroupExtendedProperties(pNext);
}
}

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

@@ -9,6 +9,7 @@
#include "shared/source/os_interface/os_library.h"
#include "level_zero/api/driver_experimental/public/zex_metric.h"
#include "level_zero/core/source/cmdlist/cmdlist.h"
#include "level_zero/core/source/device/device_imp.h"
#include "level_zero/tools/source/metrics/metric.h"
@@ -199,6 +200,42 @@ ze_result_t OaMetricSourceImp::getConcurrentMetricGroups(std::vector<zet_metric_
return ZE_RESULT_SUCCESS;
}
ze_result_t OaMetricSourceImp::handleMetricGroupExtendedProperties(void *pNext) {
ze_result_t retVal = ZE_RESULT_ERROR_INVALID_ARGUMENT;
while (pNext) {
auto extendedProperties = reinterpret_cast<zet_base_properties_t *>(pNext);
if (extendedProperties->stype == ZET_STRUCTURE_TYPE_METRIC_GLOBAL_TIMESTAMPS_RESOLUTION_EXP) {
zet_metric_global_timestamps_resolution_exp_t *metricsTimestampProperties =
reinterpret_cast<zet_metric_global_timestamps_resolution_exp_t *>(extendedProperties);
retVal = getTimerResolution(metricsTimestampProperties->timerResolution);
if (retVal != ZE_RESULT_SUCCESS) {
metricsTimestampProperties->timerResolution = 0;
metricsTimestampProperties->timestampValidBits = 0;
return retVal;
}
retVal = getTimestampValidBits(metricsTimestampProperties->timestampValidBits);
if (retVal != ZE_RESULT_SUCCESS) {
metricsTimestampProperties->timerResolution = 0;
metricsTimestampProperties->timestampValidBits = 0;
return retVal;
}
}
if (extendedProperties->stype == ZET_INTEL_STRUCTURE_TYPE_METRIC_GROUP_TYPE_EXP) {
zet_intel_metric_group_type_exp_t *groupType = reinterpret_cast<zet_intel_metric_group_type_exp_t *>(extendedProperties);
groupType->type = ZET_INTEL_METRIC_GROUP_TYPE_EXP_OTHER;
retVal = ZE_RESULT_SUCCESS;
}
pNext = extendedProperties->pNext;
}
return retVal;
}
template <>
OaMetricSourceImp &MetricDeviceContext::getMetricSource<OaMetricSourceImp>() const {
return static_cast<OaMetricSourceImp &>(*metricSources.at(MetricSource::metricSourceTypeOa));

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

@@ -34,15 +34,13 @@ class OaMetricSourceImp : public MetricSource {
std::unique_ptr<MetricsLibrary> &getMetricsLibraryObject() { return metricsLibrary; }
std::unique_ptr<MetricEnumeration> &getMetricEnumerationObject() { return metricEnumeration; }
ze_result_t getTimerResolution(uint64_t &resolution) override;
ze_result_t getTimestampValidBits(uint64_t &validBits) override;
ze_result_t activateMetricGroupsAlreadyDeferred() override;
ze_result_t activateMetricGroupsPreferDeferred(const uint32_t count,
zet_metric_group_handle_t *phMetricGroups) override;
ze_result_t metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) override;
ze_result_t getConcurrentMetricGroups(std::vector<zet_metric_group_handle_t> &hMetricGroups,
uint32_t *pConcurrentGroupCount, uint32_t *pCountPerConcurrentGroup) override;
ze_result_t handleMetricGroupExtendedProperties(void *pNext) override;
bool isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const;
bool isMetricGroupActivatedInHw() const;
void setUseCompute(const bool useCompute);
@@ -63,6 +61,8 @@ class OaMetricSourceImp : public MetricSource {
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);
};
template <>

3
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h
View File

@@ -20,8 +20,7 @@ class MockMetricSource : public L0::MetricSource {
bool isAvailable() override { return isAvailableReturn; }
ze_result_t appendMetricMemoryBarrier(L0::CommandList &commandList) override { return ZE_RESULT_ERROR_UNKNOWN; }
ze_result_t metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) override { return ZE_RESULT_ERROR_UNKNOWN; }
ze_result_t getTimerResolution(uint64_t &resolution) override { return ZE_RESULT_ERROR_UNKNOWN; }
ze_result_t getTimestampValidBits(uint64_t &validBits) override { return ZE_RESULT_ERROR_UNKNOWN; }
ze_result_t handleMetricGroupExtendedProperties(void *pNext) override { return ZE_RESULT_ERROR_UNKNOWN; }
ze_result_t activateMetricGroupsPreferDeferred(uint32_t count, zet_metric_group_handle_t *phMetricGroups) override { return ZE_RESULT_ERROR_UNKNOWN; }
ze_result_t activateMetricGroupsAlreadyDeferred() override { return ZE_RESULT_ERROR_UNKNOWN; }
ze_result_t metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) override {

33
level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp
View File

@@ -9,6 +9,7 @@
#include "shared/test/common/test_macros/hw_test.h"
#include "shared/test/common/test_macros/test_base.h"
#include "level_zero/api/driver_experimental/public/zex_metric.h"
#include "level_zero/core/source/cmdlist/cmdlist.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/include/zet_intel_gpu_metric.h"
@@ -281,6 +282,38 @@ HWTEST2_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenReadi
}
}
HWTEST2_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenQueryingMetricGroupTypeThenAppropriateGroupTypeIsReturned, EustallSupportedPlatforms) {
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<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
ASSERT_NE(metricGroups[0], nullptr);
zet_intel_metric_group_type_exp_t metricGroupType{};
metricGroupType.stype = ZET_INTEL_STRUCTURE_TYPE_METRIC_GROUP_TYPE_EXP;
metricGroupType.pNext = nullptr;
metricGroupType.type = static_cast<zet_intel_metric_group_type_exp_flags_t>(0xffffffff);
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, &metricGroupType};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.description, "EU stall sampling"), 0);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
EXPECT_EQ(metricGroupType.type, ZET_INTEL_METRIC_GROUP_TYPE_EXP_OTHER);
}
}
HWTEST2_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulOnMulitDeviceWhenReadingMetricsTimestampThenResultIsSuccess, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());

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

@@ -8,6 +8,7 @@
#include "shared/test/common/mocks/mock_device.h"
#include "shared/test/common/test_macros/test.h"
#include "level_zero/api/driver_experimental/public/zex_metric.h"
#include "level_zero/core/source/device/device_imp.h"
#include "level_zero/core/test/unit_tests/mocks/mock_driver.h"
#include "level_zero/tools/source/metrics/metric_oa_source.h"
@@ -2679,5 +2680,68 @@ TEST_F(MetricEnumerationTest, givenMetricSetWhenWaitForReportsIsCalledWaitForRep
EXPECT_EQ(metricGroup.waitForReports(timeout), ZE_RESULT_NOT_READY);
}
TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetGetMetricGroupPropertiesIsCalledToQueryGroupTypeThenReturnsSuccess) {
// Metrics Discovery device.
metricsDeviceParams.ConcurrentGroupsCount = 1;
// Metrics Discovery concurrent group.
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
metricsConcurrentGroupParams.Description = "OA description";
// Metrics Discovery:: metric set.
Mock<MetricsDiscovery::IMetricSet_1_5> 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 = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
openMetricsAdapter();
setupDefaultMocksForMetricDevice(metricsDevice);
metricsDevice.getConcurrentGroupResults.push_back(&metricsConcurrentGroup);
metricsConcurrentGroup.GetParamsResult = &metricsConcurrentGroupParams;
metricsConcurrentGroup.getMetricSetResult = &metricsSet;
metricsSet.GetParamsResult = &metricsSetParams;
// 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);
zet_intel_metric_group_type_exp_t metricGroupType{};
metricGroupType.stype = ZET_INTEL_STRUCTURE_TYPE_METRIC_GROUP_TYPE_EXP;
metricGroupType.pNext = nullptr;
metricGroupType.type = static_cast<zet_intel_metric_group_type_exp_flags_t>(0xffffffff);
metricGroupProperties.pNext = &metricGroupType;
// Metric group properties.
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(metricGroupType.type, ZET_INTEL_METRIC_GROUP_TYPE_EXP_OTHER);
}
} // namespace ult
} // namespace L0