intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-04 07:14:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

feature(sysman): support v2 engine busyness counters

Browse Source 
Updating related uapi header from v2.0-rc22

Related-To: NEO-8554

Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>
This commit is contained in:
Joshua Santosh Ranjan
2023-12-08 12:50:40 +00:00
committed by Compute-Runtime-Automation
parent 607832a8e6
commit 591c70e81e
7 changed files with 251 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
level_zero/tools/test/unit_tests/sources/sysman/engine/linux/mock_engine_prelim.h
View File

@@ -21,7 +21,6 @@ namespace ult {
constexpr int64_t mockPmuFd = 10;
constexpr uint64_t mockTimestamp = 87654321;
constexpr uint64_t mockActiveTime = 987654321;
const uint32_t microSecondsToNanoSeconds = 1000u;
constexpr uint16_t invalidEngineClass = UINT16_MAX;
const std::string deviceDir("device");
constexpr uint32_t numberOfMockedEnginesForSingleTileDevice = 7u;
@@ -106,10 +105,13 @@ struct MockEnginePmuInterfaceImp : public PmuInterfaceImp {
bool mockPmuRead = false;
bool mockPerfEventOpenRead = false;
uint32_t mockPerfEventOpenFailAtCount = 1;
int64_t perfEventOpen(perf_event_attr *attr, pid_t pid, int cpu, int groupFd, uint64_t flags) override {
if (mockPerfEventOpenRead == true) {
mockPerfEventOpenFailAtCount = std::max(mockPerfEventOpenFailAtCount - 1, 1u);
const bool shouldCheckForError = (mockPerfEventOpenFailAtCount == 1);
if (shouldCheckForError && mockPerfEventOpenRead == true) {
return mockedPerfEventOpenAndFailureReturn(attr, pid, cpu, groupFd, flags);
}
@@ -122,12 +124,18 @@ struct MockEnginePmuInterfaceImp : public PmuInterfaceImp {
int pmuRead(int fd, uint64_t *data, ssize_t sizeOfdata) override {
if (fd < 0) {
return -1;
}
if (mockPmuRead == true) {
return mockedPmuReadAndFailureReturn(fd, data, sizeOfdata);
}
data[0] = mockActiveTime;
data[1] = mockTimestamp;
data[2] = mockActiveTime;
data[3] = mockTimestamp;
return 0;
}
@@ -160,6 +168,7 @@ struct MockEngineSysfsAccess : public SysfsAccess {
bool mockReadSymLinkFailure = false;
bool mockReadSymLinkSuccess = false;
uint32_t mockReadVal = 0;
ze_result_t readSymLink(const std::string file, std::string &val) override {
@@ -180,6 +189,7 @@ struct MockEngineSysfsAccess : public SysfsAccess {
val = "/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/0000:03:00.0";
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
@@ -187,6 +197,11 @@ struct MockEngineSysfsAccess : public SysfsAccess {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t read(const std::string file, uint32_t &val) override {
val = mockReadVal;
return ZE_RESULT_SUCCESS;
}
MockEngineSysfsAccess() = default;
};
} // namespace ult

94
level_zero/tools/test/unit_tests/sources/sysman/engine/linux/test_zes_engine_prelim.cpp
View File

@@ -184,8 +184,8 @@ TEST_F(ZesEngineFixture, GivenValidEngineHandleAndIntegratedDeviceWhenCallingZes
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesEngineGetActivity(handle, &stats));
EXPECT_EQ(mockActiveTime / microSecondsToNanoSeconds, stats.activeTime);
EXPECT_EQ(mockTimestamp / microSecondsToNanoSeconds, stats.timestamp);
EXPECT_EQ(mockActiveTime, stats.activeTime);
EXPECT_EQ(mockTimestamp, stats.timestamp);
}
}
@@ -200,11 +200,97 @@ TEST_F(ZesEngineFixture, GivenValidEngineHandleAndDiscreteDeviceWhenCallingZesEn
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesEngineGetActivity(handle, &stats));
EXPECT_EQ(mockActiveTime / microSecondsToNanoSeconds, stats.activeTime);
EXPECT_EQ(mockTimestamp / microSecondsToNanoSeconds, stats.timestamp);
EXPECT_EQ(mockActiveTime, stats.activeTime);
EXPECT_EQ(mockTimestamp, stats.timestamp);
}
}
TEST_F(ZesEngineFixture, GivenValidEngineHandleAndDiscreteDeviceWhenCallingZesEngineGetActivityExtThenVerifyCallReturnsSuccess) {
auto pMemoryManagerTest = std::make_unique<MockMemoryManagerInEngineSysman>(*neoDevice->getExecutionEnvironment());
pMemoryManagerTest->localMemorySupported[0] = true;
device->getDriverHandle()->setMemoryManager(pMemoryManagerTest.get());
pSysfsAccess->mockReadVal = 2;
pSysfsAccess->mockReadSymLinkSuccess = true;
pSysmanDeviceImp->pEngineHandleContext->handleList.clear();
pSysmanDeviceImp->pEngineHandleContext->init(deviceHandles);
auto handles = getEngineHandles(handleComponentCount);
EXPECT_EQ(handleComponentCount, handles.size());
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesEngineGetActivityExt(handle, &count, nullptr));
EXPECT_EQ(count, pSysfsAccess->mockReadVal + 1);
std::vector<zes_engine_stats_t> engineStats(count);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesEngineGetActivityExt(handle, &count, engineStats.data()));
for (auto &stat : engineStats) {
EXPECT_EQ(mockActiveTime, stat.activeTime);
EXPECT_EQ(mockTimestamp, stat.timestamp);
}
}
}
TEST_F(ZesEngineFixture, GivenDiscreteDeviceWithNoVfsWhenCallingZesEngineGetActivityExtThenReturnFailure) {
auto pMemoryManagerTest = std::make_unique<MockMemoryManagerInEngineSysman>(*neoDevice->getExecutionEnvironment());
pMemoryManagerTest->localMemorySupported[0] = true;
device->getDriverHandle()->setMemoryManager(pMemoryManagerTest.get());
pSysfsAccess->mockReadVal = 0;
pSysfsAccess->mockReadSymLinkSuccess = true;
pSysmanDeviceImp->pEngineHandleContext->handleList.clear();
pSysmanDeviceImp->pEngineHandleContext->init(deviceHandles);
auto handles = getEngineHandles(handleComponentCount);
EXPECT_EQ(handleComponentCount, handles.size());
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesEngineGetActivityExt(handle, &count, nullptr));
}
}
TEST_F(ZesEngineFixture, GivenDiscreteDeviceWithValidVfsWhenPmuReadingFailsWhenCallingZesEngineGetActivityExtThenReturnFailure) {
auto pMemoryManagerTest = std::make_unique<MockMemoryManagerInEngineSysman>(*neoDevice->getExecutionEnvironment());
pMemoryManagerTest->localMemorySupported[0] = true;
device->getDriverHandle()->setMemoryManager(pMemoryManagerTest.get());
pSysfsAccess->mockReadVal = 2;
pSysfsAccess->mockReadSymLinkSuccess = true;
pPmuInterface->mockPmuRead = true;
pSysmanDeviceImp->pEngineHandleContext->handleList.clear();
pSysmanDeviceImp->pEngineHandleContext->init(deviceHandles);
auto handles = getEngineHandles(handleComponentCount);
EXPECT_EQ(handleComponentCount, handles.size());
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesEngineGetActivityExt(handle, &count, nullptr));
EXPECT_EQ(count, pSysfsAccess->mockReadVal + 1);
std::vector<zes_engine_stats_t> engineStats(count);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesEngineGetActivityExt(handle, &count, engineStats.data()));
}
}
TEST_F(ZesEngineFixture, GivenDiscreteDeviceWithOneInvalidVfWhenCallingZesEngineGetActivityExtThenReturnFailure) {
auto pMemoryManagerTest = std::make_unique<MockMemoryManagerInEngineSysman>(*neoDevice->getExecutionEnvironment());
pMemoryManagerTest->localMemorySupported[0] = true;
device->getDriverHandle()->setMemoryManager(pMemoryManagerTest.get());
pSysfsAccess->mockReadVal = 1;
pSysfsAccess->mockReadSymLinkSuccess = true;
pPmuInterface->mockPerfEventOpenRead = true;
pPmuInterface->mockPerfEventOpenFailAtCount = 4;
pSysmanDeviceImp->pEngineHandleContext->handleList.clear();
pSysmanDeviceImp->pEngineHandleContext->init(deviceHandles);
auto handles = getEngineHandles(handleComponentCount);
EXPECT_EQ(handleComponentCount, handles.size());
auto handle = handles[0];
ASSERT_NE(nullptr, handle);
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesEngineGetActivityExt(handle, &count, nullptr));
EXPECT_EQ(count, pSysfsAccess->mockReadVal + 1);
std::vector<zes_engine_stats_t> engineStats(count);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, zesEngineGetActivityExt(handle, &count, engineStats.data()));
}
TEST_F(ZesEngineFixture, GivenTestDiscreteDevicesAndValidEngineHandleWhenCallingZesEngineGetActivityAndPMUGetEventTypeFailsThenVerifyEngineGetActivityReturnsFailure) {
auto pMemoryManagerTest = std::make_unique<MockMemoryManagerInEngineSysman>(*neoDevice->getExecutionEnvironment());
pMemoryManagerTest->localMemorySupported[0] = true;