intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-11 16:45:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

feature: Add Support for 64 bit aggregated read/write counters

Browse Source 
Related-To: LOCI-4529

Signed-off-by: Mayank Raghuwanshi <mayank.raghuwanshi@intel.com>
This commit is contained in:
Mayank Raghuwanshi
2023-06-16 08:13:52 +00:00
committed by Compute-Runtime-Automation
parent b840c169c7
commit d02885767d
5 changed files with 422 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
level_zero/tools/test/unit_tests/sources/sysman/memory/linux/mock_memory_prelim.h
View File

@@ -20,6 +20,14 @@
using namespace NEO;
constexpr uint32_t VF0HbmLRead = 16;
constexpr uint32_t VF0HbmHRead = 2;
constexpr uint32_t VF0HbmLWrite = 8;
constexpr uint32_t VF0HbmHWrite = 2;
constexpr uint32_t VF1HbmLRead = 16;
constexpr uint32_t VF1HbmHRead = 2;
constexpr uint32_t VF1HbmLWrite = 8;
constexpr uint32_t VF1HbmHWrite = 2;
constexpr uint16_t vF0VfidIndex = 88;
constexpr uint16_t vF0Hbm0ReadIndex = 92;
constexpr uint16_t vF0Hbm0WriteIndex = 96;
@@ -299,6 +307,14 @@ struct MockMemoryPmt : public PlatformMonitoringTech {
val = vF0Hbm3ReadValue;
} else if (key.compare("VF0_HBM3_WRITE") == 0) {
val = vF0Hbm3WriteValue;
} else if (key.compare("VF0_HBM_READ_L") == 0) {
val = VF0HbmLRead;
} else if (key.compare("VF0_HBM_READ_H") == 0) {
val = VF0HbmHRead;
} else if (key.compare("VF0_HBM_WRITE_L") == 0) {
val = VF0HbmLWrite;
} else if (key.compare("VF0_HBM_WRITE_H") == 0) {
val = VF0HbmHWrite;
} else {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
@@ -330,6 +346,14 @@ struct MockMemoryPmt : public PlatformMonitoringTech {
val = vF1Hbm3ReadValue;
} else if (key.compare("VF1_HBM3_WRITE") == 0) {
val = vF1Hbm3WriteValue;
} else if (key.compare("VF1_HBM_READ_L") == 0) {
val = VF1HbmLRead;
} else if (key.compare("VF1_HBM_READ_H") == 0) {
val = VF1HbmHRead;
} else if (key.compare("VF1_HBM_WRITE_L") == 0) {
val = VF1HbmLWrite;
} else if (key.compare("VF1_HBM_WRITE_H") == 0) {
val = VF1HbmHWrite;
} else {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}

270
level_zero/tools/test/unit_tests/sources/sysman/memory/linux/test_sysman_memory_prelim.cpp
View File

@@ -396,6 +396,274 @@ HWTEST2_F(SysmanDeviceMemoryFixture, GivenValidMemoryHandleWhenCallingzesSysmanM
setLocalSupportedAndReinit(true);
auto handles = getMemoryHandles(memoryHandleComponentCount);
for (auto &handle : handles) {
zes_mem_bandwidth_t bandwidth{};
uint64_t expectedReadCounters = 0, expectedWriteCounters = 0;
uint64_t expectedBandwidth = 0;
zes_mem_properties_t properties = {ZES_STRUCTURE_TYPE_MEM_PROPERTIES};
zesMemoryGetProperties(handle, &properties);
auto hwInfo = pLinuxSysmanImp->getDeviceHandle()->getNEODevice()->getRootDeviceEnvironment().getMutableHardwareInfo();
auto &productHelper = pLinuxSysmanImp->getDeviceHandle()->getNEODevice()->getProductHelper();
hwInfo->platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_B, *hwInfo);
auto pPmt = static_cast<MockMemoryPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId));
pPmt->mockVfid0Status = true;
pSysfsAccess->mockReadUInt64Value.push_back(hbmRP0Frequency);
pSysfsAccess->mockReadReturnStatus.push_back(ZE_RESULT_SUCCESS);
EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_SUCCESS);
expectedReadCounters |= VF0HbmHRead;
expectedReadCounters = (expectedReadCounters << 32) | VF0HbmLRead;
expectedReadCounters = expectedReadCounters * transactionSize;
EXPECT_EQ(bandwidth.readCounter, expectedReadCounters);
expectedWriteCounters |= VF0HbmHWrite;
expectedWriteCounters = (expectedWriteCounters << 32) | VF0HbmLWrite;
expectedWriteCounters = expectedWriteCounters * transactionSize;
EXPECT_EQ(bandwidth.writeCounter, expectedWriteCounters);
expectedBandwidth = 128 * hbmRP0Frequency * 1000 * 1000 * 4;
EXPECT_EQ(bandwidth.maxBandwidth, expectedBandwidth);
}
}
HWTEST2_F(SysmanDeviceMemoryFixture, GivenValidMemoryHandleWhenCallingzesSysmanMemoryGetBandwidthWhenVFID1IsActiveThenSuccessIsReturnedAndBandwidthIsValid, IsPVC) {
setLocalSupportedAndReinit(true);
auto handles = getMemoryHandles(memoryHandleComponentCount);
for (auto &handle : handles) {
zes_mem_bandwidth_t bandwidth{};
uint64_t expectedReadCounters = 0, expectedWriteCounters = 0;
uint64_t expectedBandwidth = 0;
zes_mem_properties_t properties = {ZES_STRUCTURE_TYPE_MEM_PROPERTIES};
zesMemoryGetProperties(handle, &properties);
auto hwInfo = pLinuxSysmanImp->getDeviceHandle()->getNEODevice()->getRootDeviceEnvironment().getMutableHardwareInfo();
auto &productHelper = pLinuxSysmanImp->getDeviceHandle()->getNEODevice()->getProductHelper();
hwInfo->platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_B, *hwInfo);
auto pPmt = static_cast<MockMemoryPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId));
pPmt->mockVfid1Status = true;
pSysfsAccess->mockReadUInt64Value.push_back(hbmRP0Frequency);
pSysfsAccess->mockReadReturnStatus.push_back(ZE_RESULT_SUCCESS);
EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_SUCCESS);
expectedReadCounters |= VF0HbmHRead;
expectedReadCounters = (expectedReadCounters << 32) | VF0HbmLRead;
expectedReadCounters = expectedReadCounters * transactionSize;
EXPECT_EQ(bandwidth.readCounter, expectedReadCounters);
expectedWriteCounters |= VF0HbmHWrite;
expectedWriteCounters = (expectedWriteCounters << 32) | VF0HbmLWrite;
expectedWriteCounters = expectedWriteCounters * transactionSize;
EXPECT_EQ(bandwidth.writeCounter, expectedWriteCounters);
expectedBandwidth = 128 * hbmRP0Frequency * 1000 * 1000 * 4;
EXPECT_EQ(bandwidth.maxBandwidth, expectedBandwidth);
}
}
HWTEST2_F(SysmanDeviceMemoryFixture, GivenValidMemoryHandleWhenCallingzesSysmanMemoryGetBandwidthAndVF0_HBM_READ_LFailsThenFailureIsReturned, IsPVC) {
setLocalSupportedAndReinit(true);
auto handles = getMemoryHandles(memoryHandleComponentCount);
for (auto &handle : handles) {
zes_mem_properties_t properties = {};
zesMemoryGetProperties(handle, &properties);
zes_mem_bandwidth_t bandwidth;
auto pPmt = static_cast<MockMemoryPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId));
pPmt->mockReadArgumentValue.push_back(1);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); // Return success after reading VF0_VFID
pPmt->mockReadArgumentValue.push_back(0);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); // Return success after reading VF1_VFID
pPmt->mockReadArgumentValue.push_back(2);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
}
HWTEST2_F(SysmanDeviceMemoryFixture, GivenValidMemoryHandleWhenCallingzesSysmanMemoryGetBandwidthAndVF0_HBM_READ_HFailsThenFailureIsReturned, IsPVC) {
setLocalSupportedAndReinit(true);
auto handles = getMemoryHandles(memoryHandleComponentCount);
for (auto &handle : handles) {
zes_mem_properties_t properties = {};
zesMemoryGetProperties(handle, &properties);
zes_mem_bandwidth_t bandwidth;
auto pPmt = static_cast<MockMemoryPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId));
pPmt->mockReadArgumentValue.push_back(1);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); // Return success after reading VF0_VFID
pPmt->mockReadArgumentValue.push_back(0);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); // Return success after reading VF1_VFID
pPmt->mockReadArgumentValue.push_back(4);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS);
pPmt->mockReadArgumentValue.push_back(2);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
}
HWTEST2_F(SysmanDeviceMemoryFixture, GivenValidMemoryHandleWhenCallingzesSysmanMemoryGetBandwidthAndVF0_HBM_WRITE_LFailsThenFailureIsReturned, IsPVC) {
setLocalSupportedAndReinit(true);
auto handles = getMemoryHandles(memoryHandleComponentCount);
for (auto &handle : handles) {
zes_mem_properties_t properties = {};
zesMemoryGetProperties(handle, &properties);
zes_mem_bandwidth_t bandwidth;
auto pPmt = static_cast<MockMemoryPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId));
pPmt->mockReadArgumentValue.push_back(1);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); // Return success after reading VF0_VFID
pPmt->mockReadArgumentValue.push_back(0);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); // Return success after reading VF1_VFID
pPmt->mockReadArgumentValue.push_back(4);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS);
pPmt->mockReadArgumentValue.push_back(4);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS);
pPmt->mockReadArgumentValue.push_back(2);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
}
HWTEST2_F(SysmanDeviceMemoryFixture, GivenValidMemoryHandleWhenCallingzesSysmanMemoryGetBandwidthAndVF0_HBM_WRITE_HFailsThenFailureIsReturned, IsPVC) {
setLocalSupportedAndReinit(true);
auto handles = getMemoryHandles(memoryHandleComponentCount);
for (auto &handle : handles) {
zes_mem_properties_t properties = {};
zesMemoryGetProperties(handle, &properties);
zes_mem_bandwidth_t bandwidth;
auto pPmt = static_cast<MockMemoryPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId));
pPmt->mockReadArgumentValue.push_back(1);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); // Return success after reading VF0_VFID
pPmt->mockReadArgumentValue.push_back(0);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); // Return success after reading VF1_VFID
pPmt->mockReadArgumentValue.push_back(4);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS);
pPmt->mockReadArgumentValue.push_back(4);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS);
pPmt->mockReadArgumentValue.push_back(4);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS);
pPmt->mockReadArgumentValue.push_back(2);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
}
TEST_F(SysmanDeviceMemoryFixture, GivenValidMemoryHandleWhenCallingzesSysmanMemoryGetBandwidthWhenVFID0IsActiveThenSuccessIsReturnedAndBandwidthIsValid) {
setLocalSupportedAndReinit(true);
auto hwInfo = *NEO::defaultHwInfo.get();
hwInfo.platform.eProductFamily = IGFX_XE_HP_SDV;
pLinuxSysmanImp->getDeviceHandle()->getNEODevice()->getRootDeviceEnvironmentRef().setHwInfoAndInitHelpers(&hwInfo);
auto handles = getMemoryHandles(memoryHandleComponentCount);
for (auto &handle : handles) {
zes_mem_bandwidth_t bandwidth{};
uint64_t expectedReadCounters = 0, expectedWriteCounters = 0;
uint64_t expectedTimestamp = 0;
zes_mem_properties_t properties = {ZES_STRUCTURE_TYPE_MEM_PROPERTIES};
zesMemoryGetProperties(handle, &properties);
auto hwInfo = pLinuxSysmanImp->getDeviceHandle()->getNEODevice()->getRootDeviceEnvironment().getMutableHardwareInfo();
auto &productHelper = pLinuxSysmanImp->getDeviceHandle()->getNEODevice()->getProductHelper();
hwInfo->platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_B, *hwInfo);
auto pPmt = static_cast<MockMemoryPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId));
pPmt->mockVfid0Status = true;
pSysfsAccess->mockReadUInt64Value.push_back(hbmRP0Frequency);
pSysfsAccess->mockReadReturnStatus.push_back(ZE_RESULT_SUCCESS);
EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_SUCCESS);
expectedReadCounters = vF0Hbm0ReadValue + vF0Hbm1ReadValue;
EXPECT_EQ(bandwidth.readCounter, expectedReadCounters);
expectedWriteCounters = vF0Hbm0WriteValue + vF0Hbm1WriteValue;
EXPECT_EQ(bandwidth.writeCounter, expectedWriteCounters);
expectedTimestamp |= vF0TimestampHValue;
expectedTimestamp = (expectedTimestamp << 32) | vF0TimestampLValue;
EXPECT_EQ(bandwidth.timestamp, expectedTimestamp);
}
}
TEST_F(SysmanDeviceMemoryFixture, GivenValidMemoryHandleWhenCallingzesSysmanMemoryGetBandwidthAndVF0_VFIDFailsThenFailureIsReturned) {
setLocalSupportedAndReinit(true);
auto hwInfo = *NEO::defaultHwInfo.get();
hwInfo.platform.eProductFamily = IGFX_XE_HP_SDV;
pLinuxSysmanImp->getDeviceHandle()->getNEODevice()->getRootDeviceEnvironmentRef().setHwInfoAndInitHelpers(&hwInfo);
auto handles = getMemoryHandles(memoryHandleComponentCount);
for (auto &handle : handles) {
zes_mem_properties_t properties = {};
zesMemoryGetProperties(handle, &properties);
zes_mem_bandwidth_t bandwidth;
auto pPmt = static_cast<MockMemoryPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId));
pPmt->mockReadArgumentValue.push_back(2);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
}
TEST_F(SysmanDeviceMemoryFixture, GivenValidMemoryHandleWhenCallingzesSysmanMemoryGetBandwidthAndVF0_HBM_READFailsThenFailureIsReturned) {
setLocalSupportedAndReinit(true);
auto hwInfo = *NEO::defaultHwInfo.get();
hwInfo.platform.eProductFamily = IGFX_XE_HP_SDV;
pLinuxSysmanImp->getDeviceHandle()->getNEODevice()->getRootDeviceEnvironmentRef().setHwInfoAndInitHelpers(&hwInfo);
auto handles = getMemoryHandles(memoryHandleComponentCount);
for (auto &handle : handles) {
zes_mem_properties_t properties = {};
zesMemoryGetProperties(handle, &properties);
zes_mem_bandwidth_t bandwidth;
auto pPmt = static_cast<MockMemoryPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId));
pPmt->mockReadArgumentValue.push_back(1);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS);
pPmt->mockReadArgumentValue.push_back(0);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS);
pPmt->mockReadArgumentValue.push_back(4);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
}
TEST_F(SysmanDeviceMemoryFixture, GivenValidMemoryHandleWhenCallingzesSysmanMemoryGetBandwidthAndVF0_HBM_WRITEFailsThenFailureIsReturned) {
setLocalSupportedAndReinit(true);
auto hwInfo = *NEO::defaultHwInfo.get();
hwInfo.platform.eProductFamily = IGFX_XE_HP_SDV;
pLinuxSysmanImp->getDeviceHandle()->getNEODevice()->getRootDeviceEnvironmentRef().setHwInfoAndInitHelpers(&hwInfo);
auto handles = getMemoryHandles(memoryHandleComponentCount);
for (auto &handle : handles) {
zes_mem_properties_t properties = {};
zesMemoryGetProperties(handle, &properties);
zes_mem_bandwidth_t bandwidth;
auto pPmt = static_cast<MockMemoryPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId));
pPmt->mockReadArgumentValue.push_back(1);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); // Return success after reading VF0_VFID
pPmt->mockReadArgumentValue.push_back(0);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); // Return success after reading VF1_VFID
pPmt->mockReadArgumentValue.push_back(4);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS);
pPmt->mockReadArgumentValue.push_back(4);
pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
}
HWTEST2_F(SysmanDeviceMemoryFixture, GivenValidMemoryHandleWhenCallingzesSysmanMemoryGetBandwidthWhenVFID0IsActiveThenSuccessIsReturnedAndBandwidthIsValid, IsXEHP) {
setLocalSupportedAndReinit(true);
auto handles = getMemoryHandles(memoryHandleComponentCount);
for (auto &handle : handles) {
zes_mem_bandwidth_t bandwidth{};
uint64_t expectedReadCounters = 0, expectedWriteCounters = 0;
@@ -426,7 +694,7 @@ HWTEST2_F(SysmanDeviceMemoryFixture, GivenValidMemoryHandleWhenCallingzesSysmanM
}
}
HWTEST2_F(SysmanDeviceMemoryFixture, GivenValidMemoryHandleWhenCallingzesSysmanMemoryGetBandwidthWhenVFID1IsActiveThenSuccessIsReturnedAndBandwidthIsValid, IsPVC) {
HWTEST2_F(SysmanDeviceMemoryFixture, GivenValidMemoryHandleWhenCallingzesSysmanMemoryGetBandwidthWhenVFID1IsActiveThenSuccessIsReturnedAndBandwidthIsValid, IsXEHP) {
setLocalSupportedAndReinit(true);
auto handles = getMemoryHandles(memoryHandleComponentCount);