Move FabricPort implementation to L0 Spec version 1.0.

Change-Id: I7b123c2813beab1175965eb8272c96cdb7f7be27
Signed-off-by: Bill Jordan <bill.jordan@intel.com>

level_zero/tools/source/sysman/fabric_port/fabric_port.cpp

@@ -13,21 +13,23 @@
 
 namespace L0 {
 
+FabricPortHandleContext::FabricPortHandleContext(OsSysman *pOsSysman) {
+    pFabricDevice = new FabricDeviceImp(pOsSysman);
+    UNRECOVERABLE_IF(nullptr == pFabricDevice);
+}
+
 FabricPortHandleContext::~FabricPortHandleContext() {
-    if (nullptr != pFabricDevice) {
-        for (FabricPort *pFabricPort : handleList) {
-            delete pFabricPort;
-        }
-        handleList.clear();
-        delete pFabricDevice;
-        pFabricDevice = nullptr;
+    UNRECOVERABLE_IF(nullptr == pFabricDevice);
+    for (FabricPort *pFabricPort : handleList) {
+        delete pFabricPort;
     }
+    handleList.clear();
+    delete pFabricDevice;
+    pFabricDevice = nullptr;
 }
 
 ze_result_t FabricPortHandleContext::init() {
-    pFabricDevice = new FabricDeviceImp(pOsSysman);
     UNRECOVERABLE_IF(nullptr == pFabricDevice);
-
     uint32_t numPorts = pFabricDevice->getNumPorts();
 
     for (uint32_t portNum = 0; portNum < numPorts; portNum++) {
@@ -38,18 +40,35 @@ ze_result_t FabricPortHandleContext::init() {
     return ZE_RESULT_SUCCESS;
 }
 
-ze_result_t FabricPortHandleContext::fabricPortGet(uint32_t *pCount, zet_sysman_fabric_port_handle_t *phPort) {
-    if (nullptr == phPort) {
+ze_result_t FabricPortHandleContext::fabricPortGet(uint32_t *pCount, zes_fabric_port_handle_t *phPort) {
+    if (0 == *pCount || handleList.size() < *pCount) {
         *pCount = static_cast<uint32_t>(handleList.size());
-        return ZE_RESULT_SUCCESS;
     }
-    uint32_t i = 0;
-    for (FabricPort *pFabricPort : handleList) {
-        if (i >= *pCount)
-            break;
-        phPort[i++] = pFabricPort->toHandle();
+    if (nullptr != phPort) {
+        uint32_t i = 0;
+        for (FabricPort *pFabricPort : handleList) {
+            if (i >= *pCount) {
+                break;
+            }
+            phPort[i++] = pFabricPort->toZesHandle();
+        }
+    }
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t FabricPortHandleContext::fabricPortGet(uint32_t *pCount, zet_sysman_fabric_port_handle_t *phPort) {
+    if (0 == *pCount || handleList.size() < *pCount) {
+        *pCount = static_cast<uint32_t>(handleList.size());
+    }
+    if (nullptr != phPort) {
+        uint32_t i = 0;
+        for (FabricPort *pFabricPort : handleList) {
+            if (i >= *pCount) {
+                break;
+            }
+            phPort[i++] = pFabricPort->toHandle();
+        }
     }
-    *pCount = i;
     return ZE_RESULT_SUCCESS;
 }
 

level_zero/tools/source/sysman/fabric_port/fabric_port.h

@@ -6,11 +6,20 @@
  */
 
 #pragma once
+#include "shared/source/helpers/non_copyable_or_moveable.h"
+
 #include <level_zero/zet_api.h>
 
+#include "third_party/level_zero/zes_api_ext.h"
+
 #include <vector>
 
-struct _zet_sysman_fabric_port_handle_t {};
+struct _zet_sysman_fabric_port_handle_t {
+    virtual ~_zet_sysman_fabric_port_handle_t() = default;
+};
+struct _zes_fabric_port_handle_t {
+    virtual ~_zes_fabric_port_handle_t() = default;
+};
 
 namespace L0 {
 
@@ -24,9 +33,16 @@ class FabricDevice {
     virtual uint32_t getNumPorts() = 0;
 };
 
-class FabricPort : _zet_sysman_fabric_port_handle_t {
+class FabricPort : _zet_sysman_fabric_port_handle_t, _zes_fabric_port_handle_t {
   public:
     virtual ~FabricPort() = default;
+    virtual ze_result_t fabricPortGetProperties(zes_fabric_port_properties_t *pProperties) = 0;
+    virtual ze_result_t fabricPortGetLinkType(zes_fabric_link_type_t *pLinkType) = 0;
+    virtual ze_result_t fabricPortGetConfig(zes_fabric_port_config_t *pConfig) = 0;
+    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 fabricPortGetProperties(zet_fabric_port_properties_t *pProperties) = 0;
     virtual ze_result_t fabricPortGetLinkType(ze_bool_t verbose, zet_fabric_link_type_t *pLinkType) = 0;
     virtual ze_result_t fabricPortGetConfig(zet_fabric_port_config_t *pConfig) = 0;
@@ -34,22 +50,28 @@ class FabricPort : _zet_sysman_fabric_port_handle_t {
     virtual ze_result_t fabricPortGetState(zet_fabric_port_state_t *pState) = 0;
     virtual ze_result_t fabricPortGetThroughput(zet_fabric_port_throughput_t *pThroughput) = 0;
 
+    inline zet_sysman_fabric_port_handle_t toHandle() { return this; }
+    inline zes_fabric_port_handle_t toZesHandle() { return this; }
+
     static FabricPort *fromHandle(zet_sysman_fabric_port_handle_t handle) {
         return static_cast<FabricPort *>(handle);
     }
-    inline zet_sysman_fabric_port_handle_t toHandle() { return this; }
+
+    static FabricPort *fromHandle(zes_fabric_port_handle_t handle) {
+        return static_cast<FabricPort *>(handle);
+    }
 };
 
-struct FabricPortHandleContext {
-    FabricPortHandleContext(OsSysman *pOsSysman) : pOsSysman(pOsSysman){};
+struct FabricPortHandleContext : NEO::NonCopyableOrMovableClass {
+    FabricPortHandleContext(OsSysman *pOsSysman);
     ~FabricPortHandleContext();
 
     ze_result_t init();
 
+    ze_result_t fabricPortGet(uint32_t *pCount, zes_fabric_port_handle_t *phPort);
     ze_result_t fabricPortGet(uint32_t *pCount, zet_sysman_fabric_port_handle_t *phPort);
 
     FabricDevice *pFabricDevice = nullptr;
-    OsSysman *pOsSysman = nullptr;
     std::vector<FabricPort *> handleList = {};
 };
 

level_zero/tools/source/sysman/fabric_port/fabric_port_imp.cpp

@@ -33,8 +33,45 @@ void fabricPortGetTimestamp(uint64_t &timestamp) {
     timestamp = std::chrono::duration_cast<std::chrono::microseconds>(ts.time_since_epoch()).count();
 }
 
+ze_result_t FabricPortImp::fabricPortGetProperties(zes_fabric_port_properties_t *pProperties) {
+    pOsFabricPort->getModel(pProperties->model);
+    pProperties->onSubdevice = onSubdevice;
+    pProperties->subdeviceId = subdeviceId;
+    pOsFabricPort->getPortId(pProperties->portId);
+    pOsFabricPort->getMaxRxSpeed(pProperties->maxRxSpeed);
+    pOsFabricPort->getMaxTxSpeed(pProperties->maxTxSpeed);
+
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t FabricPortImp::fabricPortGetLinkType(zes_fabric_link_type_t *pLinkType) {
+    return pOsFabricPort->getLinkType(pLinkType);
+}
+
+ze_result_t FabricPortImp::fabricPortGetConfig(zes_fabric_port_config_t *pConfig) {
+    return pOsFabricPort->getConfig(pConfig);
+}
+
+ze_result_t FabricPortImp::fabricPortSetConfig(const zes_fabric_port_config_t *pConfig) {
+    return pOsFabricPort->setConfig(pConfig);
+}
+
+ze_result_t FabricPortImp::fabricPortGetState(zes_fabric_port_state_t *pState) {
+    return pOsFabricPort->getState(pState);
+}
+
+ze_result_t FabricPortImp::fabricPortGetThroughput(zes_fabric_port_throughput_t *pThroughput) {
+    fabricPortGetTimestamp(pThroughput->timestamp);
+    return pOsFabricPort->getThroughput(pThroughput);
+}
+
 ze_result_t FabricPortImp::fabricPortGetProperties(zet_fabric_port_properties_t *pProperties) {
-    *pProperties = fabricPortProperties;
+    pOsFabricPort->getModel(pProperties->model);
+    pProperties->onSubdevice = onSubdevice;
+    pProperties->subdeviceId = subdeviceId;
+    pOsFabricPort->getPortUuid(pProperties->portUuid);
+    pOsFabricPort->getMaxRxSpeed(pProperties->maxRxSpeed);
+    pOsFabricPort->getMaxTxSpeed(pProperties->maxTxSpeed);
     return ZE_RESULT_SUCCESS;
 }
 
@@ -56,17 +93,12 @@ ze_result_t FabricPortImp::fabricPortGetState(zet_fabric_port_state_t *pState) {
 
 ze_result_t FabricPortImp::fabricPortGetThroughput(zet_fabric_port_throughput_t *pThroughput) {
     fabricPortGetTimestamp(pThroughput->timestamp);
-    ze_result_t result = pOsFabricPort->getThroughput(pThroughput);
-    return result;
+    return pOsFabricPort->getThroughput(pThroughput);
 }
 
 void FabricPortImp::init() {
-    fabricPortProperties.onSubdevice = false;
-    fabricPortProperties.subdeviceId = 0L;
-    pOsFabricPort->getModel(fabricPortProperties.model);
-    pOsFabricPort->getPortUuid(fabricPortProperties.portUuid);
-    pOsFabricPort->getMaxRxSpeed(fabricPortProperties.maxRxSpeed);
-    pOsFabricPort->getMaxTxSpeed(fabricPortProperties.maxTxSpeed);
+    onSubdevice = false;
+    subdeviceId = 0L;
 }
 
 FabricPortImp::FabricPortImp(FabricDevice *pFabricDevice, uint32_t portNum) {

level_zero/tools/source/sysman/fabric_port/fabric_port_imp.h

@@ -13,6 +13,8 @@
 #include "level_zero/tools/source/sysman/fabric_port/os_fabric_port.h"
 #include <level_zero/zet_api.h>
 
+#include "third_party/level_zero/zes_api_ext.h"
+
 namespace L0 {
 
 class FabricDeviceImp : public FabricDevice, NEO::NonCopyableOrMovableClass {
@@ -29,6 +31,13 @@ class FabricDeviceImp : public FabricDevice, NEO::NonCopyableOrMovableClass {
 
 class FabricPortImp : public FabricPort, NEO::NonCopyableOrMovableClass {
   public:
+    ze_result_t fabricPortGetProperties(zes_fabric_port_properties_t *pProperties) override;
+    ze_result_t fabricPortGetLinkType(zes_fabric_link_type_t *pLinkType) override;
+    ze_result_t fabricPortGetConfig(zes_fabric_port_config_t *pConfig) override;
+    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 fabricPortGetProperties(zet_fabric_port_properties_t *pProperties) override;
     ze_result_t fabricPortGetLinkType(ze_bool_t verbose, zet_fabric_link_type_t *pLinkType) override;
     ze_result_t fabricPortGetConfig(zet_fabric_port_config_t *pConfig) override;
@@ -45,7 +54,8 @@ class FabricPortImp : public FabricPort, NEO::NonCopyableOrMovableClass {
     OsFabricPort *pOsFabricPort = nullptr;
 
   private:
-    zet_fabric_port_properties_t fabricPortProperties = {};
+    bool onSubdevice = false;
+    uint32_t subdeviceId = 0U;
 };
 
 } // namespace L0

level_zero/tools/source/sysman/fabric_port/linux/os_fabric_port_imp.cpp

@@ -21,6 +21,57 @@ LinuxFabricDeviceImp::LinuxFabricDeviceImp(OsSysman *pOsSysman) {
 LinuxFabricDeviceImp::~LinuxFabricDeviceImp() {
 }
 
+ze_result_t LinuxFabricPortImp::getLinkType(zes_fabric_link_type_t *pLinkType) {
+    ::snprintf(pLinkType->desc, ZET_MAX_FABRIC_LINK_TYPE_SIZE, "%s", "SAMPLE LINK, VERBOSE");
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t LinuxFabricPortImp::getConfig(zes_fabric_port_config_t *pConfig) {
+    *pConfig = config;
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t LinuxFabricPortImp::setConfig(const zes_fabric_port_config_t *pConfig) {
+    config = *pConfig;
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t LinuxFabricPortImp::getState(zes_fabric_port_state_t *pState) {
+    pState->status = ZES_FABRIC_PORT_STATUS_UNKNOWN;
+    pState->qualityIssues = 0U;
+    pState->failureReasons = 0U;
+    pState->remotePortId.fabricId = 0U;
+    pState->remotePortId.attachId = 0U;
+    pState->remotePortId.portNumber = 0U;
+    pState->rxSpeed.bitRate = 0LU;
+    pState->rxSpeed.width = 0U;
+    pState->txSpeed.bitRate = 0LU;
+    pState->txSpeed.width = 0U;
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t LinuxFabricPortImp::getThroughput(zes_fabric_port_throughput_t *pThroughput) {
+    pThroughput->rxCounter = 0LU;
+    pThroughput->txCounter = 0LU;
+    return ZE_RESULT_SUCCESS;
+}
+
+void LinuxFabricPortImp::getModel(char *model) {
+    ::snprintf(model, ZET_MAX_FABRIC_PORT_MODEL_SIZE, "%s", this->model.c_str());
+}
+
+void LinuxFabricPortImp::getPortId(zes_fabric_port_id_t &portId) {
+    portId = this->portId;
+}
+
+void LinuxFabricPortImp::getMaxRxSpeed(zes_fabric_port_speed_t &maxRxSpeed) {
+    maxRxSpeed = this->maxRxSpeed;
+}
+
+void LinuxFabricPortImp::getMaxTxSpeed(zes_fabric_port_speed_t &maxTxSpeed) {
+    maxTxSpeed = this->maxTxSpeed;
+}
+
 ze_result_t LinuxFabricPortImp::getLinkType(ze_bool_t verbose, zet_fabric_link_type_t *pLinkType) {
     if (verbose) {
         ::snprintf(reinterpret_cast<char *>(pLinkType->desc), ZET_MAX_FABRIC_LINK_TYPE_SIZE, "%s", "SAMPLE LINK, VERBOSE");
@@ -31,12 +82,12 @@ ze_result_t LinuxFabricPortImp::getLinkType(ze_bool_t verbose, zet_fabric_link_t
 }
 
 ze_result_t LinuxFabricPortImp::getConfig(zet_fabric_port_config_t *pConfig) {
-    *pConfig = config;
+    *pConfig = zetConfig;
     return ZE_RESULT_SUCCESS;
 }
 
 ze_result_t LinuxFabricPortImp::setConfig(const zet_fabric_port_config_t *pConfig) {
-    config = *pConfig;
+    zetConfig = *pConfig;
     return ZE_RESULT_SUCCESS;
 }
 
@@ -62,24 +113,25 @@ ze_result_t LinuxFabricPortImp::getThroughput(zet_fabric_port_throughput_t *pThr
 }
 
 void LinuxFabricPortImp::getModel(int8_t *model) {
-    ::snprintf(reinterpret_cast<char *>(model), ZET_MAX_FABRIC_PORT_MODEL_SIZE, "%s", this->model.c_str());
+    ::snprintf(reinterpret_cast<char *>(model), ZET_MAX_FABRIC_PORT_MODEL_SIZE, "%s", this->zetModel.c_str());
 }
 
 void LinuxFabricPortImp::getPortUuid(zet_fabric_port_uuid_t &portUuid) {
-    portUuid = this->portUuid;
+    portUuid = this->zetPortUuid;
 }
 
 void LinuxFabricPortImp::getMaxRxSpeed(zet_fabric_port_speed_t &maxRxSpeed) {
-    maxRxSpeed = this->maxRxSpeed;
+    maxRxSpeed = this->zetMaxRxSpeed;
 }
 
 void LinuxFabricPortImp::getMaxTxSpeed(zet_fabric_port_speed_t &maxTxSpeed) {
-    maxTxSpeed = this->maxTxSpeed;
+    maxTxSpeed = this->zetMaxTxSpeed;
 }
 
 LinuxFabricPortImp::LinuxFabricPortImp(OsFabricDevice *pOsFabricDevice, uint32_t portNum) {
     this->portNum = portNum;
     model = std::string("EXAMPLE");
+    zetModel = std::string("EXAMPLE");
 }
 
 LinuxFabricPortImp::~LinuxFabricPortImp() {

level_zero/tools/source/sysman/fabric_port/linux/os_fabric_port_imp.h

@@ -28,6 +28,16 @@ class LinuxFabricDeviceImp : public OsFabricDevice, NEO::NonCopyableOrMovableCla
 
 class LinuxFabricPortImp : public OsFabricPort, NEO::NonCopyableOrMovableClass {
   public:
+    ze_result_t getLinkType(zes_fabric_link_type_t *pLinkType) override;
+    ze_result_t getConfig(zes_fabric_port_config_t *pConfig) override;
+    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;
+    void getModel(char *model) override;
+    void getPortId(zes_fabric_port_id_t &portId) override;
+    void getMaxRxSpeed(zes_fabric_port_speed_t &maxRxSpeed) override;
+    void getMaxTxSpeed(zes_fabric_port_speed_t &maxTxSpeed) override;
+
     ze_result_t getLinkType(ze_bool_t verbose, zet_fabric_link_type_t *pLinkType) override;
     ze_result_t getConfig(zet_fabric_port_config_t *pConfig) override;
     ze_result_t setConfig(const zet_fabric_port_config_t *pConfig) override;
@@ -45,10 +55,16 @@ class LinuxFabricPortImp : public OsFabricPort, NEO::NonCopyableOrMovableClass {
   private:
     uint32_t portNum = 0;
     std::string model = "";
-    zet_fabric_port_uuid_t portUuid = {};
-    zet_fabric_port_speed_t maxRxSpeed = {};
-    zet_fabric_port_speed_t maxTxSpeed = {};
-    zet_fabric_port_config_t config = {};
+    zes_fabric_port_id_t portId = {};
+    zes_fabric_port_speed_t maxRxSpeed = {};
+    zes_fabric_port_speed_t maxTxSpeed = {};
+    zes_fabric_port_config_t config = {};
+
+    std::string zetModel = "";
+    zet_fabric_port_uuid_t zetPortUuid = {};
+    zet_fabric_port_speed_t zetMaxRxSpeed = {};
+    zet_fabric_port_speed_t zetMaxTxSpeed = {};
+    zet_fabric_port_config_t zetConfig = {};
 };
 
 } // namespace L0

level_zero/tools/source/sysman/fabric_port/os_fabric_port.h

@@ -10,6 +10,8 @@
 #include "level_zero/tools/source/sysman/os_sysman.h"
 #include <level_zero/zet_api.h>
 
+#include "third_party/level_zero/zes_api_ext.h"
+
 namespace L0 {
 
 class OsFabricDevice {
@@ -23,6 +25,16 @@ class OsFabricDevice {
 
 class OsFabricPort {
   public:
+    virtual ze_result_t getLinkType(zes_fabric_link_type_t *pLinkType) = 0;
+    virtual ze_result_t getConfig(zes_fabric_port_config_t *pConfig) = 0;
+    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 void getModel(char *model) = 0;
+    virtual void getPortId(zes_fabric_port_id_t &portId) = 0;
+    virtual void getMaxRxSpeed(zes_fabric_port_speed_t &maxRxSpeed) = 0;
+    virtual void getMaxTxSpeed(zes_fabric_port_speed_t &maxTxSpeed) = 0;
+
     virtual ze_result_t getLinkType(ze_bool_t verbose, zet_fabric_link_type_t *pLinkType) = 0;
     virtual ze_result_t getConfig(zet_fabric_port_config_t *pConfig) = 0;
     virtual ze_result_t setConfig(const zet_fabric_port_config_t *pConfig) = 0;

level_zero/tools/source/sysman/fabric_port/windows/os_fabric_port_imp.cpp

@@ -21,6 +21,42 @@ WddmFabricDeviceImp::WddmFabricDeviceImp(OsSysman *pOsSysman) {
 WddmFabricDeviceImp::~WddmFabricDeviceImp() {
 }
 
+ze_result_t WddmFabricPortImp::getLinkType(zes_fabric_link_type_t *pLinkType) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t WddmFabricPortImp::getConfig(zes_fabric_port_config_t *pConfig) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t WddmFabricPortImp::setConfig(const zes_fabric_port_config_t *pConfig) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t WddmFabricPortImp::getState(zes_fabric_port_state_t *pState) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t WddmFabricPortImp::getThroughput(zes_fabric_port_throughput_t *pThroughput) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+void WddmFabricPortImp::getModel(char *model) {
+    ::memset(model, '\0', ZES_MAX_FABRIC_PORT_MODEL_SIZE);
+}
+
+void WddmFabricPortImp::getPortId(zes_fabric_port_id_t &portId) {
+    ::memset(&portId, '\0', sizeof(portId));
+}
+
+void WddmFabricPortImp::getMaxRxSpeed(zes_fabric_port_speed_t &maxRxSpeed) {
+    ::memset(&maxRxSpeed, '\0', sizeof(maxRxSpeed));
+}
+
+void WddmFabricPortImp::getMaxTxSpeed(zes_fabric_port_speed_t &maxTxSpeed) {
+    ::memset(&maxTxSpeed, '\0', sizeof(maxTxSpeed));
+}
+
 ze_result_t WddmFabricPortImp::getLinkType(ze_bool_t verbose, zet_fabric_link_type_t *pLinkType) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }

level_zero/tools/source/sysman/fabric_port/windows/os_fabric_port_imp.h

@@ -29,6 +29,16 @@ class WddmFabricDeviceImp : public OsFabricDevice, NEO::NonCopyableOrMovableClas
 
 class WddmFabricPortImp : public OsFabricPort, NEO::NonCopyableOrMovableClass {
   public:
+    ze_result_t getLinkType(zes_fabric_link_type_t *pLinkType) override;
+    ze_result_t getConfig(zes_fabric_port_config_t *pConfig) override;
+    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;
+    void getModel(char *model) override;
+    void getPortId(zes_fabric_port_id_t &portId) override;
+    void getMaxRxSpeed(zes_fabric_port_speed_t &maxRxSpeed) override;
+    void getMaxTxSpeed(zes_fabric_port_speed_t &maxTxSpeed) override;
+
     ze_result_t getLinkType(ze_bool_t verbose, zet_fabric_link_type_t *pLinkType) override;
     ze_result_t getConfig(zet_fabric_port_config_t *pConfig) override;
     ze_result_t setConfig(const zet_fabric_port_config_t *pConfig) override;
@@ -39,6 +49,7 @@ class WddmFabricPortImp : public OsFabricPort, NEO::NonCopyableOrMovableClass {
     void getMaxRxSpeed(zet_fabric_port_speed_t &maxRxSpeed) override;
     void getMaxTxSpeed(zet_fabric_port_speed_t &maxTxSpeed) override;
 
+    WddmFabricPortImp() = delete;
     WddmFabricPortImp(OsFabricDevice *pOsFabricDevice, uint32_t portNum);
     ~WddmFabricPortImp() override;
 };

level_zero/tools/source/sysman/sysman.h

@@ -83,6 +83,7 @@ struct SysmanDevice : _ze_device_handle_t {
 
     virtual ze_result_t powerGet(uint32_t *pCount, zes_pwr_handle_t *phPower) = 0;
     virtual ze_result_t frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency) = 0;
+    virtual ze_result_t fabricPortGet(uint32_t *pCount, zes_fabric_port_handle_t *phPort) = 0;
     virtual ~SysmanDevice() = default;
 };
 

level_zero/tools/source/sysman/sysman_imp.cpp

@@ -24,9 +24,11 @@ SysmanDeviceImp::SysmanDeviceImp(ze_device_handle_t hDevice) {
     UNRECOVERABLE_IF(nullptr == pOsSysman);
     pPowerHandleContext = new PowerHandleContext(pOsSysman);
     pFrequencyHandleContext = new FrequencyHandleContext(pOsSysman);
+    pFabricPortHandleContext = new FabricPortHandleContext(pOsSysman);
 }
 
 SysmanDeviceImp::~SysmanDeviceImp() {
+    freeResource(pFabricPortHandleContext);
     freeResource(pOsSysman);
     freeResource(pPowerHandleContext);
     freeResource(pFrequencyHandleContext);
@@ -40,6 +42,9 @@ void SysmanDeviceImp::init() {
     if (pFrequencyHandleContext) {
         pFrequencyHandleContext->init();
     }
+    if (pFabricPortHandleContext) {
+        pFabricPortHandleContext->init();
+    }
 }
 
 SysmanImp::SysmanImp(ze_device_handle_t hDevice) {
@@ -224,6 +229,10 @@ ze_result_t SysmanImp::memoryGet(uint32_t *pCount, zet_sysman_mem_handle_t *phMe
     return pMemoryHandleContext->memoryGet(pCount, phMemory);
 }
 
+ze_result_t SysmanDeviceImp::fabricPortGet(uint32_t *pCount, zes_fabric_port_handle_t *phPort) {
+    return pFabricPortHandleContext->fabricPortGet(pCount, phPort);
+}
+
 ze_result_t SysmanImp::fabricPortGet(uint32_t *pCount, zet_sysman_fabric_port_handle_t *phPort) {
     return pFabricPortHandleContext->fabricPortGet(pCount, phPort);
 }

level_zero/tools/source/sysman/sysman_imp.h

@@ -94,9 +94,11 @@ struct SysmanDeviceImp : SysmanDevice, NEO::NonCopyableOrMovableClass {
     OsSysman *pOsSysman = nullptr;
     PowerHandleContext *pPowerHandleContext = nullptr;
     FrequencyHandleContext *pFrequencyHandleContext = nullptr;
+    FabricPortHandleContext *pFabricPortHandleContext = nullptr;
 
     ze_result_t powerGet(uint32_t *pCount, zes_pwr_handle_t *phPower) override;
     ze_result_t frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency) override;
+    ze_result_t fabricPortGet(uint32_t *pCount, zes_fabric_port_handle_t *phPort) override;
 
   private:
     template <typename T>

level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/CMakeLists.txt

@@ -9,5 +9,7 @@ if(UNIX)
         PRIVATE
            ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
            ${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_fabric_port.cpp
+           ${CMAKE_CURRENT_SOURCE_DIR}/test_zes_fabric_port.cpp
+           ${CMAKE_CURRENT_SOURCE_DIR}/mock_fabric_device.h
     )
 endif()

level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/mock_fabric_device.h

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
+
+#include "sysman/fabric_port/fabric_port.h"
+
+namespace L0 {
+namespace ult {
+
+template <>
+struct Mock<FabricDevice> : public FabricDevice {
+    MOCK_METHOD(uint32_t, getNumPorts, (), (override));
+    MOCK_METHOD(OsFabricDevice *, getOsFabricDevice, (), (override));
+
+    Mock() = default;
+    ~Mock() override = default;
+};
+
+} // namespace ult
+} // namespace L0

level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/test_zes_fabric_port.cpp

@@ -0,0 +1,220 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/mock_fabric_device.h"
+#include "level_zero/tools/test/unit_tests/sources/sysman/mock_sysman_fixture.h"
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+#include <limits>
+
+using ::testing::Return;
+
+namespace L0 {
+namespace ult {
+
+class ZesFabricPortFixture : public SysmanDeviceFixture {
+  protected:
+    static uint32_t numPorts;
+
+    void SetUp() override {
+        SysmanDeviceFixture::SetUp();
+        FabricPortHandleContext *pFabricPortHandleContext = pSysmanDeviceImp->pFabricPortHandleContext;
+        if (nullptr != pFabricPortHandleContext->pFabricDevice) {
+            for (FabricPort *pFabricPort : pFabricPortHandleContext->handleList) {
+                delete pFabricPort;
+            }
+            pFabricPortHandleContext->handleList.clear();
+            delete pFabricPortHandleContext->pFabricDevice;
+            pFabricPortHandleContext->pFabricDevice = nullptr;
+        }
+        Mock<FabricDevice> *mockFabricDevice = new NiceMock<Mock<FabricDevice>>;
+        ON_CALL(*mockFabricDevice, getNumPorts())
+            .WillByDefault(Return(numPorts));
+
+        pFabricPortHandleContext->pFabricDevice = mockFabricDevice;
+        pFabricPortHandleContext->init();
+    }
+    void TearDown() override {
+        SysmanDeviceFixture::TearDown();
+    }
+};
+
+uint32_t ZesFabricPortFixture::numPorts = 2U;
+
+TEST_F(ZesFabricPortFixture, GivenPortCountZeroWhenCallingZesFabricPortGetThenCountIsReturnedAndVerifyZesFabricPortGetCallSucceeds) {
+    uint32_t count = 0U;
+    ze_result_t result = zesDeviceEnumFabricPorts(device, &count, NULL);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(count, ZesFabricPortFixture::numPorts);
+}
+
+TEST_F(ZesFabricPortFixture, GivenPortCountCorrectWhenCallingZesFabricPortGetThenCountHandlesAreReturnedAndAndVerifyZesFabricPortGetCallSucceeds) {
+    uint32_t count = ZesFabricPortFixture::numPorts;
+    zes_fabric_port_handle_t hPorts[ZesFabricPortFixture::numPorts];
+    ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(count, ZesFabricPortFixture::numPorts);
+}
+
+TEST_F(ZesFabricPortFixture, GivenPortCountGreaterThanPortsWhenCallingZesFabricPortGetThenCorrectCountisReturnedAndAndVerifyZesFabricPortGetCallSucceeds) {
+    uint32_t count = ZesFabricPortFixture::numPorts + 1U;
+    zes_fabric_port_handle_t hPorts[ZesFabricPortFixture::numPorts + 1U];
+    ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(count, ZesFabricPortFixture::numPorts);
+}
+
+TEST_F(ZesFabricPortFixture, GivenPortCounLessThanPortsWhenCallingZesFabricPortGetThenCountLessTanPortsHandlesAreReturned) {
+    uint32_t count = ZesFabricPortFixture::numPorts - 1U;
+    zes_fabric_port_handle_t hPorts[ZesFabricPortFixture::numPorts - 1U];
+    ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(count, ZesFabricPortFixture::numPorts - 1U);
+}
+
+TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortGetPropertiesThenZesFabricPortGetPropertiesCallSucceeds) {
+    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;
+    // Initialize values
+    properties.onSubdevice = true;
+    properties.subdeviceId = std::numeric_limits<uint32_t>::max();
+    std::memset(properties.model, std::numeric_limits<int8_t>::max(), ZES_MAX_FABRIC_PORT_MODEL_SIZE);
+    properties.portId.fabricId = std::numeric_limits<uint32_t>::max();
+    properties.portId.attachId = std::numeric_limits<uint32_t>::max();
+    properties.portId.portNumber = std::numeric_limits<uint8_t>::max();
+    properties.maxRxSpeed.bitRate = std::numeric_limits<uint64_t>::max();
+    properties.maxRxSpeed.width = std::numeric_limits<uint32_t>::max();
+    properties.maxTxSpeed.bitRate = std::numeric_limits<uint64_t>::max();
+    properties.maxTxSpeed.width = std::numeric_limits<uint32_t>::max();
+
+    result = zesFabricPortGetProperties(hPorts[0], &properties);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_FALSE(properties.onSubdevice);
+    EXPECT_EQ(0L, properties.subdeviceId);
+    EXPECT_STREQ("EXAMPLE", properties.model);
+    EXPECT_EQ(0U, properties.portId.fabricId);
+    EXPECT_EQ(0U, properties.portId.attachId);
+    EXPECT_EQ(0U, properties.portId.portNumber);
+    EXPECT_EQ(0L, properties.maxRxSpeed.bitRate);
+    EXPECT_EQ(0, properties.maxRxSpeed.width);
+    EXPECT_EQ(0L, properties.maxTxSpeed.bitRate);
+    EXPECT_EQ(0, properties.maxTxSpeed.width);
+}
+
+TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortGetLinkTypeThenZesFabricPortGetLinkTypeCallSucceeds) {
+    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_link_type_t linkType;
+    result = zesFabricPortGetLinkType(hPorts[0], &linkType);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_STREQ("SAMPLE LINK, VERBOSE", linkType.desc);
+}
+
+TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortGetConfigThenZesFabricPortGetConfigCallSucceeds) {
+    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_config_t getConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = true, .beaconing = true};
+    result = zesFabricPortGetConfig(hPorts[0], &getConfig);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_FALSE(getConfig.enabled);
+    EXPECT_FALSE(getConfig.beaconing);
+}
+
+TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortSetConfigThenZesFabricPortGetConfigCallSucceeds) {
+    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_config_t setConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = true, .beaconing = false};
+    result = zesFabricPortSetConfig(hPorts[0U], &setConfig);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    zes_fabric_port_config_t getConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = false, .beaconing = true};
+    result = zesFabricPortGetConfig(hPorts[0], &getConfig);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_TRUE(getConfig.enabled);
+    EXPECT_FALSE(getConfig.beaconing);
+}
+
+TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortGetStateThenZesFabricPortGetStateCallSucceeds) {
+    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_state_t state;
+    result = zesFabricPortGetState(hPorts[0], &state);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(0U, state.status);
+    EXPECT_EQ(0U, state.qualityIssues);
+    EXPECT_EQ(0U, state.failureReasons);
+    EXPECT_EQ(0U, state.remotePortId.fabricId);
+    EXPECT_EQ(0U, state.remotePortId.attachId);
+    EXPECT_EQ(0U, state.remotePortId.portNumber);
+    EXPECT_EQ(0L, state.rxSpeed.bitRate);
+    EXPECT_EQ(0, state.rxSpeed.width);
+    EXPECT_EQ(0L, state.txSpeed.bitRate);
+    EXPECT_EQ(0, state.txSpeed.width);
+}
+
+TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortGetThroughputThenZesFabricPortGetThroughputCallSucceeds) {
+    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_throughput_t throughput;
+    // Initialize values
+    throughput.timestamp = 0LU;
+    throughput.rxCounter = std::numeric_limits<uint64_t>::max();
+    throughput.txCounter = std::numeric_limits<uint64_t>::max();
+
+    result = zesFabricPortGetThroughput(hPorts[0], &throughput);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_NE(0LU, throughput.timestamp);
+    EXPECT_EQ(0LU, throughput.rxCounter);
+    EXPECT_EQ(0LU, throughput.txCounter);
+}
+
+} // namespace ult
+} // namespace L0