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

refactor: make all metric and group have a metric source 

Related-To: NEO-8783


Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>
This commit is contained in:
Joshua Santosh Ranjan 2024-03-12 12:57:20 +00:00 committed by Compute-Runtime-Automation
parent ff6f308c8b
commit 9ad5445a72
13 changed files with 97 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -43,10 +43,12 @@ class MetricSource {
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;
virtual ze_result_t metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
zet_metric_group_sampling_type_flag_t samplingType,
zet_metric_group_handle_t *pMetricGroupHandle) = 0;
ze_result_t metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
zet_metric_group_sampling_type_flag_t samplingType,
zet_metric_group_handle_t *pMetricGroupHandle) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
};
virtual ~MetricSource() = default;
uint32_t getType() const {
return type;
@ -118,6 +120,18 @@ struct Metric : _zet_metric_handle_t {
inline zet_metric_handle_t toHandle() { return this; }
};
struct MetricImp : public Metric {
MetricSource &getMetricSource() {
return metricSource;
}
~MetricImp() override = default;
MetricImp(MetricSource &metricSource) : metricSource(metricSource) {}
protected:
MetricSource &metricSource;
};
struct MetricGroup : _zet_metric_group_handle_t {
virtual ~MetricGroup() = default;
MetricGroup() {}
@ -168,9 +182,11 @@ struct MetricGroupImp : public MetricGroup {
}
~MetricGroupImp() override = default;
MetricGroupImp(MetricSource &metricSource) : metricSource(metricSource) {}
bool isImmutable() { return isPredefined; }
protected:
MetricSource &metricSource;
bool isPredefined = true;
};
struct MetricGroupCalculateHeader {

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

@ -29,12 +29,6 @@ ze_result_t MetricDeviceContext::metricGroupCreate(const char name[ZET_MAX_METRI
ze_result_t OaMetricSourceImp::metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t OaMetricSourceImp::metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
zet_metric_group_sampling_type_flag_t samplingType,
zet_metric_group_handle_t *pMetricGroupHandle) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t metricProgrammableGetProperties(
zet_metric_programmable_exp_handle_t hMetricProgrammable,

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
* Copyright (C) 2022-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -93,7 +93,7 @@ void IpSamplingMetricSourceImp::cacheMetricGroup() {
strcpy_s(metricProperties.description, ZET_MAX_METRIC_DESCRIPTION, "IP address");
metricProperties.metricType = ZET_METRIC_TYPE_IP;
strcpy_s(metricProperties.resultUnits, ZET_MAX_METRIC_RESULT_UNITS, "Address");
metrics.push_back(IpSamplingMetricImp(metricProperties));
metrics.push_back(IpSamplingMetricImp(*this, metricProperties));
std::vector<std::pair<const char *, const char *>> metricPropertiesList = {
{"Active", "Active cycles"},
@ -114,7 +114,7 @@ void IpSamplingMetricSourceImp::cacheMetricGroup() {
for (auto &property : metricPropertiesList) {
strcpy_s(metricProperties.name, ZET_MAX_METRIC_NAME, property.first);
strcpy_s(metricProperties.description, ZET_MAX_METRIC_DESCRIPTION, property.second);
metrics.push_back(IpSamplingMetricImp(metricProperties));
metrics.push_back(IpSamplingMetricImp(*this, metricProperties));
}
cachedMetricGroup = IpSamplingMetricGroupImp::create(*this, metrics);
@ -654,7 +654,7 @@ std::unique_ptr<MultiDeviceIpSamplingMetricGroupImp> MultiDeviceIpSamplingMetric
return std::unique_ptr<MultiDeviceIpSamplingMetricGroupImp>(new (std::nothrow) MultiDeviceIpSamplingMetricGroupImp(metricSource, subDeviceMetricGroup));
}
IpSamplingMetricImp::IpSamplingMetricImp(zet_metric_properties_t &properties) : properties(properties) {
IpSamplingMetricImp::IpSamplingMetricImp(MetricSource &metricSource, zet_metric_properties_t &properties) : MetricImp(metricSource), properties(properties) {
}
ze_result_t IpSamplingMetricImp::getProperties(zet_metric_properties_t *pProperties) {

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

@ -31,12 +31,6 @@ class IpSamplingMetricSourceImp : public MetricSource {
ze_result_t metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
zet_metric_group_sampling_type_flag_t samplingType,
zet_metric_group_handle_t *pMetricGroupHandle) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
bool isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const;
void setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricIPSamplingpOsInterface);
static std::unique_ptr<IpSamplingMetricSourceImp> create(const MetricDeviceContext &metricDeviceContext);
@ -171,9 +165,9 @@ struct MultiDeviceIpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
std::vector<IpSamplingMetricGroupImp *> subDeviceMetricGroup = {};
};
struct IpSamplingMetricImp : public Metric {
struct IpSamplingMetricImp : public MetricImp {
~IpSamplingMetricImp() override = default;
IpSamplingMetricImp(zet_metric_properties_t &properties);
IpSamplingMetricImp(MetricSource &metricSource, zet_metric_properties_t &properties);
ze_result_t getProperties(zet_metric_properties_t *pProperties) override;
ze_result_t destroy() override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
* Copyright (C) 2020-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -433,7 +433,7 @@ ze_result_t MetricEnumeration::createMetrics(MetricsDiscovery::IMetricSet_1_5 &m
zet_metric_properties_t properties = {};
getL0MetricPropertiesFromMdapiMetric(properties, pSourceMetric);
auto pMetric = OaMetricImp::create(properties);
auto pMetric = OaMetricImp::create(metricSource, properties);
UNRECOVERABLE_IF(pMetric == nullptr);
metrics.push_back(pMetric);
@ -447,7 +447,7 @@ ze_result_t MetricEnumeration::createMetrics(MetricsDiscovery::IMetricSet_1_5 &m
zet_metric_properties_t properties = {};
getL0MetricPropertiesFromMdapiInformation(properties, pSourceInformation);
auto pMetric = OaMetricImp::create(properties);
auto pMetric = OaMetricImp::create(metricSource, properties);
UNRECOVERABLE_IF(pMetric == nullptr);
metrics.push_back(pMetric);
@ -1086,8 +1086,8 @@ MetricGroup *OaMetricGroupImp::create(zet_metric_group_properties_t &properties,
return pMetricGroup;
}
Metric *OaMetricImp::create(zet_metric_properties_t &properties) {
auto pMetric = new OaMetricImp();
Metric *OaMetricImp::create(MetricSource &metricSource, zet_metric_properties_t &properties) {
auto pMetric = new OaMetricImp(metricSource);
UNRECOVERABLE_IF(pMetric == nullptr);
pMetric->initialize(properties);
pMetric->isPredefined = true;

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

@ -195,7 +195,6 @@ struct OaMetricGroupImp : public MetricGroupImp {
uint32_t getRawReportSize();
const MetricEnumeration &getMetricEnumeration() const;
void setCachedExportDataHeapSize(size_t size);
bool isImmutable() { return isPredefined; }
protected:
void copyProperties(const zet_metric_group_properties_t &source,
@ -219,16 +218,17 @@ struct OaMetricGroupImp : public MetricGroupImp {
std::vector<zet_metric_group_handle_t> metricGroups;
size_t cachedExportDataHeapSize = 0;
bool isPredefined{};
private:
ze_result_t openForDevice(Device *pDevice, zet_metric_streamer_desc_t &desc,
zet_metric_streamer_handle_t *phMetricStreamer);
};
struct OaMetricImp : public Metric {
struct OaMetricImp : public MetricImp {
~OaMetricImp() override{};
OaMetricImp(MetricSource &metricSource) : MetricImp(metricSource) {}
ze_result_t getProperties(zet_metric_properties_t *pProperties) override;
ze_result_t destroy() override {
@ -237,7 +237,7 @@ struct OaMetricImp : public Metric {
ze_result_t initialize(const zet_metric_properties_t &sourceProperties);
static Metric *create(zet_metric_properties_t &properties);
static Metric *create(MetricSource &metricSource, zet_metric_properties_t &properties);
bool isImmutable() { return isPredefined; }

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

@ -45,10 +45,6 @@ class OaMetricSourceImp : public MetricSource {
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 metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
zet_metric_group_sampling_type_flag_t samplingType,
zet_metric_group_handle_t *pMetricGroupHandle) override;
bool isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const;
bool isMetricGroupActivatedInHw() const;
void setUseCompute(const bool useCompute);

5
level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
* Copyright (C) 2022-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -206,6 +206,9 @@ class SingleMetricCollector : public Collector {
SingleMetricCollector(ExecutionContext *executionCtxt,
const char *metricGroupName,
const zet_metric_group_sampling_type_flag_t samplingType);
SingleMetricCollector(ExecutionContext *executionCtxt,
zet_metric_group_handle_t metricGroup,
const zet_metric_group_sampling_type_flag_t samplingType);
~SingleMetricCollector() override = default;
bool prefixCommands() override = 0;

34
level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_collector.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
* Copyright (C) 2022-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -23,33 +23,15 @@ SingleMetricCollector::SingleMetricCollector(ExecutionContext *executionCtxt,
: Collector(executionCtxt), samplingType(samplingType) {
metricGroup = zmu::findMetricGroup(metricGroupName, samplingType, executionCtxt->getDeviceHandle(0));
zmu::printMetricGroupAndMetricProperties(metricGroup);
}
if (zmu::TestSettings::get()->verboseLevel.get() >= zmu::LogLevel::DEBUG) {
zet_metric_group_properties_t metricGroupProperties = {};
// Obtain metric group properties to check the group name and sampling type.
VALIDATECALL(zetMetricGroupGetProperties(metricGroup, &metricGroupProperties));
zmu::printMetricGroupProperties(metricGroupProperties);
SingleMetricCollector::SingleMetricCollector(ExecutionContext *executionCtxt,
zet_metric_group_handle_t metricGroup,
const zet_metric_group_sampling_type_flag_t samplingType)
: Collector(executionCtxt), metricGroup(metricGroup), samplingType(samplingType) {
// Print metrics from metric group.
uint32_t metricCount = 0;
std::vector<zet_metric_handle_t> metrics = {};
// Obtain metrics count for verbose purpose.
VALIDATECALL(zetMetricGet(metricGroup, &metricCount, nullptr));
// Obtain metrics for verbose purpose.
metrics.resize(metricCount);
VALIDATECALL(zetMetricGet(metricGroup, &metricCount, metrics.data()));
// Enumerate metric group metrics for verbose purpose.
for (uint32_t j = 0; j < metricCount; ++j) {
const zet_metric_handle_t metric = metrics[j];
zet_metric_properties_t metricProperties = {};
VALIDATECALL(zetMetricGetProperties(metric, &metricProperties));
zmu::printMetricProperties(metricProperties);
}
}
zmu::printMetricGroupAndMetricProperties(metricGroup);
}
///////////////////////////////////

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022 Intel Corporation
* Copyright (C) 2022-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -196,6 +196,35 @@ ze_command_list_handle_t createImmediateCommandList(ze_context_handle_t &context
return commandList;
}
void printMetricGroupAndMetricProperties(zet_metric_group_handle_t metricGroup) {
if (TestSettings::get()->verboseLevel.get() >= LogLevel::DEBUG) {
zet_metric_group_properties_t metricGroupProperties = {};
// Obtain metric group properties to check the group name and sampling type.
VALIDATECALL(zetMetricGroupGetProperties(metricGroup, &metricGroupProperties));
printMetricGroupProperties(metricGroupProperties);
// Print metrics from metric group.
uint32_t metricCount = 0;
std::vector<zet_metric_handle_t> metrics = {};
// Obtain metrics count for verbose purpose.
VALIDATECALL(zetMetricGet(metricGroup, &metricCount, nullptr));
// Obtain metrics for verbose purpose.
metrics.resize(metricCount);
VALIDATECALL(zetMetricGet(metricGroup, &metricCount, metrics.data()));
// Enumerate metric group metrics for verbose purpose.
for (uint32_t j = 0; j < metricCount; ++j) {
const zet_metric_handle_t metric = metrics[j];
zet_metric_properties_t metricProperties = {};
VALIDATECALL(zetMetricGetProperties(metric, &metricProperties));
printMetricProperties(metricProperties);
}
}
}
void printMetricGroupProperties(const zet_metric_group_properties_t &properties) {
LOG(LogLevel::DEBUG) << "METRIC GROUP: "
<< "name: " << properties.name << ", "

3
level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_util.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
* Copyright (C) 2022-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -85,6 +85,7 @@ ze_command_queue_handle_t createCommandQueue(ze_context_handle_t &contextHandle,
ze_command_list_handle_t createCommandList(ze_context_handle_t &contextHandle, ze_device_handle_t &deviceHandle);
ze_command_list_handle_t createImmediateCommandList(ze_context_handle_t &contextHandle, ze_device_handle_t &deviceHandle);
void printMetricGroupProperties(const zet_metric_group_properties_t &properties);
void printMetricGroupAndMetricProperties(zet_metric_group_handle_t metricGroup);
void printMetricProperties(const zet_metric_properties_t &properties);
void sleep(uint32_t milliseconds);
bool getTestMachineConfiguration(TestMachineConfiguration &machineConfig);

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

@ -13,8 +13,9 @@ namespace ult {
class MockMetricSource : public L0::MetricSource {
public:
bool isAvailableReturn = false;
void enable() override {}
bool isAvailable() override { return false; }
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; }
@ -24,11 +25,8 @@ class MockMetricSource : public L0::MetricSource {
ze_result_t metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
zet_metric_group_sampling_type_flag_t samplingType,
zet_metric_group_handle_t *pMetricGroupHandle) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
void setType(uint32_t type) {
this->type = type;
}
~MockMetricSource() override = default;
};
@ -104,5 +102,17 @@ class MockMetricGroup : public L0::MetricGroupImp {
}
};
class MockMetric : public L0::MetricImp {
public:
~MockMetric() override = default;
MockMetric(MetricSource &metricSource) : L0::MetricImp(metricSource) {}
ze_result_t getProperties(zet_metric_properties_t *pProperties) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t destroy() override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
};
} // namespace ult
} // namespace L0

3
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_2.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021-2023 Intel Corporation
* Copyright (C) 2021-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -344,6 +344,7 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenValidArgumentsWhenZetMetricGetProp
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, &metricHandle), ZE_RESULT_SUCCESS);
EXPECT_NE(metricHandle, nullptr);
EXPECT_TRUE(static_cast<OaMetricImp *>(metricHandle)->isImmutable());
EXPECT_TRUE(static_cast<OaMetricImp *>(metricHandle)->getMetricSource().isAvailable());
// Obtain metric params.
EXPECT_EQ(zetMetricGetProperties(metricHandle, &metricProperties), ZE_RESULT_SUCCESS);