add getDeviceHandle() at OS specific level

Change-Id: I95fc24043f8f603d6270323b0f23a78f9d8ad2f1
Signed-off-by: mraghuwa <mayank.raghuwanshi@intel.com>

level_zero/tools/source/sysman/global_operations/global_operations_imp.cpp

@@ -39,14 +39,13 @@ ze_result_t GlobalOperationsImp::processesGetState(uint32_t *pCount, zes_process
 }
 
 ze_result_t GlobalOperationsImp::deviceGetProperties(zes_device_properties_t *pProperties) {
-    Device *device = L0::Device::fromHandle(hCoreDevice);
+    Device *device = pOsGlobalOperations->getDevice();
     ze_device_properties_t deviceProperties;
     device->getProperties(&deviceProperties);
     sysmanProperties.core = deviceProperties;
     uint32_t count = 0;
     device->getSubDevices(&count, nullptr);
     sysmanProperties.numSubdevices = count;
-
     *pProperties = sysmanProperties;
     return ZE_RESULT_SUCCESS;
 }

level_zero/tools/source/sysman/global_operations/global_operations_imp.h

@@ -23,13 +23,10 @@ class GlobalOperationsImp : public GlobalOperations, NEO::NonCopyableOrMovableCl
     ze_result_t reset(ze_bool_t force) override;
     ze_result_t deviceGetProperties(zes_device_properties_t *pProperties) override;
     ze_result_t processesGetState(uint32_t *pCount, zes_process_state_t *pProcesses) override;
-
     OsGlobalOperations *pOsGlobalOperations = nullptr;
-    ze_device_handle_t hCoreDevice = {};
 
     GlobalOperationsImp() = default;
-    GlobalOperationsImp(OsSysman *pOsSysman, ze_device_handle_t hCoreDevice) : hCoreDevice(hCoreDevice),
+    GlobalOperationsImp(OsSysman *pOsSysman) : pOsSysman(pOsSysman){};
-                                                                               pOsSysman(pOsSysman){};
     ~GlobalOperationsImp() override;
 
   private:

level_zero/tools/source/sysman/global_operations/linux/os_global_operations_imp.cpp

