intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-21 01:04:57 +08:00
Code Issues Packages Projects Releases Wiki Activity

Metric Api 1.0 : Max value for zetMetricGroupCalculateMetricValues.

Browse Source 
Change-Id: Ie9022630e71a4c2e6dadb76ca4ec87b38fd8dfa5
This commit is contained in:
Piotr Maciejewski
2020-07-28 14:23:47 +02:00
committed by sys_ocldev
parent f29dacd5c0
commit e72246a74d
7 changed files with 258 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
level_zero/api/tools/zet_metric.cpp
View File

@@ -66,7 +66,18 @@ zetMetricGroupCalculateMetricValues(
const uint8_t *pRawData,
uint32_t *pMetricValueCount,
zet_typed_value_t *pMetricValues) {
return L0::MetricGroup::fromHandle(hMetricGroup)->calculateMetricValues(rawDataSize, pRawData, pMetricValueCount, pMetricValues);
return L0::MetricGroup::fromHandle(hMetricGroup)->calculateMetricValues(ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataSize, pRawData, pMetricValueCount, pMetricValues);
}
__zedllexport ze_result_t __zecall
zetMetricGroupCalculateMetricValuesExt(
zet_metric_group_handle_t hMetricGroup,
zet_metric_group_calculation_type_t type,
size_t rawDataSize,
const uint8_t *pRawData,
uint32_t *pMetricValueCount,
zet_typed_value_t *pMetricValues) {
return L0::MetricGroup::fromHandle(hMetricGroup)->calculateMetricValues(type, rawDataSize, pRawData, pMetricValueCount, pMetricValues);
}
__zedllexport ze_result_t __zecall

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

