Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

update Sysman PCI APIs to lastest Spec

Browse Source 
Change-Id: Ie4daf2eb3596f05f824579eff3fe811ebb2f2032
This commit is contained in:
Vilvaraj, T J Vivek
2020-07-23 07:04:28 +05:30
committed by sys_ocldev
parent 171c40d58a
commit a6ea7ab7db
14 changed files with 173 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
level_zero/api/sysman/zes_sysman.cpp
View File

@ -110,14 +110,14 @@ ZE_APIEXPORT ze_result_t ZE_APICALL
zesDevicePciGetProperties(
zes_device_handle_t hDevice,
zes_pci_properties_t *pProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
return L0::SysmanDevice::fromHandle(hDevice)->pciGetProperties(pProperties);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDevicePciGetState(
zes_device_handle_t hDevice,
zes_pci_state_t *pState) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
return L0::SysmanDevice::fromHandle(hDevice)->pciGetState(pState);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
@ -125,14 +125,14 @@ zesDevicePciGetBars(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_pci_bar_properties_t *pProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
return L0::SysmanDevice::fromHandle(hDevice)->pciGetBars(pCount, pProperties);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zesDevicePciGetStats(
zes_device_handle_t hDevice,
zes_pci_stats_t *pStats) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
return L0::SysmanDevice::fromHandle(hDevice)->pciGetStats(pStats);
}
ZE_APIEXPORT ze_result_t ZE_APICALL

19
level_zero/tools/source/sysman/linux/fs_access.cpp
View File

@ -70,6 +70,23 @@ ze_result_t FsAccess::read(const std::string file, double &val) {
return ZE_RESULT_SUCCESS;
}
ze_result_t FsAccess::read(const std::string file, int32_t &val) {
// Read a single line from text file without trailing newline
std::ifstream fs;
fs.open(file.c_str());
if (fs.fail()) {
return getResult(errno);
}
fs >> val;
if (fs.fail()) {
fs.close();
return getResult(errno);
}
fs.close();
return ZE_RESULT_SUCCESS;
}
ze_result_t FsAccess::read(const std::string file, uint32_t &val) {
// Read a single line from text file without trailing newline
std::ifstream fs;
@ -379,7 +396,7 @@ ze_result_t SysfsAccess::read(const std::string file, std::string &val) {
return FsAccess::read(fullPath(file).c_str(), val);
}
ze_result_t SysfsAccess::read(const std::string file, int &val) {
ze_result_t SysfsAccess::read(const std::string file, int32_t &val) {
std::string str;
ze_result_t result;

3
level_zero/tools/source/sysman/linux/fs_access.h
View File

@ -37,6 +37,7 @@ class FsAccess {
virtual ze_result_t read(const std::string file, std::vector<std::string> &val);
virtual ze_result_t read(const std::string file, double &val);
virtual ze_result_t read(const std::string file, uint32_t &val);
virtual ze_result_t read(const std::string file, int32_t &val);
virtual ze_result_t write(const std::string file, const std::string val);
@ -82,7 +83,7 @@ class SysfsAccess : private FsAccess {
ze_result_t getFileMode(const std::string file, ::mode_t &mode) override;
ze_result_t read(const std::string file, std::string &val) override;
MOCKABLE_VIRTUAL ze_result_t read(const std::string file, int &val);
ze_result_t read(const std::string file, int32_t &val) override;
ze_result_t read(const std::string file, uint32_t &val) override;
ze_result_t read(const std::string file, uint64_t &val) override;
ze_result_t read(const std::string file, double &val) override;

32
level_zero/tools/source/sysman/pci/linux/os_pci_imp.cpp
View File

@ -74,7 +74,7 @@ ze_result_t LinuxPciImp::getMaxLinkSpeed(double &maxLinkSpeed) {
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxPciImp::getMaxLinkWidth(uint32_t &maxLinkwidth) {
ze_result_t LinuxPciImp::getMaxLinkWidth(int32_t &maxLinkwidth) {
ze_result_t result;
if (isLmemSupported) {
std::string rootPortPath;
@ -85,30 +85,30 @@ ze_result_t LinuxPciImp::getMaxLinkWidth(uint32_t &maxLinkwidth) {
// the root port is always at a fixed distance as defined in HW
rootPortPath = changeDirNLevelsUp(realRootPath, 2);
if (ZE_RESULT_SUCCESS != result) {
maxLinkwidth = 0;
maxLinkwidth = -1;
return result;
}
result = pfsAccess->read(rootPortPath + '/' + "max_link_width", maxLinkwidth);
if (ZE_RESULT_SUCCESS != result) {
maxLinkwidth = 0;
maxLinkwidth = -1;
return result;
}
if (maxLinkwidth == static_cast<uint32_t>(unknownPcieLinkWidth)) {
maxLinkwidth = 0;
if (maxLinkwidth == static_cast<int32_t>(unknownPcieLinkWidth)) {
maxLinkwidth = -1;
}
} else {
result = pSysfsAccess->read(maxLinkWidthFile, maxLinkwidth);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
if (maxLinkwidth == static_cast<uint32_t>(unknownPcieLinkWidth)) {
maxLinkwidth = 0;
if (maxLinkwidth == static_cast<int32_t>(unknownPcieLinkWidth)) {
maxLinkwidth = -1;
}
}
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxPciImp::getLinkGen(uint32_t &linkGen) {
ze_result_t LinuxPciImp::getLinkGen(int32_t &linkGen) {
double maxLinkSpeed;
getMaxLinkSpeed(maxLinkSpeed);
if (maxLinkSpeed == 2.5) {
@ -122,7 +122,7 @@ ze_result_t LinuxPciImp::getLinkGen(uint32_t &linkGen) {
} else if (maxLinkSpeed == 32) {
linkGen = 5;
} else {
linkGen = 0;
linkGen = -1;
}
return ZE_RESULT_SUCCESS;
@ -152,18 +152,20 @@ ze_result_t LinuxPciImp::initializeBarProperties(std::vector<zes_pci_bar_propert
for (uint32_t i = 0; i <= maxPciBars; i++) {
uint64_t baseAddr, barSize, barFlags;
getBarBaseAndSize(ReadBytes[i], baseAddr, barSize, barFlags);
if (baseAddr) {
if (baseAddr && !(barFlags & 0x1)) { // we do not update for I/O ports
zes_pci_bar_properties_t *pBarProp = new zes_pci_bar_properties_t;
pBarProp->index = i;
pBarProp->base = baseAddr;
pBarProp->size = barSize;
// Bar Flags Desc.
// Bit-0 - Value 0x0 -> MMIO type BAR
// Bit-0 - Value 0x1 -> I/O Type BAR
// Bit-1 - Reserved
// Bit-2 - Valid only for MMIO type BAR
// Value 0x1 -> 64bit BAR*/
pBarProp->type = ZES_PCI_BAR_TYPE_MMIO;
// Bit-0 - Value 0x1 -> I/O type BAR
if (i == 0) { // GRaphics MMIO is at BAR0, and is a 64-bit
pBarProp->type = ZES_PCI_BAR_TYPE_MMIO;
}
if (i == 2) {
pBarProp->type = ZES_PCI_BAR_TYPE_MEM; // device memory is always at BAR2
}
if (i == 6) { // the 7th entry of resource file is expected to be ROM BAR
pBarProp->type = ZES_PCI_BAR_TYPE_ROM;
}

4
level_zero/tools/source/sysman/pci/linux/os_pci_imp.h
View File

@ -19,8 +19,8 @@ class LinuxPciImp : public OsPci, NEO::NonCopyableOrMovableClass {
public:
ze_result_t getPciBdf(std::string &bdf) override;
ze_result_t getMaxLinkSpeed(double &maxLinkSpeed) override;
ze_result_t getMaxLinkWidth(uint32_t &maxLinkwidth) override;
ze_result_t getLinkGen(uint32_t &linkGen) override;
ze_result_t getMaxLinkWidth(int32_t &maxLinkwidth) override;
ze_result_t getLinkGen(int32_t &linkGen) override;
void setLmemSupport(bool val) override;
ze_result_t initializeBarProperties(std::vector<zes_pci_bar_properties_t *> &pBarProperties) override;
LinuxPciImp() = default;

4
level_zero/tools/source/sysman/pci/os_pci.h
View File

@ -19,8 +19,8 @@ class OsPci {
public:
virtual ze_result_t getPciBdf(std::string &bdf) = 0;
virtual ze_result_t getMaxLinkSpeed(double &maxLinkSpeed) = 0;
virtual ze_result_t getMaxLinkWidth(uint32_t &maxLinkWidth) = 0;
virtual ze_result_t getLinkGen(uint32_t &linkGen) = 0;
virtual ze_result_t getMaxLinkWidth(int32_t &maxLinkWidth) = 0;
virtual ze_result_t getLinkGen(int32_t &linkGen) = 0;
virtual void setLmemSupport(bool val) = 0;
virtual ze_result_t initializeBarProperties(std::vector<zes_pci_bar_properties_t *> &pBarProperties) = 0;
static OsPci *create(OsSysman *pOsSysman);

15
level_zero/tools/source/sysman/pci/pci_imp.cpp
View File

@ -23,7 +23,7 @@ namespace L0 {
// pcieSpeedWithEnc = maxLinkSpeedInGt * (Gigabit to Megabit) * Encoding =
// maxLinkSpeedInGt * 1000 * Encoding
//
uint64_t convertPcieSpeedFromGTsToBs(double maxLinkSpeedInGt) {
int64_t convertPcieSpeedFromGTsToBs(double maxLinkSpeedInGt) {
double pcieSpeedWithEnc;
if ((maxLinkSpeedInGt == 16) || (maxLinkSpeedInGt == 8)) {
pcieSpeedWithEnc = maxLinkSpeedInGt * 1000 * 128 / 130;
@ -39,7 +39,7 @@ uint64_t convertPcieSpeedFromGTsToBs(double maxLinkSpeedInGt) {
// Now, because 1Mb/s = (1000*1000)/8 bytes/second = 125000 bytes/second
//
pcieSpeedWithEnc = pcieSpeedWithEnc * 125000;
return static_cast<uint64_t>(pcieSpeedWithEnc);
return static_cast<int64_t>(pcieSpeedWithEnc);
}
ze_result_t PciImp::pciStaticProperties(zes_pci_properties_t *pProperties) {
@ -80,14 +80,17 @@ void PciImp::init() {
&pciProperties.address.device, &pciProperties.address.function);
}
uint32_t maxLinkWidth = 0, gen = 0;
uint64_t maxBandWidth = 0;
int32_t maxLinkWidth = -1, gen = -1;
int64_t maxBandWidth = -1;
double maxLinkSpeed = 0;
pOsPci->getMaxLinkSpeed(maxLinkSpeed);
pOsPci->getMaxLinkWidth(maxLinkWidth);
maxBandWidth = maxLinkWidth * convertPcieSpeedFromGTsToBs(maxLinkSpeed);
pciProperties.maxSpeed.maxBandwidth = maxBandWidth;
if (maxBandWidth == 0) {
pciProperties.maxSpeed.maxBandwidth = -1;
} else {
pciProperties.maxSpeed.maxBandwidth = maxBandWidth;
}
pciProperties.maxSpeed.width = maxLinkWidth;
pOsPci->getLinkGen(gen);
pciProperties.maxSpeed.gen = gen;

8
level_zero/tools/source/sysman/pci/windows/os_pci_imp.cpp
View File

@ -14,8 +14,8 @@ class WddmPciImp : public OsPci {
public:
ze_result_t getPciBdf(std::string &bdf) override;
ze_result_t getMaxLinkSpeed(double &maxLinkSpeed) override;
ze_result_t getMaxLinkWidth(uint32_t &maxLinkwidth) override;
ze_result_t getLinkGen(uint32_t &linkGen) override;
ze_result_t getMaxLinkWidth(int32_t &maxLinkwidth) override;
ze_result_t getLinkGen(int32_t &linkGen) override;
void setLmemSupport(bool val) override;
ze_result_t initializeBarProperties(std::vector<zes_pci_bar_properties_t *> &pBarProperties) override;
~WddmPciImp() override = default;
@ -29,11 +29,11 @@ ze_result_t WddmPciImp::getMaxLinkSpeed(double &maxLinkSpeed) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmPciImp::getMaxLinkWidth(uint32_t &maxLinkwidth) {
ze_result_t WddmPciImp::getMaxLinkWidth(int32_t &maxLinkwidth) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmPciImp::getLinkGen(uint32_t &linkGen) {
ze_result_t WddmPciImp::getLinkGen(int32_t &linkGen) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}

4
level_zero/tools/source/sysman/sysman.h
View File

@ -37,6 +37,10 @@ struct SysmanDevice : _ze_device_handle_t {
virtual ze_result_t temperatureGet(uint32_t *pCount, zes_temp_handle_t *phTemperature) = 0;
virtual ze_result_t standbyGet(uint32_t *pCount, zes_standby_handle_t *phStandby) = 0;
virtual ze_result_t engineGet(uint32_t *pCount, zes_engine_handle_t *phEngine) = 0;
virtual ze_result_t pciGetProperties(zes_pci_properties_t *pProperties) = 0;
virtual ze_result_t pciGetState(zes_pci_state_t *pState) = 0;
virtual ze_result_t pciGetBars(uint32_t *pCount, zes_pci_bar_properties_t *pProperties) = 0;
virtual ze_result_t pciGetStats(zes_pci_stats_t *pStats) = 0;
virtual ~SysmanDevice() = default;
};

21
level_zero/tools/source/sysman/sysman_imp.cpp
View File

@ -22,6 +22,7 @@ SysmanDeviceImp::SysmanDeviceImp(ze_device_handle_t hDevice) {
hCoreDevice = hDevice;
pOsSysman = OsSysman::create(this);
UNRECOVERABLE_IF(nullptr == pOsSysman);
pPci = new PciImp(pOsSysman, hCoreDevice);
pPowerHandleContext = new PowerHandleContext(pOsSysman);
pFrequencyHandleContext = new FrequencyHandleContext(pOsSysman);
pFabricPortHandleContext = new FabricPortHandleContext(pOsSysman);
@ -35,6 +36,7 @@ SysmanDeviceImp::~SysmanDeviceImp() {
freeResource(pStandbyHandleContext);
freeResource(pTempHandleContext);
freeResource(pFabricPortHandleContext);
freeResource(pPci);
freeResource(pFrequencyHandleContext);
freeResource(pPowerHandleContext);
freeResource(pOsSysman);
@ -54,6 +56,9 @@ void SysmanDeviceImp::init() {
if (pTempHandleContext) {
pTempHandleContext->init();
}
if (pPci) {
pPci->init();
}
if (pStandbyHandleContext) {
pStandbyHandleContext->init();
}
@ -66,6 +71,22 @@ ze_result_t SysmanDeviceImp::frequencyGet(uint32_t *pCount, zes_freq_handle_t *p
return pFrequencyHandleContext->frequencyGet(pCount, phFrequency);
}
ze_result_t SysmanDeviceImp::pciGetProperties(zes_pci_properties_t *pProperties) {
return pPci->pciStaticProperties(pProperties);
}
ze_result_t SysmanDeviceImp::pciGetState(zes_pci_state_t *pState) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t SysmanDeviceImp::pciGetBars(uint32_t *pCount, zes_pci_bar_properties_t *pProperties) {
return pPci->pciGetInitializedBars(pCount, pProperties);
}
ze_result_t SysmanDeviceImp::pciGetStats(zes_pci_stats_t *pStats) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t SysmanDeviceImp::powerGet(uint32_t *pCount, zes_pwr_handle_t *phPower) {
return pPowerHandleContext->powerGet(pCount, phPower);
}

5
level_zero/tools/source/sysman/sysman_imp.h
View File

@ -26,6 +26,7 @@ struct SysmanDeviceImp : SysmanDevice, NEO::NonCopyableOrMovableClass {
ze_device_handle_t hCoreDevice = nullptr;
OsSysman *pOsSysman = nullptr;
Pci *pPci = nullptr;
PowerHandleContext *pPowerHandleContext = nullptr;
FrequencyHandleContext *pFrequencyHandleContext = nullptr;
FabricPortHandleContext *pFabricPortHandleContext = nullptr;
@ -39,6 +40,10 @@ struct SysmanDeviceImp : SysmanDevice, NEO::NonCopyableOrMovableClass {
ze_result_t temperatureGet(uint32_t *pCount, zes_temp_handle_t *phTemperature) override;
ze_result_t standbyGet(uint32_t *pCount, zes_standby_handle_t *phStandby) override;
ze_result_t engineGet(uint32_t *pCount, zes_engine_handle_t *phEngine) override;
ze_result_t pciGetProperties(zes_pci_properties_t *pProperties) override;
ze_result_t pciGetState(zes_pci_state_t *pState) override;
ze_result_t pciGetBars(uint32_t *pCount, zes_pci_bar_properties_t *pProperties) override;
ze_result_t pciGetStats(zes_pci_stats_t *pStats) override;
private:
template <typename T>

6
level_zero/tools/test/unit_tests/sources/sysman/pci/linux/CMakeLists.txt
View File

@ -7,8 +7,8 @@
if(UNIX)
target_sources(${TARGET_NAME}
PRIVATE
# ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
# ${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_pci.cpp
# ${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_pci.h
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_pci.h
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_pci.cpp
)
endif()

18
level_zero/tools/test/unit_tests/sources/sysman/pci/linux/mock_sysfs_pci.h
View File

@ -12,8 +12,6 @@
#include "sysman/pci/pci_imp.h"
using ::testing::_;
namespace L0 {
namespace ult {
@ -49,9 +47,9 @@ class PcifsAccess : public FsAccess {};
template <>
struct Mock<PcifsAccess> : public PcifsAccess {
uint32_t mockMaxLinkWidth = 0;
int32_t mockMaxLinkWidth = 0;
MOCK_METHOD(ze_result_t, read, (const std::string file, double &val), (override));
MOCK_METHOD(ze_result_t, read, (const std::string file, uint32_t &val), (override));
MOCK_METHOD(ze_result_t, read, (const std::string file, int32_t &val), (override));
ze_result_t getValDouble(const std::string file, double &val) {
if (file.compare(mockRealPath2LevelsUp + '/' + "max_link_speed") == 0) {
@ -61,7 +59,7 @@ struct Mock<PcifsAccess> : public PcifsAccess {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t getValInt(const std::string file, uint32_t &val) {
ze_result_t getValInt(const std::string file, int32_t &val) {
if (file.compare(mockRealPath2LevelsUp + '/' + "max_link_width") == 0) {
val = mockMaxLinkWidth;
return ZE_RESULT_SUCCESS;
@ -69,7 +67,7 @@ struct Mock<PcifsAccess> : public PcifsAccess {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t setValInt(const std::string file, uint32_t val) {
ze_result_t setValInt(const std::string file, int32_t val) {
if (file.compare(maxLinkWidthFile) == 0) {
mockMaxLinkWidth = val;
}
@ -79,9 +77,9 @@ struct Mock<PcifsAccess> : public PcifsAccess {
template <>
struct Mock<PciSysfsAccess> : public PciSysfsAccess {
uint32_t mockMaxLinkWidth = 0;
int32_t mockMaxLinkWidth = 0;
MOCK_METHOD(ze_result_t, read, (const std::string file, double &val), (override));
MOCK_METHOD(ze_result_t, read, (const std::string file, uint32_t &val), (override));
MOCK_METHOD(ze_result_t, read, (const std::string file, int32_t &val), (override));
MOCK_METHOD(ze_result_t, read, (const std::string file, std::vector<std::string> &val), (override));
MOCK_METHOD(ze_result_t, readSymLink, (const std::string file, std::string &buf), (override));
MOCK_METHOD(ze_result_t, getRealPath, (const std::string file, std::string &buf), (override));
@ -94,7 +92,7 @@ struct Mock<PciSysfsAccess> : public PciSysfsAccess {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t setValInt(const std::string file, uint32_t val) {
ze_result_t setValInt(const std::string file, int32_t val) {
if (file.compare(maxLinkWidthFile) == 0) {
mockMaxLinkWidth = val;
return ZE_RESULT_SUCCESS;
@ -102,7 +100,7 @@ struct Mock<PciSysfsAccess> : public PciSysfsAccess {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t getValInt(const std::string file, uint32_t &val) {
ze_result_t getValInt(const std::string file, int32_t &val) {
if (file.compare(maxLinkWidthFile) == 0) {
val = mockMaxLinkWidth;
return ZE_RESULT_SUCCESS;

150
level_zero/tools/test/unit_tests/sources/sysman/pci/linux/test_sysman_pci.cpp → level_zero/tools/test/unit_tests/sources/sysman/pci/linux/test_zes_pci.cpp
View File

@ -5,24 +5,17 @@
*
*/
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/core/test/unit_tests/mocks/mock_memory_manager.h"
#include "level_zero/tools/source/sysman/pci/linux/os_pci_imp.h"
#include "level_zero/tools/source/sysman/sysman_imp.h"
#include "level_zero/tools/test/unit_tests/sources/sysman/mock_sysman_fixture.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "mock_sysfs_pci.h"
#include <string>
using ::testing::_;
using ::testing::DoAll;
using ::testing::InSequence;
using ::testing::Invoke;
using ::testing::Matcher;
using ::testing::NiceMock;
using ::testing::Return;
namespace L0 {
namespace ult {
@ -31,29 +24,25 @@ constexpr int mockMaxLinkWidthInvalid = 255;
constexpr uint32_t expectedBus = 0u;
constexpr uint32_t expectedDevice = 2u;
constexpr uint32_t expectedFunction = 0u;
constexpr uint32_t expectedWidth = 1u;
constexpr uint32_t expectedGen = 1u; // As mockMaxLinkSpeed = 2.5, hence expectedGen should be 1
constexpr int32_t expectedWidth = 1u;
constexpr int32_t expectedGen = 1u; // As mockMaxLinkSpeed = 2.5, hence expectedGen should be 1
// As mockMaxLinkSpeed = 2.5, hence, pcieSpeedWithEnc = mockMaxLinkWidth * (2.5 * 1000 * 8/10 * 125000) = 250000000
constexpr uint64_t expectedBandwidth = 250000000u;
constexpr int64_t expectedBandwidth = 250000000u;
struct MockMemoryManagerPci : public MemoryManagerMock {
MockMemoryManagerPci(NEO::ExecutionEnvironment &executionEnvironment) : MemoryManagerMock(const_cast<NEO::ExecutionEnvironment &>(executionEnvironment)) {}
};
class SysmanPciFixture : public ::testing::Test {
class ZesPciFixture : public ::testing::Test {
protected:
std::unique_ptr<SysmanImp> sysmanImp;
zet_sysman_handle_t hSysman;
OsPci *pOsPci = nullptr;
Mock<PciSysfsAccess> *pSysfsAccess = nullptr;
Mock<PcifsAccess> *pfsAccess = nullptr;
L0::Pci *pPciPrev = nullptr;
L0::PciImp pciImp;
PublicLinuxPciImp linuxPciImp;
std::unique_ptr<Mock<PciSysfsAccess>> pSysfsAccess;
std::unique_ptr<Mock<PcifsAccess>> pfsAccess;
MockMemoryManagerPci *memoryManager = nullptr;
SysfsAccess *pOriginalSysfsAccess = nullptr;
FsAccess *pOriginalFsAccess = nullptr;
L0::PciImp *pPciImp;
OsPci *pOsPciPrev;
std::unique_ptr<Mock<L0::DriverHandleImp>> driverHandle;
NEO::MockDevice *neoDevice = nullptr;
L0::Device *device = nullptr;
@ -68,55 +57,64 @@ class SysmanPciFixture : public ::testing::Test {
driverHandle->initialize(std::move(devices));
device = driverHandle->devices[0];
sysmanImp = std::make_unique<SysmanImp>(device->toHandle());
pSysfsAccess = new NiceMock<Mock<PciSysfsAccess>>;
linuxPciImp.pSysfsAccess = pSysfsAccess;
pfsAccess = new NiceMock<Mock<PcifsAccess>>;
linuxPciImp.pfsAccess = pfsAccess;
pOsPci = static_cast<OsPci *>(&linuxPciImp);
neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[device->getRootDeviceIndex()]->osInterface = std::make_unique<NEO::OSInterface>();
auto osInterface = device->getOsInterface().get();
osInterface->setDrm(new SysmanMockDrm(const_cast<NEO::RootDeviceEnvironment &>(neoDevice->getRootDeviceEnvironment())));
setenv("ZES_ENABLE_SYSMAN", "1", 1);
device->setSysmanHandle(L0::SysmanDeviceHandleContext::init(device->toHandle()));
pSysmanDevice = device->getSysmanHandle();
pSysmanDeviceImp = static_cast<SysmanDeviceImp *>(pSysmanDevice);
pOsSysman = pSysmanDeviceImp->pOsSysman;
pLinuxSysmanImp = static_cast<PublicLinuxSysmanImp *>(pOsSysman);
pSysfsAccess = std::make_unique<NiceMock<Mock<PciSysfsAccess>>>();
pOriginalSysfsAccess = pLinuxSysmanImp->pSysfsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
pfsAccess = std::make_unique<NiceMock<Mock<PcifsAccess>>>();
pOriginalFsAccess = pLinuxSysmanImp->pFsAccess;
pLinuxSysmanImp->pFsAccess = pfsAccess.get();
pSysfsAccess->setValInt(maxLinkWidthFile, mockMaxLinkWidth);
pfsAccess->setValInt(maxLinkWidthFile, mockMaxLinkWidth);
ON_CALL(*pSysfsAccess, read(_, Matcher<std::vector<std::string> &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess, &Mock<PciSysfsAccess>::getValVector));
ON_CALL(*pSysfsAccess, read(_, Matcher<uint32_t &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess, &Mock<PciSysfsAccess>::getValInt));
ON_CALL(*pSysfsAccess, readSymLink(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess, &Mock<PciSysfsAccess>::getValStringSymLink));
ON_CALL(*pSysfsAccess, getRealPath(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess, &Mock<PciSysfsAccess>::getValStringRealPath));
ON_CALL(*pSysfsAccess, read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess, &Mock<PciSysfsAccess>::getValDouble));
ON_CALL(*pfsAccess, read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pfsAccess, &Mock<PcifsAccess>::getValDouble));
ON_CALL(*pfsAccess, read(_, Matcher<uint32_t &>(_)))
.WillByDefault(::testing::Invoke(pfsAccess, &Mock<PcifsAccess>::getValInt));
pPciPrev = sysmanImp->pPci;
sysmanImp->pPci = static_cast<Pci *>(&pciImp);
pciImp.pOsPci = pOsPci;
pciImp.hCoreDevice = device;
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<std::vector<std::string> &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PciSysfsAccess>::getValVector));
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<int32_t &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PciSysfsAccess>::getValInt));
ON_CALL(*pSysfsAccess.get(), readSymLink(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PciSysfsAccess>::getValStringSymLink));
ON_CALL(*pSysfsAccess.get(), getRealPath(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PciSysfsAccess>::getValStringRealPath));
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PciSysfsAccess>::getValDouble));
ON_CALL(*pfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pfsAccess.get(), &Mock<PcifsAccess>::getValDouble));
ON_CALL(*pfsAccess.get(), read(_, Matcher<int32_t &>(_)))
.WillByDefault(::testing::Invoke(pfsAccess.get(), &Mock<PcifsAccess>::getValInt));
pPciImp = static_cast<L0::PciImp *>(pSysmanDeviceImp->pPci);
pPciImp->hCoreDevice = device->toHandle();
pOsPciPrev = pPciImp->pOsPci;
pPciImp->pOsPci = nullptr;
memoryManager->localMemorySupported[0] = 0;
pciImp.init();
hSysman = sysmanImp->toHandle();
pPciImp->init();
}
void TearDown() override {
sysmanImp->pPci = pPciPrev;
pciImp.pOsPci = nullptr;
// cleanup
if (pSysfsAccess != nullptr) {
delete pSysfsAccess;
pSysfsAccess = nullptr;
}
if (pfsAccess != nullptr) {
delete pfsAccess;
pfsAccess = nullptr;
if (nullptr != pPciImp->pOsPci) {
delete pPciImp->pOsPci;
}
pPciImp->pOsPci = pOsPciPrev;
pPciImp = nullptr;
unsetenv("ZES_ENABLE_SYSMAN");
pLinuxSysmanImp->pSysfsAccess = pOriginalSysfsAccess;
pLinuxSysmanImp->pFsAccess = pOriginalFsAccess;
}
SysmanDevice *pSysmanDevice = nullptr;
SysmanDeviceImp *pSysmanDeviceImp = nullptr;
OsSysman *pOsSysman = nullptr;
PublicLinuxSysmanImp *pLinuxSysmanImp = nullptr;
};
TEST_F(SysmanPciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetPropertiesThenVerifyzetSysmanPciGetPropertiesCallSucceeds) {
TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetPropertiesThenVerifyzetSysmanPciGetPropertiesCallSucceeds) {
zes_pci_properties_t properties, propertiesBefore;
memset(&properties.address.bus, std::numeric_limits<int>::max(), sizeof(properties.address.bus));
@ -127,7 +125,7 @@ TEST_F(SysmanPciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetPropert
memset(&properties.maxSpeed.maxBandwidth, std::numeric_limits<int>::max(), sizeof(properties.maxSpeed.maxBandwidth));
propertiesBefore = properties;
ze_result_t result = zetSysmanPciGetProperties(hSysman, &properties);
ze_result_t result = zesDevicePciGetProperties(device, &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(properties.address.bus, expectedBus);
@ -145,10 +143,10 @@ TEST_F(SysmanPciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetPropert
EXPECT_NE(properties.maxSpeed.maxBandwidth, propertiesBefore.maxSpeed.maxBandwidth);
}
TEST_F(SysmanPciFixture, GivenValidSysmanHandleWhenSettingLmemSupportAndCallingzetSysmanPciGetPropertiesThenVerifyzetSysmanPciGetPropertiesCallSucceeds) {
TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenSettingLmemSupportAndCallingzetSysmanPciGetPropertiesThenVerifyzetSysmanPciGetPropertiesCallSucceeds) {
zes_pci_properties_t properties, propertiesBefore;
memoryManager->localMemorySupported[0] = 1;
pciImp.init();
pPciImp->init();
memset(&properties.address.bus, std::numeric_limits<int>::max(), sizeof(properties.address.bus));
memset(&properties.address.device, std::numeric_limits<int>::max(), sizeof(properties.address.device));
@ -158,7 +156,7 @@ TEST_F(SysmanPciFixture, GivenValidSysmanHandleWhenSettingLmemSupportAndCallingz
memset(&properties.maxSpeed.maxBandwidth, std::numeric_limits<int>::max(), sizeof(properties.maxSpeed.maxBandwidth));
propertiesBefore = properties;
ze_result_t result = zetSysmanPciGetProperties(hSysman, &properties);
ze_result_t result = zesDevicePciGetProperties(device, &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(properties.address.bus, expectedBus);
@ -176,31 +174,31 @@ TEST_F(SysmanPciFixture, GivenValidSysmanHandleWhenSettingLmemSupportAndCallingz
EXPECT_NE(properties.maxSpeed.maxBandwidth, propertiesBefore.maxSpeed.maxBandwidth);
}
TEST_F(SysmanPciFixture, GivenValidSysmanHandleWhenGettingPCIWidthThenZeroWidthIsReturnedIfSystemProvidesInvalidValue) {
uint32_t width = 0;
TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenGettingPCIWidthThenZeroWidthIsReturnedIfSystemProvidesInvalidValue) {
int32_t width = 0;
pSysfsAccess->setValInt(maxLinkWidthFile, mockMaxLinkWidthInvalid);
pfsAccess->setValInt(maxLinkWidthFile, mockMaxLinkWidthInvalid);
ON_CALL(*pSysfsAccess, read(_, Matcher<uint32_t &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess, &Mock<PciSysfsAccess>::getValInt));
ON_CALL(*pfsAccess, read(_, Matcher<uint32_t &>(_)))
.WillByDefault(::testing::Invoke(pfsAccess, &Mock<PcifsAccess>::getValInt));
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<int32_t &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<PciSysfsAccess>::getValInt));
ON_CALL(*pfsAccess.get(), read(_, Matcher<int32_t &>(_)))
.WillByDefault(::testing::Invoke(pfsAccess.get(), &Mock<PcifsAccess>::getValInt));
EXPECT_EQ(ZE_RESULT_SUCCESS, pciImp.pOsPci->getMaxLinkWidth(width));
EXPECT_EQ(width, 0u);
EXPECT_EQ(ZE_RESULT_SUCCESS, pPciImp->pOsPci->getMaxLinkWidth(width));
EXPECT_EQ(width, -1);
}
TEST_F(SysmanPciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetBarsThenVerifyzetSysmanPciGetBarsCallSucceeds) {
TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetBarsThenVerifyzetSysmanPciGetBarsCallSucceeds) {
uint32_t count = 0;
ze_result_t result = zetSysmanPciGetBars(hSysman, &count, nullptr);
ze_result_t result = zesDevicePciGetBars(device, &count, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_GT(count, 0u);
std::vector<zes_pci_bar_properties_t> pciBarProps(count);
result = zetSysmanPciGetBars(hSysman, &count, pciBarProps.data());
result = zesDevicePciGetBars(device, &count, pciBarProps.data());
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
for (uint32_t i = 0; i < count; i++) {
EXPECT_LE(pciBarProps[i].type, ZET_PCI_BAR_TYPE_OTHER);
EXPECT_LE(pciBarProps[i].type, ZES_PCI_BAR_TYPE_MEM);
EXPECT_NE(pciBarProps[i].base, 0u);
EXPECT_NE(pciBarProps[i].size, 0u);
}