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 3283c5bcc6..10980cc6d5 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp @@ -11,6 +11,8 @@ #include "level_zero/tools/source/metrics/os_metric_ip_sampling.h" #include +#include + namespace L0 { constexpr uint32_t ipSamplinMetricCount = 10u; constexpr uint32_t ipSamplinDomainId = 100u; @@ -149,14 +151,194 @@ ze_result_t IpSamplingMetricGroupImp::metricGet(uint32_t *pCount, zet_metric_han 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) { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + const bool calculateCountOnly = *pMetricValueCount == 0; + if (calculateCountOnly) { + return getCalculatedMetricCount(rawDataSize, *pMetricValueCount); + } else { + return getCalculatedMetricValues(type, rawDataSize, pRawData, *pMetricValueCount, pMetricValues); + } } ze_result_t IpSamplingMetricGroupImp::calculateMetricValuesExp(const zet_metric_group_calculation_type_t type, size_t rawDataSize, const uint8_t *pRawData, uint32_t *pSetCount, uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts, zet_typed_value_t *pMetricValues) { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + const bool calculationCountOnly = *pTotalMetricValueCount == 0; + ze_result_t result = this->calculateMetricValues(type, rawDataSize, pRawData, pTotalMetricValueCount, pMetricValues); + + if (result == ZE_RESULT_SUCCESS) { + *pSetCount = 1; + if (!calculationCountOnly) { + pMetricCounts[0] = *pTotalMetricValueCount; + } + } else { + if (calculationCountOnly) { + *pSetCount = 0; + *pTotalMetricValueCount = 0; + } else { + pMetricCounts[0] = 0; + } + } + return result; +} + +ze_result_t IpSamplingMetricGroupImp::getCalculatedMetricCount(const size_t rawDataSize, + uint32_t &metricValueCount) { + + uint32_t rawReportSize = 64; + + if ((rawDataSize % rawReportSize) != 0) { + return ZE_RESULT_ERROR_INVALID_SIZE; + } + + const uint32_t rawReportCount = static_cast(rawDataSize) / rawReportSize; + metricValueCount = rawReportCount * properties.metricCount; + return 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) { + StallSumIpDataMap_t stallSumIpDataMap; + + // MAX_METRIC_VALUES is not supported yet. + if (type != ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES) { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + + DEBUG_BREAK_IF(pCalculatedData == nullptr); + + uint32_t rawReportSize = 64; + + if ((rawDataSize % rawReportSize) != 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) { + stallIpDataMapUpdate(stallSumIpDataMap, pRawIpData); + } + + metricValueCount = std::min(metricValueCount, static_cast(stallSumIpDataMap.size()) * properties.metricCount); + std::vector ipDataValues; + uint32_t i = 0; + for (auto it = stallSumIpDataMap.begin(); it != stallSumIpDataMap.end(); ++it) { + stallSumIpDataToTypedValues(it->first, it->second, ipDataValues); + for (auto jt = ipDataValues.begin(); (jt != ipDataValues.end()) && (i < metricValueCount); jt++, i++) { + *(pCalculatedData + i) = *jt; + } + ipDataValues.clear(); + } + + return ZE_RESULT_SUCCESS; +} + +/* + * stall sample data item format: + * + * Bits Field + * 0 to 28 IP (addr) + * 29 to 36 active count + * 37 to 44 other count + * 45 to 52 control count + * 53 to 60 pipestall count + * 61 to 68 send count + * 69 to 76 dist_acc count + * 77 to 84 sbid count + * 85 to 92 sync count + * 93 to 100 inst_fetch count + * + * bytes 49 and 50, subSlice + * bytes 51 and 52, flags + * + * total size 64 bytes + */ +void IpSamplingMetricGroupImp::stallIpDataMapUpdate(StallSumIpDataMap_t &stallSumIpDataMap, const uint8_t *pRawIpData) { + + const uint8_t *tempAddr = pRawIpData; + uint64_t ip = 0ULL; + memcpy_s(reinterpret_cast(&ip), sizeof(ip), tempAddr, sizeof(ip)); + ip &= 0x1fffffff; + StallSumIpData_t &stallSumData = stallSumIpDataMap[ip]; + tempAddr += 3; + + auto getCount = [&tempAddr]() { + uint16_t tempCount = 0; + memcpy_s(reinterpret_cast(&tempCount), sizeof(tempCount), tempAddr, sizeof(tempCount)); + tempCount = (tempCount >> 5) & 0xff; + tempAddr += 1; + return static_cast(tempCount); + }; + + stallSumData.activeCount += getCount(); + stallSumData.otherCount += getCount(); + stallSumData.controlCount += getCount(); + stallSumData.pipeStallCount += getCount(); + stallSumData.sendCount += getCount(); + stallSumData.distAccCount += getCount(); + stallSumData.sbidCount += getCount(); + stallSumData.syncCount += getCount(); + stallSumData.instFetchCount += getCount(); + + struct stallCntrInfo { + uint16_t subslice; + uint16_t flags; + } stallCntrInfo = {}; + + tempAddr = pRawIpData + 48; + memcpy_s(reinterpret_cast(&stallCntrInfo), sizeof(stallCntrInfo), tempAddr, sizeof(stallCntrInfo)); + + constexpr int overflowDropFlag = (1 << 8); + if (stallCntrInfo.flags & overflowDropFlag) { + PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Stall Sampling Data Lost %s\n", " "); + } +} + +// The order of push_back calls must match the order of metricPropertiesList. +void IpSamplingMetricGroupImp::stallSumIpDataToTypedValues(uint64_t ip, + StallSumIpData_t &sumIpData, + std::vector &ipDataValues) { + zet_typed_value_t tmpValueData; + tmpValueData.type = ZET_VALUE_TYPE_UINT64; + tmpValueData.value.ui64 = ip; + ipDataValues.push_back(tmpValueData); + + tmpValueData.type = ZET_VALUE_TYPE_UINT64; + tmpValueData.value.ui64 = sumIpData.activeCount; + ipDataValues.push_back(tmpValueData); + + tmpValueData.type = ZET_VALUE_TYPE_UINT64; + tmpValueData.value.ui64 = sumIpData.controlCount; + ipDataValues.push_back(tmpValueData); + + tmpValueData.type = ZET_VALUE_TYPE_UINT64; + tmpValueData.value.ui64 = sumIpData.pipeStallCount; + ipDataValues.push_back(tmpValueData); + + tmpValueData.type = ZET_VALUE_TYPE_UINT64; + tmpValueData.value.ui64 = sumIpData.sendCount; + ipDataValues.push_back(tmpValueData); + + tmpValueData.type = ZET_VALUE_TYPE_UINT64; + tmpValueData.value.ui64 = sumIpData.distAccCount; + ipDataValues.push_back(tmpValueData); + + tmpValueData.type = ZET_VALUE_TYPE_UINT64; + tmpValueData.value.ui64 = sumIpData.sbidCount; + ipDataValues.push_back(tmpValueData); + + tmpValueData.type = ZET_VALUE_TYPE_UINT64; + tmpValueData.value.ui64 = sumIpData.syncCount; + ipDataValues.push_back(tmpValueData); + + tmpValueData.type = ZET_VALUE_TYPE_UINT64; + tmpValueData.value.ui64 = sumIpData.instFetchCount; + ipDataValues.push_back(tmpValueData); + + tmpValueData.type = ZET_VALUE_TYPE_UINT64; + tmpValueData.value.ui64 = sumIpData.otherCount; + ipDataValues.push_back(tmpValueData); } bool IpSamplingMetricGroupImp::activate() { 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 d3621e8394..caa9c283b1 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.h +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.h @@ -39,6 +39,20 @@ class IpSamplingMetricSourceImp : public MetricSource { std::unique_ptr cachedMetricGroup = nullptr; }; +typedef struct StallSumIpData { + uint64_t activeCount; + uint64_t otherCount; + uint64_t controlCount; + uint64_t pipeStallCount; + uint64_t sendCount; + uint64_t distAccCount; + uint64_t sbidCount; + uint64_t syncCount; + uint64_t instFetchCount; +} StallSumIpData_t; + +typedef std::map StallSumIpDataMap_t; + struct IpSamplingMetricGroupImp : public MetricGroup { IpSamplingMetricGroupImp(std::vector &metrics); virtual ~IpSamplingMetricGroupImp() = default; @@ -71,6 +85,12 @@ struct IpSamplingMetricGroupImp : public MetricGroup { private: std::vector> metrics = {}; zet_metric_group_properties_t properties = {}; + ze_result_t getCalculatedMetricCount(const size_t rawDataSize, uint32_t &metricValueCount); + 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); + void stallIpDataMapUpdate(StallSumIpDataMap_t &, const uint8_t *pRawIpData); + void stallSumIpDataToTypedValues(uint64_t ip, StallSumIpData_t &sumIpData, std::vector &ipDataValues); }; struct IpSamplingMetricImp : public Metric { 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 f0ec639fdc..5bc9c120a9 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 @@ -12,12 +12,79 @@ namespace L0 { namespace ult { class MockMetricIpSamplingOsInterface; + +class MockStallRawIpData { + public: + static constexpr uint32_t ipShift = 29; + static constexpr uint32_t ipMask = 0x1fffffff; + + static constexpr uint32_t byteShift = 8; + static constexpr uint32_t byteMask = 0xff; + + static constexpr uint32_t wordShift = 16; + static constexpr uint32_t wordMask = 0xffff; + + uint64_t rawData[8]; + MockStallRawIpData(uint64_t ip, uint64_t activeCount, uint64_t otherCount, uint64_t controlCount, + uint64_t pipeStallCount, uint64_t sendCount, uint64_t distAccCount, + uint64_t sbidCount, uint64_t syncCount, uint64_t instFetchCount, uint64_t subSlice, + uint64_t flags) { + + rawData[0] = (ip & ipMask) | + ((activeCount & byteMask) << ipShift) | + ((otherCount & byteMask) << (ipShift + byteShift)) | + ((controlCount & byteMask) << (ipShift + 2 * byteShift)) | + ((pipeStallCount & byteMask) << (ipShift + 3 * byteShift)) | + ((sendCount & 0x7) << (ipShift + 4 * byteShift)); + + rawData[1] = ((sendCount & 0xf8) >> 3) | + ((distAccCount & byteMask) << 5) | + ((sbidCount & byteMask) << (5 + byteShift)) | + ((syncCount & byteMask) << (5 + 2 * byteShift)) | + ((instFetchCount & byteMask) << (5 + 3 * byteShift)); + + rawData[2] = 0LL; + rawData[3] = 0LL; + rawData[4] = 0LL; + rawData[5] = 0LL; + rawData[6] = (subSlice & wordMask) | ((flags & wordMask) << wordShift); + rawData[7] = 0; + } +}; class MetricIpSamplingFixture : public MultiDeviceFixture, public ::testing::Test { public: void SetUp() override; void TearDown() override; + std::vector rawDataVector = {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1000, 0x01}, + {1, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1000, 0x02}, + {10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 1001, 0x100}, // set the overflow bit in flags + {10, 90, 80, 70, 60, 50, 40, 30, 20, 10, 1000, 0x3}}; + + size_t rawDataVectorSize = sizeof(rawDataVector[0]) * rawDataVector.size(); + std::vector expectedMetricValues = { + {ZET_VALUE_TYPE_UINT64, {1}}, + {ZET_VALUE_TYPE_UINT64, {11}}, + {ZET_VALUE_TYPE_UINT64, {11}}, + {ZET_VALUE_TYPE_UINT64, {11}}, + {ZET_VALUE_TYPE_UINT64, {11}}, + {ZET_VALUE_TYPE_UINT64, {11}}, + {ZET_VALUE_TYPE_UINT64, {11}}, + {ZET_VALUE_TYPE_UINT64, {11}}, + {ZET_VALUE_TYPE_UINT64, {11}}, + {ZET_VALUE_TYPE_UINT64, {11}}, + {ZET_VALUE_TYPE_UINT64, {10}}, + {ZET_VALUE_TYPE_UINT64, {110}}, + {ZET_VALUE_TYPE_UINT64, {110}}, + {ZET_VALUE_TYPE_UINT64, {110}}, + {ZET_VALUE_TYPE_UINT64, {110}}, + {ZET_VALUE_TYPE_UINT64, {110}}, + {ZET_VALUE_TYPE_UINT64, {110}}, + {ZET_VALUE_TYPE_UINT64, {110}}, + {ZET_VALUE_TYPE_UINT64, {110}}, + {ZET_VALUE_TYPE_UINT64, {110}}}; + std::vector osInterfaceVector = {}; std::vector testDevices = {}; }; 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 764a9d93c7..a77b75a0c3 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 @@ -175,8 +175,8 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenDependenciesAvailableWhenMetricGrou } TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulThenDummyActivationAndDeActivationHappens) { - EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); + for (auto device : testDevices) { uint32_t metricGroupCount = 0; @@ -194,10 +194,13 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulThenDummyAct EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), device->toHandle(), 0, nullptr), ZE_RESULT_SUCCESS); } } +using MetricIpSamplingCalculateMetricsTest = MetricIpSamplingFixture; -TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenCalculateMultipleMetricValuesExpIsCalledThenUnsupportedFeatureIsReturned) { - +TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMultipleMetricValuesExpIsCalledThenValidDataIsReturned) { EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); + + std::vector metricValues(30); + for (auto device : testDevices) { uint32_t metricGroupCount = 0; @@ -210,16 +213,33 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenCalculat EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); + uint32_t setCount = 0; + uint32_t totalMetricValueCount = 0; + std::vector metricCounts(2); EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], - ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, 0x0, nullptr, - nullptr, nullptr, nullptr, nullptr), - ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); + ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast(rawDataVector.data()), + &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), + ZE_RESULT_SUCCESS); + EXPECT_TRUE(setCount == 1); + EXPECT_TRUE(totalMetricValueCount == 40); + EXPECT_EQ(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_TRUE(setCount == 1); + EXPECT_TRUE(totalMetricValueCount == 20); + EXPECT_TRUE(metricCounts[0] == 20); + 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); + } } } -TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenCalculateMetricValuesIsCalledThenUnsupportedFeatureIsReturned) { +TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMultipleMetricValuesExpCalculateSizeIsCalledWithInvalidRawDataSizeThenErrorUnknownIsReturned) { EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); + for (auto device : testDevices) { uint32_t metricGroupCount = 0; @@ -232,8 +252,196 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenCalculat EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); + uint32_t setCount = 0; + uint32_t totalMetricValueCount = 0; + std::vector metricCounts(2); + EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], + ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize + 1, reinterpret_cast(rawDataVector.data()), + &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), + ZE_RESULT_ERROR_INVALID_SIZE); + } +} + +TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMultipleMetricValuesExpCalculateDataWithBadRawDataSizeIsCalledThenErrorUnknownIsReturned) { + + EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); + + std::vector metricValues(30); + + 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; + EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS); + EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0); + + uint32_t setCount = 0; + uint32_t totalMetricValueCount = 0; + std::vector metricCounts(2); + EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], + ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast(rawDataVector.data()), + &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), + ZE_RESULT_SUCCESS); + EXPECT_TRUE(setCount == 1); + EXPECT_TRUE(totalMetricValueCount == 40); + EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], + ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize + 1, reinterpret_cast(rawDataVector.data()), + &setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()), + ZE_RESULT_ERROR_INVALID_SIZE); + } +} + +TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMetricValuesIsCalledThenValidDataIsReturned) { + + EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); + + std::vector metricValues(30); + + 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; + 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, - 0, nullptr, nullptr, nullptr), + rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, nullptr), + ZE_RESULT_SUCCESS); + EXPECT_TRUE(metricValueCount == 40); + 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 == 20); + 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); + } + } +} + +TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMetricValuesIsCalledWithSmallValueCountThenValidDataIsReturned) { + + EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); + + std::vector metricValues(30); + + 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; + 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 == 40); + 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); + } + } +} + +TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWithBadRawDataSizeWhenCalculateMetricValuesCalculateSizeIsCalledThenErrorUnknownIsReturned) { + + EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); + + 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; + 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); + } +} + +TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMetricValuesWithBadRawDataSizeCalculateDataIsCalledThenUnsupportedFeatureIsReturned) { + + EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); + + std::vector metricValues(30); + + 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; + 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 == 40); + 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); + } +} + +TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWithCALCULATIONTYPEMAXWhenCalculateMetricValuesIsCalledThenErrorUnknownIsReturned) { + + EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); + + std::vector metricValues(30); + + 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; + 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 == 40); + 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); } }