@@ -76,7 +76,7 @@ struct MetricGroup : _zet_metric_group_handle_t {
virtual ze_result_t getProperties(zet_metric_group_properties_t *pProperties) = 0;
virtual ze_result_t getPropertiesExt(zet_metric_group_properties_ext_t *pProperties) = 0;
virtual ze_result_t getMetric(uint32_t *pCount, zet_metric_handle_t *phMetrics) = 0;
virtual ze_result_t calculateMetricValues(size_t rawDataSize,
virtual ze_result_t calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pMetricValueCount,
zet_typed_value_t *pMetricValues) = 0;

38
level_zero/tools/source/metrics/metric_enumeration_imp.cpp
View File

@@ -487,13 +487,13 @@ ze_result_t MetricGroupImp::closeIoStream() {
return (closeResult == MetricsDiscovery::CC_OK) ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t MetricGroupImp::calculateMetricValues(size_t rawDataSize,
ze_result_t MetricGroupImp::calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pMetricValueCount,
zet_typed_value_t *pMetricValues) {
const bool calculateCountOnly = *pMetricValueCount == 0;
const bool result = calculateCountOnly
? getCalculatedMetricCount(rawDataSize, *pMetricValueCount)
: getCalculatedMetricValues(rawDataSize, pRawData, *pMetricValueCount, pMetricValues);
: getCalculatedMetricValues(type, rawDataSize, pRawData, *pMetricValueCount, pMetricValues);
return result ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN;
}
@@ -515,7 +515,7 @@ bool MetricGroupImp::getCalculatedMetricCount(const size_t rawDataSize,
return true;
}
bool MetricGroupImp::getCalculatedMetricValues(const size_t rawDataSize, const uint8_t *pRawData,
bool MetricGroupImp::getCalculatedMetricValues(const zet_metric_group_calculation_type_t type, const size_t rawDataSize, const uint8_t *pRawData,
uint32_t &metricValueCount,
zet_typed_value_t *pCalculatedData) {
@@ -530,18 +530,20 @@ bool MetricGroupImp::getCalculatedMetricValues(const size_t rawDataSize, const u
return false;
}
// Calculated metrics container.
// Calculated metrics / maximum values container.
std::vector<MetricsDiscovery::TTypedValue_1_0> calculatedMetrics(expectedMetricValueCount);
std::vector<MetricsDiscovery::TTypedValue_1_0> maximumValues(expectedMetricValueCount);
// Set filtering type.
pReferenceMetricSet->SetApiFiltering(MetricGroupImp::getApiMask(properties.samplingType));
// Calculate metrics.
const bool result = pReferenceMetricSet->CalculateMetrics(
reinterpret_cast<unsigned char *>(const_cast<uint8_t *>(pRawData)), static_cast<uint32_t>(rawDataSize),
calculatedMetrics.data(),
static_cast<uint32_t>(calculatedMetrics.size()) * sizeof(MetricsDiscovery::TTypedValue_1_0),
&calculatedReportCount, nullptr, static_cast<uint32_t>(0)) == MetricsDiscovery::CC_OK;
const uint32_t outMetricsSize = static_cast<uint32_t>(calculatedMetrics.size()) * sizeof(MetricsDiscovery::TTypedValue_1_0);
bool result = pReferenceMetricSet->CalculateMetrics(
reinterpret_cast<unsigned char *>(const_cast<uint8_t *>(pRawData)), static_cast<uint32_t>(rawDataSize),
calculatedMetrics.data(),
outMetricsSize,
&calculatedReportCount, maximumValues.data(), outMetricsSize) == MetricsDiscovery::CC_OK;
if (result) {
@@ -549,8 +551,22 @@ bool MetricGroupImp::getCalculatedMetricValues(const size_t rawDataSize, const u
metricValueCount = std::min<uint32_t>(metricValueCount, calculatedReportCount * properties.metricCount);
// Translate metrics from metrics discovery to oneAPI format.
for (size_t i = 0; i < metricValueCount; ++i) {
copyValue(calculatedMetrics[i], pCalculatedData[i]);
switch (type) {
case ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES:
for (size_t i = 0; i < metricValueCount; ++i) {
copyValue(calculatedMetrics[i], pCalculatedData[i]);
}
break;
case ZET_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES:
for (size_t i = 0; i < metricValueCount; ++i) {
copyValue(maximumValues[i], pCalculatedData[i]);
}
break;
default:
result = false;
break;
}
}

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

@@ -75,7 +75,7 @@ struct MetricGroupImp : MetricGroup {
ze_result_t getProperties(zet_metric_group_properties_t *pProperties) override;
ze_result_t getPropertiesExt(zet_metric_group_properties_ext_t *pProperties) override;
ze_result_t getMetric(uint32_t *pCount, zet_metric_handle_t *phMetrics) override;
ze_result_t calculateMetricValues(size_t rawDataSize, const uint8_t *pRawData,
ze_result_t calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize, const uint8_t *pRawData,
uint32_t *pMetricValueCount,
zet_typed_value_t *pCalculatedData) override;
@@ -106,7 +106,7 @@ struct MetricGroupImp : MetricGroup {
bool getCalculatedMetricCount(const size_t rawDataSize,
uint32_t &metricValueCount);
bool getCalculatedMetricValues(const size_t rawDataSize, const uint8_t *pRawData,
bool getCalculatedMetricValues(const zet_metric_group_calculation_type_t, const size_t rawDataSize, const uint8_t *pRawData,
uint32_t &metricValueCount,
zet_typed_value_t *pCalculatedData);

2
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_enumeration.h
View File

@@ -135,7 +135,7 @@ struct Mock<MetricGroup> : public MetricGroup {
Mock() {}
MOCK_METHOD(ze_result_t, getMetric, (uint32_t *, zet_metric_handle_t *), (override));
MOCK_METHOD(ze_result_t, calculateMetricValues, (size_t, const uint8_t *, uint32_t *, zet_typed_value_t *), (override));
MOCK_METHOD(ze_result_t, calculateMetricValues, (const zet_metric_group_calculation_type_t, size_t, const uint8_t *, uint32_t *, zet_typed_value_t *), (override));
MOCK_METHOD(ze_result_t, getProperties, (zet_metric_group_properties_t * properties), (override));
MOCK_METHOD(ze_result_t, getPropertiesExt, (zet_metric_group_properties_ext_t * properties), (override));
MOCK_METHOD(uint32_t, getRawReportSize, (), (override));

171
level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration.cpp
View File

@@ -1956,5 +1956,176 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeAndCorrectCalculatedRepor
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroupHandle, rawResultsSize, rawResults.data(), &calculatedResultsCount, caculatedrawResults.data()), ZE_RESULT_SUCCESS);
}
TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeAndCorrectCalculatedReportCountWhenZetMetricGroupCalculateMetricValuesIsCalledThenMaxValuesAreReturned) {
// 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";
// Metrics Discovery: metric set
Mock<IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
metricsSetParams.QueryReportSize = 256;
metricsSetParams.MetricsCount = 11;
// Metrics Discovery: metric
Mock<IMetric_1_0> metric;
MetricsDiscovery::TMetricParams_1_0 metricParams = {};
// One api: metric group.
zet_metric_group_handle_t metricGroupHandle = {};
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(0);
EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockOpenMetricsDevice(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&metricsDevice), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockCloseMetricsDevice(_))
.Times(1)
.WillOnce(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(1)
.WillOnce(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(1)
.WillOnce(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.WillRepeatedly(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, GetMetric(_))
.Times(11)
.WillRepeatedly(Return(&metric));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<4>(metricsSetParams.MetricsCount), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(metric, GetParams())
.WillRepeatedly(Return(&metricParams));
// Metric group handles.
uint32_t metricGroupCount = 1;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// Return correct calculated report count for single raw report.
size_t rawResultsSize = metricsSetParams.QueryReportSize;
std::vector<uint8_t> rawResults(rawResultsSize);
uint32_t calculatedResultsCount = 0;
EXPECT_EQ(zetMetricGroupCalculateMetricValuesExt(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES, rawResultsSize, rawResults.data(), &calculatedResultsCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(calculatedResultsCount, metricsSetParams.MetricsCount);
// Provide incorrect calculated report buffer.
std::vector<zet_typed_value_t> caculatedrawResults(calculatedResultsCount);
EXPECT_EQ(zetMetricGroupCalculateMetricValuesExt(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES, rawResultsSize, rawResults.data(), &calculatedResultsCount, caculatedrawResults.data()), ZE_RESULT_SUCCESS);
}
TEST_F(MetricEnumerationTest, givenIncorrectCalculationTypeWhenZetMetricGroupCalculateMetricValuesIsCalledThenMaxValuesAreReturned) {
// 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";
// Metrics Discovery: metric set
Mock<IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
metricsSetParams.QueryReportSize = 256;
metricsSetParams.MetricsCount = 11;
// Metrics Discovery: metric
Mock<IMetric_1_0> metric;
MetricsDiscovery::TMetricParams_1_0 metricParams = {};
// One api: metric group.
zet_metric_group_handle_t metricGroupHandle = {};
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(0);
EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockOpenMetricsDevice(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&metricsDevice), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockCloseMetricsDevice(_))
.Times(1)
.WillOnce(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(1)
.WillOnce(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(1)
.WillOnce(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.WillRepeatedly(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, GetMetric(_))
.Times(11)
.WillRepeatedly(Return(&metric));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
.Times(1)
.WillOnce(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metric, GetParams())
.WillRepeatedly(Return(&metricParams));
// Metric group handles.
uint32_t metricGroupCount = 1;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// Return correct calculated report count for single raw report.
size_t rawResultsSize = metricsSetParams.QueryReportSize;
std::vector<uint8_t> rawResults(rawResultsSize);
uint32_t calculatedResultsCount = 0;
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroupHandle, rawResultsSize, rawResults.data(), &calculatedResultsCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(calculatedResultsCount, metricsSetParams.MetricsCount);
// Provide incorrect calculated report buffer.
std::vector<zet_typed_value_t> caculatedrawResults(calculatedResultsCount);
EXPECT_NE(zetMetricGroupCalculateMetricValuesExt(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_FORCE_UINT32, rawResultsSize, rawResults.data(), &calculatedResultsCount, caculatedrawResults.data()), ZE_RESULT_SUCCESS);
}
} // namespace ult
} // namespace L0

44
third_party/level_zero/zet_api_ext.h vendored
View File

@@ -376,6 +376,50 @@ zetMetricGetPropertiesExt(
zet_metric_properties_ext_t *pProperties ///< [in,out] metric properties
);
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric group calculation type
typedef enum _zet_metric_group_calculation_type_t {
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES = 0, ///< Calculated metric values from raw data.
ZET_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES = 1, ///< Maximum metric values.
ZET_METRIC_GROUP_CALCULATION_TYPE_FORCE_UINT32 = 0x7fffffff
} zet_metric_group_calculation_type_t;
///////////////////////////////////////////////////////////////////////////////
/// @brief Calculates metric values from raw data.
///
/// @details
/// - The application may call this function from simultaneous threads.
///
/// @returns
/// - ::ZE_RESULT_SUCCESS
/// - ::ZE_RESULT_ERROR_UNINITIALIZED
/// - ::ZE_RESULT_ERROR_DEVICE_LOST
/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
/// + `nullptr == hMetricGroup`
/// - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
/// + `::ZET_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES < type`
/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
/// + `nullptr == pRawData`
/// + `nullptr == pMetricValueCount`
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricGroupCalculateMetricValuesExt(
zet_metric_group_handle_t hMetricGroup, ///< [in] handle of the metric group
zet_metric_group_calculation_type_t type, ///< [in] calculation type to be applied on raw data
size_t rawDataSize, ///< [in] size in bytes of raw data buffer
const uint8_t *pRawData, ///< [in][range(0, rawDataSize)] buffer of raw data to calculate
uint32_t *pMetricValueCount, ///< [in,out] pointer to number of metric values calculated.
///< if count is zero, then the driver will update the value with the total
///< number of metric values to be calculated.
///< if count is non-zero, then driver will only calculate that number of
///< metric values.
///< if count is larger than the number available in the raw data buffer,
///< then the driver will update the value with the actual number of metric
///< values to be calculated.
zet_typed_value_t *pMetricValues ///< [in,out][optional][range(0, *pMetricValueCount)] buffer of calculated
///< metrics
);
///////////////////////////////////////////////////////////////////////////////
/// @brief Supportted profile features
typedef uint32_t zet_profile_flagsExt_t;