intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-06 02:18:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix: Revert spec 1.5 RAS changes from Sysman

Browse Source 
Related-To: LOCI-4351

Signed-off-by: Mayank Raghuwanshi <mayank.raghuwanshi@intel.com>
This commit is contained in:
Mayank Raghuwanshi
2023-04-26 18:43:48 +00:00
committed by Compute-Runtime-Automation
parent 364c2da9fb
commit 9cc5763800
36 changed files with 36 additions and 1050 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
level_zero/api/sysman/ze_sysman_loader.cpp
View File

@@ -205,7 +205,6 @@ zesGetFabricPortProcAddrTable(
pDdiTable->pfnSetConfig = L0::zesFabricPortSetConfig;
pDdiTable->pfnGetState = L0::zesFabricPortGetState;
pDdiTable->pfnGetThroughput = L0::zesFabricPortGetThroughput;
pDdiTable->pfnGetFabricErrorCounters = L0::zesFabricPortGetFabricErrorCounters;
return result;
}

14
level_zero/api/sysman/zes_sysman_api_entrypoints.h
View File

@@ -1042,12 +1042,6 @@ ze_result_t zesOverclockSetVFPointValues(
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t zesFabricPortGetFabricErrorCounters(
zes_fabric_port_handle_t hPort,
zes_fabric_port_error_counters_t *pErrors) {
return L0::FabricPort::fromHandle(hPort)->fabricPortGetErrorCounters(pErrors);
}
ze_result_t zesDeviceSetOverclockWaiver(
zes_device_handle_t hDevice) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
@@ -2124,14 +2118,6 @@ ZE_APIEXPORT ze_result_t ZE_APICALL zesOverclockSetVFPointValues(
pointValue);
}
ZE_APIEXPORT ze_result_t ZE_APICALL zesFabricPortGetFabricErrorCounters(
zes_fabric_port_handle_t hPort,
zes_fabric_port_error_counters_t *pErrors) {
return L0::zesFabricPortGetFabricErrorCounters(
hPort,
pErrors);
}
ZE_APIEXPORT ze_result_t ZE_APICALL zesInit(
zes_init_flags_t flags) {
return L0::zesInit(

1
level_zero/sysman/source/fabric_port/fabric_port.h
View File

@@ -37,7 +37,6 @@ class FabricPort : _zes_fabric_port_handle_t {
virtual ze_result_t fabricPortSetConfig(const zes_fabric_port_config_t *pConfig) = 0;
virtual ze_result_t fabricPortGetState(zes_fabric_port_state_t *pState) = 0;
virtual ze_result_t fabricPortGetThroughput(zes_fabric_port_throughput_t *pThroughput) = 0;
virtual ze_result_t fabricPortGetErrorCounters(zes_fabric_port_error_counters_t *pErrors) = 0;
inline zes_fabric_port_handle_t toZesHandle() { return this; }

4
level_zero/sysman/source/fabric_port/fabric_port_imp.cpp
View File

@@ -54,10 +54,6 @@ ze_result_t FabricPortImp::fabricPortGetState(zes_fabric_port_state_t *pState) {
return pOsFabricPort->getState(pState);
}
ze_result_t FabricPortImp::fabricPortGetErrorCounters(zes_fabric_port_error_counters_t *pErrors) {
return pOsFabricPort->getErrorCounters(pErrors);
}
ze_result_t FabricPortImp::fabricPortGetThroughput(zes_fabric_port_throughput_t *pThroughput) {
fabricPortGetTimestamp(pThroughput->timestamp);
return pOsFabricPort->getThroughput(pThroughput);

1
level_zero/sysman/source/fabric_port/fabric_port_imp.h
View File

@@ -36,7 +36,6 @@ class FabricPortImp : public FabricPort, NEO::NonCopyableOrMovableClass {
ze_result_t fabricPortSetConfig(const zes_fabric_port_config_t *pConfig) override;
ze_result_t fabricPortGetState(zes_fabric_port_state_t *pState) override;
ze_result_t fabricPortGetThroughput(zes_fabric_port_throughput_t *pThroughput) override;
ze_result_t fabricPortGetErrorCounters(zes_fabric_port_error_counters_t *pErrors) override;
FabricPortImp() = delete;
FabricPortImp(FabricDevice *pFabricDevice, uint32_t portNum);

4
level_zero/sysman/source/fabric_port/linux/os_fabric_port_imp.cpp
View File

@@ -57,10 +57,6 @@ ze_result_t LinuxFabricPortImp::getThroughput(zes_fabric_port_throughput_t *pThr
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFabricPortImp::getErrorCounters(zes_fabric_port_error_counters_t *pErrors) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFabricPortImp::getProperties(zes_fabric_port_properties_t *pProperties) {
::snprintf(pProperties->model, ZES_MAX_FABRIC_PORT_MODEL_SIZE, "%s", this->model.c_str());
pProperties->onSubdevice = false;

1
level_zero/sysman/source/fabric_port/linux/os_fabric_port_imp.h
View File

@@ -35,7 +35,6 @@ class LinuxFabricPortImp : public OsFabricPort, NEO::NonCopyableOrMovableClass {
ze_result_t setConfig(const zes_fabric_port_config_t *pConfig) override;
ze_result_t getState(zes_fabric_port_state_t *pState) override;
ze_result_t getThroughput(zes_fabric_port_throughput_t *pThroughput) override;
ze_result_t getErrorCounters(zes_fabric_port_error_counters_t *pErrors) override;
LinuxFabricPortImp() = delete;
LinuxFabricPortImp(OsFabricDevice *pOsFabricDevice, uint32_t portNum);

76
level_zero/sysman/source/fabric_port/linux/os_fabric_port_imp_prelim.cpp
View File

@@ -40,78 +40,6 @@ ze_result_t LinuxFabricDeviceImp::getThroughput(const zes_fabric_port_id_t portI
return pFabricDeviceAccess->getThroughput(portId, *pThroughput);
}
ze_result_t LinuxFabricDeviceImp::getErrorCounters(const zes_fabric_port_id_t portId, zes_fabric_port_error_counters_t *pErrors) {
FsAccess *pFsAccess = &pLinuxSysmanImp->getFsAccess();
SysfsAccess *pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
std::string devicePciPath("");
ze_result_t result = pSysfsAccess->getRealPath("device/", devicePciPath);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to get device path> <result: 0x%x>\n", __func__, result);
return result;
}
std::string path("");
std::vector<std::string> list;
result = pFsAccess->listDirectory(devicePciPath, list);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to get list of files in device directory> <result: 0x%x>\n", __func__, result);
return result;
}
for (auto entry : list) {
if ((entry.find("i915.iaf.") != std::string::npos) ||
(entry.find("iaf.") != std::string::npos)) {
path = devicePciPath + "/" + entry;
break;
}
}
if (path.empty()) {
// This device does not have a fabric
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <Device does not have fabric>\n", __func__);
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
std::string fabricFwErrorPath = path + "/sd." + std::to_string(portId.attachId);
std::string fabricLinkErrorPath = path + "/sd." + std::to_string(portId.attachId) + "/port." + std::to_string(portId.portNumber);
uint64_t linkErrorCount = 0;
std::string linkFailureFile = fabricLinkErrorPath + "/link_failures";
result = pFsAccess->read(linkFailureFile, linkErrorCount);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, linkFailureFile.c_str(), result);
linkErrorCount = 0;
}
uint64_t linkDegradeCount = 0;
std::string linkDegradeFile = fabricLinkErrorPath + "/link_degrades";
result = pFsAccess->read(linkDegradeFile, linkDegradeCount);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, linkDegradeFile.c_str(), result);
linkDegradeCount = 0;
}
uint64_t fwErrorCount = 0;
std::string fwErrorFile = fabricFwErrorPath + "/fw_error";
result = pFsAccess->read(fwErrorFile, fwErrorCount);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, fwErrorFile.c_str(), result);
fwErrorCount = 0;
}
uint64_t fwCommErrorCount = 0;
std::string fwCommErrorFile = fabricFwErrorPath + "/fw_comm_errors";
result = pFsAccess->read(fwCommErrorFile, fwCommErrorCount);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, fwCommErrorFile.c_str(), result);
fwCommErrorCount = 0;
}
pErrors->linkFailureCount = linkErrorCount;
pErrors->linkDegradeCount = linkDegradeCount;
pErrors->fwErrorCount = fwErrorCount;
pErrors->fwCommErrorCount = fwCommErrorCount;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFabricDeviceImp::performSweep() {
uint32_t start = 0U;
uint32_t end = 0U;
@@ -283,10 +211,6 @@ ze_result_t LinuxFabricPortImp::getThroughput(zes_fabric_port_throughput_t *pThr
return pLinuxFabricDeviceImp->getThroughput(portId, pThroughput);
}
ze_result_t LinuxFabricPortImp::getErrorCounters(zes_fabric_port_error_counters_t *pErrors) {
return pLinuxFabricDeviceImp->getErrorCounters(portId, pErrors);
}
ze_result_t LinuxFabricPortImp::getProperties(zes_fabric_port_properties_t *pProperties) {
::snprintf(pProperties->model, ZES_MAX_FABRIC_PORT_MODEL_SIZE, "%s", this->model.c_str());
pProperties->onSubdevice = this->onSubdevice;

2
level_zero/sysman/source/fabric_port/linux/os_fabric_port_imp_prelim.h
View File

@@ -30,7 +30,6 @@ class LinuxFabricDeviceImp : public OsFabricDevice, NEO::NonCopyableOrMovableCla
ze_result_t disablePortBeaconing(const zes_fabric_port_id_t portId);
ze_result_t getState(const zes_fabric_port_id_t portId, zes_fabric_port_state_t *pState);
ze_result_t getThroughput(const zes_fabric_port_id_t portId, zes_fabric_port_throughput_t *pThroughput);
ze_result_t getErrorCounters(const zes_fabric_port_id_t portId, zes_fabric_port_error_counters_t *pErrors);
void getPortId(const uint32_t portNumber, zes_fabric_port_id_t &portId);
void getProperties(const zes_fabric_port_id_t portId, std::string &model, bool &onSubdevice,
@@ -63,7 +62,6 @@ class LinuxFabricPortImp : public OsFabricPort, NEO::NonCopyableOrMovableClass {
ze_result_t setConfig(const zes_fabric_port_config_t *pConfig) override;
ze_result_t getState(zes_fabric_port_state_t *pState) override;
ze_result_t getThroughput(zes_fabric_port_throughput_t *pThroughput) override;
ze_result_t getErrorCounters(zes_fabric_port_error_counters_t *pErrors) override;
LinuxFabricPortImp() = delete;
LinuxFabricPortImp(OsFabricDevice *pOsFabricDevice, uint32_t portNum);

1
level_zero/sysman/source/fabric_port/os_fabric_port.h
View File

@@ -30,7 +30,6 @@ class OsFabricPort {
virtual ze_result_t setConfig(const zes_fabric_port_config_t *pConfig) = 0;
virtual ze_result_t getState(zes_fabric_port_state_t *pState) = 0;
virtual ze_result_t getThroughput(zes_fabric_port_throughput_t *pThroughput) = 0;
virtual ze_result_t getErrorCounters(zes_fabric_port_error_counters_t *pErrors) = 0;
static std::unique_ptr<OsFabricPort> create(OsFabricDevice *pOsFabricDevice, uint32_t portNum);

4
level_zero/sysman/source/fabric_port/windows/os_fabric_port_imp.cpp
View File

@@ -42,10 +42,6 @@ ze_result_t WddmFabricPortImp::getThroughput(zes_fabric_port_throughput_t *pThro
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFabricPortImp::getErrorCounters(zes_fabric_port_error_counters_t *pErrors) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFabricPortImp::getProperties(zes_fabric_port_properties_t *pProperties) {
::memset(pProperties->model, '\0', ZES_MAX_FABRIC_PORT_MODEL_SIZE);
pProperties->onSubdevice = false;

1
level_zero/sysman/source/fabric_port/windows/os_fabric_port_imp.h
View File

@@ -34,7 +34,6 @@ class WddmFabricPortImp : public OsFabricPort, NEO::NonCopyableOrMovableClass {
ze_result_t setConfig(const zes_fabric_port_config_t *pConfig) override;
ze_result_t getState(zes_fabric_port_state_t *pState) override;
ze_result_t getThroughput(zes_fabric_port_throughput_t *pThroughput) override;
ze_result_t getErrorCounters(zes_fabric_port_error_counters_t *pErrors) override;
WddmFabricPortImp() = delete;
WddmFabricPortImp(OsFabricDevice *pOsFabricDevice, uint32_t portNum);

400
level_zero/sysman/test/unit_tests/sources/fabric_port/linux/test_sysman_fabric_port_prelim.cpp
View File

@@ -557,405 +557,5 @@ TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortG
EXPECT_EQ(pMockIafNlApi->txCounter, throughput.txCounter);
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersWithLegacyPathAndCallSucceeds) {
VariableBackup<L0::Sysman::FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<L0::Sysman::SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorPath = "/mockRealPath/iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/iaf.5/sd." + std::to_string(properties.portId.attachId);
std::vector<std::string> dirs = {"driver", "drm", "iaf.5"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorPath + "/fw_error", mockFwErrors},
{fabricFwErrorPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(errors.linkFailureCount, mockLinkFailures);
EXPECT_EQ(errors.linkDegradeCount, mockLinkDegrades);
EXPECT_EQ(errors.fwErrorCount, mockFwErrors);
EXPECT_EQ(errors.fwCommErrorCount, mockFwCommErrors);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersCallSucceeds) {
VariableBackup<L0::Sysman::FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<L0::Sysman::SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId);
std::vector<std::string> dirs = {"i915.iaf.5",
"driver", "drm"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorPath + "/fw_error", mockFwErrors},
{fabricFwErrorPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(errors.linkFailureCount, mockLinkFailures);
EXPECT_EQ(errors.linkDegradeCount, mockLinkDegrades);
EXPECT_EQ(errors.fwErrorCount, mockFwErrors);
EXPECT_EQ(errors.fwCommErrorCount, mockFwCommErrors);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndGetRealPathFailsThenFailureIsReturned) {
VariableBackup<L0::Sysman::FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<L0::Sysman::SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
static_cast<MockFabricSysFsAccess *>(pSysfsAccess)->mockRealPathStatus = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndListDirectoryFailsThenFailureIsReturned) {
VariableBackup<L0::Sysman::FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<L0::Sysman::SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
static_cast<MockFabricFsAccess *>(pFsAccess)->mockListDirectory = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndIafDriverIsNotLoadedThenFailureIsReturned) {
VariableBackup<L0::Sysman::FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<L0::Sysman::SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId);
std::vector<std::string> dirs = {"driver", "drm"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorPath + "/fw_error", mockFwErrors},
{fabricFwErrorPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndLinkFailureSysfsNodeIsAbsentThenZeroLinkFailuresAreReturned) {
VariableBackup<L0::Sysman::FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<L0::Sysman::SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorIncorrectPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId + 1) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricLinkErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId);
std::vector<std::string> dirs = {"i915.iaf.5",
"driver", "drm"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorIncorrectPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorPath + "/fw_error", mockFwErrors},
{fabricFwErrorPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(errors.linkFailureCount, 0u);
EXPECT_EQ(errors.linkDegradeCount, mockLinkDegrades);
EXPECT_EQ(errors.fwErrorCount, mockFwErrors);
EXPECT_EQ(errors.fwCommErrorCount, mockFwCommErrors);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndLinkDegradesSysfsNodeIsAbsentThenZeroLinkDegradesAreReturned) {
VariableBackup<L0::Sysman::FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<L0::Sysman::SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricLinkErrorIncorrectPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId + 1) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId);
std::vector<std::string> dirs = {"i915.iaf.5",
"driver", "drm"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorIncorrectPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorPath + "/fw_error", mockFwErrors},
{fabricFwErrorPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(errors.linkFailureCount, mockLinkFailures);
EXPECT_EQ(errors.linkDegradeCount, 0u);
EXPECT_EQ(errors.fwErrorCount, mockFwErrors);
EXPECT_EQ(errors.fwCommErrorCount, mockFwCommErrors);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndFwErrorSysfsNodeIsAbsentThenZeroFwErrorsAreReturned) {
VariableBackup<L0::Sysman::FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<L0::Sysman::SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId);
std::string fabricFwErrorIncorrectPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId + 1);
std::vector<std::string> dirs = {"i915.iaf.5",
"driver", "drm"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorIncorrectPath + "/fw_error", mockFwErrors},
{fabricFwErrorPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(errors.linkFailureCount, mockLinkFailures);
EXPECT_EQ(errors.linkDegradeCount, mockLinkDegrades);
EXPECT_EQ(errors.fwErrorCount, 0u);
EXPECT_EQ(errors.fwCommErrorCount, mockFwCommErrors);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndFwCommErrorSysfsNodeIsAbsentThenZeroFwCommErrorsAreReturned) {
VariableBackup<L0::Sysman::FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<L0::Sysman::SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId);
std::string fabricFwErrorIncorrectPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId + 1);
std::vector<std::string> dirs = {"i915.iaf.5",
"driver", "drm"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorPath + "/fw_error", mockFwErrors},
{fabricFwErrorIncorrectPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(errors.linkFailureCount, mockLinkFailures);
EXPECT_EQ(errors.linkDegradeCount, mockLinkDegrades);
EXPECT_EQ(errors.fwErrorCount, mockFwErrors);
EXPECT_EQ(errors.fwCommErrorCount, 0u);
delete pFsAccess;
delete pSysfsAccess;
}
} // namespace ult
} // namespace L0

1
level_zero/tools/source/sysman/fabric_port/fabric_port.h
View File

@@ -36,7 +36,6 @@ class FabricPort : _zes_fabric_port_handle_t {
virtual ze_result_t fabricPortSetConfig(const zes_fabric_port_config_t *pConfig) = 0;
virtual ze_result_t fabricPortGetState(zes_fabric_port_state_t *pState) = 0;
virtual ze_result_t fabricPortGetThroughput(zes_fabric_port_throughput_t *pThroughput) = 0;
virtual ze_result_t fabricPortGetErrorCounters(zes_fabric_port_error_counters_t *pErrors) = 0;
inline zes_fabric_port_handle_t toZesHandle() { return this; }

4
level_zero/tools/source/sysman/fabric_port/fabric_port_imp.cpp
View File

@@ -53,10 +53,6 @@ ze_result_t FabricPortImp::fabricPortGetState(zes_fabric_port_state_t *pState) {
return pOsFabricPort->getState(pState);
}
ze_result_t FabricPortImp::fabricPortGetErrorCounters(zes_fabric_port_error_counters_t *pErrors) {
return pOsFabricPort->getErrorCounters(pErrors);
}
ze_result_t FabricPortImp::fabricPortGetThroughput(zes_fabric_port_throughput_t *pThroughput) {
fabricPortGetTimestamp(pThroughput->timestamp);
return pOsFabricPort->getThroughput(pThroughput);

1
level_zero/tools/source/sysman/fabric_port/fabric_port_imp.h
View File

@@ -35,7 +35,6 @@ class FabricPortImp : public FabricPort, NEO::NonCopyableOrMovableClass {
ze_result_t fabricPortSetConfig(const zes_fabric_port_config_t *pConfig) override;
ze_result_t fabricPortGetState(zes_fabric_port_state_t *pState) override;
ze_result_t fabricPortGetThroughput(zes_fabric_port_throughput_t *pThroughput) override;
ze_result_t fabricPortGetErrorCounters(zes_fabric_port_error_counters_t *pErrors) override;
FabricPortImp() = delete;
FabricPortImp(FabricDevice *pFabricDevice, uint32_t portNum);

4
level_zero/tools/source/sysman/fabric_port/linux/os_fabric_port_imp.cpp
View File

@@ -56,10 +56,6 @@ ze_result_t LinuxFabricPortImp::getThroughput(zes_fabric_port_throughput_t *pThr
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFabricPortImp::getErrorCounters(zes_fabric_port_error_counters_t *pErrors) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFabricPortImp::getProperties(zes_fabric_port_properties_t *pProperties) {
::snprintf(pProperties->model, ZES_MAX_FABRIC_PORT_MODEL_SIZE, "%s", this->model.c_str());
pProperties->onSubdevice = false;

1
level_zero/tools/source/sysman/fabric_port/linux/os_fabric_port_imp.h
View File

@@ -34,7 +34,6 @@ class LinuxFabricPortImp : public OsFabricPort, NEO::NonCopyableOrMovableClass {
ze_result_t setConfig(const zes_fabric_port_config_t *pConfig) override;
ze_result_t getState(zes_fabric_port_state_t *pState) override;
ze_result_t getThroughput(zes_fabric_port_throughput_t *pThroughput) override;
ze_result_t getErrorCounters(zes_fabric_port_error_counters_t *pErrors) override;
LinuxFabricPortImp() = delete;
LinuxFabricPortImp(OsFabricDevice *pOsFabricDevice, uint32_t portNum);

76
level_zero/tools/source/sysman/fabric_port/linux/os_fabric_port_imp_prelim.cpp
View File

@@ -39,78 +39,6 @@ ze_result_t LinuxFabricDeviceImp::getThroughput(const zes_fabric_port_id_t portI
return pFabricDeviceAccess->getThroughput(portId, *pThroughput);
}
ze_result_t LinuxFabricDeviceImp::getErrorCounters(const zes_fabric_port_id_t portId, zes_fabric_port_error_counters_t *pErrors) {
FsAccess *pFsAccess = &pLinuxSysmanImp->getFsAccess();
SysfsAccess *pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
std::string devicePciPath("");
ze_result_t result = pSysfsAccess->getRealPath("device/", devicePciPath);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to get device path> <result: 0x%x>\n", __func__, result);
return result;
}
std::string path("");
std::vector<std::string> list;
result = pFsAccess->listDirectory(devicePciPath, list);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to get list of files in device directory> <result: 0x%x>\n", __func__, result);
return result;
}
for (auto entry : list) {
if ((entry.find("i915.iaf.") != std::string::npos) ||
(entry.find("iaf.") != std::string::npos)) {
path = devicePciPath + "/" + entry;
break;
}
}
if (path.empty()) {
// This device does not have a fabric
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <Device does not have fabric>\n", __func__);
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
std::string fabricFwErrorPath = path + "/sd." + std::to_string(portId.attachId);
std::string fabricLinkErrorPath = path + "/sd." + std::to_string(portId.attachId) + "/port." + std::to_string(portId.portNumber);
uint64_t linkErrorCount = 0;
std::string linkFailureFile = fabricLinkErrorPath + "/link_failures";
result = pFsAccess->read(linkFailureFile, linkErrorCount);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, linkFailureFile.c_str(), result);
linkErrorCount = 0;
}
uint64_t linkDegradeCount = 0;
std::string linkDegradeFile = fabricLinkErrorPath + "/link_degrades";
result = pFsAccess->read(linkDegradeFile, linkDegradeCount);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, linkDegradeFile.c_str(), result);
linkDegradeCount = 0;
}
uint64_t fwErrorCount = 0;
std::string fwErrorFile = fabricFwErrorPath + "/fw_error";
result = pFsAccess->read(fwErrorFile, fwErrorCount);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, fwErrorFile.c_str(), result);
fwErrorCount = 0;
}
uint64_t fwCommErrorCount = 0;
std::string fwCommErrorFile = fabricFwErrorPath + "/fw_comm_errors";
result = pFsAccess->read(fwCommErrorFile, fwCommErrorCount);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, fwCommErrorFile.c_str(), result);
fwCommErrorCount = 0;
}
pErrors->linkFailureCount = linkErrorCount;
pErrors->linkDegradeCount = linkDegradeCount;
pErrors->fwErrorCount = fwErrorCount;
pErrors->fwCommErrorCount = fwCommErrorCount;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFabricDeviceImp::performSweep() {
uint32_t start = 0U;
uint32_t end = 0U;
@@ -291,10 +219,6 @@ ze_result_t LinuxFabricPortImp::getThroughput(zes_fabric_port_throughput_t *pThr
return pLinuxFabricDeviceImp->getThroughput(portId, pThroughput);
}
ze_result_t LinuxFabricPortImp::getErrorCounters(zes_fabric_port_error_counters_t *pErrors) {
return pLinuxFabricDeviceImp->getErrorCounters(portId, pErrors);
}
ze_result_t LinuxFabricPortImp::getProperties(zes_fabric_port_properties_t *pProperties) {
::snprintf(pProperties->model, ZES_MAX_FABRIC_PORT_MODEL_SIZE, "%s", this->model.c_str());
pProperties->onSubdevice = this->onSubdevice;

2
level_zero/tools/source/sysman/fabric_port/linux/os_fabric_port_imp_prelim.h
View File

@@ -30,7 +30,6 @@ class LinuxFabricDeviceImp : public OsFabricDevice, NEO::NonCopyableOrMovableCla
ze_result_t disablePortBeaconing(const zes_fabric_port_id_t portId);
ze_result_t getState(const zes_fabric_port_id_t portId, zes_fabric_port_state_t *pState);
ze_result_t getThroughput(const zes_fabric_port_id_t portId, zes_fabric_port_throughput_t *pThroughput);
ze_result_t getErrorCounters(const zes_fabric_port_id_t portId, zes_fabric_port_error_counters_t *pErrors);
void getPortId(const uint32_t portNumber, zes_fabric_port_id_t &portId);
void getProperties(const zes_fabric_port_id_t portId, std::string &model, bool &onSubdevice,
@@ -63,7 +62,6 @@ class LinuxFabricPortImp : public OsFabricPort, NEO::NonCopyableOrMovableClass {
ze_result_t setConfig(const zes_fabric_port_config_t *pConfig) override;
ze_result_t getState(zes_fabric_port_state_t *pState) override;
ze_result_t getThroughput(zes_fabric_port_throughput_t *pThroughput) override;
ze_result_t getErrorCounters(zes_fabric_port_error_counters_t *pErrors) override;
LinuxFabricPortImp() = delete;
LinuxFabricPortImp(OsFabricDevice *pOsFabricDevice, uint32_t portNum);

1
level_zero/tools/source/sysman/fabric_port/os_fabric_port.h
View File

@@ -29,7 +29,6 @@ class OsFabricPort {
virtual ze_result_t setConfig(const zes_fabric_port_config_t *pConfig) = 0;
virtual ze_result_t getState(zes_fabric_port_state_t *pState) = 0;
virtual ze_result_t getThroughput(zes_fabric_port_throughput_t *pThroughput) = 0;
virtual ze_result_t getErrorCounters(zes_fabric_port_error_counters_t *pErrors) = 0;
static std::unique_ptr<OsFabricPort> create(OsFabricDevice *pOsFabricDevice, uint32_t portNum);

4
level_zero/tools/source/sysman/fabric_port/windows/os_fabric_port_imp.cpp
View File

@@ -41,10 +41,6 @@ ze_result_t WddmFabricPortImp::getThroughput(zes_fabric_port_throughput_t *pThro
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFabricPortImp::getErrorCounters(zes_fabric_port_error_counters_t *pErrors) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFabricPortImp::getProperties(zes_fabric_port_properties_t *pProperties) {
::memset(pProperties->model, '\0', ZES_MAX_FABRIC_PORT_MODEL_SIZE);
pProperties->onSubdevice = false;

1
level_zero/tools/source/sysman/fabric_port/windows/os_fabric_port_imp.h
View File

@@ -33,7 +33,6 @@ class WddmFabricPortImp : public OsFabricPort, NEO::NonCopyableOrMovableClass {
ze_result_t setConfig(const zes_fabric_port_config_t *pConfig) override;
ze_result_t getState(zes_fabric_port_state_t *pState) override;
ze_result_t getThroughput(zes_fabric_port_throughput_t *pThroughput) override;
ze_result_t getErrorCounters(zes_fabric_port_error_counters_t *pErrors) override;
WddmFabricPortImp() = delete;
WddmFabricPortImp(OsFabricDevice *pOsFabricDevice, uint32_t portNum);

4
level_zero/tools/source/sysman/ras/linux/os_ras_imp.cpp
View File

@@ -19,14 +19,14 @@ ze_result_t LinuxRasImp::osRasGetState(zes_ras_state_t &state, ze_bool_t clear)
ze_result_t LinuxRasImp::osRasGetConfig(zes_ras_config_t *config) {
config->totalThreshold = totalThreshold;
memcpy(config->detailedThresholds.category, categoryThreshold, sizeof(config->detailedThresholds.category));
memcpy(config->detailedThresholds.category, categoryThreshold, maxRasErrorCategoryCount * sizeof(uint64_t));
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxRasImp::osRasSetConfig(const zes_ras_config_t *config) {
if (pFsAccess->isRootUser() == true) {
totalThreshold = config->totalThreshold;
memcpy(categoryThreshold, config->detailedThresholds.category, sizeof(config->detailedThresholds.category));
memcpy(categoryThreshold, config->detailedThresholds.category, maxRasErrorCategoryCount * sizeof(uint64_t));
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;

5
level_zero/tools/source/sysman/ras/linux/os_ras_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -9,6 +9,7 @@
#include "shared/source/helpers/non_copyable_or_moveable.h"
#include "level_zero/tools/source/sysman/ras/os_ras.h"
#include "level_zero/tools/source/sysman/sysman_const.h"
namespace L0 {
class FsAccess;
@@ -32,7 +33,7 @@ class LinuxRasImp : public OsRas, NEO::NonCopyableOrMovableClass {
bool isSubdevice = false;
uint32_t subdeviceId = 0;
uint64_t totalThreshold = 0;
uint64_t categoryThreshold[ZES_MAX_RAS_ERROR_CATEGORY_COUNT] = {0};
uint64_t categoryThreshold[maxRasErrorCategoryCount] = {0};
};
} // namespace L0

7
level_zero/tools/source/sysman/ras/linux/os_ras_imp_gt.cpp
View File

@@ -32,8 +32,7 @@ static const std::map<zes_ras_error_cat_t, std::vector<std::string>> categoryToL
{ZES_RAS_ERROR_CAT_DRIVER_ERRORS,
{"driver-object-migration", "driver-engine-other", "driver-ggtt",
"driver-gt-interrupt", "driver-gt-other", "driver-guc-communication",
"driver-rps"}},
{ZES_RAS_ERROR_CAT_L3FABRIC_ERRORS, {"soc-fatal-mdfi-east", "soc-fatal-mdfi-south", "soc-fatal-mdfi-west", "fatal-l3-fabric", "soc-fatal-cd0-mdfi"}}};
"driver-rps"}}};
static const std::map<zes_ras_error_cat_t, std::vector<std::string>> categoryToListOfEventsCorrectable = {
{ZES_RAS_ERROR_CAT_CACHE_ERRORS,
@@ -145,8 +144,8 @@ ze_result_t LinuxRasSourceGt::osRasGetState(zes_ras_state_t &state, ze_bool_t cl
if (clear == true) {
closeFds();
totalEventCount = 0;
memset(state.category, 0, sizeof(state.category));
memset(initialErrorCount, 0, sizeof(initialErrorCount));
memset(state.category, 0, maxRasErrorCategoryCount * sizeof(uint64_t));
memset(initialErrorCount, 0, maxRasErrorCategoryCount * sizeof(uint64_t));
}
initRasErrors(clear);
// Iterate over all the file descriptor values present in vector which is mapped to given ras error category

6
level_zero/tools/source/sysman/ras/linux/os_ras_imp_prelim.cpp
View File

@@ -38,14 +38,14 @@ void OsRas::getSupportedRasErrorTypes(std::set<zes_ras_error_type_t> &errorType,
ze_result_t LinuxRasImp::osRasGetConfig(zes_ras_config_t *config) {
config->totalThreshold = totalThreshold;
memcpy_s(config->detailedThresholds.category, sizeof(config->detailedThresholds.category), categoryThreshold, sizeof(config->detailedThresholds.category));
memcpy_s(config->detailedThresholds.category, maxRasErrorCategoryCount * sizeof(uint64_t), categoryThreshold, maxRasErrorCategoryCount * sizeof(uint64_t));
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxRasImp::osRasSetConfig(const zes_ras_config_t *config) {
if (pFsAccess->isRootUser() == true) {
totalThreshold = config->totalThreshold;
memcpy_s(categoryThreshold, sizeof(config->detailedThresholds.category), config->detailedThresholds.category, sizeof(config->detailedThresholds.category));
memcpy_s(categoryThreshold, maxRasErrorCategoryCount * sizeof(uint64_t), config->detailedThresholds.category, maxRasErrorCategoryCount * sizeof(uint64_t));
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
@@ -73,7 +73,7 @@ ze_result_t LinuxRasImp::osRasGetState(zes_ras_state_t &state, ze_bool_t clear)
if (localResult != ZE_RESULT_SUCCESS) {
continue;
}
for (int i = 0; i < ZES_MAX_RAS_ERROR_CATEGORY_COUNT; i++) {
for (uint32_t i = 0; i < maxRasErrorCategoryCount; i++) {
state.category[i] += localState.category[i];
}
result = ZE_RESULT_SUCCESS;

5
level_zero/tools/source/sysman/ras/linux/os_ras_imp_prelim.h
View File

@@ -9,6 +9,7 @@
#include "shared/source/helpers/non_copyable_or_moveable.h"
#include "level_zero/tools/source/sysman/ras/os_ras.h"
#include "level_zero/tools/source/sysman/sysman_const.h"
#include <map>
#include <memory>
@@ -45,7 +46,7 @@ class LinuxRasImp : public OsRas, NEO::NonCopyableOrMovableClass {
bool isSubdevice = false;
uint32_t subdeviceId = 0;
uint64_t totalThreshold = 0;
uint64_t categoryThreshold[ZES_MAX_RAS_ERROR_CATEGORY_COUNT] = {0};
uint64_t categoryThreshold[maxRasErrorCategoryCount] = {0};
};
class LinuxRasSources : NEO::NonCopyableOrMovableClass {
@@ -83,7 +84,7 @@ class LinuxRasSourceGt : public LinuxRasSources {
void closeFds();
int64_t groupFd = -1;
std::vector<int64_t> memberFds = {};
uint64_t initialErrorCount[ZES_MAX_RAS_ERROR_CATEGORY_COUNT] = {0};
uint64_t initialErrorCount[maxRasErrorCategoryCount] = {0};
std::map<zes_ras_error_cat_t, uint64_t> errorCategoryToEventCount;
uint64_t totalEventCount = 0;
bool isSubdevice = false;

5
level_zero/tools/source/sysman/ras/ras_imp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -9,6 +9,7 @@
#include "shared/source/helpers/string.h"
#include "level_zero/tools/source/sysman/sysman_const.h"
#include "level_zero/tools/source/sysman/sysman_imp.h"
#include <cstring>
@@ -29,7 +30,7 @@ ze_result_t RasImp::rasSetConfig(const zes_ras_config_t *pConfig) {
}
ze_result_t RasImp::rasGetState(zes_ras_state_t *pState, ze_bool_t clear) {
memset(pState->category, 0, sizeof(pState->category));
memset(pState->category, 0, maxRasErrorCategoryCount * sizeof(uint64_t));
return pOsRas->osRasGetState(*pState, clear);
}

12
level_zero/tools/source/sysman/sysman_const.h
View File

@@ -13,7 +13,7 @@ const std::string unknown("unknown");
const std::string intelPciId("0x8086");
constexpr uint32_t MbpsToBytesPerSecond = 125000;
constexpr double milliVoltsFactor = 1000.0;
constexpr uint32_t maxRasErrorCategoryCount = 7;
namespace L0 {
struct SteadyClock {
typedef std::chrono::duration<uint64_t, std::milli> duration;
@@ -25,6 +25,16 @@ struct SteadyClock {
return time_point(std::chrono::duration_cast<duration>(std::chrono::steady_clock::now() - epoch));
}
};
typedef struct _zes_fabric_port_error_counters_t {
void *pNext;
uint64_t linkFailureCount;
uint64_t fwCommErrorCount;
uint64_t fwErrorCount;
uint64_t linkDegradeCount;
} zes_fabric_port_error_counters_t;
} // namespace L0
namespace PciLinkSpeeds {

9
level_zero/tools/test/black_box_tests/zello_sysman.cpp
View File

@@ -1175,7 +1175,6 @@ void testSysmanFabricPort(ze_device_handle_t &device) {
zes_fabric_port_config_t fabricPortConfig = {};
zes_fabric_port_state_t fabricPortState = {};
zes_fabric_port_throughput_t fabricPortThroughput = {};
zes_fabric_port_error_counters_t fabricPortErrorCounters = {};
VALIDATECALL(zesFabricPortGetProperties(handle, &fabricPortProperties));
if (verbose) {
@@ -1224,14 +1223,6 @@ void testSysmanFabricPort(ze_device_handle_t &device) {
std::cout << "RX Counter = " << fabricPortThroughput.rxCounter << std::endl;
std::cout << "TX Counter = " << fabricPortThroughput.txCounter << std::endl;
}
VALIDATECALL(zesFabricPortGetFabricErrorCounters(handle, &fabricPortErrorCounters));
if (verbose) {
std::cout << "Link Failures = " << fabricPortErrorCounters.linkFailureCount << std::endl;
std::cout << "Link Degrades = " << fabricPortErrorCounters.linkDegradeCount << std::endl;
std::cout << "Fw Errors = " << fabricPortErrorCounters.fwErrorCount << std::endl;
std::cout << "Fw comm Errors = " << fabricPortErrorCounters.fwCommErrorCount << std::endl;
}
}
}

400
level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/test_sysman_fabric_port_prelim.cpp
View File

@@ -562,405 +562,5 @@ TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortG
EXPECT_EQ(pMockIafNlApi->txCounter, throughput.txCounter);
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersWithLegacyPathAndCallSucceeds) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorPath = "/mockRealPath/iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/iaf.5/sd." + std::to_string(properties.portId.attachId);
std::vector<std::string> dirs = {"driver", "drm", "iaf.5"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorPath + "/fw_error", mockFwErrors},
{fabricFwErrorPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(errors.linkFailureCount, mockLinkFailures);
EXPECT_EQ(errors.linkDegradeCount, mockLinkDegrades);
EXPECT_EQ(errors.fwErrorCount, mockFwErrors);
EXPECT_EQ(errors.fwCommErrorCount, mockFwCommErrors);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersCallSucceeds) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId);
std::vector<std::string> dirs = {"i915.iaf.5",
"driver", "drm"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorPath + "/fw_error", mockFwErrors},
{fabricFwErrorPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(errors.linkFailureCount, mockLinkFailures);
EXPECT_EQ(errors.linkDegradeCount, mockLinkDegrades);
EXPECT_EQ(errors.fwErrorCount, mockFwErrors);
EXPECT_EQ(errors.fwCommErrorCount, mockFwCommErrors);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndGetRealPathFailsThenFailureIsReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
static_cast<MockFabricSysFsAccess *>(pSysfsAccess)->mockRealPathStatus = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndListDirectoryFailsThenFailureIsReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
static_cast<MockFabricFsAccess *>(pFsAccess)->mockListDirectory = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndIafDriverIsNotLoadedThenFailureIsReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId);
std::vector<std::string> dirs = {"driver", "drm"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorPath + "/fw_error", mockFwErrors},
{fabricFwErrorPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndLinkFailureSysfsNodeIsAbsentThenZeroLinkFailuresAreReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorIncorrectPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId + 1) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricLinkErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId);
std::vector<std::string> dirs = {"i915.iaf.5",
"driver", "drm"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorIncorrectPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorPath + "/fw_error", mockFwErrors},
{fabricFwErrorPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(errors.linkFailureCount, 0u);
EXPECT_EQ(errors.linkDegradeCount, mockLinkDegrades);
EXPECT_EQ(errors.fwErrorCount, mockFwErrors);
EXPECT_EQ(errors.fwCommErrorCount, mockFwCommErrors);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndLinkDegradesSysfsNodeIsAbsentThenZeroLinkDegradesAreReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricLinkErrorIncorrectPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId + 1) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId);
std::vector<std::string> dirs = {"i915.iaf.5",
"driver", "drm"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorIncorrectPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorPath + "/fw_error", mockFwErrors},
{fabricFwErrorPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(errors.linkFailureCount, mockLinkFailures);
EXPECT_EQ(errors.linkDegradeCount, 0u);
EXPECT_EQ(errors.fwErrorCount, mockFwErrors);
EXPECT_EQ(errors.fwCommErrorCount, mockFwCommErrors);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndFwErrorSysfsNodeIsAbsentThenZeroFwErrorsAreReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId);
std::string fabricFwErrorIncorrectPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId + 1);
std::vector<std::string> dirs = {"i915.iaf.5",
"driver", "drm"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorIncorrectPath + "/fw_error", mockFwErrors},
{fabricFwErrorPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(errors.linkFailureCount, mockLinkFailures);
EXPECT_EQ(errors.linkDegradeCount, mockLinkDegrades);
EXPECT_EQ(errors.fwErrorCount, 0u);
EXPECT_EQ(errors.fwCommErrorCount, mockFwCommErrors);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndFwCommErrorSysfsNodeIsAbsentThenZeroFwCommErrorsAreReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId);
std::string fabricFwErrorIncorrectPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId + 1);
std::vector<std::string> dirs = {"i915.iaf.5",
"driver", "drm"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorPath + "/fw_error", mockFwErrors},
{fabricFwErrorIncorrectPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(errors.linkFailureCount, mockLinkFailures);
EXPECT_EQ(errors.linkDegradeCount, mockLinkDegrades);
EXPECT_EQ(errors.fwErrorCount, mockFwErrors);
EXPECT_EQ(errors.fwCommErrorCount, 0u);
delete pFsAccess;
delete pSysfsAccess;
}
} // namespace ult
} // namespace L0

5
level_zero/tools/test/unit_tests/sources/sysman/fabric_port/windows/test_zes_fabric_port.cpp
View File

@@ -58,11 +58,6 @@ TEST_F(SysmanFabricPortFixture, GivenValidFabricPortHandleWhenCallingFabricPortG
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFabricPortImp->fabricPortGetThroughput(&pThroughput));
}
TEST_F(SysmanFabricPortFixture, GivenValidFabricPortHandleWhenCallingFabricPortGetErrorCountersThenFailureIsReturned) {
zes_fabric_port_error_counters_t pErrors = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFabricPortImp->fabricPortGetErrorCounters(&pErrors));
}
TEST_F(SysmanFabricPortFixture, GivenValidFabricPortHandleWhenCallingFabricPortGetLinkTupeThenFailureIsReturned) {
zes_fabric_link_type_t pLinkType = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFabricPortImp->fabricPortGetLinkType(&pLinkType));

5
level_zero/tools/test/unit_tests/sources/sysman/ras/linux/mock_fs_ras_prelim.h
View File

@@ -143,8 +143,6 @@ struct MockRasPmuInterfaceImp : public PmuInterfaceImp {
data[8] = fatalEuErrorCount;
data[9] = socFatalPsfCsc0Count;
data[10] = fatalTlb;
data[11] = 0;
data[12] = socFatalMdfiEastCount;
return 0;
}
@@ -173,8 +171,6 @@ struct MockRasPmuInterfaceImp : public PmuInterfaceImp {
data[11] = nonFatalGscAonParity;
data[12] = nonFataGscSelfmBist;
data[13] = fatalTlb;
data[14] = 0;
data[15] = socFatalMdfiEastCount;
return 0;
}
@@ -198,7 +194,6 @@ struct MockRasPmuInterfaceImp : public PmuInterfaceImp {
data[7] = socFatalPunitTile1;
data[8] = fatalIdiParityErrorCountTile1;
data[9] = fatalL3BankTile1;
data[10] = socFatalMdfiWestCountTile1;
return 0;
}

7
level_zero/tools/test/unit_tests/sources/sysman/ras/linux/test_zes_ras.cpp
View File

@@ -5,6 +5,7 @@
*
*/
#include "level_zero/tools/source/sysman/sysman_const.h"
#include "level_zero/tools/test/unit_tests/sources/sysman/linux/mock_sysman_fixture.h"
#include "mock_fs_ras.h"
@@ -137,11 +138,11 @@ TEST_F(SysmanRasFixture, GivenValidRasHandleWhenCallingzesRasGetConfigAfterzesRa
zes_ras_config_t setConfig = {};
zes_ras_config_t getConfig = {};
setConfig.totalThreshold = 50;
memset(setConfig.detailedThresholds.category, 1, sizeof(setConfig.detailedThresholds.category));
memset(setConfig.detailedThresholds.category, 1, maxRasErrorCategoryCount * sizeof(uint64_t));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasSetConfig(handle, &setConfig));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasGetConfig(handle, &getConfig));
EXPECT_EQ(setConfig.totalThreshold, getConfig.totalThreshold);
int compare = std::memcmp(setConfig.detailedThresholds.category, getConfig.detailedThresholds.category, sizeof(setConfig.detailedThresholds.category));
int compare = std::memcmp(setConfig.detailedThresholds.category, getConfig.detailedThresholds.category, maxRasErrorCategoryCount * sizeof(uint64_t));
EXPECT_EQ(0, compare);
}
pSysmanDeviceImp->pRasHandleContext->handleList.pop_back();
@@ -158,7 +159,7 @@ TEST_F(SysmanRasFixture, GivenValidRasHandleWhenCallingzesRasSetConfigWithoutPer
for (auto handle : handles) {
zes_ras_config_t setConfig = {};
setConfig.totalThreshold = 50;
memset(setConfig.detailedThresholds.category, 1, sizeof(setConfig.detailedThresholds.category));
memset(setConfig.detailedThresholds.category, 1, maxRasErrorCategoryCount * sizeof(uint64_t));
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, zesRasSetConfig(handle, &setConfig));
}
pSysmanDeviceImp->pRasHandleContext->releaseRasHandles();

11
level_zero/tools/test/unit_tests/sources/sysman/ras/linux/test_zes_ras_prelim.cpp
View File

@@ -5,6 +5,7 @@
*
*/
#include "level_zero/tools/source/sysman/sysman_const.h"
#include "level_zero/tools/test/unit_tests/sources/sysman/linux/mock_sysman_fixture.h"
#include "level_zero/tools/test/unit_tests/sources/sysman/ras/linux/mock_fs_ras_prelim.h"
@@ -244,7 +245,6 @@ TEST_F(SysmanRasFixture, GivenValidRasHandleWhenCallingzesRasGeStateForGtThenSuc
EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_NON_COMPUTE_ERRORS], socFatalPsfCsc0Count + initialUncorrectableNonComputeErrors);
EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_DISPLAY_ERRORS], 0u);
EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_DRIVER_ERRORS], driverMigration + driverGgtt + driverRps + initialUncorrectableDriverErrors);
EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_L3FABRIC_ERRORS], socFatalMdfiEastCount + initialUncorrectableFabricErrors);
}
}
}
@@ -281,7 +281,6 @@ TEST_F(SysmanRasFixture, GivenValidRasHandleWhenCallingzesRasGeStateForGtAfterCl
EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_NON_COMPUTE_ERRORS], socFatalPsfCsc0Count + initialUncorrectableNonComputeErrors);
EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_DISPLAY_ERRORS], 0u);
EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_DRIVER_ERRORS], driverMigration + driverGgtt + driverRps + initialUncorrectableDriverErrors);
EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_L3FABRIC_ERRORS], socFatalMdfiEastCount + initialUncorrectableFabricErrors);
}
}
correctable = true;
@@ -473,12 +472,12 @@ TEST_F(SysmanRasFixture, GivenValidRasHandleWhenCallingzesRasGetConfigAfterzesRa
zes_ras_config_t setConfig = {};
zes_ras_config_t getConfig = {};
setConfig.totalThreshold = 50;
memset(setConfig.detailedThresholds.category, 1, sizeof(setConfig.detailedThresholds.category));
memset(setConfig.detailedThresholds.category, 1, maxRasErrorCategoryCount * sizeof(uint64_t));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasSetConfig(handle, &setConfig));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasGetConfig(handle, &getConfig));
EXPECT_EQ(setConfig.totalThreshold, getConfig.totalThreshold);
int compare = std::memcmp(setConfig.detailedThresholds.category, getConfig.detailedThresholds.category, sizeof(setConfig.detailedThresholds.category));
int compare = std::memcmp(setConfig.detailedThresholds.category, getConfig.detailedThresholds.category, maxRasErrorCategoryCount * sizeof(uint64_t));
EXPECT_EQ(0, compare);
}
}
@@ -492,7 +491,7 @@ TEST_F(SysmanRasFixture, GivenValidRasHandleWhenCallingzesRasSetConfigWithoutPer
for (auto handle : handles) {
zes_ras_config_t setConfig = {};
setConfig.totalThreshold = 50;
memset(setConfig.detailedThresholds.category, 1, sizeof(setConfig.detailedThresholds.category));
memset(setConfig.detailedThresholds.category, 1, maxRasErrorCategoryCount * sizeof(uint64_t));
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, zesRasSetConfig(handle, &setConfig));
}
}
@@ -706,7 +705,6 @@ TEST_F(SysmanRasMultiDeviceFixture, GivenValidRasHandleWhenCallingzesRasGeStateF
EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_NON_COMPUTE_ERRORS], socFatalPsfCsc0Count + nonFatalGscAonParity + nonFataGscSelfmBist + initialUncorrectableNonComputeErrorsTile0);
EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_DISPLAY_ERRORS], 0u);
EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_DRIVER_ERRORS], driverMigration + driverGgtt + driverRps + initialUncorrectableDriverErrorsTile0);
EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_L3FABRIC_ERRORS], socFatalMdfiEastCount + initialUncorrectableFabricErrorsTile0);
} else if (handleIndex == 2u) {
EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_CACHE_ERRORS], 0u); // No. of correctable error type for subdevice 1
EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_RESET], 0u);
@@ -723,7 +721,6 @@ TEST_F(SysmanRasMultiDeviceFixture, GivenValidRasHandleWhenCallingzesRasGeStateF
EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_NON_COMPUTE_ERRORS], socFatalMdfiWestCountTile1 + socFatalPunitTile1 + initialUncorrectableNonComputeErrorsTile1);
EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_DISPLAY_ERRORS], 0u);
EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_DRIVER_ERRORS], driverMigration + driverEngineOther + initialUncorrectableDriverErrorsTile1);
EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_L3FABRIC_ERRORS], socFatalMdfiWestCountTile1 + initialUncorrectableFabricErrorsTile1);
}
handleIndex++;
}