intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-05 18:06:32 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add Ip sampling metrics calculate values Support

Browse Source 
Related-To: LOCI-2757

Signed-off-by: davidoli <david.olien@intel.com>
This commit is contained in:
davidoli
2022-03-15 01:56:44 +00:00
committed by Compute-Runtime-Automation
parent 0791898c9e
commit 5dfd68a729
4 changed files with 487 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h
View File

@@ -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<MockStallRawIpData> 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<zet_typed_value_t> 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<MockMetricIpSamplingOsInterface *> osInterfaceVector = {};
std::vector<L0::Device *> testDevices = {};
};

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

@@ -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<zet_typed_value_t> 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<uint32_t> 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<uint8_t *>(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<uint8_t *>(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<uint32_t> metricCounts(2);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0],
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize + 1, reinterpret_cast<uint8_t *>(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<zet_typed_value_t> metricValues(30);
for (auto device : testDevices) {
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
std::vector<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
ASSERT_NE(metricGroups[0], nullptr);
zet_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<uint32_t> metricCounts(2);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0],
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast<uint8_t *>(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<uint8_t *>(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<zet_typed_value_t> metricValues(30);
for (auto device : testDevices) {
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
std::vector<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
ASSERT_NE(metricGroups[0], nullptr);
zet_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<uint8_t *>(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<uint8_t *>(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<zet_typed_value_t> metricValues(30);
for (auto device : testDevices) {
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
std::vector<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
ASSERT_NE(metricGroups[0], nullptr);
zet_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<uint8_t *>(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<uint8_t *>(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<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
ASSERT_NE(metricGroups[0], nullptr);
zet_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<uint8_t *>(rawDataVector.data()), &metricValueCount, nullptr),
ZE_RESULT_ERROR_INVALID_SIZE);
}
}
TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMetricValuesWithBadRawDataSizeCalculateDataIsCalledThenUnsupportedFeatureIsReturned) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
std::vector<zet_typed_value_t> metricValues(30);
for (auto device : testDevices) {
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
std::vector<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
ASSERT_NE(metricGroups[0], nullptr);
zet_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<uint8_t *>(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<uint8_t *>(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<zet_typed_value_t> metricValues(30);
for (auto device : testDevices) {
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
std::vector<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
ASSERT_NE(metricGroups[0], nullptr);
zet_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<uint8_t *>(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<uint8_t *>(rawDataVector.data()), &metricValueCount, metricValues.data()),
ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
}