Debian Codegraph @

level_zero/tools/test/unit_tests/sources/metrics/test_metric_concurrent_groups.cpp

raw
1 /*
2 * Copyright (C) 2020-2024 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "shared/test/common/test_macros/test.h"
9
10 #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
11 #include "level_zero/tools/source/metrics/metric.h"
12 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h"
13
14 #include "gtest/gtest.h"
15
16 namespace L0 {
17 namespace ult {
18
19 class ConcurrentMetricGroupFixture : public DeviceFixture,
20 public ::testing::Test {
21 public:
22 std::unique_ptr<MetricDeviceContext> deviceContext = nullptr;
23
24 protected:
25 void SetUp() override;
26 void TearDown() override;
27 };
28
29 void ConcurrentMetricGroupFixture::TearDown() {
30 DeviceFixture::tearDown();
31 deviceContext.reset();
32 }
33
34 void ConcurrentMetricGroupFixture::SetUp() {
35 DeviceFixture::setUp();
36 deviceContext = std::make_unique<MetricDeviceContext>(*device);
37 }
38
39 class MockMetricSourceType1 : public MockMetricSource {
40 ze_result_t getConcurrentMetricGroups(std::vector<zet_metric_group_handle_t> &hMetricGroups,
41 uint32_t *pConcurrentGroupCount,
42 uint32_t *pCountPerConcurrentGroup) override {
43 // No overlap possible
44 if (*pConcurrentGroupCount == 0) {
45 *pConcurrentGroupCount = static_cast<uint32_t>(hMetricGroups.size());
46 return ZE_RESULT_SUCCESS;
47 }
48
49 *pConcurrentGroupCount = std::min(*pConcurrentGroupCount, static_cast<uint32_t>(hMetricGroups.size()));
50 for (uint32_t index = 0; index < *pConcurrentGroupCount; index++) {
51 pCountPerConcurrentGroup[index] = 1;
52 }
53 return ZE_RESULT_SUCCESS;
54 }
55 };
56
57 class MockMetricSourceType2 : public MockMetricSource {
58 ze_result_t getConcurrentMetricGroups(std::vector<zet_metric_group_handle_t> &hMetricGroups,
59 uint32_t *pConcurrentGroupCount,
60 uint32_t *pCountPerConcurrentGroup) override {
61 // Requires the number of metric groups to be a multiple of 2
62 if (hMetricGroups.size() & 1) {
63 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
64 }
65
66 // No overlap possible
67 if (*pConcurrentGroupCount == 0) {
68 *pConcurrentGroupCount = static_cast<uint32_t>(hMetricGroups.size());
69 return ZE_RESULT_SUCCESS;
70 }
71
72 *pConcurrentGroupCount = std::min(*pConcurrentGroupCount, static_cast<uint32_t>(hMetricGroups.size() / 2));
73 for (uint32_t index = 0; index < *pConcurrentGroupCount; index++) {
74 pCountPerConcurrentGroup[index] = 2;
75 }
76 return ZE_RESULT_SUCCESS;
77 }
78 };
79
80 TEST_F(ConcurrentMetricGroupFixture, WhenGetConcurrentMetricGroupsIsCalledForDifferentSourcesThenGeneratedGroupsAreCorrect) {
81
82 MockMetricSourceType1 sourceType1;
83 sourceType1.setType(1);
84 MockMetricGroup metricGroupType1[] = {MockMetricGroup(sourceType1), MockMetricGroup(sourceType1), MockMetricGroup(sourceType1)};
85
86 MockMetricSourceType2 sourceType2;
87 sourceType2.setType(2);
88 MockMetricGroup metricGroupType2[] = {MockMetricGroup(sourceType2), MockMetricGroup(sourceType2), MockMetricGroup(sourceType2), MockMetricGroup(sourceType2)};
89
90 std::vector<zet_metric_group_handle_t> metricGroupHandles{};
91
92 metricGroupHandles.push_back(metricGroupType1[0].toHandle());
93 metricGroupHandles.push_back(metricGroupType2[1].toHandle());
94 metricGroupHandles.push_back(metricGroupType1[1].toHandle());
95 metricGroupHandles.push_back(metricGroupType2[3].toHandle());
96 metricGroupHandles.push_back(metricGroupType1[2].toHandle());
97 metricGroupHandles.push_back(metricGroupType2[0].toHandle());
98 metricGroupHandles.push_back(metricGroupType2[2].toHandle());
99
100 auto backupMetricGroupHandles = metricGroupHandles;
101
102 uint32_t concurrentGroupCount = 0;
103 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->getConcurrentMetricGroups(static_cast<uint32_t>(metricGroupHandles.size()), metricGroupHandles.data(), &concurrentGroupCount, nullptr));
104 EXPECT_EQ(concurrentGroupCount, 4u);
105 std::vector<uint32_t> countPerConcurrentGroup(concurrentGroupCount);
106 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->getConcurrentMetricGroups(static_cast<uint32_t>(metricGroupHandles.size()), metricGroupHandles.data(), &concurrentGroupCount, countPerConcurrentGroup.data()));
107
108 EXPECT_EQ(countPerConcurrentGroup[0], 3u);
109 EXPECT_EQ(countPerConcurrentGroup[1], 3u);
110 EXPECT_EQ(countPerConcurrentGroup[2], 1u);
111
112 // Ensure that re-arranged metric group handles were originally present in the vector
113 for (auto &metricGroupHandle : metricGroupHandles) {
114 EXPECT_TRUE(std::find(backupMetricGroupHandles.begin(), backupMetricGroupHandles.end(), metricGroupHandle) != backupMetricGroupHandles.end());
115 }
116 }
117
118 TEST_F(ConcurrentMetricGroupFixture, WhenGetConcurrentMetricGroupsIsCalledWithIncorrectGroupCountThenFailureIsReturned) {
119
120 MockMetricSourceType1 sourceType1;
121 sourceType1.setType(1);
122 MockMetricGroup metricGroupType1[] = {MockMetricGroup(sourceType1), MockMetricGroup(sourceType1), MockMetricGroup(sourceType1)};
123
124 MockMetricSourceType2 sourceType2;
125 sourceType2.setType(2);
126 MockMetricGroup metricGroupType2[] = {MockMetricGroup(sourceType2), MockMetricGroup(sourceType2), MockMetricGroup(sourceType2), MockMetricGroup(sourceType2)};
127
128 std::vector<zet_metric_group_handle_t> metricGroupHandles{};
129
130 metricGroupHandles.push_back(metricGroupType1[0].toHandle());
131 metricGroupHandles.push_back(metricGroupType2[1].toHandle());
132 metricGroupHandles.push_back(metricGroupType1[1].toHandle());
133 metricGroupHandles.push_back(metricGroupType2[3].toHandle());
134 metricGroupHandles.push_back(metricGroupType1[2].toHandle());
135 metricGroupHandles.push_back(metricGroupType2[0].toHandle());
136 metricGroupHandles.push_back(metricGroupType2[2].toHandle());
137
138 uint32_t concurrentGroupCount = 0;
139 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->getConcurrentMetricGroups(static_cast<uint32_t>(metricGroupHandles.size()), metricGroupHandles.data(), &concurrentGroupCount, nullptr));
140 EXPECT_EQ(concurrentGroupCount, 4u);
141 concurrentGroupCount -= 1;
142 std::vector<uint32_t> countPerConcurrentGroup(concurrentGroupCount);
143 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, deviceContext->getConcurrentMetricGroups(static_cast<uint32_t>(metricGroupHandles.size()), metricGroupHandles.data(), &concurrentGroupCount, countPerConcurrentGroup.data()));
144 EXPECT_EQ(concurrentGroupCount, 0u);
145 }
146
147 class MockMetricSourceError : public MockMetricSource {
148 public:
149 static int32_t errorCallCount;
150 ze_result_t getConcurrentMetricGroups(std::vector<zet_metric_group_handle_t> &hMetricGroups,
151 uint32_t *pConcurrentGroupCount,
152 uint32_t *pCountPerConcurrentGroup) override {
153 errorCallCount -= 1;
154 errorCallCount = std::max(0, errorCallCount);
155 *pConcurrentGroupCount = 10;
156 if (errorCallCount) {
157 return ZE_RESULT_SUCCESS;
158 }
159 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
160 }
161
162 ~MockMetricSourceError() override {
163 errorCallCount = 0;
164 }
165 };
166
167 int32_t MockMetricSourceError::errorCallCount = 1;
168
169 TEST_F(ConcurrentMetricGroupFixture, WhenGetConcurrentMetricGroupsIsCalledAndSourceImplementationReturnsErrorThenErrorIsObserved) {
170
171 MockMetricSourceError sourceTypeError;
172 sourceTypeError.setType(1);
173 MockMetricGroup metricGroupError[] = {MockMetricGroup(sourceTypeError),
174 MockMetricGroup(sourceTypeError),
175 MockMetricGroup(sourceTypeError)};
176
177 std::vector<zet_metric_group_handle_t> metricGroupHandles{};
178
179 metricGroupHandles.push_back(metricGroupError[0].toHandle());
180 metricGroupHandles.push_back(metricGroupError[1].toHandle());
181 metricGroupHandles.push_back(metricGroupError[1].toHandle());
182
183 uint32_t concurrentGroupCount = 0;
184 MockMetricSourceError::errorCallCount = 3;
185 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->getConcurrentMetricGroups(static_cast<uint32_t>(metricGroupHandles.size()), metricGroupHandles.data(), &concurrentGroupCount, nullptr));
186 concurrentGroupCount = 10;
187 std::vector<uint32_t> countPerConcurrentGroup(10);
188 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, deviceContext->getConcurrentMetricGroups(static_cast<uint32_t>(metricGroupHandles.size()), metricGroupHandles.data(), &concurrentGroupCount, countPerConcurrentGroup.data()));
189 EXPECT_EQ(concurrentGroupCount, 0u);
190
191 MockMetricSourceError::errorCallCount = 1;
192 concurrentGroupCount = 0;
193 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, deviceContext->getConcurrentMetricGroups(static_cast<uint32_t>(metricGroupHandles.size()), metricGroupHandles.data(), &concurrentGroupCount, nullptr));
194 EXPECT_EQ(concurrentGroupCount, 0u);
195 }
196
197 } // namespace ult
198 } // namespace L0