| 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 |