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 f5b8b9fa97..a5a7084bb9 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp @@ -37,6 +37,10 @@ IpSamplingMetricSourceImp::IpSamplingMetricSourceImp(const MetricDeviceContext & metricIPSamplingpOsInterface = MetricIpSamplingOsInterface::create(metricDeviceContext.getDevice()); activationTracker = std::make_unique(metricDeviceContext.getSubDeviceIndex()); type = MetricSource::metricSourceTypeIpSampling; + + const auto deviceImp = static_cast(&metricDeviceContext.getDevice()); + L0::L0GfxCoreHelper &l0GfxCoreHelper = deviceImp->getNEODevice()->getRootDeviceEnvironment().getHelper(); + ipSamplingCalculation = std::make_unique(l0GfxCoreHelper, *this); } ze_result_t IpSamplingMetricSourceImp::getTimerResolution(uint64_t &resolution) { @@ -350,19 +354,7 @@ bool IpSamplingMetricGroupBase::isMultiDeviceCaptureData(const size_t rawDataSiz ze_result_t IpSamplingMetricGroupImp::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; - - if (isMultiDeviceCaptureData(rawDataSize, pRawData)) { - METRICS_LOG_ERR("%s", "The call is not supported for multiple devices"); - METRICS_LOG_ERR("%s", "Please use zetMetricGroupCalculateMultipleMetricValuesExp instead"); - return ZE_RESULT_ERROR_INVALID_ARGUMENT; - } - - if (calculateCountOnly) { - return getCalculatedMetricCount(pRawData, rawDataSize, *pMetricValueCount); - } else { - return getCalculatedMetricValues(type, rawDataSize, pRawData, *pMetricValueCount, pMetricValues); - } + return getMetricSource().ipSamplingCalculation->calculateMetricForSubdevice(type, rawDataSize, pRawData, pMetricValueCount, pMetricValues); } ze_result_t IpSamplingMetricGroupImp::calculateMetricValuesExp(const zet_metric_group_calculation_type_t type, size_t rawDataSize, @@ -379,11 +371,8 @@ ze_result_t IpSamplingMetricGroupImp::calculateMetricValuesExp(const zet_metric_ if (!isMultiDeviceCaptureData(rawDataSize, pRawData)) { result = this->calculateMetricValues(type, rawDataSize, pRawData, pTotalMetricValueCount, pMetricValues); } else { - if (calculateCountOnly) { - result = getCalculatedMetricCount(pRawData, rawDataSize, *pTotalMetricValueCount, 0); - } else { - result = getCalculatedMetricValues(type, rawDataSize, pRawData, *pTotalMetricValueCount, pMetricValues, 0); - } + METRICS_LOG_ERR("%s", "Calculating sub-device results using root device captured data is not supported"); + return ZE_RESULT_ERROR_INVALID_ARGUMENT; } if ((result == ZE_RESULT_SUCCESS) || (result == ZE_RESULT_WARNING_DROPPED_DATA)) { @@ -429,146 +418,6 @@ ze_result_t IpSamplingMetricGroupImp::getMetricTimestampsExp(const ze_bool_t syn return getDeviceTimestamps(deviceImp, synchronizedWithHost, globalTimestamp, metricTimestamp); } -ze_result_t IpSamplingMetricGroupImp::getCalculatedMetricCount(const uint8_t *pRawData, const size_t rawDataSize, - uint32_t &metricValueCount) { - - std::unordered_set stallReportIpCount{}; - constexpr uint32_t rawReportSize = IpSamplingMetricGroupBase::rawReportSize; - - if ((rawDataSize % rawReportSize) != 0) { - METRICS_LOG_ERR("%s", "Invalid input raw data size"); - metricValueCount = 0; - return ZE_RESULT_ERROR_INVALID_SIZE; - } - - DeviceImp *deviceImp = static_cast(&this->getMetricSource().getMetricDeviceContext().getDevice()); - auto &l0GfxCoreHelper = deviceImp->getNEODevice()->getRootDeviceEnvironment().getHelper(); - const uint32_t rawReportCount = static_cast(rawDataSize) / rawReportSize; - - for (const uint8_t *pRawIpData = pRawData; pRawIpData < pRawData + (rawReportCount * rawReportSize); pRawIpData += rawReportSize) { - uint64_t ip = 0ULL; - memcpy_s(reinterpret_cast(&ip), sizeof(ip), pRawIpData, sizeof(ip)); - ip &= l0GfxCoreHelper.getIpSamplingIpMask(); - stallReportIpCount.insert(ip); - } - - metricValueCount = static_cast(stallReportIpCount.size()) * properties.metricCount; - return ZE_RESULT_SUCCESS; -} - -ze_result_t IpSamplingMetricGroupImp::getCalculatedMetricCount(const uint8_t *pMultiMetricData, const size_t rawDataSize, uint32_t &metricValueCount, const uint32_t setIndex) { - - // Iterate through headers and assign required sizes - auto processedSize = 0u; - while (processedSize < rawDataSize) { - auto processMetricData = pMultiMetricData + processedSize; - if (!isMultiDeviceCaptureData(rawDataSize - processedSize, processMetricData)) { - return ZE_RESULT_ERROR_INVALID_SIZE; - } - - auto header = reinterpret_cast(processMetricData); - processedSize += sizeof(IpSamplingMetricDataHeader) + header->rawDataSize; - if (header->setIndex != setIndex) { - continue; - } - - auto currTotalMetricValueCount = 0u; - auto result = this->getCalculatedMetricCount((processMetricData + sizeof(IpSamplingMetricDataHeader)), header->rawDataSize, currTotalMetricValueCount); - if (result != ZE_RESULT_SUCCESS) { - metricValueCount = 0; - return result; - } - metricValueCount += currTotalMetricValueCount; - } - return ZE_RESULT_SUCCESS; -} - -ze_result_t IpSamplingMetricGroupImp::getCalculatedMetricValues(const zet_metric_group_calculation_type_t type, const size_t rawDataSize, const uint8_t *pMultiMetricData, - uint32_t &metricValueCount, - zet_typed_value_t *pCalculatedData, const uint32_t setIndex) { - - auto processedSize = 0u; - auto isDataDropped = false; - auto requestTotalMetricValueCount = metricValueCount; - - while (processedSize < rawDataSize && requestTotalMetricValueCount > 0) { - auto processMetricData = pMultiMetricData + processedSize; - if (!isMultiDeviceCaptureData(rawDataSize - processedSize, processMetricData)) { - return ZE_RESULT_ERROR_INVALID_SIZE; - } - - auto header = reinterpret_cast(processMetricData); - processedSize += header->rawDataSize + sizeof(IpSamplingMetricDataHeader); - if (header->setIndex != setIndex) { - continue; - } - - auto processMetricRawData = processMetricData + sizeof(IpSamplingMetricDataHeader); - auto currTotalMetricValueCount = requestTotalMetricValueCount; - auto result = this->calculateMetricValues(type, header->rawDataSize, processMetricRawData, &currTotalMetricValueCount, pCalculatedData); - if (result != ZE_RESULT_SUCCESS) { - if (result == ZE_RESULT_WARNING_DROPPED_DATA) { - isDataDropped = true; - } else { - metricValueCount = 0; - return result; - } - } - pCalculatedData += currTotalMetricValueCount; - requestTotalMetricValueCount -= currTotalMetricValueCount; - } - - metricValueCount -= requestTotalMetricValueCount; - return isDataDropped ? ZE_RESULT_WARNING_DROPPED_DATA : ZE_RESULT_SUCCESS; -} - -ze_result_t IpSamplingMetricGroupImp::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) { - bool dataOverflow = false; - std::map stallReportDataMap; - - // MAX_METRIC_VALUES is not supported yet. - if (type != ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES) { - METRICS_LOG_ERR("%s", "IP sampling only supports ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES"); - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - } - - DEBUG_BREAK_IF(pCalculatedData == nullptr); - - const uint32_t rawReportSize = IpSamplingMetricGroupBase::rawReportSize; - - if ((rawDataSize % rawReportSize) != 0) { - METRICS_LOG_ERR("%s", "Invalid input raw data size"); - metricValueCount = 0; - return ZE_RESULT_ERROR_INVALID_SIZE; - } - - const uint32_t rawReportCount = static_cast(rawDataSize) / rawReportSize; - - DeviceImp *deviceImp = static_cast(&this->getMetricSource().getMetricDeviceContext().getDevice()); - auto &l0GfxCoreHelper = deviceImp->getNEODevice()->getRootDeviceEnvironment().getHelper(); - - for (const uint8_t *pRawIpData = pRawData; pRawIpData < pRawData + (rawReportCount * rawReportSize); pRawIpData += rawReportSize) { - dataOverflow |= l0GfxCoreHelper.stallIpDataMapUpdate(stallReportDataMap, pRawIpData); - } - - metricValueCount = std::min(metricValueCount, static_cast(stallReportDataMap.size()) * properties.metricCount); - std::vector ipDataValues; - uint32_t i = 0; - for (auto it = stallReportDataMap.begin(); it != stallReportDataMap.end(); ++it) { - l0GfxCoreHelper.stallSumIpDataToTypedValues(it->first, it->second, ipDataValues); - for (auto jt = ipDataValues.begin(); (jt != ipDataValues.end()) && (i < metricValueCount); jt++, i++) { - *(pCalculatedData + i) = *jt; - } - ipDataValues.clear(); - } - l0GfxCoreHelper.stallIpDataMapDelete(stallReportDataMap); - stallReportDataMap.clear(); - - return dataOverflow ? ZE_RESULT_WARNING_DROPPED_DATA : ZE_RESULT_SUCCESS; -} - zet_metric_group_handle_t IpSamplingMetricGroupImp::getMetricGroupForSubDevice(const uint32_t subDeviceIndex) { return toHandle(); } @@ -589,7 +438,15 @@ ze_result_t MultiDeviceIpSamplingMetricGroupImp::metricGet(uint32_t *pCount, zet ze_result_t MultiDeviceIpSamplingMetricGroupImp::calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize, const uint8_t *pRawData, uint32_t *pMetricValueCount, zet_typed_value_t *pMetricValues) { - return subDeviceMetricGroup[0]->calculateMetricValues(type, rawDataSize, pRawData, pMetricValueCount, pMetricValues); + + if (IpSamplingCalculation::isMultiDeviceCaptureData(rawDataSize, pRawData)) { + METRICS_LOG_ERR("%s", "The API is not supported for root device captured data"); + METRICS_LOG_ERR("%s", "Please use zetMetricGroupCalculateMultipleMetricValuesExp instead"); + } else { + METRICS_LOG_ERR("%s", "Cannot validate root device captured data. Input size or captured data are invalid"); + } + + return ZE_RESULT_ERROR_INVALID_ARGUMENT; } ze_result_t MultiDeviceIpSamplingMetricGroupImp::calculateMetricValuesExp(const zet_metric_group_calculation_type_t type, size_t rawDataSize, @@ -601,12 +458,13 @@ ze_result_t MultiDeviceIpSamplingMetricGroupImp::calculateMetricValuesExp(const bool isDroppedData = false; ze_result_t result = ZE_RESULT_SUCCESS; + auto calcUtils = getMetricSource().ipSamplingCalculation.get(); if (calculateCountOnly) { *pSetCount = 0; *pTotalMetricValueCount = 0; for (uint32_t setIndex = 0; setIndex < subDeviceMetricGroup.size(); setIndex++) { uint32_t currTotalMetricValueCount = 0; - result = subDeviceMetricGroup[setIndex]->getCalculatedMetricCount(pRawData, rawDataSize, currTotalMetricValueCount, setIndex); + result = calcUtils->getMetricCountSubDevIndex(pRawData, rawDataSize, currTotalMetricValueCount, setIndex); if (result != ZE_RESULT_SUCCESS) { return result; } @@ -620,7 +478,7 @@ ze_result_t MultiDeviceIpSamplingMetricGroupImp::calculateMetricValuesExp(const auto tempTotalMetricValueCount = *pTotalMetricValueCount; for (uint32_t setIndex = 0; setIndex < maxSets; setIndex++) { uint32_t currTotalMetricValueCount = tempTotalMetricValueCount; - result = subDeviceMetricGroup[setIndex]->getCalculatedMetricValues(type, rawDataSize, pRawData, currTotalMetricValueCount, pMetricValues, setIndex); + result = calcUtils->calculateMetricValuesSubDevIndex(type, rawDataSize, pRawData, currTotalMetricValueCount, pMetricValues, setIndex); if (result != ZE_RESULT_SUCCESS) { if (result == ZE_RESULT_WARNING_DROPPED_DATA) { isDroppedData = true; @@ -684,6 +542,168 @@ ze_result_t IpSamplingMetricImp::getProperties(zet_metric_properties_t *pPropert return ZE_RESULT_SUCCESS; } +bool IpSamplingCalculation::isMultiDeviceCaptureData(const size_t rawDataSize, const uint8_t *pRawData) { + if (rawDataSize >= sizeof(IpSamplingMetricDataHeader)) { + const auto header = reinterpret_cast(pRawData); + return header->magic == IpSamplingMetricDataHeader::magicValue; + } + return false; +} + +ze_result_t IpSamplingCalculation::getMetricCount(const uint8_t *pRawData, const size_t rawDataSize, + uint32_t &metricValueCount) { + + std::unordered_set stallReportIpCount{}; + constexpr uint32_t rawReportSize = IpSamplingMetricGroupBase::rawReportSize; + + if ((rawDataSize % rawReportSize) != 0) { + METRICS_LOG_ERR("%s", "Invalid input raw data size"); + metricValueCount = 0; + return ZE_RESULT_ERROR_INVALID_SIZE; + } + + const uint32_t rawReportCount = static_cast(rawDataSize) / rawReportSize; + + for (const uint8_t *pRawIpData = pRawData; pRawIpData < pRawData + (rawReportCount * rawReportSize); pRawIpData += rawReportSize) { + uint64_t ip = 0ULL; + memcpy_s(reinterpret_cast(&ip), sizeof(ip), pRawIpData, sizeof(ip)); + ip &= gfxCoreHelper.getIpSamplingIpMask(); + stallReportIpCount.insert(ip); + } + + metricValueCount = static_cast(stallReportIpCount.size()) * metricSource.metricSourceCount; + return ZE_RESULT_SUCCESS; +} + +ze_result_t IpSamplingCalculation::getMetricCountSubDevIndex(const uint8_t *pMultiMetricData, const size_t rawDataSize, uint32_t &metricValueCount, const uint32_t setIndex) { + + // Iterate through headers and assign required sizes + auto processedSize = 0u; + while (processedSize < rawDataSize) { + auto processMetricData = pMultiMetricData + processedSize; + if (!isMultiDeviceCaptureData(rawDataSize - processedSize, processMetricData)) { + METRICS_LOG_ERR("%s", "Cannot validate root device captured data. Input size or captured data are invalid"); + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + + auto header = reinterpret_cast(processMetricData); + processedSize += sizeof(IpSamplingMetricDataHeader) + header->rawDataSize; + if (header->setIndex != setIndex) { + continue; + } + + auto currTotalMetricValueCount = 0u; + auto result = getMetricCount((processMetricData + sizeof(IpSamplingMetricDataHeader)), header->rawDataSize, currTotalMetricValueCount); + if (result != ZE_RESULT_SUCCESS) { + metricValueCount = 0; + return result; + } + metricValueCount += currTotalMetricValueCount; + } + return ZE_RESULT_SUCCESS; +} + +ze_result_t IpSamplingCalculation::calculateMetricValues(const zet_metric_group_calculation_type_t type, const size_t rawDataSize, + const uint8_t *pRawData, uint32_t &metricValueCount, + zet_typed_value_t *pCalculatedData) { + bool dataOverflow = false; + std::map stallReportDataMap; + + // MAX_METRIC_VALUES is not supported yet. + if (type != ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES) { + METRICS_LOG_ERR("%s", "IP sampling only supports ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES"); + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + + DEBUG_BREAK_IF(pCalculatedData == nullptr); + + const uint32_t rawReportSize = IpSamplingMetricGroupBase::rawReportSize; + + if ((rawDataSize % rawReportSize) != 0) { + METRICS_LOG_ERR("%s", "Invalid input raw data size"); + metricValueCount = 0; + return ZE_RESULT_ERROR_INVALID_SIZE; + } + + const uint32_t rawReportCount = static_cast(rawDataSize) / rawReportSize; + + for (const uint8_t *pRawIpData = pRawData; pRawIpData < pRawData + (rawReportCount * rawReportSize); pRawIpData += rawReportSize) { + dataOverflow |= gfxCoreHelper.stallIpDataMapUpdate(stallReportDataMap, pRawIpData); + } + + metricValueCount = std::min(metricValueCount, static_cast(stallReportDataMap.size()) * metricSource.metricSourceCount); + std::vector ipDataValues; + uint32_t i = 0; + for (auto it = stallReportDataMap.begin(); it != stallReportDataMap.end(); ++it) { + gfxCoreHelper.stallSumIpDataToTypedValues(it->first, it->second, ipDataValues); + for (auto jt = ipDataValues.begin(); (jt != ipDataValues.end()) && (i < metricValueCount); jt++, i++) { + *(pCalculatedData + i) = *jt; + } + ipDataValues.clear(); + } + gfxCoreHelper.stallIpDataMapDelete(stallReportDataMap); + stallReportDataMap.clear(); + + return dataOverflow ? ZE_RESULT_WARNING_DROPPED_DATA : ZE_RESULT_SUCCESS; +} + +ze_result_t IpSamplingCalculation::calculateMetricValuesSubDevIndex(const zet_metric_group_calculation_type_t type, const size_t rawDataSize, + const uint8_t *pMultiMetricData, uint32_t &metricValueCount, + zet_typed_value_t *pCalculatedData, const uint32_t setIndex) { + + auto processedSize = 0u; + auto isDataDropped = false; + auto requestTotalMetricValueCount = metricValueCount; + + while (processedSize < rawDataSize && requestTotalMetricValueCount > 0) { + auto processMetricData = pMultiMetricData + processedSize; + if (!isMultiDeviceCaptureData(rawDataSize - processedSize, processMetricData)) { + METRICS_LOG_ERR("%s", "Calculating root device results using sub-device captured data is not supported"); + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + + auto header = reinterpret_cast(processMetricData); + processedSize += header->rawDataSize + sizeof(IpSamplingMetricDataHeader); + if (header->setIndex != setIndex) { + continue; + } + + auto processMetricRawData = processMetricData + sizeof(IpSamplingMetricDataHeader); + auto currTotalMetricValueCount = requestTotalMetricValueCount; + auto result = calculateMetricValues(type, header->rawDataSize, processMetricRawData, currTotalMetricValueCount, pCalculatedData); + if (result != ZE_RESULT_SUCCESS) { + if (result == ZE_RESULT_WARNING_DROPPED_DATA) { + isDataDropped = true; + } else { + metricValueCount = 0; + return result; + } + } + pCalculatedData += currTotalMetricValueCount; + requestTotalMetricValueCount -= currTotalMetricValueCount; + } + + metricValueCount -= requestTotalMetricValueCount; + return isDataDropped ? ZE_RESULT_WARNING_DROPPED_DATA : ZE_RESULT_SUCCESS; +} + +ze_result_t IpSamplingCalculation::calculateMetricForSubdevice(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; + + if (isMultiDeviceCaptureData(rawDataSize, pRawData)) { + METRICS_LOG_ERR("%s", "Calculating sub-device results using root device captured data is not supported"); + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + + if (calculateCountOnly) { + return getMetricCount(pRawData, rawDataSize, *pMetricValueCount); + } else { + return calculateMetricValues(type, rawDataSize, pRawData, *pMetricValueCount, pMetricValues); + } +} + template <> IpSamplingMetricSourceImp &MetricDeviceContext::getMetricSource() const { return static_cast(*metricSources.at(MetricSource::metricSourceTypeIpSampling)); 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 d97a2cd470..2d57accd12 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.h +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.h @@ -15,6 +15,7 @@ namespace L0 { struct IpSamplingMetricImp; struct IpSamplingMetricGroupImp; struct IpSamplingMetricStreamerImp; +struct IpSamplingCalculation; class IpSamplingMetricSourceImp : public MetricSource { @@ -66,6 +67,8 @@ class IpSamplingMetricSourceImp : public MetricSource { bool canDisable() override; void initMetricScopes(MetricDeviceContext &metricDeviceContext) override; + std::unique_ptr ipSamplingCalculation = nullptr; + protected: ze_result_t cacheMetricGroup(); bool isEnabled = false; @@ -131,18 +134,10 @@ struct IpSamplingMetricGroupImp : public IpSamplingMetricGroupBase { zet_metric_streamer_handle_t *phMetricStreamer) override; static std::unique_ptr create(IpSamplingMetricSourceImp &metricSource, std::vector &ipSamplingMetrics); - ze_result_t getCalculatedMetricValues(const zet_metric_group_calculation_type_t type, const size_t rawDataSize, const uint8_t *pMultiMetricData, - uint32_t &metricValueCount, - zet_typed_value_t *pCalculatedData, const uint32_t setIndex); - ze_result_t getCalculatedMetricCount(const uint8_t *pRawData, const size_t rawDataSize, uint32_t &metricValueCount); - ze_result_t getCalculatedMetricCount(const uint8_t *pMultiMetricData, const size_t rawDataSize, uint32_t &metricValueCount, const uint32_t setIndex); private: std::vector> metrics = {}; zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; - ze_result_t 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); }; struct MultiDeviceIpSamplingMetricGroupImp : public IpSamplingMetricGroupBase { @@ -189,6 +184,40 @@ struct IpSamplingMetricImp : public MetricImp { zet_metric_properties_t properties; }; +struct IpSamplingCalculation { + + IpSamplingCalculation(L0::L0GfxCoreHelper &gfxCoreHelper, IpSamplingMetricSourceImp &metricSource) + : gfxCoreHelper(gfxCoreHelper), metricSource(metricSource) {} + ~IpSamplingCalculation() = default; + + static bool isMultiDeviceCaptureData(const size_t rawDataSize, const uint8_t *pRawData); + + ze_result_t getMetricCount(const uint8_t *pRawData, const size_t rawDataSize, + uint32_t &metricValueCount); + ze_result_t getMetricCountSubDevIndex(const uint8_t *pMultiMetricData, const size_t rawDataSize, + uint32_t &metricValueCount, const uint32_t setIndex); + + ze_result_t calculateMetricValues(const zet_metric_group_calculation_type_t type, const size_t rawDataSize, + const uint8_t *pRawData, uint32_t &metricValueCount, + zet_typed_value_t *pCalculatedData); + ze_result_t calculateMetricValuesSubDevIndex(const zet_metric_group_calculation_type_t type, const size_t rawDataSize, + const uint8_t *pMultiMetricData, uint32_t &metricValueCount, + zet_typed_value_t *pCalculatedData, const uint32_t setIndex); + + ze_result_t calculateMetricForSubdevice(const zet_metric_group_calculation_type_t type, size_t rawDataSize, + const uint8_t *pRawData, uint32_t *pMetricValueCount, + zet_typed_value_t *pMetricValues); + + void fillStallDataMap(const size_t rawDataSize, const uint8_t *pRawData, size_t *processedSize, + L0GfxCoreHelper &l0GfxCoreHelper, + std::map &stallReportDataMap, + bool *dataOverflow); + + protected: + L0::L0GfxCoreHelper &gfxCoreHelper; + IpSamplingMetricSourceImp &metricSource; +}; + struct IpSamplingMetricDataHeader { static constexpr uint32_t magicValue = 0xFEEDBCBA; uint32_t magic; diff --git a/level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp b/level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp index efcd6ab772..1668620201 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp +++ b/level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp @@ -190,7 +190,9 @@ ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValuesSingle(const size_t uint32_t resultCount = 0; *usedSize = 0; - status = static_cast(metricGroupBase)->getCalculatedMetricCount(pRawData, rawDataSize, resultCount); + auto calcUtils = metricGroupBase->getMetricSource().ipSamplingCalculation.get(); + + status = calcUtils->getMetricCount(pRawData, rawDataSize, resultCount); if (status != ZE_RESULT_SUCCESS) { *pTotalMetricReportCount = 0; return status; 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 e1083a5f32..6c0e3e8251 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 @@ -43,6 +43,7 @@ void MetricIpSamplingMultiDevFixture::SetUp() { osInterfaceVector.push_back(mockMetricIpSamplingOsInterface); std::unique_ptr metricIpSamplingOsInterface = std::unique_ptr(mockMetricIpSamplingOsInterface); auto &metricSource = device->getMetricDeviceContext().getMetricSource(); + metricSource.metricSourceCount = platformIpMetricCountXe; metricSource.setMetricOsInterface(metricIpSamplingOsInterface); auto &metricOaSource = device->getMetricDeviceContext().getMetricSource(); @@ -63,6 +64,7 @@ void MetricIpSamplingFixture::SetUp() { std::unique_ptr metricIpSamplingOsInterface = std::unique_ptr(mockMetricIpSamplingOsInterface); auto &metricSource = device->getMetricDeviceContext().getMetricSource(); + metricSource.metricSourceCount = platformIpMetricCountXe; metricSource.setMetricOsInterface(metricIpSamplingOsInterface); auto &metricOaSource = device->getMetricDeviceContext().getMetricSource(); 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 7d76059c0b..f7a7e0a23e 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 @@ -59,6 +59,8 @@ class MockStallRawIpData { rawData[7] = 0; } }; + +constexpr uint32_t platformIpMetricCountXe = 10; class MetricIpSamplingMultiDevFixture : public MultiDeviceFixture, public ::testing::Test { public: 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 3693a730bc..76bf255bf2 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 @@ -580,12 +580,16 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen for (auto device : testDevices) { - auto expectedSetCount = 2u; + bool isRootdevice = true; + ze_result_t expectedResult = ZE_RESULT_SUCCESS; ze_device_properties_t props = {}; device->getProperties(&props); if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { - expectedSetCount = 1u; + // Root device data (rawDataWithHeader) will work only with root device metric group handle. + // Calling calculate with sub-device metric group handle will return INVALID ARGUMENT. + isRootdevice = false; + expectedResult = ZE_RESULT_ERROR_INVALID_ARGUMENT; } uint32_t metricGroupCount = 0; @@ -608,19 +612,21 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast(rawDataWithHeader.data()), &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), - ZE_RESULT_SUCCESS); - EXPECT_EQ(setCount, expectedSetCount); - EXPECT_EQ(totalMetricValueCount, 30u); // Three IPs plus nine metrics per IP - EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], - ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast(rawDataWithHeader.data()), - &setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()), - ZE_RESULT_SUCCESS); - EXPECT_EQ(setCount, expectedSetCount); - EXPECT_EQ(totalMetricValueCount, 30u); - EXPECT_EQ(metricCounts[0], 30u); - for (uint32_t i = 0; i < totalMetricValueCount; i++) { - EXPECT_TRUE(expectedMetricValues[i].type == metricValues[i].type); - EXPECT_TRUE(expectedMetricValues[i].value.ui64 == metricValues[i].value.ui64); + expectedResult); + if (isRootdevice) { + EXPECT_EQ(setCount, 2u); + EXPECT_EQ(totalMetricValueCount, 30u); // Three IPs plus nine metrics per IP + EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], + ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast(rawDataWithHeader.data()), + &setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()), + ZE_RESULT_SUCCESS); + EXPECT_EQ(setCount, 2u); + EXPECT_EQ(totalMetricValueCount, 30u); + EXPECT_EQ(metricCounts[0], 30u); + for (uint32_t i = 0; i < totalMetricValueCount; i++) { + EXPECT_TRUE(expectedMetricValues[i].type == metricValues[i].type); + EXPECT_TRUE(expectedMetricValues[i].value.ui64 == metricValues[i].value.ui64); + } } } } @@ -629,39 +635,31 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); std::vector metricValues(30); + auto device = testDevices[0]; // Root device data (rawDataWithHeader) makes sense only for calculating with root device mg handle. - for (auto device : testDevices) { + uint32_t metricGroupCount = 0; + zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); + std::vector metricGroups; + metricGroups.resize(metricGroupCount); + ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); + ASSERT_NE(metricGroups[0], nullptr); + zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; + EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); + EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); - ze_device_properties_t props = {}; - device->getProperties(&props); + std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)); + addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 0); + auto header = reinterpret_cast(rawDataWithHeader.data()); + header->magic = IpSamplingMetricDataHeader::magicValue - 1; - if ((props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) == 0) { - - uint32_t metricGroupCount = 0; - zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); - std::vector metricGroups; - metricGroups.resize(metricGroupCount); - ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); - ASSERT_NE(metricGroups[0], nullptr); - zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; - EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); - EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); - - std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)); - addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 0); - auto header = reinterpret_cast(rawDataWithHeader.data()); - header->magic = IpSamplingMetricDataHeader::magicValue - 1; - - uint32_t setCount = 0; - // Use random initializer - uint32_t totalMetricValueCount = std::numeric_limits::max(); - std::vector metricCounts(2); - EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], - ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast(rawDataWithHeader.data()), - &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), - ZE_RESULT_ERROR_INVALID_SIZE); - } - } + uint32_t setCount = 0; + // Use random initializer + uint32_t totalMetricValueCount = std::numeric_limits::max(); + std::vector metricCounts(2); + EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], + ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast(rawDataWithHeader.data()), + &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), + ZE_RESULT_ERROR_INVALID_ARGUMENT); } HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMultipleMetricValuesExpIsCalledWithDataFromSingleDeviceThenValidDataIsReturned, EustallSupportedPlatforms) { @@ -671,13 +669,10 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen for (auto device : testDevices) { - auto expectedSetCount = 2u; ze_device_properties_t props = {}; device->getProperties(&props); if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { - expectedSetCount = 1u; - uint32_t metricGroupCount = 0; zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); std::vector metricGroups; @@ -696,13 +691,13 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), ZE_RESULT_SUCCESS); - EXPECT_EQ(setCount, expectedSetCount); + EXPECT_EQ(setCount, 1u); EXPECT_EQ(totalMetricValueCount, 30u); EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()), ZE_RESULT_SUCCESS); - EXPECT_EQ(setCount, expectedSetCount); + EXPECT_EQ(setCount, 1u); EXPECT_EQ(totalMetricValueCount, 30u); EXPECT_EQ(metricCounts[0], 30u); for (uint32_t i = 0; i < totalMetricValueCount; i++) { @@ -749,56 +744,48 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen std::vector metricValues(30); - for (auto device : testDevices) { + auto device = testDevices[0]; // Root device data (rawDataWithHeader) makes sense only for calculating with root device mg handle. - auto expectedSetCount = 2u; - ze_device_properties_t props = {}; - device->getProperties(&props); + uint32_t metricGroupCount = 0; + zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); + std::vector metricGroups; + metricGroups.resize(metricGroupCount); + ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); + ASSERT_NE(metricGroups[0], nullptr); + zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; + EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); + EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); - if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { - expectedSetCount = 1u; - } + // Allocate for 2 reads + std::vector rawDataWithHeader((rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)) * 2); + addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 1); + addHeader(rawDataWithHeader.data() + rawDataVectorSize + sizeof(IpSamplingMetricDataHeader), + rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 0); - uint32_t metricGroupCount = 0; - zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); - std::vector metricGroups; - metricGroups.resize(metricGroupCount); - ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); - ASSERT_NE(metricGroups[0], nullptr); - zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; - EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); - EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); + // Use random initializer + uint32_t setCount = std::numeric_limits::max(); + uint32_t totalMetricValueCount = 0; + std::vector metricCounts(2); + EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], + ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), + reinterpret_cast(rawDataWithHeader.data()), + &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), + ZE_RESULT_SUCCESS); - // Allocate for 2 reads - std::vector rawDataWithHeader((rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)) * 2); - addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 0); - addHeader(rawDataWithHeader.data() + rawDataVectorSize + sizeof(IpSamplingMetricDataHeader), - rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 0); - - // Use random initializer - uint32_t setCount = std::numeric_limits::max(); - uint32_t totalMetricValueCount = 0; - std::vector metricCounts(2); - EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], - ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), - reinterpret_cast(rawDataWithHeader.data()), - &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), - ZE_RESULT_SUCCESS); - EXPECT_EQ(setCount, expectedSetCount); - EXPECT_EQ(totalMetricValueCount, 60u); - totalMetricValueCount = 10; - EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], - ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), - reinterpret_cast(rawDataWithHeader.data()), - &setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()), - ZE_RESULT_SUCCESS); - EXPECT_EQ(setCount, expectedSetCount); - EXPECT_EQ(totalMetricValueCount, 10u); - EXPECT_EQ(metricCounts[0], 10u); - for (uint32_t i = 0; i < totalMetricValueCount; i++) { - EXPECT_TRUE(expectedMetricValues[i].type == metricValues[i].type); - EXPECT_TRUE(expectedMetricValues[i].value.ui64 == metricValues[i].value.ui64); - } + EXPECT_EQ(setCount, 2u); + EXPECT_EQ(totalMetricValueCount, 60u); + totalMetricValueCount = 10; + EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], + ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), + reinterpret_cast(rawDataWithHeader.data()), + &setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()), + ZE_RESULT_SUCCESS); + EXPECT_EQ(setCount, 2u); + EXPECT_EQ(totalMetricValueCount, 10u); + EXPECT_EQ(metricCounts[0], 10u); + for (uint32_t i = 0; i < totalMetricValueCount; i++) { + EXPECT_TRUE(expectedMetricValues[i].type == metricValues[i].type); + EXPECT_TRUE(expectedMetricValues[i].value.ui64 == metricValues[i].value.ui64); } } @@ -827,7 +814,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size() + 1, reinterpret_cast(rawDataWithHeader.data()), &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), - ZE_RESULT_ERROR_INVALID_SIZE); + ZE_RESULT_ERROR_INVALID_ARGUMENT); } } @@ -837,32 +824,45 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, WhenCalculateMultipleMetricValue std::vector metricValues(30); for (auto device : testDevices) { + bool isRootdevice = false; + ze_device_properties_t props = {}; + device->getProperties(&props); + if (!(props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE)) { + isRootdevice = true; + } - uint32_t metricGroupCount = 0; - zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); - std::vector metricGroups; - metricGroups.resize(metricGroupCount); - ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); - ASSERT_NE(metricGroups[0], nullptr); - zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; - EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); - EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); + uint32_t metricGroupCount = 1; + zet_metric_group_handle_t hMetricGroup; - std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)); - addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 0); + ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &hMetricGroup), ZE_RESULT_SUCCESS); + + std::vector rawData; + if (isRootdevice) { // Root device data (rawDataWithHeader) makes sense only for calculating with root device mg handle. + rawData.resize(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)); + addHeader(rawData.data(), rawData.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 0); + } else { + rawData.resize(rawDataVectorSize); + memcpy_s(rawData.data(), rawData.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize); + } uint32_t setCount = 0; uint32_t totalMetricValueCount = 0; std::vector metricCounts(2); - EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], - ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast(rawDataWithHeader.data()), + EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(hMetricGroup, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, + rawData.size(), reinterpret_cast(rawData.data()), &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), ZE_RESULT_SUCCESS); - // Incorrect raw data size - auto header = reinterpret_cast(rawDataWithHeader.data()); - header->rawDataSize = static_cast(rawDataVectorSize - 1); - EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], - ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast(rawDataWithHeader.data()), + // Force incorrect raw data size + size_t rawDatSize = rawData.size(); + if (isRootdevice) { + auto header = reinterpret_cast(rawData.data()); + header->rawDataSize = static_cast(rawDataVectorSize - 1); + } else { + rawDatSize = rawData.size() - 1; + } + + EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(hMetricGroup, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, + rawDatSize, reinterpret_cast(rawData.data()), &setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()), ZE_RESULT_ERROR_INVALID_SIZE); } @@ -872,59 +872,57 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, WhenCalculateMultipleMetricValue EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); - for (auto device : testDevices) { + auto device = testDevices[0]; // Root device data (rawDataWithHeader) makes sense only for calculating with root device mg handle. - uint32_t metricGroupCount = 0; - zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); - std::vector metricGroups; - metricGroups.resize(metricGroupCount); - ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); - ASSERT_NE(metricGroups[0], nullptr); - zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; - EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); - EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); + uint32_t metricGroupCount = 0; + zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); + std::vector metricGroups; + metricGroups.resize(metricGroupCount); + ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); + ASSERT_NE(metricGroups[0], nullptr); + zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; + EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); + EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); - std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader) + 1); - addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize - 1, 0); + std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader) + 1); + addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize - 1, 0); - uint32_t setCount = 0; - uint32_t totalMetricValueCount = 0; - std::vector metricCounts(2); - EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], - ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast(rawDataWithHeader.data()), - &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), - ZE_RESULT_ERROR_INVALID_SIZE); - } + uint32_t setCount = 0; + uint32_t totalMetricValueCount = 0; + std::vector metricCounts(2); + EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], + ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast(rawDataWithHeader.data()), + &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), + ZE_RESULT_ERROR_INVALID_SIZE); } HWTEST2_F(MetricIpSamplingCalculateMetricsTest, WhenCalculateMultipleMetricValuesExpCalculateSizeIsCalledWithInvalidRawDataSizeInHeaderThenErrorIsReturned, EustallSupportedPlatforms) { EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); - for (auto device : testDevices) { + auto device = testDevices[0]; // Root device data (rawDataWithHeader) makes sense only for calculating with root device mg handle. - uint32_t metricGroupCount = 0; - zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); - std::vector metricGroups; - metricGroups.resize(metricGroupCount); - ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); - ASSERT_NE(metricGroups[0], nullptr); - zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; - EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); - EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); + uint32_t metricGroupCount = 0; + zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); + std::vector metricGroups; + metricGroups.resize(metricGroupCount); + ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); + ASSERT_NE(metricGroups[0], nullptr); + zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; + EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); + EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); - std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader) + 1); - addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize - 1, 0); + std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader) + 1); + addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize - 1, 0); - uint32_t setCount = 0; - uint32_t totalMetricValueCount = 10; - std::vector metricCounts(2); - std::vector metricValues(30); - EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], - ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast(rawDataWithHeader.data()), - &setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()), - ZE_RESULT_ERROR_INVALID_SIZE); - } + uint32_t setCount = 0; + uint32_t totalMetricValueCount = 10; + std::vector metricCounts(2); + std::vector metricValues(30); + EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], + ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast(rawDataWithHeader.data()), + &setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()), + ZE_RESULT_ERROR_INVALID_SIZE); } HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMultipleMetricValuesExpCalculateDataWithBadRawDataSizeIsCalledThenErrorUnknownIsReturned, EustallSupportedPlatforms) { @@ -932,45 +930,36 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); std::vector metricValues(30); + auto device = testDevices[0]; // Root device data (rawDataWithHeader) makes sense only for calculating with root device mg handle. - for (auto device : testDevices) { + uint32_t metricGroupCount = 0; + zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); + std::vector metricGroups; + metricGroups.resize(metricGroupCount); + ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); + ASSERT_NE(metricGroups[0], nullptr); + zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; + EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); + EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); - auto expectedSetCount = 2u; - ze_device_properties_t props = {}; - device->getProperties(&props); + std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)); + addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 0); - if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { - expectedSetCount = 1u; - } + uint32_t setCount = 0; + uint32_t totalMetricValueCount = 0; + std::vector metricCounts(2); + EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], + ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast(rawDataWithHeader.data()), + &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), + ZE_RESULT_SUCCESS); - uint32_t metricGroupCount = 0; - zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); - std::vector metricGroups; - metricGroups.resize(metricGroupCount); - ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); - ASSERT_NE(metricGroups[0], nullptr); - zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; - EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); - EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); - - std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)); - addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 0); - - uint32_t setCount = 0; - uint32_t totalMetricValueCount = 0; - std::vector metricCounts(2); - EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], - ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast(rawDataWithHeader.data()), - &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), - ZE_RESULT_SUCCESS); - EXPECT_EQ(setCount, expectedSetCount); - EXPECT_EQ(totalMetricValueCount, 30u); - totalMetricValueCount += 1; - EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], - ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size() + 1, reinterpret_cast(rawDataWithHeader.data()), - &setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()), - ZE_RESULT_ERROR_INVALID_SIZE); - } + EXPECT_EQ(setCount, 2u); + EXPECT_EQ(totalMetricValueCount, 30u); + totalMetricValueCount += 1; + EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], + ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size() + 1, reinterpret_cast(rawDataWithHeader.data()), + &setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()), + ZE_RESULT_ERROR_INVALID_ARGUMENT); } HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMetricValuesIsCalledThenValidDataIsReturned, EustallSupportedPlatforms) { @@ -980,6 +969,17 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen std::vector metricValues(30); for (auto device : testDevices) { + bool isRootdevice = false; + ze_result_t expectedResult = ZE_RESULT_SUCCESS; + ze_device_properties_t props = {}; + device->getProperties(&props); + + if (!(props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE)) { + // Sub-device data (rawDataVector) will work only with sub-device metric group handle. + // Calling calculate with root-device metric group handle will return INVALID ARGUMENT. + isRootdevice = true; + expectedResult = ZE_RESULT_ERROR_INVALID_ARGUMENT; + } uint32_t metricGroupCount = 0; zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); @@ -994,15 +994,17 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen uint32_t metricValueCount = 0; EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, nullptr), - ZE_RESULT_SUCCESS); - EXPECT_TRUE(metricValueCount == 30); - EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, - rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, metricValues.data()), - ZE_RESULT_SUCCESS); - EXPECT_TRUE(metricValueCount == 30); - for (uint32_t i = 0; i < metricValueCount; i++) { - EXPECT_TRUE(expectedMetricValues[i].type == metricValues[i].type); - EXPECT_TRUE(expectedMetricValues[i].value.ui64 == metricValues[i].value.ui64); + expectedResult); + if (!isRootdevice) { + EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, + rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, metricValues.data()), + expectedResult); + + EXPECT_TRUE(metricValueCount == 30); + for (uint32_t i = 0; i < metricValueCount; i++) { + EXPECT_TRUE(expectedMetricValues[i].type == metricValues[i].type); + EXPECT_TRUE(expectedMetricValues[i].value.ui64 == metricValues[i].value.ui64); + } } } } @@ -1014,7 +1016,6 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen std::vector metricValues(30); for (auto device : testDevices) { - uint32_t metricGroupCount = 0; zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); std::vector metricGroups; @@ -1042,83 +1043,95 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen std::vector metricValues(30); for (auto device : testDevices) { + ze_device_properties_t props = {}; + device->getProperties(&props); + if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { // Sub-device data (rawDataVector) will work only with sub-device metric group handle. + uint32_t metricGroupCount = 0; + zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); + std::vector metricGroups; + metricGroups.resize(metricGroupCount); + ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); + ASSERT_NE(metricGroups[0], nullptr); + zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; + EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); + EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); - uint32_t metricGroupCount = 0; - zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); - std::vector metricGroups; - metricGroups.resize(metricGroupCount); - ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); - ASSERT_NE(metricGroups[0], nullptr); - zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; - EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); - EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); + uint32_t metricValueCount = 0; + EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, + rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, nullptr), + ZE_RESULT_SUCCESS); - uint32_t metricValueCount = 0; - EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, - rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, nullptr), - ZE_RESULT_SUCCESS); - EXPECT_TRUE(metricValueCount == 30); - metricValueCount = 15; - EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, - rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, metricValues.data()), - ZE_RESULT_SUCCESS); - EXPECT_TRUE(metricValueCount == 15); - for (uint32_t i = 0; i < metricValueCount; i++) { - EXPECT_TRUE(expectedMetricValues[i].type == metricValues[i].type); - EXPECT_TRUE(expectedMetricValues[i].value.ui64 == metricValues[i].value.ui64); + EXPECT_TRUE(metricValueCount == 30); + metricValueCount = 15; + EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, + rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, metricValues.data()), + ZE_RESULT_SUCCESS); + EXPECT_TRUE(metricValueCount == 15); + for (uint32_t i = 0; i < metricValueCount; i++) { + EXPECT_TRUE(expectedMetricValues[i].type == metricValues[i].type); + EXPECT_TRUE(expectedMetricValues[i].value.ui64 == metricValues[i].value.ui64); + } } } } -HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWithBadRawDataSizeWhenCalculateMetricValuesCalculateSizeIsCalledThenErrorUnknownIsReturned, EustallSupportedPlatforms) { +HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWithBadRawDataSizeWhenCalculateMetricValuesCalculateSizeIsCalledThenInvalidSizeIsReturned, EustallSupportedPlatforms) { EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); for (auto device : testDevices) { + ze_device_properties_t props = {}; + device->getProperties(&props); + if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { // Sub-device data (rawDataVector) will work only with sub-device metric group handle. + uint32_t metricGroupCount = 0; + zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); + std::vector metricGroups; + metricGroups.resize(metricGroupCount); + ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); + ASSERT_NE(metricGroups[0], nullptr); + zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; + EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); + EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); - uint32_t metricGroupCount = 0; - zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); - std::vector metricGroups; - metricGroups.resize(metricGroupCount); - ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); - ASSERT_NE(metricGroups[0], nullptr); - zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; - EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); - EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); - - uint32_t metricValueCount = 0; - EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, - rawDataVectorSize - 1, reinterpret_cast(rawDataVector.data()), &metricValueCount, nullptr), - ZE_RESULT_ERROR_INVALID_SIZE); + uint32_t metricValueCount = 0; + EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, + rawDataVectorSize - 1, reinterpret_cast(rawDataVector.data()), &metricValueCount, nullptr), + ZE_RESULT_ERROR_INVALID_SIZE); + } } } -HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMetricValuesWithBadRawDataSizeCalculateDataIsCalledThenUnsupportedFeatureIsReturned, EustallSupportedPlatforms) { +HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMetricValuesWithBadRawDataSizeCalculateDataIsCalledThenInvalidSizeIsReturned, EustallSupportedPlatforms) { EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); std::vector metricValues(30); for (auto device : testDevices) { + ze_device_properties_t props = {}; + device->getProperties(&props); + if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { // Sub-device data (rawDataVector) will work only with sub-device metric group handle. - uint32_t metricGroupCount = 0; - zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); - std::vector metricGroups; - metricGroups.resize(metricGroupCount); - ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); - ASSERT_NE(metricGroups[0], nullptr); - zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; - EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); - EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); + uint32_t metricGroupCount = 0; + zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); + std::vector metricGroups; + metricGroups.resize(metricGroupCount); + ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); + ASSERT_NE(metricGroups[0], nullptr); + zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; + EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); + EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); - uint32_t metricValueCount = 0; - EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, - rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, nullptr), - ZE_RESULT_SUCCESS); - EXPECT_TRUE(metricValueCount == 30); - EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, - rawDataVectorSize - 1, reinterpret_cast(rawDataVector.data()), &metricValueCount, metricValues.data()), - ZE_RESULT_ERROR_INVALID_SIZE); + uint32_t metricValueCount = 0; + EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, + rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, nullptr), + ZE_RESULT_SUCCESS); + + EXPECT_TRUE(metricValueCount == 30u); + EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, + rawDataVectorSize - 1, reinterpret_cast(rawDataVector.data()), &metricValueCount, metricValues.data()), + ZE_RESULT_ERROR_INVALID_SIZE); + } } } @@ -1128,43 +1141,47 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenDataOverflowOccurredWhenStr std::vector metricValues(30); for (auto device : testDevices) { - - auto expectedSetCount = 2u; + uint32_t expectedSetCount = 1u; + bool isRootdevice = false; ze_device_properties_t props = {}; device->getProperties(&props); - - if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { - expectedSetCount = 1u; + if (!(props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE)) { + isRootdevice = true; + expectedSetCount = 2u; } - uint32_t metricGroupCount = 0; - zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); - std::vector metricGroups; - metricGroups.resize(metricGroupCount); - ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); - ASSERT_NE(metricGroups[0], nullptr); - zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; - EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); - EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); - std::vector rawDataWithHeader(rawDataVectorOverflowSize + sizeof(IpSamplingMetricDataHeader)); - addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVectorOverflow.data()), rawDataVectorOverflowSize, 0); + uint32_t metricGroupCount = 1; + zet_metric_group_handle_t hMetricGroup; + + ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &hMetricGroup), ZE_RESULT_SUCCESS); + + std::vector rawData; + if (isRootdevice) { // Root device data (rawDataWithHeader) makes sense only for calculating with root device mg handle. + rawData.resize(rawDataVectorOverflowSize + sizeof(IpSamplingMetricDataHeader)); + addHeader(rawData.data(), rawData.size(), reinterpret_cast(rawDataVectorOverflow.data()), rawDataVectorOverflowSize, 0); + } else { + rawData.resize(rawDataVectorOverflowSize); + memcpy_s(rawData.data(), rawData.size(), reinterpret_cast(rawDataVectorOverflow.data()), rawDataVectorOverflowSize); + } uint32_t setCount = 0; uint32_t totalMetricValueCount = 0; std::vector metricCounts(2); - EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], - ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast(rawDataWithHeader.data()), + EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(hMetricGroup, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, + rawData.size(), reinterpret_cast(rawData.data()), &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), ZE_RESULT_SUCCESS); + EXPECT_EQ(setCount, expectedSetCount); EXPECT_EQ(totalMetricValueCount, 20u); - EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], - ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast(rawDataWithHeader.data()), + EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(hMetricGroup, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, + rawData.size(), reinterpret_cast(rawData.data()), &setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()), ZE_RESULT_WARNING_DROPPED_DATA); EXPECT_EQ(setCount, expectedSetCount); EXPECT_EQ(totalMetricValueCount, 20u); EXPECT_TRUE(metricCounts[0] == 20); + for (uint32_t i = 0; i < totalMetricValueCount; i++) { EXPECT_TRUE(expectedMetricOverflowValues[i].type == metricValues[i].type); EXPECT_TRUE(expectedMetricOverflowValues[i].value.ui64 == metricValues[i].value.ui64); @@ -1179,25 +1196,30 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWith std::vector metricValues(30); for (auto device : testDevices) { + ze_device_properties_t props = {}; + device->getProperties(&props); + if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { // Sub-device data (rawDataVector) will work only with sub-device metric group handle. - uint32_t metricGroupCount = 0; - zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); - std::vector metricGroups; - metricGroups.resize(metricGroupCount); - ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); - ASSERT_NE(metricGroups[0], nullptr); - zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; - EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); - EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); + uint32_t metricGroupCount = 0; + zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); + std::vector metricGroups; + metricGroups.resize(metricGroupCount); + ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); + ASSERT_NE(metricGroups[0], nullptr); + zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; + EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); + EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); - uint32_t metricValueCount = 0; - EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, - rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, nullptr), - ZE_RESULT_SUCCESS); - EXPECT_TRUE(metricValueCount == 30); - EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES, - rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, metricValues.data()), - ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); + uint32_t metricValueCount = 0; + EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, + rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, nullptr), + ZE_RESULT_SUCCESS); + + EXPECT_EQ(metricValueCount, 30u); + EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES, + rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, metricValues.data()), + ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); + } } }