@@ -44,6 +44,10 @@ void LinuxGlobalOperationsImp::getSerialNumber(char (&serialNumber)[ZES_STRING_P
     std::strncpy(serialNumber, unknown.c_str(), ZES_STRING_PROPERTY_SIZE);
 }
 
+Device *LinuxGlobalOperationsImp::getDevice() {
+    return pDevice;
+}
+
 void LinuxGlobalOperationsImp::getBoardNumber(char (&boardNumber)[ZES_STRING_PROPERTY_SIZE]) {
     std::strncpy(boardNumber, unknown.c_str(), ZES_STRING_PROPERTY_SIZE);
 }
@@ -358,6 +362,7 @@ LinuxGlobalOperationsImp::LinuxGlobalOperationsImp(OsSysman *pOsSysman) {
 
     pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
     pFsAccess = &pLinuxSysmanImp->getFsAccess();
+    pDevice = pLinuxSysmanImp->getDeviceHandle();
 }
 
 OsGlobalOperations *OsGlobalOperations::create(OsSysman *pOsSysman) {

level_zero/tools/source/sysman/global_operations/linux/os_global_operations_imp.h

@@ -11,6 +11,7 @@
 
 namespace L0 {
 class SysfsAccess;
+struct Device;
 
 class LinuxGlobalOperationsImp : public OsGlobalOperations, NEO::NonCopyableOrMovableClass {
   public:
@@ -20,6 +21,7 @@ class LinuxGlobalOperationsImp : public OsGlobalOperations, NEO::NonCopyableOrMo
     void getModelName(char (&modelName)[ZES_STRING_PROPERTY_SIZE]) override;
     void getVendorName(char (&vendorName)[ZES_STRING_PROPERTY_SIZE]) override;
     void getDriverVersion(char (&driverVersion)[ZES_STRING_PROPERTY_SIZE]) override;
+    Device *getDevice() override;
     ze_result_t reset(ze_bool_t force) override;
     ze_result_t scanProcessesState(std::vector<zes_process_state_t> &pProcessList) override;
     LinuxGlobalOperationsImp() = default;
@@ -30,6 +32,7 @@ class LinuxGlobalOperationsImp : public OsGlobalOperations, NEO::NonCopyableOrMo
     FsAccess *pFsAccess = nullptr;
     SysfsAccess *pSysfsAccess = nullptr;
     LinuxSysmanImp *pLinuxSysmanImp = nullptr;
+    Device *pDevice = nullptr;
 
   private:
     static const std::string deviceDir;

level_zero/tools/source/sysman/global_operations/os_global_operations.h

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include "level_zero/core/source/device/device.h"
 #include "level_zero/tools/source/sysman/os_sysman.h"
 #include <level_zero/zes_api.h>
 
@@ -23,6 +24,7 @@ class OsGlobalOperations {
     virtual void getModelName(char (&modelName)[ZES_STRING_PROPERTY_SIZE]) = 0;
     virtual void getVendorName(char (&vendorName)[ZES_STRING_PROPERTY_SIZE]) = 0;
     virtual void getDriverVersion(char (&driverVersion)[ZES_STRING_PROPERTY_SIZE]) = 0;
+    virtual Device *getDevice() = 0;
     virtual ze_result_t reset(ze_bool_t force) = 0;
     virtual ze_result_t scanProcessesState(std::vector<zes_process_state_t> &pProcessList) = 0;
     static OsGlobalOperations *create(OsSysman *pOsSysman);

level_zero/tools/source/sysman/global_operations/windows/os_global_operations_imp.cpp

@@ -18,6 +18,7 @@ class WddmGlobalOperationsImp : public OsGlobalOperations {
     void getModelName(char (&modelName)[ZES_STRING_PROPERTY_SIZE]) override;
     void getVendorName(char (&vendorName)[ZES_STRING_PROPERTY_SIZE]) override;
     void getDriverVersion(char (&driverVersion)[ZES_STRING_PROPERTY_SIZE]) override;
+    Device *getDevice() override;
     ze_result_t reset(ze_bool_t force) override;
     ze_result_t scanProcessesState(std::vector<zes_process_state_t> &pProcessList) override;
 
@@ -27,8 +28,15 @@ class WddmGlobalOperationsImp : public OsGlobalOperations {
     // Don't allow copies of the WddmGlobalOperationsImp object
     WddmGlobalOperationsImp(const WddmGlobalOperationsImp &obj) = delete;
     WddmGlobalOperationsImp &operator=(const WddmGlobalOperationsImp &obj) = delete;
+
+  private:
+    Device *pDevice = nullptr;
 };
 
+Device *WddmGlobalOperationsImp::getDevice() {
+    return pDevice;
+}
+
 void WddmGlobalOperationsImp::getSerialNumber(char (&serialNumber)[ZES_STRING_PROPERTY_SIZE]) {
 }
 
@@ -56,6 +64,8 @@ ze_result_t WddmGlobalOperationsImp::scanProcessesState(std::vector<zes_process_
 }
 
 WddmGlobalOperationsImp::WddmGlobalOperationsImp(OsSysman *pOsSysman) {
+    WddmSysmanImp *pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
+    pDevice = pWddmSysmanImp->getDeviceHandle();
 }
 
 OsGlobalOperations *OsGlobalOperations::create(OsSysman *pOsSysman) {

level_zero/tools/source/sysman/linux/os_sysman_imp.cpp

@@ -20,12 +20,7 @@ ze_result_t LinuxSysmanImp::init() {
     pProcfsAccess = ProcfsAccess::create();
     UNRECOVERABLE_IF(nullptr == pProcfsAccess);
 
-    Device *pDevice = nullptr;
+    pDevice = Device::fromHandle(pParentSysmanDeviceImp->hCoreDevice);
-    if (pParentSysmanDeviceImp != nullptr) {
-        pDevice = Device::fromHandle(pParentSysmanDeviceImp->hCoreDevice);
-    } else {
-        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-    }
     UNRECOVERABLE_IF(nullptr == pDevice);
     NEO::OSInterface &OsInterface = pDevice->getOsInterface();
     pDrm = OsInterface.get()->getDrm();
@@ -70,6 +65,10 @@ NEO::Drm &LinuxSysmanImp::getDrm() {
     return *pDrm;
 }
 
+Device *LinuxSysmanImp::getDeviceHandle() {
+    return pDevice;
+}
+
 PlatformMonitoringTech &LinuxSysmanImp::getPlatformMonitoringTechAccess() {
     UNRECOVERABLE_IF(nullptr == pPmt);
     return *pPmt;

level_zero/tools/source/sysman/linux/os_sysman_imp.h

@@ -31,6 +31,7 @@ class LinuxSysmanImp : public OsSysman, NEO::NonCopyableOrMovableClass {
     SysfsAccess &getSysfsAccess();
     NEO::Drm &getDrm();
     PlatformMonitoringTech &getPlatformMonitoringTechAccess();
+    Device *getDeviceHandle();
 
   protected:
     XmlParser *pXmlParser = nullptr;
@@ -39,6 +40,7 @@ class LinuxSysmanImp : public OsSysman, NEO::NonCopyableOrMovableClass {
     SysfsAccess *pSysfsAccess = nullptr;
     PlatformMonitoringTech *pPmt = nullptr;
     NEO::Drm *pDrm = nullptr;
+    Device *pDevice = nullptr;
 
   private:
     LinuxSysmanImp() = delete;

level_zero/tools/source/sysman/memory/linux/dg1/os_memory_imp.cpp

@@ -16,6 +16,11 @@ namespace L0 {
 LinuxMemoryImp::LinuxMemoryImp(OsSysman *pOsSysman) {
     LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
     pDrm = &pLinuxSysmanImp->getDrm();
+    pDevice = pLinuxSysmanImp->getDeviceHandle();
+}
+
+bool LinuxMemoryImp::isMemoryModuleSupported() {
+    return pDevice->getDriverHandle()->getMemoryManager()->isLocalMemorySupported(pDevice->getRootDeviceIndex());
 }
 
 ze_result_t LinuxMemoryImp::getProperties(zes_mem_properties_t *pProperties) {

level_zero/tools/source/sysman/memory/linux/dg1/os_memory_imp.h

@@ -14,17 +14,20 @@
 namespace L0 {
 
 class SysfsAccess;
+struct Device;
 
 class LinuxMemoryImp : public OsMemory, NEO::NonCopyableOrMovableClass {
   public:
     ze_result_t getProperties(zes_mem_properties_t *pProperties) override;
     ze_result_t getBandwidth(zes_mem_bandwidth_t *pBandwidth) override;
     ze_result_t getState(zes_mem_state_t *pState) override;
+    bool isMemoryModuleSupported() override;
     LinuxMemoryImp(OsSysman *pOsSysman);
     LinuxMemoryImp() = default;
     ~LinuxMemoryImp() override = default;
 
   protected:
     NEO::Drm *pDrm = nullptr;
+    Device *pDevice = nullptr;
 };
 } // namespace L0

level_zero/tools/source/sysman/memory/linux/os_memory_imp.cpp

@@ -7,8 +7,18 @@
 
 #include "level_zero/tools/source/sysman/memory/linux/os_memory_imp.h"
 
+#include "sysman/linux/os_sysman_imp.h"
+
 namespace L0 {
 
+LinuxMemoryImp::LinuxMemoryImp(OsSysman *pOsSysman) {
+    LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
+    pDevice = pLinuxSysmanImp->getDeviceHandle();
+}
+bool LinuxMemoryImp::isMemoryModuleSupported() {
+    return pDevice->getDriverHandle()->getMemoryManager()->isLocalMemorySupported(pDevice->getRootDeviceIndex());
+}
+
 ze_result_t LinuxMemoryImp::getProperties(zes_mem_properties_t *pProperties) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
@@ -22,7 +32,7 @@ ze_result_t LinuxMemoryImp::getState(zes_mem_state_t *pState) {
 }
 
 OsMemory *OsMemory::create(OsSysman *pOsSysman) {
-    LinuxMemoryImp *pLinuxMemoryImp = new LinuxMemoryImp();
+    LinuxMemoryImp *pLinuxMemoryImp = new LinuxMemoryImp(pOsSysman);
     return static_cast<OsMemory *>(pLinuxMemoryImp);
 }
 

level_zero/tools/source/sysman/memory/linux/os_memory_imp.h

@@ -13,14 +13,19 @@
 namespace L0 {
 
 class SysfsAccess;
+struct Device;
 
 class LinuxMemoryImp : public OsMemory, NEO::NonCopyableOrMovableClass {
   public:
     ze_result_t getProperties(zes_mem_properties_t *pProperties) override;
     ze_result_t getBandwidth(zes_mem_bandwidth_t *pBandwidth) override;
     ze_result_t getState(zes_mem_state_t *pState) override;
+    bool isMemoryModuleSupported() override;
     LinuxMemoryImp(OsSysman *pOsSysman);
     LinuxMemoryImp() = default;
     ~LinuxMemoryImp() override = default;
+
+  protected:
+    Device *pDevice = nullptr;
 };
 } // namespace L0

level_zero/tools/source/sysman/memory/memory.cpp

@@ -19,15 +19,17 @@ MemoryHandleContext::~MemoryHandleContext() {
     }
 }
 
-ze_result_t MemoryHandleContext::init() {
+void MemoryHandleContext::createHandle() {
-    Device *device = L0::Device::fromHandle(hCoreDevice);
+    Memory *pMemory = new MemoryImp(pOsSysman);
-
+    if (pMemory->initSuccess == true) {
-    isLmemSupported = device->getDriverHandle()->getMemoryManager()->isLocalMemorySupported(device->getRootDeviceIndex());
-
-    if (isLmemSupported) {
-        Memory *pMemory = new MemoryImp(pOsSysman);
         handleList.push_back(pMemory);
+    } else {
+        delete pMemory;
     }
+}
+
+ze_result_t MemoryHandleContext::init() {
+    createHandle();
     return ZE_RESULT_SUCCESS;
 }
 

level_zero/tools/source/sysman/memory/memory.h

@@ -28,10 +28,11 @@ class Memory : _zes_mem_handle_t {
         return static_cast<Memory *>(handle);
     }
     inline zes_mem_handle_t toHandle() { return this; }
+    bool initSuccess = false;
 };
 
 struct MemoryHandleContext {
-    MemoryHandleContext(OsSysman *pOsSysman, ze_device_handle_t hCoreDevice) : pOsSysman(pOsSysman), hCoreDevice(hCoreDevice){};
+    MemoryHandleContext(OsSysman *pOsSysman) : pOsSysman(pOsSysman){};
     ~MemoryHandleContext();
 
     ze_result_t init();
@@ -41,7 +42,9 @@ struct MemoryHandleContext {
     OsSysman *pOsSysman = nullptr;
     bool isLmemSupported = false;
     std::vector<Memory *> handleList = {};
-    ze_device_handle_t hCoreDevice;
+
+  private:
+    void createHandle();
 };
 
 } // namespace L0

level_zero/tools/source/sysman/memory/memory_imp.cpp

@@ -23,7 +23,10 @@ ze_result_t MemoryImp::memoryGetProperties(zes_mem_properties_t *pProperties) {
 }
 
 void MemoryImp::init() {
-    pOsMemory->getProperties(&memoryProperties);
+    this->initSuccess = pOsMemory->isMemoryModuleSupported();
+    if (this->initSuccess == true) {
+        pOsMemory->getProperties(&memoryProperties);
+    }
 }
 
 MemoryImp::MemoryImp(OsSysman *pOsSysman) {

level_zero/tools/source/sysman/memory/os_memory.h

@@ -17,6 +17,7 @@ class OsMemory {
     virtual ze_result_t getProperties(zes_mem_properties_t *pProperties) = 0;
     virtual ze_result_t getBandwidth(zes_mem_bandwidth_t *pBandwidth) = 0;
     virtual ze_result_t getState(zes_mem_state_t *pState) = 0;
+    virtual bool isMemoryModuleSupported() = 0;
     static OsMemory *create(OsSysman *pOsSysman);
     virtual ~OsMemory() {}
 };

level_zero/tools/source/sysman/memory/windows/os_memory_imp.cpp

@@ -8,7 +8,9 @@
 #include "sysman/memory/windows/os_memory_imp.h"
 
 namespace L0 {
-
+bool WddmMemoryImp::isMemoryModuleSupported() {
+    return pDevice->getDriverHandle()->getMemoryManager()->isLocalMemorySupported(pDevice->getRootDeviceIndex());
+}
 ze_result_t WddmMemoryImp::getProperties(zes_mem_properties_t *pProperties) {
     ze_result_t status = ZE_RESULT_SUCCESS;
     uint32_t valueSmall = 0;
@@ -177,6 +179,7 @@ ze_result_t WddmMemoryImp::getState(zes_mem_state_t *pState) {
 WddmMemoryImp::WddmMemoryImp(OsSysman *pOsSysman) {
     WddmSysmanImp *pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
     pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
+    pDevice = pWddmSysmanImp->getDeviceHandle();
 }
 
 OsMemory *OsMemory::create(OsSysman *pOsSysman) {

level_zero/tools/source/sysman/memory/windows/os_memory_imp.h

@@ -21,12 +21,14 @@ class WddmMemoryImp : public OsMemory, NEO::NonCopyableOrMovableClass {
     ze_result_t getProperties(zes_mem_properties_t *pProperties) override;
     ze_result_t getBandwidth(zes_mem_bandwidth_t *pBandwidth) override;
     ze_result_t getState(zes_mem_state_t *pState) override;
+    bool isMemoryModuleSupported() override;
     WddmMemoryImp(OsSysman *pOsSysman);
     WddmMemoryImp() = default;
     ~WddmMemoryImp() override = default;
 
   protected:
     KmdSysManager *pKmdSysManager = nullptr;
+    Device *pDevice = nullptr;
 };
 
 } // namespace L0

level_zero/tools/source/sysman/pci/linux/os_pci_imp.cpp

@@ -31,9 +31,7 @@ std::string changeDirNLevelsUp(std::string realRootPath, uint8_t nLevel) {
     }
     return realRootPath;
 }
-void LinuxPciImp::setLmemSupport(bool val) {
+
-    isLmemSupported = val;
-}
 ze_result_t LinuxPciImp::getPciBdf(std::string &bdf) {
     std::string bdfDir;
     ze_result_t result = pSysfsAccess->readSymLink(deviceDir, bdfDir);
@@ -182,6 +180,8 @@ LinuxPciImp::LinuxPciImp(OsSysman *pOsSysman) {
     LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
     pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
     pfsAccess = &pLinuxSysmanImp->getFsAccess();
+    Device *pDevice = pLinuxSysmanImp->getDeviceHandle();
+    isLmemSupported = pDevice->getDriverHandle()->getMemoryManager()->isLocalMemorySupported(pDevice->getRootDeviceIndex());
 }
 
 OsPci *OsPci::create(OsSysman *pOsSysman) {

level_zero/tools/source/sysman/pci/linux/os_pci_imp.h

@@ -21,7 +21,6 @@ class LinuxPciImp : public OsPci, NEO::NonCopyableOrMovableClass {
     ze_result_t getMaxLinkSpeed(double &maxLinkSpeed) 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;
     LinuxPciImp(OsSysman *pOsSysman);

level_zero/tools/source/sysman/pci/os_pci.h

@@ -14,6 +14,7 @@
 #include <vector>
 
 namespace L0 {
+std::string changeDirNLevelsUp(std::string realRootPath, uint8_t nLevel);
 
 class OsPci {
   public:
@@ -21,7 +22,6 @@ class OsPci {
     virtual ze_result_t getMaxLinkSpeed(double &maxLinkSpeed) = 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);
     virtual ~OsPci() = default;

level_zero/tools/source/sysman/pci/pci_imp.cpp

@@ -66,8 +66,6 @@ void PciImp::init() {
         pOsPci = OsPci::create(pOsSysman);
     }
     UNRECOVERABLE_IF(nullptr == pOsPci);
-    Device *device = L0::Device::fromHandle(hCoreDevice);
-    pOsPci->setLmemSupport(device->getDriverHandle()->getMemoryManager()->isLocalMemorySupported(device->getRootDeviceIndex()));
     std::string bdf;
     pOsPci->getPciBdf(bdf);
     if (bdf.empty()) {

level_zero/tools/source/sysman/pci/pci_imp.h

@@ -26,13 +26,9 @@ class PciImp : public Pci, NEO::NonCopyableOrMovableClass {
     ze_result_t pciGetInitializedBars(uint32_t *pCount, zes_pci_bar_properties_t *pProperties) override;
 
     PciImp() = default;
-    PciImp(OsSysman *pOsSysman, ze_device_handle_t hDevice) : pOsSysman(pOsSysman) {
+    PciImp(OsSysman *pOsSysman) : pOsSysman(pOsSysman){};
-        pOsPci = nullptr;
-        hCoreDevice = hDevice;
-    };
     ~PciImp() override;
     OsPci *pOsPci = nullptr;
-    ze_device_handle_t hCoreDevice = {};
 
   private:
     OsSysman *pOsSysman = nullptr;

level_zero/tools/source/sysman/pci/windows/os_pci_imp.cpp

@@ -16,7 +16,6 @@ class WddmPciImp : public OsPci {
     ze_result_t getMaxLinkSpeed(double &maxLinkSpeed) 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;
 };
@@ -37,8 +36,6 @@ ze_result_t WddmPciImp::getLinkGen(int32_t &linkGen) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-void WddmPciImp::setLmemSupport(bool val) {}
-
 ze_result_t WddmPciImp::initializeBarProperties(std::vector<zes_pci_bar_properties_t *> &pBarProperties) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }

level_zero/tools/source/sysman/sysman_imp.cpp

@@ -21,7 +21,7 @@ SysmanDeviceImp::SysmanDeviceImp(ze_device_handle_t hDevice) {
     hCoreDevice = hDevice;
     pOsSysman = OsSysman::create(this);
     UNRECOVERABLE_IF(nullptr == pOsSysman);
-    pPci = new PciImp(pOsSysman, hCoreDevice);
+    pPci = new PciImp(pOsSysman);
     pPowerHandleContext = new PowerHandleContext(pOsSysman);
     pFrequencyHandleContext = new FrequencyHandleContext(pOsSysman);
     pFabricPortHandleContext = new FabricPortHandleContext(pOsSysman);
@@ -30,8 +30,8 @@ SysmanDeviceImp::SysmanDeviceImp(ze_device_handle_t hDevice) {
     pEngineHandleContext = new EngineHandleContext(pOsSysman);
     pSchedulerHandleContext = new SchedulerHandleContext(pOsSysman);
     pRasHandleContext = new RasHandleContext(pOsSysman);
-    pMemoryHandleContext = new MemoryHandleContext(pOsSysman, hCoreDevice);
+    pMemoryHandleContext = new MemoryHandleContext(pOsSysman);
-    pGlobalOperations = new GlobalOperationsImp(pOsSysman, hCoreDevice);
+    pGlobalOperations = new GlobalOperationsImp(pOsSysman);
 }
 
 SysmanDeviceImp::~SysmanDeviceImp() {

level_zero/tools/source/sysman/windows/os_sysman_imp.cpp

@@ -10,12 +10,7 @@
 namespace L0 {
 
 ze_result_t WddmSysmanImp::init() {
-    Device *pDevice = nullptr;
+    pDevice = Device::fromHandle(pParentSysmanDeviceImp->hCoreDevice);
-    if (pParentSysmanDeviceImp != nullptr) {
-        pDevice = Device::fromHandle(pParentSysmanDeviceImp->hCoreDevice);
-    } else {
-        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-    }
     UNRECOVERABLE_IF(nullptr == pDevice);
 
     NEO::OSInterface &OsInterface = pDevice->getOsInterface();
@@ -26,6 +21,10 @@ ze_result_t WddmSysmanImp::init() {
     return ZE_RESULT_SUCCESS;
 }
 
+Device *WddmSysmanImp::getDeviceHandle() {
+    return pDevice;
+}
+
 NEO::Wddm &WddmSysmanImp::getWddm() {
     UNRECOVERABLE_IF(nullptr == pWddm);
     return *pWddm;

level_zero/tools/source/sysman/windows/os_sysman_imp.h

@@ -10,6 +10,7 @@
 #include "shared/source/os_interface/windows/os_interface.h"
 #include "shared/source/os_interface/windows/wddm/wddm.h"
 
+#include "level_zero/core/source/device/device.h"
 #include "level_zero/tools/source/sysman/sysman_imp.h"
 #include "level_zero/tools/source/sysman/windows/kmd_sys.h"
 #include "level_zero/tools/source/sysman/windows/kmd_sys_manager.h"
@@ -25,9 +26,11 @@ class WddmSysmanImp : public OsSysman, NEO::NonCopyableOrMovableClass {
 
     KmdSysManager &getKmdSysManager();
     NEO::Wddm &getWddm();
+    Device *getDeviceHandle();
 
   protected:
     KmdSysManager *pKmdSysManager = nullptr;
+    Device *pDevice = nullptr;
 
   private:
     SysmanDeviceImp *pParentSysmanDeviceImp = nullptr;

level_zero/tools/test/unit_tests/sources/sysman/global_operations/linux/test_zes_global_operations.cpp

@@ -58,7 +58,6 @@ class SysmanGlobalOperationsFixture : public SysmanDeviceFixture {
             .WillByDefault(::testing::Invoke(pFsAccess.get(), &Mock<GlobalOperationsFsAccess>::getValAgamaFile));
 
         pGlobalOperationsImp = static_cast<L0::GlobalOperationsImp *>(pSysmanDeviceImp->pGlobalOperations);
-        pGlobalOperationsImp->hCoreDevice = device->toHandle();
         pOsGlobalOperationsPrev = pGlobalOperationsImp->pOsGlobalOperations;
         pGlobalOperationsImp->pOsGlobalOperations = nullptr;
         pGlobalOperationsImp->init();

level_zero/tools/test/unit_tests/sources/sysman/linux/test_sysman.cpp

@@ -71,5 +71,9 @@ TEST_F(SysmanDeviceFixture, GivenPmtHandleWhenCallinggetPlatformMonitoringTechAc
     EXPECT_EQ(&pLinuxSysmanImp->getPlatformMonitoringTechAccess(), pLinuxSysmanImp->pPmt);
 }
 
+TEST_F(SysmanDeviceFixture, GivenValidDeviceHandleVerifyThatSameHandleIsRetrievedFromOsSpecificCode) {
+    EXPECT_EQ(pLinuxSysmanImp->getDeviceHandle(), device);
+}
+
 } // namespace ult
-} // namespace L0
+} // namespace L0

level_zero/tools/test/unit_tests/sources/sysman/pci/linux/test_zes_pci.cpp

@@ -91,7 +91,6 @@ class ZesPciFixture : public ::testing::Test {
         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;
@@ -208,5 +207,9 @@ TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetBarsThenVe
     }
 }
 
+TEST_F(ZesPciFixture, GivenValidPathWhileCallingchangeDirNLevelsUpThenReturnedPathIsNLevelUpThenTheCurrentPath) {
+    std::string testMockRealPath2LevelsUp = changeDirNLevelsUp(mockRealPath, 2);
+    EXPECT_EQ(testMockRealPath2LevelsUp, mockRealPath2LevelsUp);
+}
 } // namespace ult
 } // namespace L0