intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-20 00:24:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

feature: EUStall metrics calculation supports scopes

Browse Source 
Resolves: NEO-15142

Signed-off-by: Matias Cabral <matias.a.cabral@intel.com>
This commit is contained in:
Matias Cabral
2025-10-30 16:56:18 +00:00
committed by Compute-Runtime-Automation
parent f9225de6b1
commit a85e87da60
25 changed files with 2574 additions and 723 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h
View File

@@ -105,8 +105,10 @@ class L0GfxCoreHelper : public NEO::ApiGfxCoreHelper {
virtual void appendPlatformSpecificExtensions(std::vector<std::pair<std::string, uint32_t>> &extensions, const NEO::ProductHelper &productHelper, const NEO::HardwareInfo &hwInfo) const = 0;
virtual std::vector<std::pair<const char *, const char *>> getStallSamplingReportMetrics() const = 0;
virtual void stallSumIpDataToTypedValues(uint64_t ip, void *sumIpData, std::vector<zet_typed_value_t> &ipDataValues) = 0;
virtual bool stallIpDataMapUpdate(std::map<uint64_t, void *> &stallSumIpDataMap, const uint8_t *pRawIpData) = 0;
virtual void stallIpDataMapDelete(std::map<uint64_t, void *> &stallSumIpDataMap) = 0;
virtual bool stallIpDataMapUpdateFromData(const uint8_t *pRawIpData, std::map<uint64_t, void *> &stallSumIpDataMap) = 0;
virtual void stallIpDataMapUpdateFromMap(std::map<uint64_t, void *> &sourceMap, std::map<uint64_t, void *> &stallSumIpDataMap) = 0;
virtual void stallIpDataMapDeleteSumData(std::map<uint64_t, void *> &stallSumIpDataMap) = 0;
virtual void stallIpDataMapDeleteSumDataEntry(std::map<uint64_t, void *>::iterator it) = 0;
virtual uint32_t getIpSamplingMetricCount() = 0;
virtual uint64_t getIpSamplingIpMask() const = 0;
virtual bool synchronizedDispatchSupported() const = 0;
@@ -164,8 +166,10 @@ class L0GfxCoreHelperHw : public L0GfxCoreHelper {
void appendPlatformSpecificExtensions(std::vector<std::pair<std::string, uint32_t>> &extensions, const NEO::ProductHelper &productHelper, const NEO::HardwareInfo &hwInfo) const override;
std::vector<std::pair<const char *, const char *>> getStallSamplingReportMetrics() const override;
void stallSumIpDataToTypedValues(uint64_t ip, void *sumIpData, std::vector<zet_typed_value_t> &ipDataValues) override;
bool stallIpDataMapUpdate(std::map<uint64_t, void *> &stallSumIpDataMap, const uint8_t *pRawIpData) override;
void stallIpDataMapDelete(std::map<uint64_t, void *> &stallSumIpDataMap) override;
bool stallIpDataMapUpdateFromData(const uint8_t *pRawIpData, std::map<uint64_t, void *> &stallSumIpDataMap) override;
void stallIpDataMapUpdateFromMap(std::map<uint64_t, void *> &sourceMap, std::map<uint64_t, void *> &stallSumIpDataMap) override;
void stallIpDataMapDeleteSumData(std::map<uint64_t, void *> &stallSumIpDataMap) override;
void stallIpDataMapDeleteSumDataEntry(std::map<uint64_t, void *>::iterator it) override;
uint32_t getIpSamplingMetricCount() override;
uint64_t getIpSamplingIpMask() const override;
bool synchronizedDispatchSupported() const override;

14
level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper_tgllp_to_dg2.inl
View File

@@ -119,15 +119,25 @@ uint32_t L0GfxCoreHelperHw<Family>::getIpSamplingMetricCount() {
}
template <typename Family>
void L0GfxCoreHelperHw<Family>::stallIpDataMapDelete(std::map<uint64_t, void *> &stallSumIpDataMap) {
void L0GfxCoreHelperHw<Family>::stallIpDataMapDeleteSumData(std::map<uint64_t, void *> &stallSumIpDataMap) {
return;
}
template <typename Family>
bool L0GfxCoreHelperHw<Family>::stallIpDataMapUpdate(std::map<uint64_t, void *> &stallSumIpDataMap, const uint8_t *pRawIpData) {
void L0GfxCoreHelperHw<Family>::stallIpDataMapDeleteSumDataEntry(std::map<uint64_t, void *>::iterator it) {
return;
}
template <typename Family>
bool L0GfxCoreHelperHw<Family>::stallIpDataMapUpdateFromData(const uint8_t *pRawIpData, std::map<uint64_t, void *> &stallSumIpDataMap) {
return false;
}
template <typename Family>
void L0GfxCoreHelperHw<Family>::stallIpDataMapUpdateFromMap(std::map<uint64_t, void *> &sourceMap, std::map<uint64_t, void *> &stallSumIpDataMap) {
return;
}
// Order of ipDataValues must match stallSamplingReportList
template <typename Family>
void L0GfxCoreHelperHw<Family>::stallSumIpDataToTypedValues(uint64_t ip, void *sumIpData, std::vector<zet_typed_value_t> &ipDataValues) {

40
level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper_xe2_hpg_and_later.inl
View File

@@ -83,7 +83,7 @@ uint32_t L0GfxCoreHelperHw<Family>::getIpSamplingMetricCount() {
}
template <typename Family>
void L0GfxCoreHelperHw<Family>::stallIpDataMapDelete(std::map<uint64_t, void *> &stallSumIpDataMap) {
void L0GfxCoreHelperHw<Family>::stallIpDataMapDeleteSumData(std::map<uint64_t, void *> &stallSumIpDataMap) {
for (auto i = stallSumIpDataMap.begin(); i != stallSumIpDataMap.end(); i++) {
StallSumIpDataXeCore_t *stallSumData = reinterpret_cast<StallSumIpDataXeCore_t *>(i->second);
if (stallSumData) {
@@ -94,7 +94,16 @@ void L0GfxCoreHelperHw<Family>::stallIpDataMapDelete(std::map<uint64_t, void *>
}
template <typename Family>
bool L0GfxCoreHelperHw<Family>::stallIpDataMapUpdate(std::map<uint64_t, void *> &stallSumIpDataMap, const uint8_t *pRawIpData) {
void L0GfxCoreHelperHw<Family>::stallIpDataMapDeleteSumDataEntry(std::map<uint64_t, void *>::iterator it) {
StallSumIpDataXeCore_t *stallSumData = reinterpret_cast<StallSumIpDataXeCore_t *>(it->second);
if (stallSumData) {
delete stallSumData;
it->second = nullptr;
}
}
template <typename Family>
bool L0GfxCoreHelperHw<Family>::stallIpDataMapUpdateFromData(const uint8_t *pRawIpData, std::map<uint64_t, void *> &stallSumIpDataMap) {
constexpr int ipStallSamplingOffset = 3; // Offset to read the first Stall Sampling report after IP Address.
constexpr int ipStallSamplingReportShift = 5; // Shift in bits required to read the stall sampling report data due to the IP address [0-28] bits to access the next report category data.
constexpr int stallSamplingReportCategoryMask = 0xff; // Mask for Stall Sampling Report Category.
@@ -144,6 +153,33 @@ bool L0GfxCoreHelperHw<Family>::stallIpDataMapUpdate(std::map<uint64_t, void *>
return false;
}
template <typename Family>
void L0GfxCoreHelperHw<Family>::stallIpDataMapUpdateFromMap(std::map<uint64_t, void *> &sourceMap, std::map<uint64_t, void *> &stallSumIpDataMap) {
for (auto &entry : sourceMap) {
uint64_t ip = entry.first;
StallSumIpDataXeCore_t *sourceData = reinterpret_cast<StallSumIpDataXeCore_t *>(entry.second);
if (stallSumIpDataMap.count(ip) == 0) {
StallSumIpDataXeCore_t *newData = new StallSumIpDataXeCore_t{};
memcpy_s(newData, sizeof(StallSumIpDataXeCore_t), sourceData, sizeof(StallSumIpDataXeCore_t));
stallSumIpDataMap[ip] = newData;
} else {
StallSumIpDataXeCore_t *destData = reinterpret_cast<StallSumIpDataXeCore_t *>(stallSumIpDataMap[ip]);
destData->tdrCount += sourceData->tdrCount;
destData->otherCount += sourceData->otherCount;
destData->controlCount += sourceData->controlCount;
destData->pipeStallCount += sourceData->pipeStallCount;
destData->sendCount += sourceData->sendCount;
destData->distAccCount += sourceData->distAccCount;
destData->sbidCount += sourceData->sbidCount;
destData->syncCount += sourceData->syncCount;
destData->instFetchCount += sourceData->instFetchCount;
destData->activeCount += sourceData->activeCount;
}
}
}
// Order of ipDataValues must match stallSamplingReportList
template <typename Family>
void L0GfxCoreHelperHw<Family>::stallSumIpDataToTypedValues(uint64_t ip, void *sumIpData, std::vector<zet_typed_value_t> &ipDataValues) {

38
level_zero/core/source/xe_hpc_core/l0_gfx_core_helper_xe_hpc_core.cpp
View File

@@ -77,7 +77,7 @@ uint32_t L0GfxCoreHelperHw<Family>::getIpSamplingMetricCount() {
}
template <>
void L0GfxCoreHelperHw<Family>::stallIpDataMapDelete(std::map<uint64_t, void *> &stallSumIpDataMap) {
void L0GfxCoreHelperHw<Family>::stallIpDataMapDeleteSumData(std::map<uint64_t, void *> &stallSumIpDataMap) {
for (auto i = stallSumIpDataMap.begin(); i != stallSumIpDataMap.end(); i++) {
StallSumIpData_t *stallSumData = reinterpret_cast<StallSumIpData_t *>(i->second);
if (stallSumData) {
@@ -88,7 +88,16 @@ void L0GfxCoreHelperHw<Family>::stallIpDataMapDelete(std::map<uint64_t, void *>
}
template <>
bool L0GfxCoreHelperHw<Family>::stallIpDataMapUpdate(std::map<uint64_t, void *> &stallSumIpDataMap, const uint8_t *pRawIpData) {
void L0GfxCoreHelperHw<Family>::stallIpDataMapDeleteSumDataEntry(std::map<uint64_t, void *>::iterator it) {
StallSumIpData_t *stallSumData = reinterpret_cast<StallSumIpData_t *>(it->second);
if (stallSumData) {
delete stallSumData;
it->second = nullptr;
}
}
template <>
bool L0GfxCoreHelperHw<Family>::stallIpDataMapUpdateFromData(const uint8_t *pRawIpData, std::map<uint64_t, void *> &stallSumIpDataMap) {
constexpr int ipStallSamplingOffset = 3; // Offset to read the first Stall Sampling report after IP Address.
constexpr int ipStallSamplingReportShift = 5; // Shift in bits required to read the stall sampling report data due to the IP address [0-28] bits to access the next report category data.
constexpr int stallSamplingReportCategoryMask = 0xff; // Mask for Stall Sampling Report Category.
@@ -148,6 +157,31 @@ bool L0GfxCoreHelperHw<Family>::stallIpDataMapUpdate(std::map<uint64_t, void *>
return stallCntrInfo.flags & overflowDropFlag;
}
template <>
void L0GfxCoreHelperHw<Family>::stallIpDataMapUpdateFromMap(std::map<uint64_t, void *> &sourceMap, std::map<uint64_t, void *> &stallSumIpDataMap) {
for (auto &entry : sourceMap) {
uint64_t ip = entry.first;
StallSumIpData_t *sourceData = reinterpret_cast<StallSumIpData_t *>(entry.second);
if (stallSumIpDataMap.count(ip) == 0) {
StallSumIpData_t *newData = new StallSumIpData_t{};
memcpy_s(newData, sizeof(StallSumIpData_t), sourceData, sizeof(StallSumIpData_t));
stallSumIpDataMap[ip] = newData;
} else {
StallSumIpData_t *destData = reinterpret_cast<StallSumIpData_t *>(stallSumIpDataMap[ip]);
destData->activeCount += sourceData->activeCount;
destData->otherCount += sourceData->otherCount;
destData->controlCount += sourceData->controlCount;
destData->pipeStallCount += sourceData->pipeStallCount;
destData->sendCount += sourceData->sendCount;
destData->distAccCount += sourceData->distAccCount;
destData->sbidCount += sourceData->sbidCount;
destData->syncCount += sourceData->syncCount;
destData->instFetchCount += sourceData->instFetchCount;
}
}
}
// Order of ipDataValues must match stallSamplingReportList
template <>
void L0GfxCoreHelperHw<Family>::stallSumIpDataToTypedValues(uint64_t ip, void *sumIpData, std::vector<zet_typed_value_t> &ipDataValues) {

21
level_zero/core/test/unit_tests/gen12lp/test_l0_gfx_core_helper_gen12lp.cpp
View File

@@ -81,17 +81,32 @@ GEN12LPTEST_F(L0GfxCoreHelperTestGen12Lp, GivenGen12LpWhenGetStallSamplingReport
EXPECT_EQ(expectedStallSamplingReportList, l0GfxCoreHelper.getStallSamplingReportMetrics());
}
GEN12LPTEST_F(L0GfxCoreHelperTestGen12Lp, GivenGen12LpWhenStallIpDataMapUpdateIsCalledThenFalseIsReturned) {
GEN12LPTEST_F(L0GfxCoreHelperTestGen12Lp, GivenGen12LpWhenStallIpDataMapUpdateFromDataIsCalledThenFalseIsReturned) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSumIpDataMap;
EXPECT_FALSE(l0GfxCoreHelper.stallIpDataMapUpdate(stallSumIpDataMap, nullptr));
EXPECT_FALSE(l0GfxCoreHelper.stallIpDataMapUpdateFromData(nullptr, stallSumIpDataMap));
}
GEN12LPTEST_F(L0GfxCoreHelperTestGen12Lp, GivenGen12LpWhenStallIpDataMapUpdateFromMapIsCalledThenDoesNothing) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSourceIpDataMap;
std::map<uint64_t, void *> stallSumIpDataMap;
l0GfxCoreHelper.stallIpDataMapUpdateFromMap(stallSourceIpDataMap, stallSumIpDataMap);
}
GEN12LPTEST_F(L0GfxCoreHelperTestGen12Lp, GivenGen12LpWhenStallIpDataMapDeleteIsCalledThenMapisUnchanged) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSumIpDataMap;
size_t mapSizeBefore = stallSumIpDataMap.size();
l0GfxCoreHelper.stallIpDataMapDelete(stallSumIpDataMap);
l0GfxCoreHelper.stallIpDataMapDeleteSumData(stallSumIpDataMap);
EXPECT_EQ(mapSizeBefore, stallSumIpDataMap.size());
}
GEN12LPTEST_F(L0GfxCoreHelperTestGen12Lp, GivenGen12LpWhenStallIpDataMapDeleteEntryIsCalledThenMapisUnchanged) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSumIpDataMap;
size_t mapSizeBefore = stallSumIpDataMap.size();
std::map<uint64_t, void *>::iterator it = stallSumIpDataMap.begin();
l0GfxCoreHelper.stallIpDataMapDeleteSumDataEntry(it);
EXPECT_EQ(mapSizeBefore, stallSumIpDataMap.size());
}

81
level_zero/core/test/unit_tests/xe2_hpg_core/test_l0_gfx_core_helper_xe2_hpg_core.cpp
View File

@@ -137,14 +137,91 @@ XE2_HPG_CORETEST_F(L0GfxCoreHelperTestXe2Hpg, GivenXe3pWhenCallingisThreadContro
EXPECT_TRUE(l0GfxCoreHelper.isThreadControlStoppedSupported());
}
XE2_HPG_CORETEST_F(L0GfxCoreHelperTestXe2Hpg, GivenXe2HpgWhenCheckingL0HelperForDeletingIpSamplingEntryWithNullValuesThenMapRemainstheSameSize) {
XE2_HPG_CORETEST_F(L0GfxCoreHelperTestXe2Hpg, GivenXe2HpgWhenCheckingL0HelperForDeletingIpSamplingMapWithNullValuesThenMapRemainstheSameSize) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSumIpDataMap;
stallSumIpDataMap.emplace(std::pair<uint64_t, void *>(0ull, nullptr));
l0GfxCoreHelper.stallIpDataMapDelete(stallSumIpDataMap);
l0GfxCoreHelper.stallIpDataMapDeleteSumData(stallSumIpDataMap);
EXPECT_NE(0u, stallSumIpDataMap.size());
}
#pragma pack(1)
typedef struct StallSumIpDataXeCore {
uint64_t tdrCount;
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 activeCount;
} StallSumIpDataXeCore_t;
#pragma pack()
XE2_HPG_CORETEST_F(L0GfxCoreHelperTestXe2Hpg, GivenXe2HpgWhenCheckingL0HelperForDeletingIpSamplingEntryWithThenMapRemainstheSameSize) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSumIpDataMap;
StallSumIpDataXeCore *stallSumData = new StallSumIpDataXeCore;
stallSumIpDataMap.emplace(std::pair<uint64_t, void *>(0ull, stallSumData));
std::map<uint64_t, void *>::iterator it = stallSumIpDataMap.begin();
l0GfxCoreHelper.stallIpDataMapDeleteSumDataEntry(it);
EXPECT_EQ(1u, stallSumIpDataMap.size());
l0GfxCoreHelper.stallIpDataMapDeleteSumDataEntry(it); // if entry not found it is skipped
EXPECT_EQ(1u, stallSumIpDataMap.size());
stallSumIpDataMap.clear();
}
XE2_HPG_CORETEST_F(L0GfxCoreHelperTestXe2Hpg, GivenXe2HpgWhenL0HelperCanAddIPsFromDataThenSuccess) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSumIpDataMap;
// Raw reports are 64Bytes, 8 x uint64_t
std::array<uint64_t, 8> ipData = {
0x0000000000000001,
0x0000000000000002,
0x0000000000000003,
0x0000000000000004,
0x0000000000000005,
0x0000000000000006,
0x0000000000000007,
0x0000000000000008};
uint8_t *data = reinterpret_cast<uint8_t *>(ipData.data());
// Call for new IP
l0GfxCoreHelper.stallIpDataMapUpdateFromData(data, stallSumIpDataMap);
// Call for repeated IP
l0GfxCoreHelper.stallIpDataMapUpdateFromData(data, stallSumIpDataMap);
// Delete the sumData
l0GfxCoreHelper.stallIpDataMapDeleteSumData(stallSumIpDataMap);
stallSumIpDataMap.clear();
}
XE2_HPG_CORETEST_F(L0GfxCoreHelperTestXe2Hpg, GivenXe2HpgWhenL0HelperCanAddIPsFromMapThenSuccess) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSourceIpDataMap;
StallSumIpDataXeCore_t *stallSumData = new StallSumIpDataXeCore_t;
stallSourceIpDataMap.emplace(std::pair<uint64_t, void *>(0ull, stallSumData));
std::map<uint64_t, void *> stallSumIpDataMap;
// Call for new IP
l0GfxCoreHelper.stallIpDataMapUpdateFromMap(stallSourceIpDataMap, stallSumIpDataMap);
// Call for repeated IP
l0GfxCoreHelper.stallIpDataMapUpdateFromMap(stallSourceIpDataMap, stallSumIpDataMap);
// Delete the sumData
l0GfxCoreHelper.stallIpDataMapDeleteSumData(stallSourceIpDataMap);
stallSourceIpDataMap.clear();
l0GfxCoreHelper.stallIpDataMapDeleteSumData(stallSumIpDataMap);
stallSumIpDataMap.clear();
}
XE2_HPG_CORETEST_F(L0GfxCoreHelperTestXe2Hpg, GivenXe2HpgWhenCheckingL0HelperForGetIpSamplingIpMaskThenCorrectValueIsReturned) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
EXPECT_EQ(0x1fffffffull, l0GfxCoreHelper.getIpSamplingIpMask());

32
level_zero/core/test/unit_tests/xe_hpc_core/test_l0_gfx_core_helper_xe_hpc_core.cpp
View File

@@ -78,14 +78,42 @@ XE_HPC_CORETEST_F(L0GfxCoreHelperTestXeHpc, GivenXeHpcWhenGettingRecordReplayGra
EXPECT_EQ(0u, l0GfxCoreHelper.getPlatformRecordReplayGraphCapabilities());
}
XE_HPC_CORETEST_F(L0GfxCoreHelperTestXeHpc, GivenXeHpcWhenCheckingL0HelperForDeletingIpSamplingEntryWithNullValuesThenMapRemainstheSameSize) {
XE_HPC_CORETEST_F(L0GfxCoreHelperTestXeHpc, GivenXeHpcWhenCheckingL0HelperForDeletingIpSamplingMapWithNullValuesThenMapRemainstheSameSize) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSumIpDataMap;
stallSumIpDataMap.emplace(std::pair<uint64_t, void *>(0ull, nullptr));
l0GfxCoreHelper.stallIpDataMapDelete(stallSumIpDataMap);
l0GfxCoreHelper.stallIpDataMapDeleteSumData(stallSumIpDataMap);
EXPECT_NE(0u, stallSumIpDataMap.size());
}
XE_HPC_CORETEST_F(L0GfxCoreHelperTestXeHpc, GivenXeHpcWhenCheckingL0HelperForDeletingIpSamplingEntryWithThenMapRemainstheSameSize) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSumIpDataMap;
#pragma pack(1)
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;
#pragma pack()
StallSumIpData_t *stallSumData = new StallSumIpData_t;
stallSumIpDataMap.emplace(std::pair<uint64_t, void *>(0ull, stallSumData));
std::map<uint64_t, void *>::iterator it = stallSumIpDataMap.begin();
l0GfxCoreHelper.stallIpDataMapDeleteSumDataEntry(it);
EXPECT_EQ(1u, stallSumIpDataMap.size());
l0GfxCoreHelper.stallIpDataMapDeleteSumDataEntry(it); // if entry not found it is skipped
EXPECT_EQ(1u, stallSumIpDataMap.size());
}
XE_HPC_CORETEST_F(L0GfxCoreHelperTestXeHpc, GivenXeHpcWhenCheckingL0HelperForGetIpSamplingIpMaskThenCorrectValueIsReturned) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
EXPECT_EQ(0x1fffffffull, l0GfxCoreHelper.getIpSamplingIpMask());

13
level_zero/core/test/unit_tests/xe_hpg_core/test_l0_gfx_core_helper_xe_hpg_core.cpp
View File

@@ -93,14 +93,23 @@ XE_HPG_CORETEST_F(L0GfxCoreHelperTestXeHpg, GivenXeHpgWhenGetStallSamplingReport
XE_HPG_CORETEST_F(L0GfxCoreHelperTestXeHpg, GivenXeHpgWhenStallIpDataMapUpdateIsCalledThenFalseIsReturned) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSumIpDataMap;
EXPECT_FALSE(l0GfxCoreHelper.stallIpDataMapUpdate(stallSumIpDataMap, nullptr));
EXPECT_FALSE(l0GfxCoreHelper.stallIpDataMapUpdateFromData(nullptr, stallSumIpDataMap));
}
XE_HPG_CORETEST_F(L0GfxCoreHelperTestXeHpg, GivenXeHpgWhenStallIpDataMapDeleteIsCalledThenMapisUnchanged) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSumIpDataMap;
size_t mapSizeBefore = stallSumIpDataMap.size();
l0GfxCoreHelper.stallIpDataMapDelete(stallSumIpDataMap);
l0GfxCoreHelper.stallIpDataMapDeleteSumData(stallSumIpDataMap);
EXPECT_EQ(mapSizeBefore, stallSumIpDataMap.size());
}
XE_HPG_CORETEST_F(L0GfxCoreHelperTestXeHpg, GivenXeHpgWhenStallIpDataMapDeleteEntryIsCalledThenMapisUnchanged) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSumIpDataMap;
size_t mapSizeBefore = stallSumIpDataMap.size();
std::map<uint64_t, void *>::iterator it = stallSumIpDataMap.begin();
l0GfxCoreHelper.stallIpDataMapDeleteSumDataEntry(it);
EXPECT_EQ(mapSizeBefore, stallSumIpDataMap.size());
}

5
level_zero/include/level_zero/ze_intel_results.h
View File

@@ -15,8 +15,7 @@
#include <cstdint>
// Metrics experimental return codes
#define ZE_INTEL_RESULT_WARNING_DATA_NOT_PROCESSED_EXP static_cast<ze_result_t>(0x40000000) // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
#define ZE_INTEL_RESULT_WARNING_NOT_CALCULABLE_METRICS_IGNORED_EXP static_cast<ze_result_t>(0x40000001) // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
#define ZE_INTEL_RESULT_WARNING_TIME_PARAMS_IGNORED_EXP static_cast<ze_result_t>(0x40000002) // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
#define ZE_INTEL_RESULT_WARNING_NOT_CALCULABLE_METRICS_IGNORED_EXP static_cast<ze_result_t>(0x40000000) // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
#define ZE_INTEL_RESULT_WARNING_TIME_PARAMS_IGNORED_EXP static_cast<ze_result_t>(0x40000001) // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
#endif // _ZE_INTEL_RESULTS_H

29
level_zero/tools/source/metrics/metric.cpp
View File

@@ -38,21 +38,27 @@ void MetricSource::initComputeMetricScopes(MetricDeviceContext &metricDeviceCont
// When supported, aggregated scope should be first (ID 0)
auto &l0GfxCoreHelper = metricDeviceContext.getDevice().getNEODevice()->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
if (l0GfxCoreHelper.supportMetricsAggregation()) {
metricDeviceContext.addMetricScope(aggregatedScopeName, aggregatedScopeDescription);
metricDeviceContext.addMetricScope(aggregatedScopeName, aggregatedScopeDescription, 0);
}
auto deviceImp = static_cast<DeviceImp *>(&metricDeviceContext.getDevice());
uint32_t subDeviceCount = deviceImp->numSubDevices;
for (uint32_t i = 0; i < subDeviceCount; i++) {
std::string scopeName = std::string(computeScopeNamePrefix) + std::to_string(i);
std::string scopeDesc = std::string(computeScopeDescriptionPrefix) + std::to_string(i);
metricDeviceContext.addMetricScope(scopeName, scopeDesc);
std::vector<ze_device_handle_t> subDevices(subDeviceCount);
deviceImp->getSubDevices(&subDeviceCount, subDevices.data());
for (auto &subDeviceHandle : subDevices) {
auto neoSubDevice = static_cast<NEO::SubDevice *>(Device::fromHandle(subDeviceHandle)->getNEODevice());
uint32_t subDeviceIndex = neoSubDevice->getSubDeviceIndex();
std::string scopeName = std::string(computeScopeNamePrefix) + std::to_string(subDeviceIndex);
std::string scopeDesc = std::string(computeScopeDescriptionPrefix) + std::to_string(subDeviceIndex);
metricDeviceContext.addMetricScope(scopeName, scopeDesc, subDeviceIndex);
}
} else {
auto subDeviceIndex = metricDeviceContext.getSubDeviceIndex();
std::string scopeName = std::string(computeScopeNamePrefix) + std::to_string(subDeviceIndex);
std::string scopeDesc = std::string(computeScopeDescriptionPrefix) + std::to_string(subDeviceIndex);
metricDeviceContext.addMetricScope(scopeName, scopeDesc);
metricDeviceContext.addMetricScope(scopeName, scopeDesc, subDeviceIndex);
}
metricDeviceContext.setComputeMetricScopeInitialized();
@@ -633,6 +639,9 @@ ze_result_t MetricDeviceContext::calcOperationCreate(zet_context_handle_t hConte
if (pCalculationDesc->metricScopesCount == 0) {
METRICS_LOG_ERR("%s", "Must define at least one metric scope");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
} else if (!isImplicitScalingCapable() && (pCalculationDesc->metricScopesCount > 1)) {
METRICS_LOG_ERR("%s", "Sub-device can only calculate single metric scope");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
std::vector<MetricScopeImp *> metricScopes;
@@ -654,8 +663,8 @@ ze_result_t MetricDeviceContext::calcOperationCreate(zet_context_handle_t hConte
return metricSource.calcOperationCreate(*this, pCalculationDesc, metricScopes, phCalculationOperation);
}
std::unique_ptr<MetricScopeImp> MetricScopeImp::create(zet_intel_metric_scope_properties_exp_t &scopeProperties, bool aggregated) {
return std::make_unique<MetricScopeImp>(scopeProperties, aggregated);
std::unique_ptr<MetricScopeImp> MetricScopeImp::create(zet_intel_metric_scope_properties_exp_t &scopeProperties, bool aggregated, uint32_t computeSubDeviceIndex) {
return std::make_unique<MetricScopeImp>(scopeProperties, aggregated, computeSubDeviceIndex);
}
void MetricDeviceContext::initMetricScopes() {
@@ -696,7 +705,7 @@ ze_result_t MetricDeviceContext::metricScopesGet(zet_context_handle_t hContext,
return ZE_RESULT_SUCCESS;
}
uint32_t MetricDeviceContext::addMetricScope(std::string_view scopeName, std::string_view scopeDescription) {
uint32_t MetricDeviceContext::addMetricScope(std::string_view scopeName, std::string_view scopeDescription, uint32_t scopeSubDeviceIndex) {
// If scope exists, return id
for (const auto &scopePtr : metricScopes) {
@@ -711,7 +720,7 @@ uint32_t MetricDeviceContext::addMetricScope(std::string_view scopeName, std::st
snprintf(properties.description, sizeof(properties.description), "%s", scopeDescription.data());
properties.iD = static_cast<uint32_t>(metricScopes.size());
bool aggregated = (scopeName == aggregatedScopeName);
auto newScope = MetricScopeImp::create(properties, aggregated);
auto newScope = MetricScopeImp::create(properties, aggregated, scopeSubDeviceIndex);
metricScopes.push_back(std::move(newScope));
return properties.iD;

79
level_zero/tools/source/metrics/metric.h
View File

@@ -13,7 +13,6 @@
#include <map>
#include <vector>
namespace L0 {
struct Device;
} // namespace L0
@@ -192,7 +191,7 @@ class MetricDeviceContext {
return multiDeviceCapable;
}
uint32_t addMetricScope(std::string_view scopeName, std::string_view scopeDescription);
uint32_t addMetricScope(std::string_view scopeName, std::string_view scopeDescription, uint32_t scopeSubDeviceIndex);
void setComputeMetricScopeInitialized() {
computeMetricScopesInitialized = true;
@@ -488,6 +487,47 @@ struct MetricCalcOp : _zet_intel_metric_calculation_operation_exp_handle_t {
zet_intel_metric_result_exp_t *pMetricResults) = 0;
};
static constexpr std::string_view computeScopeNamePrefix = "COMPUTE_TILE_";
static constexpr std::string_view computeScopeDescriptionPrefix = "Metrics results for tile ";
static constexpr std::string_view aggregatedScopeName = "DEVICE_AGGREGATED";
static constexpr std::string_view aggregatedScopeDescription = "Metrics results aggregated at device level";
struct MetricScope : _zet_intel_metric_scope_exp_handle_t {
virtual ~MetricScope() = default;
MetricScope() {}
static MetricScope *fromHandle(zet_intel_metric_scope_exp_handle_t handle) {
return static_cast<MetricScope *>(handle);
}
inline zet_intel_metric_scope_exp_handle_t toHandle() { return this; }
};
struct MetricScopeImp : public MetricScope {
~MetricScopeImp() override = default;
MetricScopeImp(zet_intel_metric_scope_properties_exp_t &properties, bool aggregated, uint32_t computeSubDeviceIndex)
: properties(properties), aggregated(aggregated), computeSubDevIndex(computeSubDeviceIndex) {}
virtual ze_result_t getProperties(zet_intel_metric_scope_properties_exp_t *pProperties);
static std::unique_ptr<MetricScopeImp> create(zet_intel_metric_scope_properties_exp_t &scopeProperties,
bool aggregated, uint32_t computeSubDeviceIndex);
bool isAggregated() const { return aggregated; }
uint32_t getId() const {
return properties.iD;
}
uint32_t getComputeSubDeviceIndex() const {
return computeSubDevIndex;
}
bool isName(std::string_view name) const {
return strcmp(properties.name, name.data()) == 0;
}
private:
zet_intel_metric_scope_properties_exp_t properties;
bool aggregated = false;
uint32_t computeSubDevIndex = 0; // valid for compute scopes when aggregated is false
};
struct MetricCalcOpImp : public MetricCalcOp {
~MetricCalcOpImp() override = default;
MetricCalcOpImp(bool multiDevice,
@@ -513,41 +553,6 @@ struct MetricCalcOpImp : public MetricCalcOp {
std::vector<MetricImp *> excludedMetrics{};
};
static constexpr std::string_view computeScopeNamePrefix = "COMPUTE_TILE_";
static constexpr std::string_view computeScopeDescriptionPrefix = "Metrics results for tile ";
static constexpr std::string_view aggregatedScopeName = "DEVICE_AGGREGATED";
static constexpr std::string_view aggregatedScopeDescription = "Metrics results aggregated at device level";
struct MetricScope : _zet_intel_metric_scope_exp_handle_t {
virtual ~MetricScope() = default;
MetricScope() {}
static MetricScope *fromHandle(zet_intel_metric_scope_exp_handle_t handle) {
return static_cast<MetricScope *>(handle);
}
inline zet_intel_metric_scope_exp_handle_t toHandle() { return this; }
};
struct MetricScopeImp : public MetricScope {
~MetricScopeImp() override = default;
MetricScopeImp(zet_intel_metric_scope_properties_exp_t &properties, bool aggregated) : properties(properties), aggregated(aggregated) {}
virtual ze_result_t getProperties(zet_intel_metric_scope_properties_exp_t *pProperties);
static std::unique_ptr<MetricScopeImp> create(zet_intel_metric_scope_properties_exp_t &scopeProperties, bool aggregated);
bool isAggregated() const { return aggregated; }
uint32_t getId() const {
return properties.iD;
}
bool isName(std::string_view name) const {
return strcmp(properties.name, name.data()) == 0;
}
private:
zet_intel_metric_scope_properties_exp_t properties;
bool aggregated = false;
};
// MetricGroup.
ze_result_t metricGroupGet(zet_device_handle_t hDevice, uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups);

210
level_zero/tools/source/metrics/metric_ip_sampling_source.cpp
View File

@@ -23,7 +23,6 @@
#include <level_zero/zet_api.h>
#include <cstring>
#include <unordered_set>
namespace L0 {
constexpr uint32_t ipSamplinDomainId = 100u;
@@ -99,7 +98,7 @@ ze_result_t IpSamplingMetricSourceImp::cacheMetricGroup() {
std::vector<IpSamplingMetricImp> metrics = {};
auto &l0GfxCoreHelper = deviceImp->getNEODevice()->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
metrics.reserve(l0GfxCoreHelper.getIpSamplingMetricCount());
metricSourceCount = l0GfxCoreHelper.getIpSamplingMetricCount();
metricCount = l0GfxCoreHelper.getIpSamplingMetricCount();
zet_metric_properties_t metricProperties = {};
@@ -309,7 +308,7 @@ IpSamplingMetricGroupImp::IpSamplingMetricGroupImp(IpSamplingMetricSourceImp &me
strcpy_s(properties.description, ZET_MAX_METRIC_GROUP_DESCRIPTION, "EU stall sampling");
properties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED;
properties.domain = ipSamplinDomainId;
properties.metricCount = this->getMetricSource().metricSourceCount;
properties.metricCount = this->getMetricSource().metricCount;
}
ze_result_t IpSamplingMetricGroupImp::getProperties(zet_metric_group_properties_t *pProperties) {
@@ -342,14 +341,6 @@ ze_result_t IpSamplingMetricGroupImp::metricGet(uint32_t *pCount, zet_metric_han
return ZE_RESULT_SUCCESS;
}
bool IpSamplingMetricGroupBase::isMultiDeviceCaptureData(const size_t rawDataSize, const uint8_t *pRawData) {
if (rawDataSize >= sizeof(IpSamplingMetricDataHeader)) {
const auto header = reinterpret_cast<const IpSamplingMetricDataHeader *>(pRawData);
return header->magic == IpSamplingMetricDataHeader::magicValue;
}
return false;
}
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) {
@@ -367,7 +358,7 @@ ze_result_t IpSamplingMetricGroupImp::calculateMetricValuesExp(const zet_metric_
*pSetCount = 0;
}
if (!isMultiDeviceCaptureData(rawDataSize, pRawData)) {
if (!IpSamplingCalculation::isMultiDeviceCaptureData(rawDataSize, pRawData)) {
result = this->calculateMetricValues(type, rawDataSize, pRawData, pTotalMetricValueCount, pMetricValues);
} else {
METRICS_LOG_ERR("%s", "Calculating sub-device results using root device captured data is not supported");
@@ -463,7 +454,7 @@ ze_result_t MultiDeviceIpSamplingMetricGroupImp::calculateMetricValuesExp(const
*pTotalMetricValueCount = 0;
for (uint32_t setIndex = 0; setIndex < subDeviceMetricGroup.size(); setIndex++) {
uint32_t currTotalMetricValueCount = 0;
result = calcUtils->getMetricCountSubDevIndex(pRawData, rawDataSize, currTotalMetricValueCount, setIndex);
result = calcUtils->getMetricValueCountSubDevIndex(rawDataSize, pRawData, currTotalMetricValueCount, setIndex);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
@@ -542,22 +533,17 @@ ze_result_t IpSamplingMetricImp::getProperties(zet_metric_properties_t *pPropert
}
bool IpSamplingCalculation::isMultiDeviceCaptureData(const size_t rawDataSize, const uint8_t *pRawData) {
if (rawDataSize >= sizeof(IpSamplingMetricDataHeader)) {
const auto header = reinterpret_cast<const IpSamplingMetricDataHeader *>(pRawData);
return header->magic == IpSamplingMetricDataHeader::magicValue;
if (rawDataSize >= sizeof(IpSamplingMultiDevDataHeader)) {
const auto header = reinterpret_cast<const IpSamplingMultiDevDataHeader *>(pRawData);
return header->magic == IpSamplingMultiDevDataHeader::magicValue;
}
return false;
}
ze_result_t IpSamplingCalculation::getMetricCount(const uint8_t *pRawData, const size_t rawDataSize,
uint32_t &metricValueCount) {
std::unordered_set<uint64_t> stallReportIpCount{};
constexpr uint32_t rawReportSize = IpSamplingMetricGroupBase::rawReportSize;
ze_result_t IpSamplingCalculation::getIpsInRawData(const size_t rawDataSize, const uint8_t *pRawData,
std::unordered_set<uint64_t> &iPs) {
if ((rawDataSize % rawReportSize) != 0) {
METRICS_LOG_ERR("%s", "Invalid input raw data size");
metricValueCount = 0;
return ZE_RESULT_ERROR_INVALID_SIZE;
}
@@ -567,15 +553,13 @@ ze_result_t IpSamplingCalculation::getMetricCount(const uint8_t *pRawData, const
uint64_t ip = 0ULL;
memcpy_s(reinterpret_cast<uint8_t *>(&ip), sizeof(ip), pRawIpData, sizeof(ip));
ip &= gfxCoreHelper.getIpSamplingIpMask();
stallReportIpCount.insert(ip);
iPs.insert(ip);
}
metricValueCount = static_cast<uint32_t>(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) {
ze_result_t IpSamplingCalculation::getIpsInRawDataForSubDevIndex(const size_t rawDataSize, const uint8_t *pMultiMetricData, const uint32_t setIndex, std::unordered_set<uint64_t> &iPs) {
// Iterate through headers and assign required sizes
auto processedSize = 0u;
while (processedSize < rawDataSize) {
@@ -585,23 +569,51 @@ ze_result_t IpSamplingCalculation::getMetricCountSubDevIndex(const uint8_t *pMul
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
auto header = reinterpret_cast<const IpSamplingMetricDataHeader *>(processMetricData);
processedSize += sizeof(IpSamplingMetricDataHeader) + header->rawDataSize;
auto header = reinterpret_cast<const IpSamplingMultiDevDataHeader *>(processMetricData);
processedSize += sizeof(IpSamplingMultiDevDataHeader) + header->rawDataSize;
if (header->setIndex != setIndex) {
continue;
}
auto currTotalMetricValueCount = 0u;
auto result = getMetricCount((processMetricData + sizeof(IpSamplingMetricDataHeader)), header->rawDataSize, currTotalMetricValueCount);
auto result = getIpsInRawData(header->rawDataSize, processMetricData + sizeof(IpSamplingMultiDevDataHeader), iPs);
if (result != ZE_RESULT_SUCCESS) {
metricValueCount = 0;
iPs.clear();
return result;
}
metricValueCount += currTotalMetricValueCount;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingCalculation::getMetricValueCount(const size_t rawDataSize, const uint8_t *pRawData,
uint32_t &metricValueCount) {
ze_result_t status = ZE_RESULT_SUCCESS;
std::unordered_set<uint64_t> stallReportIpCount{};
status = getIpsInRawData(rawDataSize, pRawData, stallReportIpCount);
if (status != ZE_RESULT_SUCCESS) {
metricValueCount = 0;
return status;
}
metricValueCount = static_cast<uint32_t>(stallReportIpCount.size()) * metricSource.metricCount;
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingCalculation::getMetricValueCountSubDevIndex(const size_t rawDataSize, const uint8_t *pMultiMetricData, uint32_t &metricValueCount, const uint32_t setIndex) {
ze_result_t status = ZE_RESULT_SUCCESS;
std::unordered_set<uint64_t> stallReportIpCount{};
status = getIpsInRawDataForSubDevIndex(rawDataSize, pMultiMetricData, setIndex, stallReportIpCount);
if (status != ZE_RESULT_SUCCESS) {
metricValueCount = 0;
return status;
}
metricValueCount = static_cast<uint32_t>(stallReportIpCount.size()) * metricSource.metricCount;
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) {
@@ -616,32 +628,14 @@ ze_result_t IpSamplingCalculation::calculateMetricValues(const zet_metric_group_
DEBUG_BREAK_IF(pCalculatedData == nullptr);
const uint32_t rawReportSize = IpSamplingMetricGroupBase::rawReportSize;
if ((rawDataSize % rawReportSize) != 0) {
METRICS_LOG_ERR("%s", "Invalid input raw data size");
ze_result_t status = updateStallDataMapFromData(rawDataSize, pRawData, stallReportDataMap, &dataOverflow);
if (status != ZE_RESULT_SUCCESS) {
metricValueCount = 0;
return ZE_RESULT_ERROR_INVALID_SIZE;
METRICS_LOG_ERR("%s", "Failed to update stall data map");
return status;
}
const uint32_t rawReportCount = static_cast<uint32_t>(rawDataSize) / rawReportSize;
for (const uint8_t *pRawIpData = pRawData; pRawIpData < pRawData + (rawReportCount * rawReportSize); pRawIpData += rawReportSize) {
dataOverflow |= gfxCoreHelper.stallIpDataMapUpdate(stallReportDataMap, pRawIpData);
}
metricValueCount = std::min<uint32_t>(metricValueCount, static_cast<uint32_t>(stallReportDataMap.size()) * metricSource.metricSourceCount);
std::vector<zet_typed_value_t> 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();
stallDataMapToTypedValues(stallReportDataMap, metricValueCount, pCalculatedData);
return dataOverflow ? ZE_RESULT_WARNING_DROPPED_DATA : ZE_RESULT_SUCCESS;
}
@@ -661,13 +655,13 @@ ze_result_t IpSamplingCalculation::calculateMetricValuesSubDevIndex(const zet_me
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
auto header = reinterpret_cast<const IpSamplingMetricDataHeader *>(processMetricData);
processedSize += header->rawDataSize + sizeof(IpSamplingMetricDataHeader);
auto header = reinterpret_cast<const IpSamplingMultiDevDataHeader *>(processMetricData);
processedSize += header->rawDataSize + sizeof(IpSamplingMultiDevDataHeader);
if (header->setIndex != setIndex) {
continue;
}
auto processMetricRawData = processMetricData + sizeof(IpSamplingMetricDataHeader);
auto processMetricRawData = processMetricData + sizeof(IpSamplingMultiDevDataHeader);
auto currTotalMetricValueCount = requestTotalMetricValueCount;
auto result = calculateMetricValues(type, header->rawDataSize, processMetricRawData, currTotalMetricValueCount, pCalculatedData);
if (result != ZE_RESULT_SUCCESS) {
@@ -697,12 +691,108 @@ ze_result_t IpSamplingCalculation::calculateMetricForSubdevice(const zet_metric_
}
if (calculateCountOnly) {
return getMetricCount(pRawData, rawDataSize, *pMetricValueCount);
return getMetricValueCount(rawDataSize, pRawData, *pMetricValueCount);
} else {
return calculateMetricValues(type, rawDataSize, pRawData, *pMetricValueCount, pMetricValues);
}
}
ze_result_t IpSamplingCalculation::updateStallDataMapFromData(const size_t rawDataSize, const uint8_t *pRawData,
std::map<uint64_t, void *> &stallReportDataMap,
bool *dataOverflow) {
if ((rawDataSize % rawReportSize) != 0) {
METRICS_LOG_ERR("%s", "Invalid input raw data size");
return ZE_RESULT_ERROR_INVALID_SIZE;
}
size_t processedSize = 0;
const uint8_t *dataToProcess = pRawData;
do {
*dataOverflow |= gfxCoreHelper.stallIpDataMapUpdateFromData(dataToProcess, stallReportDataMap);
processedSize += rawReportSize;
dataToProcess += rawReportSize;
} while (processedSize < rawDataSize);
return ZE_RESULT_SUCCESS;
}
void IpSamplingCalculation::multiDataMapToMetricResults(std::map<uint32_t, std::map<uint64_t, void *> *> &perScopeIpDataCaches,
uint32_t metricReportCount,
std::vector<uint32_t> includedMetricIndexes,
zet_intel_metric_result_exp_t *pMetricResults) {
// Every report includes the filtered metrics per scope
std::vector<zet_typed_value_t> ipDataValues;
uint32_t resultIndex = 0;
for (uint32_t reportIndex = 0; reportIndex < metricReportCount; reportIndex++) {
for (auto &entry : perScopeIpDataCaches) {
ipDataValues.clear();
std::map<uint64_t, void *> *scopeCache = entry.second;
bool cacheEmpty = scopeCache->empty();
if (!cacheEmpty) {
auto it = scopeCache->begin();
gfxCoreHelper.stallSumIpDataToTypedValues(it->first, it->second, ipDataValues);
gfxCoreHelper.stallIpDataMapDeleteSumDataEntry(it);
it = scopeCache->erase(it);
}
for (uint32_t j = 0; j < includedMetricIndexes.size(); j++) {
if (cacheEmpty) {
(pMetricResults + resultIndex)->value.ui64 = 0;
(pMetricResults + resultIndex)->resultStatus = ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID;
} else {
(pMetricResults + resultIndex)->value = ipDataValues[includedMetricIndexes[j]].value;
(pMetricResults + resultIndex)->resultStatus = ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID;
}
resultIndex++;
}
}
}
}
void IpSamplingCalculation::stallDataMapToMetricResults(std::map<uint64_t, void *> &stallReportDataMap,
uint32_t metricReportCount,
std::vector<uint32_t> includedMetricIndexes,
zet_intel_metric_result_exp_t *pMetricResults) {
std::vector<zet_typed_value_t> ipDataValues;
uint32_t i = 0;
auto endIt = stallReportDataMap.begin();
std::advance(endIt, metricReportCount);
for (auto it = stallReportDataMap.begin(); it != endIt;) {
ipDataValues.clear();
gfxCoreHelper.stallSumIpDataToTypedValues(it->first, it->second, ipDataValues);
for (uint32_t j = 0; j < includedMetricIndexes.size(); j++) {
(pMetricResults + i)->value = ipDataValues[includedMetricIndexes[j]].value;
(pMetricResults + i)->resultStatus = ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID;
i++;
}
gfxCoreHelper.stallIpDataMapDeleteSumDataEntry(it);
it = stallReportDataMap.erase(it);
}
}
void IpSamplingCalculation::stallDataMapToTypedValues(std::map<uint64_t, void *> &stallReportDataMap,
uint32_t &metricValueCount,
zet_typed_value_t *pTypedValues) {
metricValueCount = std::min<uint32_t>(metricValueCount, static_cast<uint32_t>(stallReportDataMap.size()) * metricSource.metricCount);
std::vector<zet_typed_value_t> 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++) {
*(pTypedValues + i) = *jt;
}
ipDataValues.clear();
}
gfxCoreHelper.stallIpDataMapDeleteSumData(stallReportDataMap);
stallReportDataMap.clear();
}
template <>
IpSamplingMetricSourceImp &MetricDeviceContext::getMetricSource<IpSamplingMetricSourceImp>() const {
return static_cast<IpSamplingMetricSourceImp &>(*metricSources.at(MetricSource::metricSourceTypeIpSampling));

47
level_zero/tools/source/metrics/metric_ip_sampling_source.h
View File

@@ -10,6 +10,7 @@
#include "level_zero/tools/source/metrics/metric.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
#include <unordered_set>
namespace L0 {
class L0GfxCoreHelper;
struct IpSamplingMetricImp;
@@ -63,7 +64,7 @@ class IpSamplingMetricSourceImp : public MetricSource {
const std::vector<MetricScopeImp *> &metricScopes,
zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation) override;
uint32_t metricSourceCount = 0;
uint32_t metricCount = 0;
bool canDisable() override;
void initMetricScopes(MetricDeviceContext &metricDeviceContext) override;
@@ -83,7 +84,7 @@ class IpSamplingMetricSourceImp : public MetricSource {
struct IpSamplingMetricGroupBase : public MetricGroupImp {
IpSamplingMetricGroupBase(MetricSource &metricSource) : MetricGroupImp(metricSource) {}
static constexpr uint32_t rawReportSize = 64u;
bool activate() override { return true; }
bool deactivate() override { return true; };
ze_result_t metricQueryPoolCreate(
@@ -105,7 +106,6 @@ struct IpSamplingMetricGroupBase : public MetricGroupImp {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
static bool isMultiDeviceCaptureData(const size_t rawDataSize, const uint8_t *pRawData);
IpSamplingMetricSourceImp &getMetricSource() { return static_cast<IpSamplingMetricSourceImp &>(metricSource); }
};
@@ -190,35 +190,50 @@ struct IpSamplingCalculation {
: gfxCoreHelper(gfxCoreHelper), metricSource(metricSource) {}
~IpSamplingCalculation() = default;
static constexpr uint32_t rawReportSize = 64u;
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 getIpsInRawData(const size_t rawDataSize, const uint8_t *pRawData,
std::unordered_set<uint64_t> &iPs);
ze_result_t getIpsInRawDataForSubDevIndex(const size_t rawDataSize,
const uint8_t *pMultiMetricData,
const uint32_t setIndex,
std::unordered_set<uint64_t> &iPs);
ze_result_t getMetricValueCount(const size_t rawDataSize,
const uint8_t *pRawData,
uint32_t &metricValueCount);
ze_result_t getMetricValueCountSubDevIndex(const size_t rawDataSize, const uint8_t *pMultiMetricData,
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<uint64_t, void *> &stallReportDataMap,
bool *dataOverflow);
ze_result_t updateStallDataMapFromData(const size_t rawDataSize, const uint8_t *pRawData,
std::map<uint64_t, void *> &stallReportDataMap,
bool *dataOverflow);
void stallDataMapToMetricResults(std::map<uint64_t, void *> &stallReportDataMap,
uint32_t metricReportCount,
std::vector<uint32_t> includedMetricIndexes,
zet_intel_metric_result_exp_t *pMetricResults);
void multiDataMapToMetricResults(std::map<uint32_t, std::map<uint64_t, void *> *> &perScopeIpDataCaches,
uint32_t metricReportCount,
std::vector<uint32_t> includedMetricIndexes,
zet_intel_metric_result_exp_t *pMetricResults);
void stallDataMapToTypedValues(std::map<uint64_t, void *> &stallReportDataMap,
uint32_t &metricValueCount,
zet_typed_value_t *pTypedValues);
protected:
L0::L0GfxCoreHelper &gfxCoreHelper;
IpSamplingMetricSourceImp &metricSource;
};
struct IpSamplingMetricDataHeader {
struct IpSamplingMultiDevDataHeader {
static constexpr uint32_t magicValue = 0xFEEDBCBA;
uint32_t magic;
uint32_t rawDataSize;

422
level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp
View File

@@ -105,6 +105,48 @@ uint32_t IpSamplingMetricStreamerImp::getMaxSupportedReportCount() {
return ipSamplingSource.getMetricOsInterface()->getRequiredBufferSize(UINT32_MAX) / unitReportSize;
}
IpSamplingMetricCalcOpImp::IpSamplingMetricCalcOpImp(bool multidevice,
const std::vector<MetricScopeImp *> &metricScopesInCalcOp,
std::vector<MetricImp *> &metricsInReport,
const std::vector<MetricScopeImp *> &metricScopesInReport,
IpSamplingMetricSourceImp &metricSource,
std::vector<uint32_t> &includedMetricIndexes)
: MetricCalcOpImp(multidevice, metricScopesInReport, metricsInReport, std::vector<MetricImp *>()),
metricSource(metricSource), includedMetricIndexes(includedMetricIndexes), metricScopesInCalcOp(metricScopesInCalcOp) {
// Create an IP data cache for each scope in the calcOp
for (auto &scope : metricScopesInCalcOp) {
auto scopeId = scope->getId();
perScopeIpDataCaches[scopeId] = new std::map<uint64_t, void *>{};
if (scope->isAggregated()) {
isAggregateScopeIncluded = true;
aggregateScopeId = scope->getId();
}
}
const auto deviceImp = static_cast<DeviceImp *>(&(metricSource.getMetricDeviceContext().getDevice()));
l0GfxCoreHelper = &(deviceImp->getNEODevice()->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>());
}
void IpSamplingMetricCalcOpImp::clearScopesCaches() {
for (auto &entry : perScopeIpDataCaches) {
l0GfxCoreHelper->stallIpDataMapDeleteSumData(*entry.second);
entry.second->clear();
}
}
ze_result_t IpSamplingMetricCalcOpImp::destroy() {
clearScopesCaches();
for (auto &it : perScopeIpDataCaches) {
delete it.second;
it.second = nullptr;
}
perScopeIpDataCaches.clear();
delete this;
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingMetricCalcOpImp::create(bool isMultiDevice,
const std::vector<MetricScopeImp *> &metricScopes,
IpSamplingMetricSourceImp &metricSource,
@@ -123,39 +165,40 @@ ze_result_t IpSamplingMetricCalcOpImp::create(bool isMultiDevice,
if (auto ret = metricSource.metricGroupGet(&metricGroupCount, &hMetricGroup); ret != ZE_RESULT_SUCCESS) {
return ret;
}
uint32_t metricCount = 0;
MetricGroup::fromHandle(hMetricGroup)->metricGet(&metricCount, nullptr);
std::vector<zet_metric_handle_t> hMetrics(metricCount);
MetricGroup::fromHandle(hMetricGroup)->metricGet(&metricCount, hMetrics.data());
std::vector<MetricImp *> filteredMetrics = {};
std::vector<uint32_t> filteredMetricIndexes = {};
std::vector<MetricImp *> includedMetrics = {};
std::vector<uint32_t> includedMetricIndexes = {};
for (uint32_t i = 0; i < metricCount; i++) {
auto metric = static_cast<MetricImp *>(Metric::fromHandle(hMetrics[i]));
if (pCalculationDesc->metricGroupCount > 0) {
filteredMetrics.push_back(metric);
filteredMetricIndexes.push_back(i);
includedMetrics.push_back(metric);
includedMetricIndexes.push_back(i);
} else {
if (uniqueMetricHandles.find(hMetrics[i]) != uniqueMetricHandles.end()) {
filteredMetrics.push_back(metric);
filteredMetricIndexes.push_back(i);
includedMetrics.push_back(metric);
includedMetricIndexes.push_back(i);
}
}
}
// Create metricsInReport and corresponding scopes in scopesForMetricsInReport
// Create metricsInReport and corresponding scopes in metricScopesInReport
std::vector<MetricImp *> metricsInReport = {};
std::vector<MetricScopeImp *> scopesForMetricsInReport = {};
std::vector<MetricScopeImp *> metricScopesInReport = {};
for (uint32_t scopeIndex = 0; scopeIndex < metricScopes.size(); scopeIndex++) {
for (uint32_t metricIndex = 0; metricIndex < filteredMetrics.size(); metricIndex++) {
metricsInReport.push_back(filteredMetrics[metricIndex]);
scopesForMetricsInReport.push_back(metricScopes[scopeIndex]);
for (uint32_t metricIndex = 0; metricIndex < includedMetrics.size(); metricIndex++) {
metricsInReport.push_back(includedMetrics[metricIndex]);
metricScopesInReport.push_back(metricScopes[scopeIndex]);
}
}
auto calcOp = new IpSamplingMetricCalcOpImp(isMultiDevice, scopesForMetricsInReport, static_cast<uint32_t>(hMetrics.size()),
metricsInReport, filteredMetricIndexes);
auto calcOp = new IpSamplingMetricCalcOpImp(isMultiDevice, metricScopes, metricsInReport,
metricScopesInReport, metricSource, includedMetricIndexes);
*phCalculationOperation = calcOp->toHandle();
ze_result_t status = ZE_RESULT_SUCCESS;
if ((pCalculationDesc->timeWindowsCount > 0) || (pCalculationDesc->timeAggregationWindow != 0)) {
@@ -167,99 +210,232 @@ ze_result_t IpSamplingMetricCalcOpImp::create(bool isMultiDevice,
return status;
}
ze_result_t IpSamplingMetricCalcOpImp::destroy() {
delete this;
ze_result_t IpSamplingMetricCalcOpImp::getSingleComputeScopeReportCount(const size_t rawDataSize, const uint8_t *pRawData,
bool newData, uint32_t scopeId, uint32_t *pTotalMetricReportCount) {
ze_result_t status = ZE_RESULT_ERROR_UNKNOWN;
auto ipSamplingCalculation = metricSource.ipSamplingCalculation.get();
std::unordered_set<uint64_t> iPs{};
if (newData) {
status = ipSamplingCalculation->getIpsInRawData(rawDataSize, pRawData, iPs);
if (status != ZE_RESULT_SUCCESS) {
*pTotalMetricReportCount = 0;
return status;
}
}
*pTotalMetricReportCount = getUniqueIpCountForScope(scopeId, iPs);
DEBUG_BREAK_IF(*pTotalMetricReportCount == 0);
return ZE_RESULT_SUCCESS;
}
void IpSamplingMetricCalcOpImp::fillStallDataMap(const size_t rawDataSize, const uint8_t *pRawData, size_t *processedSize,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
std::map<uint64_t, void *> &stallReportDataMap,
bool *dataOverflow) {
ze_result_t IpSamplingMetricCalcOpImp::getMultiScopeReportCount(const size_t rawDataSize, const uint8_t *pRawData,
bool newData, uint32_t *pTotalMetricReportCount) {
const uint32_t rawReportSize = IpSamplingMetricGroupBase::rawReportSize;
*processedSize = 0;
const uint8_t *dataToProcess = pRawData;
do {
*dataOverflow |= l0GfxCoreHelper.stallIpDataMapUpdate(stallReportDataMap, dataToProcess);
*processedSize += rawReportSize;
dataToProcess += rawReportSize;
} while (*processedSize < rawDataSize);
return;
}
ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValuesSingle(const size_t rawDataSize, const uint8_t *pRawData,
uint32_t *pTotalMetricReportCount,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
IpSamplingMetricGroupBase *metricGroupBase,
bool getSize,
size_t *usedSize,
bool &dataOverflow,
std::map<uint64_t, void *> &stallReportDataMap) {
ze_result_t status = ZE_RESULT_ERROR_UNKNOWN;
uint32_t resultCount = 0;
*usedSize = 0;
auto ipSamplingCalculation = metricSource.ipSamplingCalculation.get();
auto calcUtils = metricGroupBase->getMetricSource().ipSamplingCalculation.get();
// IPs are shared across sub-devices. So, if aggregated scope is provided, the number of reports is the total
// number of unique IPs across all sub-devices data.
// Otherwise, the number of reports is the number of IPs in the sub-device compute scope that has the most IPs, and
// results will have invalid status for reports in compute scopes that have fewer IPs.
status = calcUtils->getMetricCount(pRawData, rawDataSize, resultCount);
if (status != ZE_RESULT_SUCCESS) {
*pTotalMetricReportCount = 0;
return status;
if (newData) {
std::unordered_set<uint64_t> iPs{};
std::vector<uint32_t> subDeviceIndexes{};
std::vector<MetricScopeImp *>::iterator it = metricScopesInCalcOp.begin();
if (isAggregateScopeIncluded) {
DeviceImp *deviceImp = static_cast<DeviceImp *>(&metricSource.getMetricDeviceContext().getDevice());
uint32_t subDeviceCount = deviceImp->numSubDevices;
std::vector<ze_device_handle_t> subDevices(subDeviceCount);
deviceImp->getSubDevices(&subDeviceCount, subDevices.data());
for (auto &subDeviceHandle : subDevices) {
auto neoSubDevice = static_cast<NEO::SubDevice *>(Device::fromHandle(subDeviceHandle)->getNEODevice());
subDeviceIndexes.push_back(neoSubDevice->getSubDeviceIndex());
}
} else {
for (auto &scope : metricScopesInCalcOp) {
subDeviceIndexes.push_back(scope->getComputeSubDeviceIndex());
}
}
for (auto &subdevIndex : subDeviceIndexes) {
status = ipSamplingCalculation->getIpsInRawDataForSubDevIndex(rawDataSize, pRawData, subdevIndex, iPs);
if (status != ZE_RESULT_SUCCESS) {
*pTotalMetricReportCount = 0;
return status;
}
if (!isAggregateScopeIncluded) {
*pTotalMetricReportCount = std::max(*pTotalMetricReportCount, getUniqueIpCountForScope((*it)->getId(), iPs));
it++;
iPs.clear();
}
}
if (isAggregateScopeIncluded) {
*pTotalMetricReportCount = getUniqueIpCountForScope(aggregateScopeId, iPs);
}
} else {
*pTotalMetricReportCount = getLargestCacheSize();
}
uint32_t rawDataReportCount = resultCount / cachedMetricsCount;
if (getSize) {
*pTotalMetricReportCount = rawDataReportCount;
return ZE_RESULT_SUCCESS;
}
if (*pTotalMetricReportCount < rawDataReportCount) {
METRICS_LOG_ERR("%s", "EU Stall does not allow calculating fewer results than available in raw data");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
fillStallDataMap(rawDataSize, pRawData, usedSize, l0GfxCoreHelper, stallReportDataMap,
&dataOverflow);
*pTotalMetricReportCount = static_cast<uint32_t>(stallReportDataMap.size());
return status;
DEBUG_BREAK_IF(*pTotalMetricReportCount == 0);
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValuesMulti(const size_t rawDataSize, const uint8_t *pRawData,
uint32_t *pTotalMetricReportCount,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
IpSamplingMetricGroupBase *metricGroupBase,
bool getSize,
uint32_t numSubDevices,
size_t *usedSize,
bool &dataOverflow,
std::map<uint64_t, void *> &stallReportDataMap) {
ze_result_t status = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
return status;
ze_result_t IpSamplingMetricCalcOpImp::updateCacheForSingleScope(const size_t rawDataSize, const uint8_t *pRawData,
bool newData, std::map<uint64_t, void *> &reportDataMap, bool &dataOverflow) {
if (newData) {
ze_result_t status = ZE_RESULT_ERROR_UNKNOWN;
auto ipSamplingCalculation = metricSource.ipSamplingCalculation.get();
status = ipSamplingCalculation->updateStallDataMapFromData(rawDataSize, pRawData,
reportDataMap, &dataOverflow);
if (status != ZE_RESULT_SUCCESS) {
METRICS_LOG_ERR("%s", "Failed to update stall data map");
return status;
}
}
DEBUG_BREAK_IF(reportDataMap.empty());
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingMetricCalcOpImp::updateCachesForMultiScopes(const size_t rawDataSize, const uint8_t *pRawData,
bool newData, bool &dataOverflow) {
// Process new data only once per sub-device.
// Aggregated scope update needs metrics only from new data. So:
// a) Save sub-devices data in temporary caches for each compute scope
// b) Update aggregated scope temporary caches data.
// For compute scopes use the temporary caches to update each compute scope cache accordingly
if (newData) {
MetricScopeImp *aggregatedScope = nullptr;
std::map<uint32_t, std::map<uint64_t, void *> *> computeNewIpsCaches{};
std::vector<uint32_t> subDevIndexesForComputeScopes{};
ze_result_t status = ZE_RESULT_ERROR_UNKNOWN;
auto traverseDataAndUpdateCache = [this, rawDataSize, pRawData, newData, &dataOverflow](uint32_t subDeviceIndex, std::map<uint64_t, void *> &reportDataMap) -> ze_result_t {
auto processedSize = 0u;
ze_result_t result = ZE_RESULT_ERROR_UNKNOWN;
while (processedSize < rawDataSize) {
auto processMetricData = pRawData + processedSize;
auto header = reinterpret_cast<const IpSamplingMultiDevDataHeader *>(processMetricData);
processedSize += sizeof(IpSamplingMultiDevDataHeader) + header->rawDataSize;
if (header->setIndex != subDeviceIndex) {
continue;
}
result = updateCacheForSingleScope(header->rawDataSize,
(processMetricData + sizeof(IpSamplingMultiDevDataHeader)),
newData, reportDataMap, dataOverflow);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
}
return ZE_RESULT_SUCCESS;
};
auto clearTempCaches = [&computeNewIpsCaches, this]() {
for (auto &it : computeNewIpsCaches) {
l0GfxCoreHelper->stallIpDataMapDeleteSumData(*it.second);
it.second->clear();
delete it.second;
}
computeNewIpsCaches.clear();
};
for (auto &scope : metricScopesInCalcOp) {
if (!scope->isAggregated()) {
uint32_t subDeviceIndex = scope->getComputeSubDeviceIndex();
subDevIndexesForComputeScopes.push_back(subDeviceIndex);
// Temporary cache for new data per compute scope to allow updating aggregated and compute cached independently
computeNewIpsCaches[scope->getId()] = new std::map<uint64_t, void *>{};
status = traverseDataAndUpdateCache(subDeviceIndex, *computeNewIpsCaches[scope->getId()]);
if (status != ZE_RESULT_SUCCESS) {
clearTempCaches();
return status;
}
} else {
aggregatedScope = scope;
}
}
if (aggregatedScope) {
// Process data for the sub-devices not already processed above.
std::map<uint64_t, void *> *aggregatedScopeCache = perScopeIpDataCaches[aggregatedScope->getId()];
DeviceImp *deviceImp = static_cast<DeviceImp *>(&metricSource.getMetricDeviceContext().getDevice());
uint32_t subDeviceCount = deviceImp->numSubDevices;
std::vector<ze_device_handle_t> subDevices(subDeviceCount);
deviceImp->getSubDevices(&subDeviceCount, subDevices.data());
std::vector<uint32_t> pendingSubDeviceIndexes{};
for (auto &subDeviceHandle : subDevices) {
auto neoSubDevice = static_cast<NEO::SubDevice *>(Device::fromHandle(subDeviceHandle)->getNEODevice());
uint32_t subdevIndex = neoSubDevice->getSubDeviceIndex();
if (std::find(subDevIndexesForComputeScopes.begin(), subDevIndexesForComputeScopes.end(), subdevIndex) == subDevIndexesForComputeScopes.end()) {
pendingSubDeviceIndexes.push_back(subdevIndex);
}
}
for (auto &subDeviceIndex : pendingSubDeviceIndexes) {
status = traverseDataAndUpdateCache(subDeviceIndex, *aggregatedScopeCache);
if (status != ZE_RESULT_SUCCESS) {
clearTempCaches();
return status;
}
}
// Update aggregated scope cache with Ips from new data in sub-devices caches.
for (auto &it : computeNewIpsCaches) {
l0GfxCoreHelper->stallIpDataMapUpdateFromMap(*it.second, *aggregatedScopeCache);
}
}
// Update each compute scope cache with its data and free the temporary caches
for (auto &it : computeNewIpsCaches) {
l0GfxCoreHelper->stallIpDataMapUpdateFromMap(*it.second, *perScopeIpDataCaches[it.first]);
}
clearTempCaches();
}
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValues(const size_t rawDataSize, const uint8_t *pRawData,
bool final, size_t *usedSize,
uint32_t *pTotalMetricReportCount,
zet_intel_metric_result_exp_t *pMetricResults) {
ze_result_t status = ZE_RESULT_ERROR_UNKNOWN;
*usedSize = 0;
uint32_t metricReportCount = 0;
bool dataOverflow = false;
uint32_t metricGroupCount = 1;
zet_metric_group_handle_t hMetricGroup = {};
metricsInReport[0]->getMetricSource().metricGroupGet(&metricGroupCount, &hMetricGroup);
bool isMultiDeviceData = IpSamplingMetricGroupBase::isMultiDeviceCaptureData(rawDataSize, pRawData);
IpSamplingMetricGroupBase *metricGroupBase = static_cast<IpSamplingMetricGroupBase *>(MetricGroup::fromHandle(hMetricGroup));
DeviceImp *deviceImp = static_cast<DeviceImp *>(&metricGroupBase->getMetricSource().getMetricDeviceContext().getDevice());
L0::L0GfxCoreHelper &l0GfxCoreHelper = deviceImp->getNEODevice()->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
auto ipSamplingCalculation = metricSource.ipSamplingCalculation.get();
bool getSize = (*pTotalMetricReportCount == 0);
std::map<uint64_t, void *> stallReportDataMap;
bool newData = false; // Track if there is fresh new raw data that requires updating caches
uint64_t dataSize = rawDataSize;
const uint8_t *rawDataStart = pRawData;
ze_result_t status = ZE_RESULT_SUCCESS;
if (areAllCachesEmpty()) {
// All data is new: user asked to calculate all results available in the raw data. So, all caches are empty
newData = true;
} else if (rawDataSize > processedSize) {
// Previous call user requested fewer results than available. So, algo cached pending results and
// processed size = input size - rawReportSize because returned used size = rawReportSize.
// Then user is expected to move pRawData by rawReportSize. If data gets appended user must update
// new size accordingly.
newData = true;
rawDataStart += processedSize;
dataSize = rawDataSize - processedSize;
}
if (newData) { // only check on new data. Otherwise, cached values are guaranteed to be valid
isMultiDeviceData = IpSamplingCalculation::isMultiDeviceCaptureData(dataSize, rawDataStart);
}
if (!isMultiDevice) {
if (isMultiDeviceData) {
@@ -267,36 +443,54 @@ ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValues(const size_t rawDat
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
status = metricCalculateValuesSingle(rawDataSize, pRawData, pTotalMetricReportCount,
l0GfxCoreHelper, metricGroupBase, getSize, usedSize, dataOverflow, stallReportDataMap);
uint32_t scopeId = metricScopesInCalcOp[0]->getId(); // Sub-devices calcOp can only have single scope
DEBUG_BREAK_IF(metricScopesInCalcOp[0]->isAggregated());
DEBUG_BREAK_IF(scopeId != 0);
if (getSize) {
return getSingleComputeScopeReportCount(dataSize, rawDataStart, newData, scopeId, pTotalMetricReportCount);
}
status = updateCacheForSingleScope(dataSize, rawDataStart, newData, *perScopeIpDataCaches[scopeId], dataOverflow);
if (status != ZE_RESULT_SUCCESS) {
clearScopesCaches();
METRICS_LOG_ERR("%s", "Failed to update stall data");
return status;
}
metricReportCount = std::min<uint32_t>(*pTotalMetricReportCount, getLargestCacheSize());
ipSamplingCalculation->stallDataMapToMetricResults(*getScopeCache(scopeId), metricReportCount, includedMetricIndexes, pMetricResults);
} else {
if (!isMultiDeviceData) {
METRICS_LOG_ERR("%s", "Cannot use sub-device raw data in a root device calculation operation handle");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
status = metricCalculateValuesMulti(rawDataSize, pRawData, pTotalMetricReportCount,
l0GfxCoreHelper, metricGroupBase, getSize, deviceImp->numSubDevices,
usedSize, dataOverflow, stallReportDataMap);
}
if ((status != ZE_RESULT_SUCCESS) || (getSize)) {
return status;
}
std::vector<zet_typed_value_t> ipDataValues;
uint32_t i = 0;
for (auto it = stallReportDataMap.begin(); it != stallReportDataMap.end(); ++it) {
l0GfxCoreHelper.stallSumIpDataToTypedValues(it->first, it->second, ipDataValues);
for (uint32_t j = 0; j < includedMetricIndexes.size(); j++) {
(pMetricResults + i)->value = ipDataValues[includedMetricIndexes[j]].value;
(pMetricResults + i)->resultStatus = ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID;
i++;
if (getSize) {
return getMultiScopeReportCount(dataSize, rawDataStart, newData, pTotalMetricReportCount);
}
ipDataValues.clear();
status = updateCachesForMultiScopes(dataSize, rawDataStart, newData, dataOverflow);
if (status != ZE_RESULT_SUCCESS) {
// clearScopesCaches();
METRICS_LOG_ERR("%s", "Failed to update stall data map");
return status;
}
metricReportCount = std::min<uint32_t>(*pTotalMetricReportCount, getLargestCacheSize());
ipSamplingCalculation->multiDataMapToMetricResults(perScopeIpDataCaches, metricReportCount, includedMetricIndexes, pMetricResults);
}
// Update with the actual number of reports calculated
*pTotalMetricReportCount = metricReportCount;
if (final || areAllCachesEmpty()) {
clearScopesCaches();
*usedSize = rawDataSize;
processedSize = 0;
} else {
*usedSize = IpSamplingCalculation::rawReportSize;
processedSize = rawDataSize - IpSamplingCalculation::rawReportSize;
}
l0GfxCoreHelper.stallIpDataMapDelete(stallReportDataMap);
stallReportDataMap.clear();
return dataOverflow ? ZE_RESULT_WARNING_DROPPED_DATA : ZE_RESULT_SUCCESS;
}
@@ -344,7 +538,7 @@ ze_result_t MultiDeviceIpSamplingMetricGroupImp::streamerOpen(
ze_result_t MultiDeviceIpSamplingMetricStreamerImp::readData(uint32_t maxReportCount, size_t *pRawDataSize, uint8_t *pRawData) {
const int32_t totalHeaderSize = static_cast<int32_t>(sizeof(IpSamplingMetricDataHeader) * subDeviceStreamers.size());
const int32_t totalHeaderSize = static_cast<int32_t>(sizeof(IpSamplingMultiDevDataHeader) * subDeviceStreamers.size());
// Find single report size
size_t singleReportSize = 0;
subDeviceStreamers[0]->readData(1, &singleReportSize, nullptr);
@@ -375,8 +569,8 @@ ze_result_t MultiDeviceIpSamplingMetricStreamerImp::readData(uint32_t maxReportC
auto &streamer = subDeviceStreamers[index];
// Get header address
auto header = reinterpret_cast<IpSamplingMetricDataHeader *>(pCurrRawData);
pCurrRawData += sizeof(IpSamplingMetricDataHeader);
auto header = reinterpret_cast<IpSamplingMultiDevDataHeader *>(pCurrRawData);
pCurrRawData += sizeof(IpSamplingMultiDevDataHeader);
result = streamer->readData(maxReportCount, &currRawDataSize, pCurrRawData);
if (result != ZE_RESULT_SUCCESS) {
@@ -385,8 +579,8 @@ ze_result_t MultiDeviceIpSamplingMetricStreamerImp::readData(uint32_t maxReportC
}
// Update to header
memset(header, 0, sizeof(IpSamplingMetricDataHeader));
header->magic = IpSamplingMetricDataHeader::magicValue;
memset(header, 0, sizeof(IpSamplingMultiDevDataHeader));
header->magic = IpSamplingMultiDevDataHeader::magicValue;
header->rawDataSize = static_cast<uint32_t>(currRawDataSize);
header->setIndex = index;

89
level_zero/tools/source/metrics/metric_ip_sampling_streamer.h
View File

@@ -10,6 +10,7 @@
#include "level_zero/tools/source/metrics/metric.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
#include <unordered_set>
namespace L0 {
class IpSamplingMetricSourceImp;
@@ -49,15 +50,13 @@ struct MultiDeviceIpSamplingMetricStreamerImp : public IpSamplingMetricStreamerB
struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp {
IpSamplingMetricCalcOpImp(bool multidevice,
const std::vector<MetricScopeImp *> &metricScopes,
uint32_t cachedMetricsCount,
const std::vector<MetricScopeImp *> &metricScopesInCalcOp,
std::vector<MetricImp *> &metricsInReport,
std::vector<uint32_t> &includedMetricIndexes)
: MetricCalcOpImp(multidevice, metricScopes, metricsInReport, std::vector<MetricImp *>()),
cachedMetricsCount(cachedMetricsCount),
includedMetricIndexes(includedMetricIndexes) {}
const std::vector<MetricScopeImp *> &metricScopesInReport,
IpSamplingMetricSourceImp &metricSource,
std::vector<uint32_t> &includedMetricIndexes);
~IpSamplingMetricCalcOpImp() override{};
static ze_result_t create(bool isMultiDevice,
const std::vector<MetricScopeImp *> &metricScopes,
IpSamplingMetricSourceImp &metricSource,
@@ -70,32 +69,60 @@ struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp {
uint32_t *pTotalMetricReportCount,
zet_intel_metric_result_exp_t *pMetricResults) override;
void fillStallDataMap(const size_t rawDataSize, const uint8_t *pRawData, size_t *processedSize,
L0GfxCoreHelper &l0GfxCoreHelper,
std::map<uint64_t, void *> &stallReportDataMap,
bool *dataOverflow);
protected:
ze_result_t metricCalculateValuesSingle(const size_t rawDataSize, const uint8_t *pRawData,
uint32_t *pTotalMetricReportCount,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
IpSamplingMetricGroupBase *metricGroupBase,
bool getSize,
size_t *usedSize,
bool &dataOverflow,
std::map<uint64_t, void *> &stallReportDataMap);
ze_result_t metricCalculateValuesMulti(const size_t rawDataSize, const uint8_t *pRawData,
uint32_t *pTotalMetricReportCount,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
IpSamplingMetricGroupBase *metricGroupBase,
bool getSize,
uint32_t numSubDevices,
size_t *usedSize,
bool &dataOverflow,
std::map<uint64_t, void *> &stallReportDataMap);
uint32_t cachedMetricsCount = 0;
IpSamplingMetricSourceImp &metricSource;
std::vector<uint32_t> includedMetricIndexes{};
std::vector<MetricScopeImp *> metricScopesInCalcOp{};
bool isMultiDeviceData = false;
bool isAggregateScopeIncluded = false;
uint32_t aggregateScopeId = 0; // valid if isAggregateScopeIncluded is true
std::map<uint32_t, std::map<uint64_t, void *> *> perScopeIpDataCaches{};
size_t processedSize = 0;
L0::L0GfxCoreHelper *l0GfxCoreHelper = nullptr;
ze_result_t getSingleComputeScopeReportCount(const size_t rawDataSize, const uint8_t *pRawData,
bool newData, uint32_t scopeId, uint32_t *pTotalMetricReportCount);
ze_result_t getMultiScopeReportCount(const size_t rawDataSize, const uint8_t *pRawData,
bool newData, uint32_t *pTotalMetricReportCount);
ze_result_t updateCacheForSingleScope(const size_t rawDataSize, const uint8_t *pRawData,
bool newData, std::map<uint64_t, void *> &reportDataMap, bool &dataOverflow);
ze_result_t updateCachesForMultiScopes(const size_t rawDataSize, const uint8_t *pRawData,
bool newData, bool &dataOverflow);
bool isScopeCacheEmpty(uint32_t scopeId) {
return perScopeIpDataCaches[scopeId]->empty();
}
bool areAllCachesEmpty() {
for (const auto &it : perScopeIpDataCaches) {
if (!isScopeCacheEmpty(it.first)) {
return false;
}
}
return true;
}
void clearScopesCaches();
// Get unique IPs count from new data and scope cache
uint32_t getUniqueIpCountForScope(uint32_t scopeId, std::unordered_set<uint64_t> &ips) {
for (const auto &entry : *perScopeIpDataCaches[scopeId]) {
ips.insert(entry.first);
}
return static_cast<uint32_t>(ips.size());
}
std::map<uint64_t, void *> *getScopeCache(uint32_t scopeId) {
return perScopeIpDataCaches[scopeId];
}
uint32_t getLargestCacheSize() {
uint32_t maxSize = 0;
for (auto &it : perScopeIpDataCaches) {
maxSize = std::max(maxSize, static_cast<uint32_t>(it.second->size()));
}
return maxSize;
}
};
} // namespace L0

5
level_zero/tools/test/unit_tests/sources/metrics/CMakeLists.txt
View File

@@ -11,6 +11,8 @@ target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/metric_query_pool_fixture.cpp
${CMAKE_CURRENT_SOURCE_DIR}/metric_query_pool_fixture.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_metric_ip_sampling_source.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_ip_sampling_raw_data.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_metric_ip_sampling.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_metric_oa.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_metric_source.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_metric_oa.cpp
@@ -31,7 +33,8 @@ target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/mock_metric_oa_programmable.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_group.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_ip_sampling_enumeration.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_ip_sampling_streamer.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_ip_sampling_streamer_1.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_ip_sampling_streamer_2.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_oa_export.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_programmable.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_concurrent_groups.cpp

136
level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.cpp
View File

@@ -43,7 +43,7 @@ void MetricIpSamplingMultiDevFixture::SetUp() {
osInterfaceVector.push_back(mockMetricIpSamplingOsInterface);
std::unique_ptr<MetricIpSamplingOsInterface> metricIpSamplingOsInterface = std::unique_ptr<MetricIpSamplingOsInterface>(mockMetricIpSamplingOsInterface);
auto &metricSource = device->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
metricSource.metricSourceCount = platformIpMetricCountXe;
metricSource.metricCount = platformIpMetricCountXe;
metricSource.setMetricOsInterface(metricIpSamplingOsInterface);
auto &metricOaSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
@@ -64,7 +64,7 @@ void MetricIpSamplingFixture::SetUp() {
std::unique_ptr<MetricIpSamplingOsInterface> metricIpSamplingOsInterface = std::unique_ptr<MetricIpSamplingOsInterface>(mockMetricIpSamplingOsInterface);
auto &metricSource = device->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
metricSource.metricSourceCount = platformIpMetricCountXe;
metricSource.metricCount = platformIpMetricCountXe;
metricSource.setMetricOsInterface(metricIpSamplingOsInterface);
auto &metricOaSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
@@ -78,12 +78,20 @@ void MetricIpSamplingFixture::TearDown() {
globalDriverHandles->clear();
}
void MetricIpSamplingCalculateBaseFixture::initRawReports() {
MockRawDataHelper::rawElementsToRawReports(static_cast<uint32_t>(rawDataElements.size()), rawDataElements, rawReports);
rawReportsBytesSize = sizeof(rawReports[0][0]) * rawReports[0].size() * rawReports.size();
MockRawDataHelper::rawElementsToRawReports(static_cast<uint32_t>(rawDataElementsOverflow.size()), rawDataElementsOverflow, rawReportsOverflow);
rawReportsBytesSizeOverflow = sizeof(rawReportsOverflow[0][0]) * rawReportsOverflow[0].size() * rawReportsOverflow.size();
}
void MetricIpSamplingCalculateBaseFixture::initCalcDescriptor() {
zet_intel_metric_scope_properties_exp_t scopeProperties{};
scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP;
scopeProperties.pNext = nullptr;
mockMetricScope = new MockMetricScope(scopeProperties, false);
mockMetricScope = new MockMetricScope(scopeProperties, false, 0);
hMockScope = mockMetricScope->toHandle();
calculationDesc.stype = ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP;
@@ -107,6 +115,8 @@ void MetricIpSamplingCalculateBaseFixture::cleanupCalcDescriptor() {
void MetricIpSamplingCalculateMultiDevFixture::SetUp() {
MetricIpSamplingMultiDevFixture::SetUp();
initCalcDescriptor();
initRawReports();
// metricGroupHandle is expected to be set by each test for the expected device level
}
void MetricIpSamplingCalculateMultiDevFixture::TearDown() {
@@ -117,6 +127,7 @@ void MetricIpSamplingCalculateMultiDevFixture::TearDown() {
void MetricIpSamplingCalculateSingleDevFixture::SetUp() {
MetricIpSamplingFixture::SetUp();
initCalcDescriptor();
initRawReports();
device->getMetricDeviceContext().enableMetricApi();
uint32_t metricGroupCount = 1;
@@ -131,5 +142,124 @@ void MetricIpSamplingCalculateSingleDevFixture::TearDown() {
cleanupCalcDescriptor();
}
void MetricIpSamplingMetricsAggregationMultiDevFixture::initMultiRawReports() {
MockRawDataHelper::rawElementsToRawReports(static_cast<uint32_t>(rawDataElements2.size()), rawDataElements2, rawReports2);
rawReports2BytesSize = sizeof(rawReports2[0][0]) * rawReports2[0].size() * rawReports2.size();
MockRawDataHelper::rawElementsToRawReports(static_cast<uint32_t>(rawDataElementsAppend.size()), rawDataElementsAppend, rawReportsAppend);
rawReportsAppendBytesSize = sizeof(rawReportsAppend[0][0]) * rawReportsAppend[0].size() * rawReportsAppend.size();
}
void MetricIpSamplingMetricsAggregationMultiDevFixture::SetUp() {
MetricIpSamplingMultiDevFixture::SetUp();
initRawReports();
initMultiRawReports();
rootDevice = testDevices[0];
EXPECT_EQ(ZE_RESULT_SUCCESS, rootDevice->getMetricDeviceContext().enableMetricApi());
uint32_t metricGroupCount = 1;
EXPECT_EQ(zetMetricGroupGet(rootDevice->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
zet_intel_metric_calculation_exp_desc_t calculationDesc{};
calculationDesc.stype = ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP;
calculationDesc.pNext = nullptr;
calculationDesc.metricGroupCount = 1;
calculationDesc.phMetricGroups = &metricGroupHandle;
calculationDesc.metricCount = 0;
calculationDesc.phMetrics = nullptr;
calculationDesc.timeWindowsCount = 0;
calculationDesc.pCalculationTimeWindows = nullptr;
calculationDesc.timeAggregationWindow = 0;
zet_intel_metric_scope_properties_exp_t scopeProperties{};
scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP;
scopeProperties.pNext = nullptr;
scopeProperties.iD = 0; // aggregated scope
mockMetricScopeAggregated = new MockMetricScope(scopeProperties, true, 0);
hMockScopeAggregated = mockMetricScopeAggregated->toHandle();
scopeProperties.iD = 1; // compute scope for sub-device 0, since aggregated scope is present, ID is sub-device index + 1
mockMetricScopeCompute0 = new MockMetricScope(scopeProperties, false, 0);
hMockScopeCompute0 = mockMetricScopeCompute0->toHandle();
scopeProperties.iD = 2; // compute scope for sub-device 1, since aggregated scope is present, ID is sub-device index + 1
mockMetricScopeCompute1 = new MockMetricScope(scopeProperties, false, 1);
hMockScopeCompute1 = mockMetricScopeCompute1->toHandle();
hComputeMetricScopes = {hMockScopeCompute0, hMockScopeCompute1};
hAllScopes = {hMockScopeAggregated, hMockScopeCompute0, hMockScopeCompute1};
// Calculation operation for sub-device 0, compute scope 1
calculationDesc.metricScopesCount = 1;
calculationDesc.phMetricScopes = &hMockScopeCompute0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
rootDevice->toHandle(), &calculationDesc,
&hCalcOpCompScope1));
EXPECT_NE(hCalcOpCompScope1, nullptr);
hCalcOps.push_back(hCalcOpCompScope1);
// Calculation operation for sub-device 1, compute scope 2
calculationDesc.phMetricScopes = &hMockScopeCompute1;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
rootDevice->toHandle(), &calculationDesc,
&hCalcOpCompScope2));
EXPECT_NE(hCalcOpCompScope2, nullptr);
hCalcOps.push_back(hCalcOpCompScope2);
// Calculation operation for all subdevices
calculationDesc.metricScopesCount = 2;
calculationDesc.phMetricScopes = hComputeMetricScopes.data();
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
rootDevice->toHandle(), &calculationDesc,
&hCalcOpAllCompScopes));
EXPECT_NE(hCalcOpAllCompScopes, nullptr);
hCalcOps.push_back(hCalcOpAllCompScopes);
// Calculation operation for only aggregated scope
calculationDesc.metricScopesCount = 1;
calculationDesc.phMetricScopes = &hMockScopeAggregated;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
rootDevice->toHandle(), &calculationDesc,
&hCalcOpAggScope));
EXPECT_NE(hCalcOpAggScope, nullptr);
hCalcOps.push_back(hCalcOpAggScope);
// Calculation operation for all scopes aggregated and two compute
calculationDesc.metricScopesCount = 3;
calculationDesc.phMetricScopes = hAllScopes.data();
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
rootDevice->toHandle(), &calculationDesc,
&hCalcOpAllScopes));
EXPECT_NE(hCalcOpAllScopes, nullptr);
hCalcOps.push_back(hCalcOpAllScopes);
}
void MetricIpSamplingMetricsAggregationMultiDevFixture::TearDown() {
MetricIpSamplingMultiDevFixture::TearDown();
hCalcOps.clear();
rootDevice = nullptr;
delete mockMetricScopeAggregated;
mockMetricScopeAggregated = nullptr;
hMockScopeAggregated = nullptr;
delete mockMetricScopeCompute0;
mockMetricScopeCompute0 = nullptr;
hMockScopeCompute0 = nullptr;
delete mockMetricScopeCompute1;
mockMetricScopeCompute1 = nullptr;
hMockScopeCompute1 = nullptr;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalcOpCompScope1));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalcOpCompScope2));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalcOpAllCompScopes));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalcOpAggScope));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalcOpAllScopes));
}
} // namespace ult
} // namespace L0

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

@@ -6,10 +6,12 @@
*/
#pragma once
#include "shared/test/common/test_macros/hw_test.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_ip_sampling_raw_data.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h"
#include <level_zero/zet_api.h>
@@ -21,45 +23,6 @@ class MockMetricIpSamplingOsInterface;
using EustallSupportedPlatforms = IsProduct<IGFX_PVC>;
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;
}
};
constexpr uint32_t platformIpMetricCountXe = 10;
class MetricIpSamplingMultiDevFixture : public MultiDeviceFixture,
public ::testing::Test {
@@ -83,32 +46,22 @@ class MetricIpSamplingFixture : public DeviceFixture,
class MetricIpSamplingCalculateBaseFixture {
public:
void addHeader(uint8_t *rawDataOut, size_t rawDataOutSize, uint8_t *rawDataIn, size_t rawDataInSize, uint32_t setIndex) {
std::vector<MockRawDataHelper::RawReportElements> rawDataElements = {
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1000, 0x01}, // 1st raw report
{10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 1001, 0x000}, // 2nd raw report
{1, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1000, 0x02}, // 3rd raw report
{10, 90, 80, 70, 60, 50, 40, 30, 20, 10, 1000, 0x3}, // 4th raw report
{100, 190, 180, 170, 160, 150, 140, 130, 120, 110, 1000, 0x3}, // 5th raw report
{100, 20, 30, 40, 50, 60, 70, 80, 90, 100, 1000, 0x3}}; // 6th raw report
const auto expectedOutSize = sizeof(IpSamplingMetricDataHeader) + rawDataInSize;
if (expectedOutSize <= rawDataOutSize) {
auto header = reinterpret_cast<IpSamplingMetricDataHeader *>(rawDataOut);
header->magic = IpSamplingMetricDataHeader::magicValue;
header->rawDataSize = static_cast<uint32_t>(rawDataInSize);
header->setIndex = setIndex;
memcpy_s(rawDataOut + sizeof(IpSamplingMetricDataHeader), rawDataOutSize - sizeof(IpSamplingMetricDataHeader),
rawDataIn, rawDataInSize);
}
}
std::vector<MockStallRawIpData> rawDataVector = {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1000, 0x01},
{10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 1001, 0x000},
{1, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1000, 0x02},
{10, 90, 80, 70, 60, 50, 40, 30, 20, 10, 1000, 0x3},
{100, 190, 180, 170, 160, 150, 140, 130, 120, 110, 1000, 0x3},
{100, 20, 30, 40, 50, 60, 70, 80, 90, 100, 1000, 0x3}};
// Raw reports are 64Bytes, 8 x uint64_t
std::vector<std::array<uint64_t, 8>> rawReports = std::vector<std::array<uint64_t, 8>>(rawDataElements.size());
size_t rawReportsBytesSize = 0;
std::vector<std::string> expectedMetricNamesInReport = {"IP", "Active", "ControlStall", "PipeStall",
"SendStall", "DistStall", "SbidStall", "SyncStall",
"InstrFetchStall", "OtherStall"};
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}}, // 1st raw report + 3rd raw report
@@ -141,7 +94,22 @@ class MetricIpSamplingCalculateBaseFixture {
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}}};
std::vector<zet_typed_value_t> interruptedExpectedMetricValues12 = {
// Expected values when calculating only IP1 on first and third *raw* reports in rawReports
std::vector<zet_typed_value_t> expectedMetricValuesIP1 = {
{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}},
};
// Expected values when calculating only IP1 only on first *raw* reports in rawReports
std::vector<zet_typed_value_t> expectedMetricValuesIP1FirstRawReport = {
{ZET_VALUE_TYPE_UINT64, {1}},
{ZET_VALUE_TYPE_UINT64, {2}},
{ZET_VALUE_TYPE_UINT64, {4}},
@@ -151,20 +119,11 @@ class MetricIpSamplingCalculateBaseFixture {
{ZET_VALUE_TYPE_UINT64, {8}},
{ZET_VALUE_TYPE_UINT64, {9}},
{ZET_VALUE_TYPE_UINT64, {10}},
{ZET_VALUE_TYPE_UINT64, {3}}, // L0GfxCoreHelperHw arranges "OtherStall" to the end
{ZET_VALUE_TYPE_UINT64, {10}},
{ZET_VALUE_TYPE_UINT64, {20}},
{ZET_VALUE_TYPE_UINT64, {40}},
{ZET_VALUE_TYPE_UINT64, {50}},
{ZET_VALUE_TYPE_UINT64, {60}},
{ZET_VALUE_TYPE_UINT64, {70}},
{ZET_VALUE_TYPE_UINT64, {80}},
{ZET_VALUE_TYPE_UINT64, {90}},
{ZET_VALUE_TYPE_UINT64, {100}},
{ZET_VALUE_TYPE_UINT64, {30}} // L0GfxCoreHelperHw arranges "OtherStall" to the end
{ZET_VALUE_TYPE_UINT64, {3}}, // L0GfxCoreHelperHw arranges "OtherStall" metric at the end
};
std::vector<zet_typed_value_t> interruptedExpectedMetricValues3 = {
// Expected values when calculating only IP1 only on third *raw* reports in rawReports
std::vector<zet_typed_value_t> expectedMetricValuesIP1thirdRawReport = {
{ZET_VALUE_TYPE_UINT64, {1}},
{ZET_VALUE_TYPE_UINT64, {9}},
{ZET_VALUE_TYPE_UINT64, {7}},
@@ -174,22 +133,27 @@ class MetricIpSamplingCalculateBaseFixture {
{ZET_VALUE_TYPE_UINT64, {3}},
{ZET_VALUE_TYPE_UINT64, {2}},
{ZET_VALUE_TYPE_UINT64, {1}},
{ZET_VALUE_TYPE_UINT64, {8}} // L0GfxCoreHelperHw arranges "OtherStall" to the end
{ZET_VALUE_TYPE_UINT64, {8}}, // L0GfxCoreHelperHw arranges "OtherStall" metric at the end
};
std::vector<zet_typed_value_t> interruptedExpectedMetricValues456 = {
{ZET_VALUE_TYPE_UINT64, {10}}, // 4rd raw report
{ZET_VALUE_TYPE_UINT64, {90}},
{ZET_VALUE_TYPE_UINT64, {70}},
{ZET_VALUE_TYPE_UINT64, {60}},
{ZET_VALUE_TYPE_UINT64, {50}},
{ZET_VALUE_TYPE_UINT64, {40}},
{ZET_VALUE_TYPE_UINT64, {30}},
{ZET_VALUE_TYPE_UINT64, {20}},
// Expected values when calculating only IP10, which is in second and fourth *raw* reports in rawReports
std::vector<zet_typed_value_t> expectedMetricValuesIP10 = {
{ZET_VALUE_TYPE_UINT64, {10}},
{ZET_VALUE_TYPE_UINT64, {80}}, // L0GfxCoreHelperHw arranges "OtherStall" to the end
{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}},
};
// Expected values when calculating only IP100, which is in fifth and sixth *raw* reports in rawReports
std::vector<zet_typed_value_t> expectedMetricValuesIP100 = {
{ZET_VALUE_TYPE_UINT64, {100}},
{ZET_VALUE_TYPE_UINT64, {210}}, // 5th raw report + th raw report
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}},
@@ -199,12 +163,15 @@ class MetricIpSamplingCalculateBaseFixture {
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}}};
std::vector<MockStallRawIpData> rawDataVectorOverflow = {{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}};
std::vector<MockRawDataHelper::RawReportElements> rawDataElementsOverflow = {
{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}};
// Raw reports are 64Bytes, 8 x uint64_t
std::vector<std::array<uint64_t, 8>> rawReportsOverflow = std::vector<std::array<uint64_t, 8>>(rawDataElementsOverflow.size());
size_t rawReportsBytesSizeOverflow = 0;
size_t rawDataVectorOverflowSize = sizeof(rawDataVectorOverflow[0]) * rawDataVectorOverflow.size();
std::vector<zet_typed_value_t> expectedMetricOverflowValues = {
{ZET_VALUE_TYPE_UINT64, {1}},
{ZET_VALUE_TYPE_UINT64, {11}},
@@ -232,6 +199,7 @@ class MetricIpSamplingCalculateBaseFixture {
zet_intel_metric_calculation_exp_desc_t calculationDesc{};
zet_metric_group_handle_t metricGroupHandle = nullptr;
void initRawReports();
void initCalcDescriptor();
void cleanupCalcDescriptor();
};
@@ -247,5 +215,251 @@ struct MetricIpSamplingCalculateMultiDevFixture : public MetricIpSamplingCalcula
void TearDown() override;
};
struct MetricIpSamplingMetricsAggregationMultiDevFixture : public MetricIpSamplingCalculateBaseFixture, MetricIpSamplingMultiDevFixture {
public:
void SetUp() override;
void TearDown() override;
void initMultiRawReports();
L0::Device *rootDevice = nullptr;
MockMetricScope *mockMetricScopeCompute0 = nullptr;
zet_intel_metric_scope_exp_handle_t hMockScopeCompute0 = nullptr;
MockMetricScope *mockMetricScopeCompute1 = nullptr;
zet_intel_metric_scope_exp_handle_t hMockScopeCompute1 = nullptr;
MockMetricScope *mockMetricScopeAggregated = nullptr;
zet_intel_metric_scope_exp_handle_t hMockScopeAggregated = nullptr;
std::vector<zet_intel_metric_scope_exp_handle_t> hComputeMetricScopes;
std::vector<zet_intel_metric_scope_exp_handle_t> hAllScopes;
zet_intel_metric_calculation_operation_exp_handle_t hCalcOpCompScope1 = nullptr;
zet_intel_metric_calculation_operation_exp_handle_t hCalcOpCompScope2 = nullptr;
zet_intel_metric_calculation_operation_exp_handle_t hCalcOpAllCompScopes = nullptr;
zet_intel_metric_calculation_operation_exp_handle_t hCalcOpAggScope = nullptr;
zet_intel_metric_calculation_operation_exp_handle_t hCalcOpAllScopes = nullptr;
std::vector<zet_intel_metric_calculation_operation_exp_handle_t> hCalcOps;
std::vector<MockRawDataHelper::RawReportElements> rawDataElements2 = {
{2, 10, 11, 12, 13, 14, 15, 16, 17, 18, 1000, 0x01}, // 1st raw report: new IP and values
{100, 90, 91, 92, 93, 94, 95, 96, 97, 98, 1000, 0x3}, // 2nd raw report: repeated IP and new values from rawDataElements
{2, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1000, 0x02}, // 3rd raw report
{100, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1000, 0x3}}; // 4th raw report
// Raw reports are 64Bytes, 8 x uint64_t
std::vector<std::array<uint64_t, 8>> rawReports2 = std::vector<std::array<uint64_t, 8>>(rawDataElements2.size());
size_t rawReports2BytesSize = 0;
std::vector<zet_typed_value_t> expectedMetricValues2 = {
{ZET_VALUE_TYPE_UINT64, {2}},
{ZET_VALUE_TYPE_UINT64, {20}}, // 1st raw report + 3rd raw report
{ZET_VALUE_TYPE_UINT64, {20}},
{ZET_VALUE_TYPE_UINT64, {20}},
{ZET_VALUE_TYPE_UINT64, {20}},
{ZET_VALUE_TYPE_UINT64, {20}},
{ZET_VALUE_TYPE_UINT64, {20}},
{ZET_VALUE_TYPE_UINT64, {20}},
{ZET_VALUE_TYPE_UINT64, {20}},
{ZET_VALUE_TYPE_UINT64, {20}},
{ZET_VALUE_TYPE_UINT64, {100}},
{ZET_VALUE_TYPE_UINT64, {99}}, // 2nd raw report + 4th raw report
{ZET_VALUE_TYPE_UINT64, {99}},
{ZET_VALUE_TYPE_UINT64, {99}},
{ZET_VALUE_TYPE_UINT64, {99}},
{ZET_VALUE_TYPE_UINT64, {99}},
{ZET_VALUE_TYPE_UINT64, {99}},
{ZET_VALUE_TYPE_UINT64, {99}},
{ZET_VALUE_TYPE_UINT64, {99}},
{ZET_VALUE_TYPE_UINT64, {99}}};
// result types will always be ZET_VALUE_TYPE_UINT64 no need to check them always
// Report format is: 10 Metrics ComputeScope 0, 10 Metrics ComputeScope 1
std::vector<uint64_t> expectedMetricValuesCalcOpAllCompScopes = {
// --- first result report ---
1, 11, 11, 11, 11, 11, 11, 11, 11, 11, // Sub-dev 0 based on expectedMetricValues
2, 20, 20, 20, 20, 20, 20, 20, 20, 20, // sub-dev 1 based on expectedMetricValues2
// --- second result report ---
10, 110, 110, 110, 110, 110, 110, 110, 110, 110, // Sub-dev 0
100, 99, 99, 99, 99, 99, 99, 99, 99, 99, // sub-dev 1
// --- third result report ---
100, 210, 210, 210, 210, 210, 210, 210, 210, 210, // Sub-dev 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // sub-dev 1, invalid
// Report format is: 10 Metrics AggregatedScope
std::vector<uint64_t> expectedMetricValuesCalcOpAggScope = {
// --- first result report ---
1, 11, 11, 11, 11, 11, 11, 11, 11, 11, // IP1 from sub-dev 0
// --- second result report ---
2, 20, 20, 20, 20, 20, 20, 20, 20, 20, // IP2 from sub-dev 1
// --- third result report ---
10, 110, 110, 110, 110, 110, 110, 110, 110, 110, // IP10 from sub-dev 0
// --- fourth result report ---
100, 309, 309, 309, 309, 309, 309, 309, 309, 309}; // IP100 from sub-dev 0 and sub-dev 1, summed values
// Report format is: 10 Metrics AggregatedScope, 10 Metrics ComputeScope 0, 10 Metrics ComputeScope 1
std::vector<uint64_t> expectedMetricValuesCalcOpAllScopes = {
// --- first result report ---
1, 11, 11, 11, 11, 11, 11, 11, 11, 11, // IP1 aggregated. Only available in sub-dev 0
1, 11, 11, 11, 11, 11, 11, 11, 11, 11, // Sub-dev 0 based on expectedMetricValues
2, 20, 20, 20, 20, 20, 20, 20, 20, 20, // sub-dev 1 based on expectedMetricValues2
// --- second result report ---
2, 20, 20, 20, 20, 20, 20, 20, 20, 20, // IP2 aggregated. Only available in sub-dev 1
10, 110, 110, 110, 110, 110, 110, 110, 110, 110, // Sub-dev 0
100, 99, 99, 99, 99, 99, 99, 99, 99, 99, // sub-dev1
// --- third result report ---
10, 110, 110, 110, 110, 110, 110, 110, 110, 110, // IP10 from aggregated. Only available in sub-dev 0
100, 210, 210, 210, 210, 210, 210, 210, 210, 210, // Sub-dev 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // sub-dev 1, invalid (no more IPs)
// --- fourth result report ---
100, 309, 309, 309, 309, 309, 309, 309, 309, 309, // IP100 aggregated, present in both sub-devs.
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Sub-dev 0, invalid (no more IPs)
0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // Sub-dev 1, invalid (no more IPs)
std::vector<MockRawDataHelper::RawReportElements> rawDataElementsAppend = {
{3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 1000, 0x01}, // 1st raw report: new IP and values
{100, 90, 91, 92, 93, 94, 95, 96, 97, 98, 1000, 0x3}}; // 2nd raw report: repeated IP and new values from rawDataElements
// Raw reports are 64Bytes, 8 x uint64_t
std::vector<std::array<uint64_t, 8>> rawReportsAppend = std::vector<std::array<uint64_t, 8>>(rawDataElementsAppend.size());
size_t rawReportsAppendBytesSize = 0;
// Expected results for IP3 from rawDataElementsAppend
std::vector<uint64_t> expectedMetricValuesIP3 = {
3, 4, 6, 7, 8, 9, 10, 11, 12, 5};
// Expected results for IP10 and IP100 after appending rawReportsAppend to original rawReports.
// IP100 has entries in both so values are added
std::vector<uint64_t> expectedMetricValuesIP10IP100AppendToRawReports = {
10, 110, 110, 110, 110, 110, 110, 110, 110, 110,
100, 300, 302, 303, 304, 305, 306, 307, 308, 301};
// Expected results for IP100 after appending rawReportsAppend to original rawReports2.
// IP100 has entries in both so values are added
std::vector<uint64_t> expectedMetricValuesIP100AppendToRawReports2 = {
100, 189, 191, 192, 193, 194, 195, 196, 197, 190};
std::vector<uint64_t> expectedMetricValuesAppendToAllComputeScopes = {
/// --- first result report ---
10, 110, 110, 110, 110, 110, 110, 110, 110, 110, // Sub-dev 0, IP10 from original rawReports
100, 189, 191, 192, 193, 194, 195, 196, 197, 190, // Sub-dev 1, IP100 from original rawReports2 + rawReportsAppend
// --- second result report ---
100, 300, 302, 303, 304, 305, 306, 307, 308, 301, // Sub-dev 0, IP100 from original rawReports + rawReportsAppend
0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // Sub-dev 1, invalid (no more IPs)
};
std::vector<uint64_t> expectedMetricValuesAppendToAggregatedScope = {
3, 8, 12, 14, 16, 18, 20, 22, 24, 10, // IP3 from rawReportsAppend *2 since was appended in both sub-devs
10, 110, 110, 110, 110, 110, 110, 110, 110, 110, // IP10 from original rawReports
100, 489, 493, 495, 497, 499, 501, 503, 505, 491 // IP100 from rawReports + rawReports2 + appended * 2 since was appended in both sub-devs
};
// In aggregated scope all results will be valid. Expect three IPs: IP3, IP10, IP100
// Sub-dev 0 has two IPs: IP10, IP100. So third report results will be invalid.
// Sub-dev 1 has one IP: IP100. So, second and third report results will be invalid.
std::vector<zet_intel_metric_result_exp_t> expectedMetricResultsAfterAppendForAllScopes = {
// --- first result report ---
// * Aggregated Scope, IP 3 aggregated from both sub-devices
{{3}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{8}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{12}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{14}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{16}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{18}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{20}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{22}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{24}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{10}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
// * Compute Scope 1, IP 10 from rawReports
{{10}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{110}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{110}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{110}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{110}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{110}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{110}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{110}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{110}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{110}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
// * Compute Scope 2, IP 100 from rawReports2 + rawReportsAppend
{{100}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{189}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{191}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{192}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{193}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{194}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{195}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{196}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{197}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{190}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
// --- second result report ---
// * Aggregated scope, IP10 from rawReports
{{10}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{110}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{110}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{110}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{110}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{110}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{110}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{110}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{110}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{110}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
// * Compute Scope 1, IP100 from rawReports + rawReportsAppend
{{100}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{300}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{302}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{303}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{304}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{305}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{306}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{307}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{308}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{301}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
// * Compute Scope 2, invalid (no more IPs)
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
// --- third result report ---
// * Aggregated scope, IP100 from rawReports + rawReports2 + appended from both sub-devs
{{100}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{489}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{493}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{495}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{497}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{499}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{501}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{503}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{505}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
{{491}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID},
// * Compute Scope 1, invalid (no more IPs)
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
// * Compute Scope 2, invalid (no more IPs)
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID},
{{0}, ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID}};
};
} // namespace ult
} // namespace L0

98
level_zero/tools/test/unit_tests/sources/metrics/mock_ip_sampling_raw_data.h Normal file
View File

@@ -0,0 +1,98 @@
/*
* Copyright (C) 2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
namespace L0 {
namespace ult {
class MockRawDataHelper {
public:
MockRawDataHelper() = default;
~MockRawDataHelper() = default;
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;
struct RawReportElements {
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;
};
static void rawElementsToRawReports(uint32_t reportCount, std::vector<RawReportElements> inputElements, std::vector<std::array<uint64_t, 8>> &rawReports) {
for (uint32_t i = 0; i < reportCount; i++) {
rawReports[i][0] = (inputElements[i].ip & ipMask) |
((inputElements[i].activeCount & byteMask) << ipShift) |
((inputElements[i].otherCount & byteMask) << (ipShift + byteShift)) |
((inputElements[i].controlCount & byteMask) << (ipShift + 2 * byteShift)) |
((inputElements[i].pipeStallCount & byteMask) << (ipShift + 3 * byteShift)) |
((inputElements[i].sendCount & 0x7) << (ipShift + 4 * byteShift));
rawReports[i][1] = ((inputElements[i].sendCount & 0xf8) >> 3) |
((inputElements[i].distAccCount & byteMask) << 5) |
((inputElements[i].sbidCount & byteMask) << (5 + byteShift)) |
((inputElements[i].syncCount & byteMask) << (5 + 2 * byteShift)) |
((inputElements[i].instFetchCount & byteMask) << (5 + 3 * byteShift));
rawReports[i][2] = 0LL;
rawReports[i][3] = 0LL;
rawReports[i][4] = 0LL;
rawReports[i][5] = 0LL;
rawReports[i][6] = (inputElements[i].subSlice & wordMask) | ((inputElements[i].flags & wordMask) << wordShift);
rawReports[i][7] = 0;
}
}
static void rawReportsToRawElements(uint32_t reportCount, const std::vector<std::array<uint64_t, 8>> &rawReports, std::vector<RawReportElements> &outputElements) {
outputElements.resize(reportCount);
for (uint32_t i = 0; i < reportCount; i++) {
outputElements[i].ip = rawReports[i][0] & ipMask;
outputElements[i].activeCount = (rawReports[i][0] >> ipShift) & byteMask;
outputElements[i].otherCount = (rawReports[i][0] >> (ipShift + byteShift)) & byteMask;
outputElements[i].controlCount = (rawReports[i][0] >> (ipShift + 2 * byteShift)) & byteMask;
outputElements[i].pipeStallCount = (rawReports[i][0] >> (ipShift + 3 * byteShift)) & byteMask;
outputElements[i].sendCount = ((rawReports[i][0] >> (ipShift + 4 * byteShift)) & 0x7) |
((rawReports[i][1] & 0x1f) << 3);
outputElements[i].distAccCount = (rawReports[i][1] >> 5) & byteMask;
outputElements[i].sbidCount = (rawReports[i][1] >> (5 + byteShift)) & byteMask;
outputElements[i].syncCount = (rawReports[i][1] >> (5 + 2 * byteShift)) & byteMask;
outputElements[i].instFetchCount = (rawReports[i][1] >> (5 + 3 * byteShift)) & byteMask;
outputElements[i].subSlice = rawReports[i][6] & wordMask;
outputElements[i].flags = (rawReports[i][6] >> wordShift) & wordMask;
}
}
static void addMultiSubDevHeader(uint8_t *rawDataOut, size_t rawDataOutSize, uint8_t *rawDataIn, size_t rawDataInSize, uint32_t setIndex) {
const auto expectedOutSize = sizeof(IpSamplingMultiDevDataHeader) + rawDataInSize;
if (expectedOutSize <= rawDataOutSize) {
auto header = reinterpret_cast<IpSamplingMultiDevDataHeader *>(rawDataOut);
header->magic = IpSamplingMultiDevDataHeader::magicValue;
header->rawDataSize = static_cast<uint32_t>(rawDataInSize);
header->setIndex = setIndex;
memcpy_s(rawDataOut + sizeof(IpSamplingMultiDevDataHeader), rawDataOutSize - sizeof(IpSamplingMultiDevDataHeader),
rawDataIn, rawDataInSize);
}
}
};
} // namespace ult
} // namespace L0

28
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h
View File

@@ -117,25 +117,33 @@ class MockMetricSource : public L0::MetricSource {
bool canDisable() override { return false; }
void initMetricScopes(MetricDeviceContext &metricDeviceContext) override {
for (auto index = 0u; index < static_cast<uint32_t>(testMetricScopeNames.size()); index++) {
metricDeviceContext.addMetricScope(testMetricScopeNames[index].first, testMetricScopeNames[index].second);
for (auto index = 0u; index < static_cast<uint32_t>(testMetricScopes.size()); index++) {
metricDeviceContext.addMetricScope(testMetricScopes[index].name,
testMetricScopes[index].description,
testMetricScopes[index].computeSubDeviceIndex);
}
initComputeMetricScopes(metricDeviceContext);
}
void addTestMetricScope(const std::string &name, const std::string &description) {
testMetricScopeNames.emplace_back(name, description);
void addTestMetricScope(const std::string &name, const std::string &description, uint32_t computeSubDeviceIndex) {
testMetricScopes.emplace_back(TestMetricScope{name, description, computeSubDeviceIndex});
}
void removeTestMetricScope(const std::string &name) {
testMetricScopeNames.erase(std::remove_if(testMetricScopeNames.begin(), testMetricScopeNames.end(),
[&name](const auto &pair) { return pair.first == name; }),
testMetricScopeNames.end());
testMetricScopes.erase(std::remove_if(testMetricScopes.begin(), testMetricScopes.end(),
[&name](const TestMetricScope &scope) { return scope.name == name; }),
testMetricScopes.end());
}
uint32_t enableCallCount = 0;
bool isAvailableReturn = false;
std::vector<std::pair<std::string, std::string>> testMetricScopeNames{};
struct TestMetricScope {
std::string name;
std::string description;
uint32_t computeSubDeviceIndex = 0;
};
std::vector<TestMetricScope> testMetricScopes{};
};
class MockMetricGroup : public L0::MetricGroupImp {
@@ -234,8 +242,8 @@ class MockMetricDeviceContext : public MetricDeviceContext {
class MockMetricScope : public MetricScopeImp {
public:
~MockMetricScope() override = default;
MockMetricScope(zet_intel_metric_scope_properties_exp_t &properties, bool aggregated)
: MetricScopeImp(properties, aggregated) {}
MockMetricScope(zet_intel_metric_scope_properties_exp_t &properties, bool aggregated, uint32_t computeSubDeviceIndex)
: MetricScopeImp(properties, aggregated, computeSubDeviceIndex) {}
ze_result_t getProperties(zet_intel_metric_scope_properties_exp_t *pProperties) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}

28
level_zero/tools/test/unit_tests/sources/metrics/test_metric.cpp
View File

@@ -69,7 +69,7 @@ void CalcOperationFixture::SetUp() {
scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP;
scopeProperties.pNext = nullptr;
mockMetricScope = new MockMetricScope(scopeProperties, false);
mockMetricScope = new MockMetricScope(scopeProperties, false, 0);
hMetricScope = mockMetricScope->toHandle();
}
@@ -254,6 +254,30 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedHierarchiesThenErrorIsRe
&hCalculationOperation));
}
TEST_F(CalcOperationFixture, WhenCreatingCalcSubDeviceOnlyAcceptsOneScope) {
std::vector<zet_intel_metric_scope_exp_handle_t> metricScopes{hMetricScope, hMetricScope};
zet_intel_metric_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
nullptr, // pNext
1, // metricGroupCount
&hMetricGroup, // phMetricGroups
0, // metricCount
nullptr, // phMetrics
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
1000, // timeAggregationWindow
2, // metricScopesCount
metricScopes.data(), // phMetricScopes
};
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculationOperationCreateExp(context,
device->toHandle(), &calculationDesc,
&hCalculationOperation));
}
TEST_F(CalcOperationFixture, WhenCreatingCalcOpUseTheSourceFromMetricGroupOrMetricWhenAvailable) {
MockMetricGroup mockMetricGroup2(mockMetricSource);
@@ -443,7 +467,7 @@ TEST_F(MetricScopesMultiDeviceFixture, MetricScopeObjectToAndFromHandleBaseClass
scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP;
scopeProperties.pNext = nullptr;
MockMetricScope mockMetricScope(scopeProperties, false);
MockMetricScope mockMetricScope(scopeProperties, false, 0);
auto hMockScope = mockMetricScope.toHandle();
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricScopeGetPropertiesExp(hMockScope,

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

@@ -577,8 +577,6 @@ using MetricIpSamplingCalculateMetricsTest = MetricIpSamplingCalculateMultiDevFi
HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMultipleMetricValuesExpIsCalledThenValidDataIsReturned, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
std::vector<zet_typed_value_t> metricValues(30);
for (auto device : testDevices) {
bool isRootdevice = true;
@@ -603,30 +601,37 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader));
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
// Simulate data from two tiles
std::vector<uint8_t> rawDataWithHeader((rawReportsBytesSize + sizeof(IpSamplingMultiDevDataHeader)) * 2);
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 0);
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data() + sizeof(IpSamplingMultiDevDataHeader) + rawReportsBytesSize,
rawDataWithHeader.size() - sizeof(IpSamplingMultiDevDataHeader) - rawReportsBytesSize,
reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 1);
uint32_t setCount = 0;
// Use random initializer
uint32_t totalMetricValueCount = std::numeric_limits<uint32_t>::max();
std::vector<uint32_t> metricCounts(2);
EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0],
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataWithHeader.data()),
&setCount, &totalMetricValueCount, metricCounts.data(), nullptr),
&setCount, &totalMetricValueCount, nullptr, nullptr),
expectedResult);
if (isRootdevice) {
EXPECT_EQ(setCount, 2u);
EXPECT_EQ(totalMetricValueCount, 30u); // Three IPs plus nine metrics per IP
EXPECT_EQ(totalMetricValueCount, 60u); // Three IPs plus nine metrics per IP for two sub-devices
std::vector<zet_typed_value_t> metricValues(totalMetricValueCount);
std::vector<uint32_t> metricCounts(setCount);
EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0],
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataWithHeader.data()),
&setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()),
ZE_RESULT_SUCCESS);
EXPECT_EQ(setCount, 2u);
EXPECT_EQ(totalMetricValueCount, 30u);
EXPECT_EQ(totalMetricValueCount, 60u);
EXPECT_EQ(metricCounts[0], 30u);
EXPECT_EQ(metricCounts[1], 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);
EXPECT_TRUE(expectedMetricValues[i % expectedMetricValues.size()].type == metricValues[i].type);
EXPECT_TRUE(expectedMetricValues[i % expectedMetricValues.size()].value.ui64 == metricValues[i].value.ui64);
}
}
}
@@ -635,7 +640,6 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMultipleMetricValuesExpIsCalledWithInvalidHeaderThenErrorIsReturned, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
std::vector<zet_typed_value_t> metricValues(30);
auto device = testDevices[0]; // Root device data (rawDataWithHeader) makes sense only for calculating with root device mg handle.
uint32_t metricGroupCount = 0;
@@ -648,26 +652,23 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader));
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
auto header = reinterpret_cast<IpSamplingMetricDataHeader *>(rawDataWithHeader.data());
header->magic = IpSamplingMetricDataHeader::magicValue - 1;
std::vector<uint8_t> rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMultiDevDataHeader));
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 0);
auto header = reinterpret_cast<IpSamplingMultiDevDataHeader *>(rawDataWithHeader.data());
header->magic = IpSamplingMultiDevDataHeader::magicValue - 1;
uint32_t setCount = 0;
// Use random initializer
uint32_t totalMetricValueCount = std::numeric_limits<uint32_t>::max();
std::vector<uint32_t> metricCounts(2);
EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0],
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataWithHeader.data()),
&setCount, &totalMetricValueCount, metricCounts.data(), nullptr),
&setCount, &totalMetricValueCount, nullptr, nullptr),
ZE_RESULT_ERROR_INVALID_ARGUMENT);
}
HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMultipleMetricValuesExpIsCalledWithDataFromSingleDeviceThenValidDataIsReturned, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
std::vector<zet_typed_value_t> metricValues(30);
for (auto device : testDevices) {
ze_device_properties_t props = {};
@@ -687,15 +688,17 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
uint32_t setCount = 0;
// Use random initializer
uint32_t totalMetricValueCount = std::numeric_limits<uint32_t>::max();
std::vector<uint32_t> metricCounts(1);
EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0],
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
&setCount, &totalMetricValueCount, metricCounts.data(), nullptr),
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()),
&setCount, &totalMetricValueCount, nullptr, nullptr),
ZE_RESULT_SUCCESS);
EXPECT_EQ(setCount, 1u);
EXPECT_EQ(totalMetricValueCount, 30u);
std::vector<uint32_t> metricCounts(setCount);
std::vector<zet_typed_value_t> metricValues(totalMetricValueCount);
EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0],
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()),
&setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()),
ZE_RESULT_SUCCESS);
EXPECT_EQ(setCount, 1u);
@@ -712,8 +715,6 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMultipleMetricValuesExpIsCalledWithDataFromSingleDeviceAndInvalidRawDataThenErrorIsReturned, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
std::vector<zet_typed_value_t> metricValues(30);
for (auto device : testDevices) {
ze_device_properties_t props = {};
device->getProperties(&props);
@@ -730,11 +731,10 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
uint32_t setCount = 0;
uint32_t totalMetricValueCount = std::numeric_limits<uint32_t>::max();
std::vector<uint32_t> metricCounts(1);
EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0],
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, 1,
reinterpret_cast<uint8_t *>(rawDataVector.data()),
&setCount, &totalMetricValueCount, metricCounts.data(), nullptr),
reinterpret_cast<uint8_t *>(rawReports.data()),
&setCount, &totalMetricValueCount, nullptr, nullptr),
ZE_RESULT_ERROR_INVALID_SIZE);
}
}
@@ -757,11 +757,11 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
// Allocate for 2 reads
std::vector<uint8_t> rawDataWithHeader((rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)) * 2);
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 1);
addHeader(rawDataWithHeader.data() + rawDataVectorSize + sizeof(IpSamplingMetricDataHeader),
rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
// Allocate for 2 sub-devices
std::vector<uint8_t> rawDataWithHeader((rawReportsBytesSize + sizeof(IpSamplingMultiDevDataHeader)) * 2);
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 0);
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data() + rawReportsBytesSize + sizeof(IpSamplingMultiDevDataHeader),
rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 1);
// Use random initializer
uint32_t setCount = std::numeric_limits<uint32_t>::max();
@@ -806,15 +806,14 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader) + 1);
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
std::vector<uint8_t> rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMultiDevDataHeader) + 1);
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 0);
uint32_t setCount = 0;
uint32_t totalMetricValueCount = 0;
std::vector<uint32_t> metricCounts(2);
EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0],
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size() + 1, reinterpret_cast<uint8_t *>(rawDataWithHeader.data()),
&setCount, &totalMetricValueCount, metricCounts.data(), nullptr),
&setCount, &totalMetricValueCount, nullptr, nullptr),
ZE_RESULT_ERROR_INVALID_ARGUMENT);
}
}
@@ -839,11 +838,11 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, WhenCalculateMultipleMetricValue
std::vector<uint8_t> 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<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
rawData.resize(rawReportsBytesSize + sizeof(IpSamplingMultiDevDataHeader));
MockRawDataHelper::addMultiSubDevHeader(rawData.data(), rawData.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 0);
} else {
rawData.resize(rawDataVectorSize);
memcpy_s(rawData.data(), rawData.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize);
rawData.resize(rawReportsBytesSize);
memcpy_s(rawData.data(), rawData.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize);
}
uint32_t setCount = 0;
@@ -856,8 +855,8 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, WhenCalculateMultipleMetricValue
// Force incorrect raw data size
size_t rawDatSize = rawData.size();
if (isRootdevice) {
auto header = reinterpret_cast<IpSamplingMetricDataHeader *>(rawData.data());
header->rawDataSize = static_cast<uint32_t>(rawDataVectorSize - 1);
auto header = reinterpret_cast<IpSamplingMultiDevDataHeader *>(rawData.data());
header->rawDataSize = static_cast<uint32_t>(rawReportsBytesSize - 1);
} else {
rawDatSize = rawData.size() - 1;
}
@@ -885,8 +884,8 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, WhenCalculateMultipleMetricValue
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader) + 1);
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize - 1, 0);
std::vector<uint8_t> rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMultiDevDataHeader) + 1);
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize - 1, 0);
uint32_t setCount = 0;
uint32_t totalMetricValueCount = 0;
@@ -913,8 +912,8 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, WhenCalculateMultipleMetricValue
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader) + 1);
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize - 1, 0);
std::vector<uint8_t> rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMultiDevDataHeader) + 1);
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize - 1, 0);
uint32_t setCount = 0;
uint32_t totalMetricValueCount = 10;
@@ -943,8 +942,8 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader));
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
std::vector<uint8_t> rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMultiDevDataHeader));
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 0);
uint32_t setCount = 0;
uint32_t totalMetricValueCount = 0;
@@ -976,7 +975,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
device->getProperties(&props);
if (!(props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE)) {
// Sub-device data (rawDataVector) will work only with sub-device metric group handle.
// Sub-device data (rawReports) 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;
@@ -994,11 +993,11 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
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),
rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()), &metricValueCount, nullptr),
expectedResult);
if (!isRootdevice) {
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()), &metricValueCount, metricValues.data()),
rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()), &metricValueCount, metricValues.data()),
expectedResult);
EXPECT_TRUE(metricValueCount == 30);
@@ -1027,8 +1026,8 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader));
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
std::vector<uint8_t> rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMultiDevDataHeader));
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 0);
uint32_t metricValueCount = 0;
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataWithHeader.data()),
@@ -1046,7 +1045,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
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.
if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { // Sub-device data (rawReports) will work only with sub-device metric group handle.
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
std::vector<zet_metric_group_handle_t> metricGroups;
@@ -1059,13 +1058,13 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
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),
rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.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<uint8_t *>(rawDataVector.data()), &metricValueCount, metricValues.data()),
rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()), &metricValueCount, metricValues.data()),
ZE_RESULT_SUCCESS);
EXPECT_TRUE(metricValueCount == 15);
for (uint32_t i = 0; i < metricValueCount; i++) {
@@ -1083,7 +1082,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWith
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.
if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { // Sub-device data (rawReports) will work only with sub-device metric group handle.
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
std::vector<zet_metric_group_handle_t> metricGroups;
@@ -1096,7 +1095,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWith
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),
rawReportsBytesSize - 1, reinterpret_cast<uint8_t *>(rawReports.data()), &metricValueCount, nullptr),
ZE_RESULT_ERROR_INVALID_SIZE);
}
}
@@ -1111,7 +1110,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
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.
if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { // Sub-device data (rawReports) will work only with sub-device metric group handle.
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
@@ -1125,12 +1124,12 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
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),
rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.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<uint8_t *>(rawDataVector.data()), &metricValueCount, metricValues.data()),
rawReportsBytesSize - 1, reinterpret_cast<uint8_t *>(rawReports.data()), &metricValueCount, metricValues.data()),
ZE_RESULT_ERROR_INVALID_SIZE);
}
}
@@ -1158,11 +1157,11 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenDataOverflowOccurredWhenStr
std::vector<uint8_t> 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<uint8_t *>(rawDataVectorOverflow.data()), rawDataVectorOverflowSize, 0);
rawData.resize(rawReportsBytesSizeOverflow + sizeof(IpSamplingMultiDevDataHeader));
MockRawDataHelper::addMultiSubDevHeader(rawData.data(), rawData.size(), reinterpret_cast<uint8_t *>(rawReportsOverflow.data()), rawReportsBytesSizeOverflow, 0);
} else {
rawData.resize(rawDataVectorOverflowSize);
memcpy_s(rawData.data(), rawData.size(), reinterpret_cast<uint8_t *>(rawDataVectorOverflow.data()), rawDataVectorOverflowSize);
rawData.resize(rawReportsBytesSizeOverflow);
memcpy_s(rawData.data(), rawData.size(), reinterpret_cast<uint8_t *>(rawReportsOverflow.data()), rawReportsBytesSizeOverflow);
}
uint32_t setCount = 0;
@@ -1199,7 +1198,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWith
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.
if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { // Sub-device data (rawReports) will work only with sub-device metric group handle.
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
@@ -1213,12 +1212,12 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWith
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),
rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.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<uint8_t *>(rawDataVector.data()), &metricValueCount, metricValues.data()),
rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()), &metricValueCount, metricValues.data()),
ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
}

323
level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer.cpp → level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer_1.cpp
View File

@@ -5,20 +5,9 @@
*
*/
#include "shared/test/common/test_macros/test_base.h"
#include "level_zero/core/source/cmdlist/cmdlist.h"
#include "level_zero/core/source/device/device.h"
#include "level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
#include "level_zero/tools/source/metrics/metric_ip_sampling_streamer.h"
#include "level_zero/tools/source/metrics/metric_oa_source.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_ip_sampling.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h"
#include <level_zero/zet_api.h>
namespace L0 {
extern _ze_driver_handle_t *globalDriverHandle;
@@ -474,19 +463,19 @@ TEST_F(MetricIpSamplingStreamerTest, GivenAllInputsAreCorrectWhenReadDataIsCalle
std::vector<uint8_t> rawData = {};
rawData.resize(rawSize);
EXPECT_EQ(zetMetricStreamerReadData(streamerHandle, 75, &rawSize, rawData.data()), ZE_RESULT_SUCCESS);
EXPECT_EQ(rawSize, osInterfaceVector[1]->fillDataSize + osInterfaceVector[2]->fillDataSize + sizeof(IpSamplingMetricDataHeader) * 2u);
auto header = reinterpret_cast<IpSamplingMetricDataHeader *>(rawData.data());
EXPECT_EQ(header->magic, IpSamplingMetricDataHeader::magicValue);
EXPECT_EQ(rawSize, osInterfaceVector[1]->fillDataSize + osInterfaceVector[2]->fillDataSize + sizeof(IpSamplingMultiDevDataHeader) * 2u);
auto header = reinterpret_cast<IpSamplingMultiDevDataHeader *>(rawData.data());
EXPECT_EQ(header->magic, IpSamplingMultiDevDataHeader::magicValue);
EXPECT_EQ(header->rawDataSize, osInterfaceVector[1]->fillDataSize);
EXPECT_EQ(header->setIndex, 0u);
const auto subDeviceDataOffset = sizeof(IpSamplingMetricDataHeader) + osInterfaceVector[1]->fillDataSize;
header = reinterpret_cast<IpSamplingMetricDataHeader *>(rawData.data() + subDeviceDataOffset);
EXPECT_EQ(header->magic, IpSamplingMetricDataHeader::magicValue);
const auto subDeviceDataOffset = sizeof(IpSamplingMultiDevDataHeader) + osInterfaceVector[1]->fillDataSize;
header = reinterpret_cast<IpSamplingMultiDevDataHeader *>(rawData.data() + subDeviceDataOffset);
EXPECT_EQ(header->magic, IpSamplingMultiDevDataHeader::magicValue);
EXPECT_EQ(header->rawDataSize, osInterfaceVector[2]->fillDataSize);
EXPECT_EQ(header->setIndex, 1u);
const auto rawDataStartOffset = sizeof(IpSamplingMetricDataHeader);
const auto rawDataStartOffset = sizeof(IpSamplingMultiDevDataHeader);
EXPECT_EQ(rawData[rawDataStartOffset], 2u);
EXPECT_EQ(rawData[rawDataStartOffset + osInterfaceVector[1]->fillDataSize - 1], 2u);
EXPECT_EQ(rawData[subDeviceDataOffset + rawDataStartOffset], 4u);
@@ -549,12 +538,12 @@ TEST_F(MetricIpSamplingStreamerTest, GivenNotEnoughMemoryWhileReadingWhenReadDat
EXPECT_EQ(zetMetricStreamerReadData(streamerHandle, 75, &rawSize, rawData.data()), ZE_RESULT_SUCCESS);
// Expect less than the fillDataSize, since Header size needs to be accounted for
EXPECT_LT(rawSize, osInterfaceVector[1]->fillDataSize);
const auto rawDataStartOffset = sizeof(IpSamplingMetricDataHeader);
const auto rawDataStartOffset = sizeof(IpSamplingMultiDevDataHeader);
EXPECT_EQ(rawData[rawDataStartOffset + 0], 2u);
const auto maxReportCount = (osInterfaceVector[1]->fillDataSize -
sizeof(IpSamplingMetricDataHeader) * 2) /
sizeof(IpSamplingMultiDevDataHeader) * 2) /
osInterfaceVector[1]->getUnitReportSize();
const auto firstSubDevicelastUpdatedByteOffset = sizeof(IpSamplingMetricDataHeader) + maxReportCount * osInterfaceVector[1]->getUnitReportSize();
const auto firstSubDevicelastUpdatedByteOffset = sizeof(IpSamplingMultiDevDataHeader) + maxReportCount * osInterfaceVector[1]->getUnitReportSize();
EXPECT_EQ(rawData[firstSubDevicelastUpdatedByteOffset - 1], 2u);
EXPECT_NE(rawData[firstSubDevicelastUpdatedByteOffset], 2u);
EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_SUCCESS);
@@ -609,7 +598,7 @@ TEST_F(MetricIpSamplingMetricSupportedScopeTest, givenMetricWhenGettingSupported
scopeProperties.pNext = nullptr;
std::vector<zet_intel_metric_scope_exp_handle_t> metricScopesHandles;
MockMetricScope *mockMetricScope = new MockMetricScope(scopeProperties, false);
MockMetricScope *mockMetricScope = new MockMetricScope(scopeProperties, false, 0);
metricScopesHandles.push_back(mockMetricScope->toHandle());
auto metricImp = static_cast<MockMetricImp *>(Metric::fromHandle(phMetric));
@@ -649,6 +638,7 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingMetricGroupThenCrea
calculationDesc.phMetrics = nullptr;
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
&hCalculationOperation));
@@ -771,7 +761,6 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpGetReportForm
for (auto device : testDevices) {
uint32_t metricGroupCount = 1;
zet_metric_group_handle_t metricGroupHandle = nullptr;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
@@ -834,23 +823,22 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingMultiScopeCalcOpGet
// Make compute scope be first in the scopes input array to calculationDesc
scopeProperties.iD = 1;
MockMetricScope *mockMetricScope1 = new MockMetricScope(scopeProperties, false);
MockMetricScope *mockMetricScope1 = new MockMetricScope(scopeProperties, false, 0);
metricScopesHandles.push_back(mockMetricScope1->toHandle());
// Make aggregated scope be second
scopeProperties.iD = 0;
MockMetricScope *mockMetricScope2 = new MockMetricScope(scopeProperties, true);
MockMetricScope *mockMetricScope2 = new MockMetricScope(scopeProperties, true, 0);
metricScopesHandles.push_back(mockMetricScope2->toHandle());
auto device = testDevices[0];
auto rootDevice = testDevices[0];
ze_device_properties_t props = {};
device->getProperties(&props);
rootDevice->getProperties(&props);
EXPECT_EQ(props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE, 0u);
EXPECT_EQ(ZE_RESULT_SUCCESS, device->getMetricDeviceContext().enableMetricApi());
EXPECT_EQ(ZE_RESULT_SUCCESS, rootDevice->getMetricDeviceContext().enableMetricApi());
uint32_t metricGroupCount = 1;
zet_metric_group_handle_t metricGroupHandle = nullptr;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetMetricGroupGet(rootDevice->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
@@ -862,7 +850,7 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingMultiScopeCalcOpGet
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
rootDevice->toHandle(), &calculationDesc,
&hCalculationOperation));
uint32_t metricsInReportCount = 0;
@@ -899,6 +887,52 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingMultiScopeCalcOpGet
delete mockMetricScope2;
}
HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, GivenIpSamplingRootDeviceCalcOpCalculationDoesNotAcceptSubDeviceData, EustallSupportedPlatforms) {
zet_intel_metric_scope_properties_exp_t scopeProperties{};
scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP;
scopeProperties.pNext = nullptr;
zet_intel_metric_scope_exp_handle_t hMetricScope;
scopeProperties.iD = 0;
MockMetricScope *mockMetricScope = new MockMetricScope(scopeProperties, true, 0);
hMetricScope = mockMetricScope->toHandle();
auto rootDevice = testDevices[0];
ze_device_properties_t props = {};
rootDevice->getProperties(&props);
EXPECT_EQ(props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE, 0u);
EXPECT_EQ(ZE_RESULT_SUCCESS, rootDevice->getMetricDeviceContext().enableMetricApi());
uint32_t metricGroupCount = 1;
EXPECT_EQ(zetMetricGroupGet(rootDevice->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
calculationDesc.metricGroupCount = 1;
calculationDesc.phMetricGroups = &metricGroupHandle;
calculationDesc.metricScopesCount = 1;
calculationDesc.phMetricScopes = &hMetricScope;
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
rootDevice->toHandle(), &calculationDesc,
&hCalculationOperation));
uint32_t totalMetricReportCount = 0;
bool final = true;
size_t usedSize = 0;
// root device cal op does not accept sub device data
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawReports.size(), reinterpret_cast<uint8_t *>(rawReports.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
delete mockMetricScope;
}
HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpCanGetExcludedMetricsAreZero, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
@@ -958,232 +992,5 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, WhenReadingMetricGroupTimeCalculat
EXPECT_EQ(metricGroupCalcProps.isTimeFilterSupported, false);
}
}
HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnRootDeviceExpectSuccess, EustallSupportedPlatforms) {
auto device = testDevices[0];
ze_device_properties_t props = {};
device->getProperties(&props);
EXPECT_EQ(props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE, 0u);
EXPECT_EQ(ZE_RESULT_SUCCESS, device->getMetricDeviceContext().enableMetricApi());
uint32_t metricGroupCount = 1;
zet_metric_group_handle_t metricGroupHandle = nullptr;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
calculationDesc.metricGroupCount = 1;
calculationDesc.phMetricGroups = &metricGroupHandle;
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
&hCalculationOperation));
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader));
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
uint32_t totalMetricReportCount = 0;
bool final = true;
size_t usedSize = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculateValuesExp(rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataWithHeader.data()),
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
}
using MetricIpSamplingCalcOpTest = MetricIpSamplingCalculateSingleDevFixture;
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDeviceThenSuccessIsReturned, EustallSupportedPlatforms) {
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
&hCalculationOperation));
uint32_t metricsInReportCount = 10;
std::vector<zet_metric_handle_t> metricsInReport(metricsInReportCount);
std::vector<zet_intel_metric_scope_exp_handle_t> metricScopesInReport(metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationGetReportFormatExp(hCalculationOperation,
&metricsInReportCount,
metricsInReport.data(),
metricScopesInReport.data()));
EXPECT_EQ(metricsInReportCount, 10u);
std::vector<zet_metric_properties_t> metricProperties(metricsInReportCount);
for (uint32_t i = 0; i < metricsInReportCount; i++) {
EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGetProperties(metricsInReport[i], &metricProperties[i]));
}
uint32_t totalMetricReportCount = 0;
bool final = true;
size_t usedSize = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 3U);
std::vector<zet_intel_metric_result_exp_t> metricResults(totalMetricReportCount * metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 3U);
EXPECT_EQ(usedSize, rawDataVectorSize);
for (uint32_t i = 0; i < totalMetricReportCount; i++) {
for (uint32_t j = 0; j < metricsInReportCount; j++) {
uint32_t resultIndex = i * metricsInReportCount + j;
EXPECT_TRUE(metricProperties[j].resultType == expectedMetricValues[resultIndex].type);
EXPECT_TRUE(metricResults[resultIndex].value.ui64 == expectedMetricValues[resultIndex].value.ui64);
EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID);
}
}
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
}
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDeviceThenHandleErrorConditions, EustallSupportedPlatforms) {
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
&hCalculationOperation));
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader));
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
uint32_t totalMetricReportCount = 0;
bool final = true;
size_t usedSize = 0;
// sub-device cal op does not accept root device data
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataWithHeader.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, nullptr));
// invalid input raw data size
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_SIZE, zetIntelMetricCalculateValuesExp(rawDataVectorSize / 30, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
}
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDeviceCanDetectRawDataOverflow, EustallSupportedPlatforms) {
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
&hCalculationOperation));
uint32_t totalMetricReportCount = 2;
bool final = true;
size_t usedSize = 0;
std::vector<zet_intel_metric_result_exp_t> metricResults(totalMetricReportCount * 10);
EXPECT_EQ(ZE_RESULT_WARNING_DROPPED_DATA, zetIntelMetricCalculateValuesExp(rawDataVectorOverflowSize, reinterpret_cast<uint8_t *>(rawDataVectorOverflow.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 2U);
EXPECT_EQ(usedSize, rawDataVectorOverflowSize);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
}
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDeviceFilterMetricsInReport, EustallSupportedPlatforms) {
uint32_t metricCount = 0;
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricCount, 10u);
std::vector<zet_metric_handle_t> phMetrics(metricCount);
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, phMetrics.data()), ZE_RESULT_SUCCESS);
std::vector<zet_metric_handle_t> metricsToCalculate;
// Select only odd index metrics. According to expectedMetricNamesInReport there are:
// "Active", "PipeStall" "DistStall", "SyncStall", "OtherStall"
for (uint32_t i = 0; i < metricCount; i++) {
if (i % 2) {
metricsToCalculate.push_back(phMetrics[i]);
}
}
uint32_t metricsToCalculateCount = static_cast<uint32_t>(metricsToCalculate.size());
EXPECT_EQ(metricsToCalculateCount, 5u);
calculationDesc.metricGroupCount = 0;
calculationDesc.phMetricGroups = nullptr;
calculationDesc.metricCount = metricsToCalculateCount;
calculationDesc.phMetrics = metricsToCalculate.data();
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
&hCalculationOperation));
uint32_t metricsInReportCount = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationGetReportFormatExp(hCalculationOperation, &metricsInReportCount, nullptr, nullptr));
EXPECT_EQ(metricsInReportCount, 5u);
uint32_t totalMetricReportCount = 0;
bool final = true;
size_t usedSize = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, nullptr));
std::vector<zet_intel_metric_result_exp_t> metricResults(totalMetricReportCount * metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 3U);
EXPECT_EQ(usedSize, rawDataVectorSize);
// Expect only odd index metrics results of the first report
for (uint32_t j = 0; j < metricsInReportCount; j++) {
EXPECT_TRUE(metricResults[j].value.ui64 == expectedMetricValues[j * 2 + 1].value.ui64);
}
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
}
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesDoesNotAllowLimitingResults, EustallSupportedPlatforms) {
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
&hCalculationOperation));
uint32_t totalMetricReportCount = 0;
bool final = true;
size_t usedSize = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 3U);
// Request fewer reports
totalMetricReportCount = 1;
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
}
} // namespace ult
} // namespace L0

1016
level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer_2.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

2
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp
View File

@@ -3694,7 +3694,7 @@ TEST_F(MetricEnumerationTest, givenValidOAMetricGroupThenOASourceCalcOperationIs
scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP;
scopeProperties.pNext = nullptr;
MockMetricScope mockMetricScope(scopeProperties, false);
MockMetricScope mockMetricScope(scopeProperties, false, 0);
auto hMockScope = mockMetricScope.toHandle();
// metric groups from different source