diff --git a/level_zero/tools/source/sysman/scheduler/linux/os_scheduler_imp.cpp b/level_zero/tools/source/sysman/scheduler/linux/os_scheduler_imp.cpp
index b9ec21e3be..22ccc7cc07 100644
--- a/level_zero/tools/source/sysman/scheduler/linux/os_scheduler_imp.cpp
+++ b/level_zero/tools/source/sysman/scheduler/linux/os_scheduler_imp.cpp
@@ -7,31 +7,51 @@
 
 #include "level_zero/tools/source/sysman/scheduler/linux/os_scheduler_imp.h"
 
+#include "sysman/linux/os_sysman_imp.h"
+
 namespace L0 {
 
 const std::string LinuxSchedulerImp::preemptTimeoutMilliSecs("engine/rcs0/preempt_timeout_ms");
+const std::string LinuxSchedulerImp::defaultPreemptTimeouttMilliSecs("engine/rcs0/.defaults/preempt_timeout_ms");
 const std::string LinuxSchedulerImp::timesliceDurationMilliSecs("engine/rcs0/timeslice_duration_ms");
+const std::string LinuxSchedulerImp::defaultTimesliceDurationMilliSecs("engine/rcs0/.defaults/timeslice_duration_ms");
 const std::string LinuxSchedulerImp::heartbeatIntervalMilliSecs("engine/rcs0/heartbeat_interval_ms");
+const std::string LinuxSchedulerImp::defaultHeartbeatIntervalMilliSecs("engine/rcs0/.defaults/heartbeat_interval_ms");
 constexpr uint16_t milliSecsToMicroSecs = 1000;
 
-ze_result_t LinuxSchedulerImp::getPreemptTimeout(uint64_t &timeout) {
-    ze_result_t result = pSysfsAccess->read(preemptTimeoutMilliSecs, timeout);
+ze_result_t LinuxSchedulerImp::getPreemptTimeout(uint64_t &timeout, ze_bool_t getDefault) {
+    ze_result_t result;
+    if (getDefault) {
+        result = pSysfsAccess->read(defaultPreemptTimeouttMilliSecs, timeout);
+    } else {
+        result = pSysfsAccess->read(preemptTimeoutMilliSecs, timeout);
+    }
     if (result == ZE_RESULT_SUCCESS) {
         timeout = timeout * milliSecsToMicroSecs;
     }
     return result;
 }
 
-ze_result_t LinuxSchedulerImp::getTimesliceDuration(uint64_t &timeslice) {
-    ze_result_t result = pSysfsAccess->read(timesliceDurationMilliSecs, timeslice);
+ze_result_t LinuxSchedulerImp::getTimesliceDuration(uint64_t &timeslice, ze_bool_t getDefault) {
+    ze_result_t result;
+    if (getDefault) {
+        result = pSysfsAccess->read(defaultTimesliceDurationMilliSecs, timeslice);
+    } else {
+        result = pSysfsAccess->read(timesliceDurationMilliSecs, timeslice);
+    }
     if (result == ZE_RESULT_SUCCESS) {
         timeslice = timeslice * milliSecsToMicroSecs;
     }
     return result;
 }
 
-ze_result_t LinuxSchedulerImp::getHeartbeatInterval(uint64_t &heartbeat) {
-    ze_result_t result = pSysfsAccess->read(heartbeatIntervalMilliSecs, heartbeat);
+ze_result_t LinuxSchedulerImp::getHeartbeatInterval(uint64_t &heartbeat, ze_bool_t getDefault) {
+    ze_result_t result;
+    if (getDefault) {
+        result = pSysfsAccess->read(defaultHeartbeatIntervalMilliSecs, heartbeat);
+    } else {
+        result = pSysfsAccess->read(heartbeatIntervalMilliSecs, heartbeat);
+    }
     if (result == ZE_RESULT_SUCCESS) {
         heartbeat = heartbeat * milliSecsToMicroSecs;
     }
diff --git a/level_zero/tools/source/sysman/scheduler/linux/os_scheduler_imp.h b/level_zero/tools/source/sysman/scheduler/linux/os_scheduler_imp.h
index cd848eb828..5d60a22ad9 100644
--- a/level_zero/tools/source/sysman/scheduler/linux/os_scheduler_imp.h
+++ b/level_zero/tools/source/sysman/scheduler/linux/os_scheduler_imp.h
@@ -6,10 +6,12 @@
  */
 
 #pragma once
-#include "sysman/linux/os_sysman_imp.h"
 #include "sysman/scheduler/scheduler_imp.h"
 
+#include <string>
+
 namespace L0 {
+class SysfsAccess;
 
 // Following below mappings of scheduler properties with sysfs nodes
 // zet_sched_timeslice_properties_t.interval = timeslice_duration_ms
@@ -17,9 +19,9 @@ namespace L0 {
 // zet_sched_timeout_properties_t. watchdogTimeout =  heartbeat_interval_ms
 class LinuxSchedulerImp : public NEO::NonCopyableClass, public OsScheduler {
   public:
-    ze_result_t getPreemptTimeout(uint64_t &timeout) override;
-    ze_result_t getTimesliceDuration(uint64_t &timeslice) override;
-    ze_result_t getHeartbeatInterval(uint64_t &heartbeat) override;
+    ze_result_t getPreemptTimeout(uint64_t &timeout, ze_bool_t getDefault) override;
+    ze_result_t getTimesliceDuration(uint64_t &timeslice, ze_bool_t getDefault) override;
+    ze_result_t getHeartbeatInterval(uint64_t &heartbeat, ze_bool_t getDefault) override;
     ze_result_t setPreemptTimeout(uint64_t timeout) override;
     ze_result_t setTimesliceDuration(uint64_t timeslice) override;
     ze_result_t setHeartbeatInterval(uint64_t heartbeat) override;
@@ -32,8 +34,11 @@ class LinuxSchedulerImp : public NEO::NonCopyableClass, public OsScheduler {
 
   private:
     static const std::string preemptTimeoutMilliSecs;
+    static const std::string defaultPreemptTimeouttMilliSecs;
     static const std::string timesliceDurationMilliSecs;
+    static const std::string defaultTimesliceDurationMilliSecs;
     static const std::string heartbeatIntervalMilliSecs;
+    static const std::string defaultHeartbeatIntervalMilliSecs;
 };
 
 } // namespace L0
diff --git a/level_zero/tools/source/sysman/scheduler/os_scheduler.h b/level_zero/tools/source/sysman/scheduler/os_scheduler.h
index 0e0f8ce660..5e71cd70ec 100644
--- a/level_zero/tools/source/sysman/scheduler/os_scheduler.h
+++ b/level_zero/tools/source/sysman/scheduler/os_scheduler.h
@@ -12,9 +12,9 @@ namespace L0 {
 struct OsSysman;
 class OsScheduler {
   public:
-    virtual ze_result_t getPreemptTimeout(uint64_t &timeout) = 0;
-    virtual ze_result_t getTimesliceDuration(uint64_t &timeslice) = 0;
-    virtual ze_result_t getHeartbeatInterval(uint64_t &heartbeat) = 0;
+    virtual ze_result_t getPreemptTimeout(uint64_t &timeout, ze_bool_t getDefault) = 0;
+    virtual ze_result_t getTimesliceDuration(uint64_t &timeslice, ze_bool_t getDefault) = 0;
+    virtual ze_result_t getHeartbeatInterval(uint64_t &heartbeat, ze_bool_t getDefault) = 0;
     virtual ze_result_t setPreemptTimeout(uint64_t timeout) = 0;
     virtual ze_result_t setTimesliceDuration(uint64_t timeslice) = 0;
     virtual ze_result_t setHeartbeatInterval(uint64_t heartbeat) = 0;
@@ -22,4 +22,4 @@ class OsScheduler {
     virtual ~OsScheduler() = default;
 };
 
-} // namespace L0
\ No newline at end of file
+} // namespace L0
diff --git a/level_zero/tools/source/sysman/scheduler/scheduler.h b/level_zero/tools/source/sysman/scheduler/scheduler.h
index 34403a2f6c..f472456ac4 100644
--- a/level_zero/tools/source/sysman/scheduler/scheduler.h
+++ b/level_zero/tools/source/sysman/scheduler/scheduler.h
@@ -20,7 +20,7 @@ class Scheduler {
     virtual ze_result_t setTimesliceMode(zet_sched_timeslice_properties_t *pProperties, ze_bool_t *pNeedReboot) = 0;
     virtual ze_result_t setExclusiveMode(ze_bool_t *pNeedReboot) = 0;
     virtual ze_result_t setComputeUnitDebugMode(ze_bool_t *pNeedReboot) = 0;
-    virtual ze_result_t init() = 0;
+    virtual void init() = 0;
 };
 
-} // namespace L0
\ No newline at end of file
+} // namespace L0
diff --git a/level_zero/tools/source/sysman/scheduler/scheduler_imp.cpp b/level_zero/tools/source/sysman/scheduler/scheduler_imp.cpp
index 4cf3338512..18408b6640 100644
--- a/level_zero/tools/source/sysman/scheduler/scheduler_imp.cpp
+++ b/level_zero/tools/source/sysman/scheduler/scheduler_imp.cpp
@@ -17,15 +17,15 @@ constexpr uint64_t minTimeoutInMicroSeconds = 1000u;
 ze_result_t SchedulerImp::getCurrentMode(zet_sched_mode_t *pMode) {
     uint64_t timeout = 0;
     uint64_t timeslice = 0;
-    ze_result_t result = pOsScheduler->getPreemptTimeout(timeout);
+    ze_result_t result = pOsScheduler->getPreemptTimeout(timeout, false);
     if (result != ZE_RESULT_SUCCESS) {
         return result;
     }
-    result = pOsScheduler->getTimesliceDuration(timeslice);
+    result = pOsScheduler->getTimesliceDuration(timeslice, false);
     if (result != ZE_RESULT_SUCCESS) {
         return result;
     }
-    if (timeslice != 0) {
+    if (timeslice > 0) {
         *pMode = ZET_SCHED_MODE_TIMESLICE;
     } else {
         if (timeout > 0) {
@@ -38,13 +38,8 @@ ze_result_t SchedulerImp::getCurrentMode(zet_sched_mode_t *pMode) {
 }
 
 ze_result_t SchedulerImp::getTimeoutModeProperties(ze_bool_t getDefaults, zet_sched_timeout_properties_t *pConfig) {
-    if (getDefaults) {
-        pConfig->watchdogTimeout = defaultHeartbeat;
-        return ZE_RESULT_SUCCESS;
-    }
-
     uint64_t heartbeat = 0;
-    ze_result_t result = pOsScheduler->getHeartbeatInterval(heartbeat);
+    ze_result_t result = pOsScheduler->getHeartbeatInterval(heartbeat, getDefaults);
     if (result != ZE_RESULT_SUCCESS) {
         return result;
     }
@@ -54,18 +49,12 @@ ze_result_t SchedulerImp::getTimeoutModeProperties(ze_bool_t getDefaults, zet_sc
 }
 
 ze_result_t SchedulerImp::getTimesliceModeProperties(ze_bool_t getDefaults, zet_sched_timeslice_properties_t *pConfig) {
-    if (getDefaults) {
-        pConfig->interval = defaultTimeslice;
-        pConfig->yieldTimeout = defaultPreemptTimeout;
-        return ZE_RESULT_SUCCESS;
-    }
-
     uint64_t timeout = 0, timeslice = 0;
-    ze_result_t result = pOsScheduler->getPreemptTimeout(timeout);
+    ze_result_t result = pOsScheduler->getPreemptTimeout(timeout, getDefaults);
     if (result != ZE_RESULT_SUCCESS) {
         return result;
     }
-    result = pOsScheduler->getTimesliceDuration(timeslice);
+    result = pOsScheduler->getTimesliceDuration(timeslice, getDefaults);
     if (result != ZE_RESULT_SUCCESS) {
         return result;
     }
@@ -146,32 +135,11 @@ ze_result_t SchedulerImp::setComputeUnitDebugMode(ze_bool_t *pNeedReboot) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ze_result_t SchedulerImp::init() {
+void SchedulerImp::init() {
     if (pOsScheduler == nullptr) {
         pOsScheduler = OsScheduler::create(pOsSysman);
     }
-    if (nullptr == pOsScheduler) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    }
-    uint64_t timeout = 0;
-    uint64_t timeslice = 0;
-    uint64_t heartbeat = 0;
-    ze_result_t result = pOsScheduler->getPreemptTimeout(timeout);
-    if (result != ZE_RESULT_SUCCESS) {
-        return result;
-    }
-    result = pOsScheduler->getTimesliceDuration(timeslice);
-    if (result != ZE_RESULT_SUCCESS) {
-        return result;
-    }
-    result = pOsScheduler->getHeartbeatInterval(heartbeat);
-    if (result != ZE_RESULT_SUCCESS) {
-        return result;
-    }
-    defaultPreemptTimeout = timeout;
-    defaultTimeslice = timeslice;
-    defaultHeartbeat = heartbeat;
-    return result;
+    UNRECOVERABLE_IF(nullptr == pOsScheduler);
 }
 
 SchedulerImp::~SchedulerImp() {
diff --git a/level_zero/tools/source/sysman/scheduler/scheduler_imp.h b/level_zero/tools/source/sysman/scheduler/scheduler_imp.h
index 1c2b5a3c00..affe1ea8ce 100644
--- a/level_zero/tools/source/sysman/scheduler/scheduler_imp.h
+++ b/level_zero/tools/source/sysman/scheduler/scheduler_imp.h
@@ -17,7 +17,7 @@ namespace L0 {
 
 class SchedulerImp : public NEO::NonCopyableClass, public Scheduler {
   public:
-    ze_result_t init() override;
+    void init() override;
     ze_result_t getCurrentMode(zet_sched_mode_t *pMode) override;
     ze_result_t getTimeoutModeProperties(ze_bool_t getDefaults, zet_sched_timeout_properties_t *pConfig) override;
     ze_result_t getTimesliceModeProperties(ze_bool_t getDefaults, zet_sched_timeslice_properties_t *pConfig) override;
@@ -33,9 +33,6 @@ class SchedulerImp : public NEO::NonCopyableClass, public Scheduler {
 
   private:
     OsSysman *pOsSysman = nullptr;
-    uint64_t defaultPreemptTimeout = 0;
-    uint64_t defaultTimeslice = 0;
-    uint64_t defaultHeartbeat = 0;
 };
 
-} // namespace L0
\ No newline at end of file
+} // namespace L0
diff --git a/level_zero/tools/source/sysman/scheduler/windows/os_scheduler_imp.cpp b/level_zero/tools/source/sysman/scheduler/windows/os_scheduler_imp.cpp
index e9b6699a10..744220672f 100644
--- a/level_zero/tools/source/sysman/scheduler/windows/os_scheduler_imp.cpp
+++ b/level_zero/tools/source/sysman/scheduler/windows/os_scheduler_imp.cpp
@@ -11,23 +11,23 @@ namespace L0 {
 
 class WddmSchedulerImp : public OsScheduler {
   public:
-    ze_result_t getPreemptTimeout(uint64_t &timeout) override;
-    ze_result_t getTimesliceDuration(uint64_t &timeslice) override;
-    ze_result_t getHeartbeatInterval(uint64_t &heartbeat) override;
+    ze_result_t getPreemptTimeout(uint64_t &timeout, ze_bool_t getDefault) override;
+    ze_result_t getTimesliceDuration(uint64_t &timeslice, ze_bool_t getDefault) override;
+    ze_result_t getHeartbeatInterval(uint64_t &heartbeat, ze_bool_t getDefault) override;
     ze_result_t setPreemptTimeout(uint64_t timeout) override;
     ze_result_t setTimesliceDuration(uint64_t timeslice) override;
     ze_result_t setHeartbeatInterval(uint64_t heartbeat) override;
 };
 
-ze_result_t WddmSchedulerImp::getPreemptTimeout(uint64_t &timeout) {
+ze_result_t WddmSchedulerImp::getPreemptTimeout(uint64_t &timeout, ze_bool_t getDefault) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ze_result_t WddmSchedulerImp::getTimesliceDuration(uint64_t &timeslice) {
+ze_result_t WddmSchedulerImp::getTimesliceDuration(uint64_t &timeslice, ze_bool_t getDefault) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ze_result_t WddmSchedulerImp::getHeartbeatInterval(uint64_t &heartbeat) {
+ze_result_t WddmSchedulerImp::getHeartbeatInterval(uint64_t &heartbeat, ze_bool_t getDefault) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
@@ -48,4 +48,4 @@ OsScheduler *OsScheduler::create(OsSysman *pOsSysman) {
     return static_cast<OsScheduler *>(pWddmSchedulerImp);
 }
 
-} // namespace L0
\ No newline at end of file
+} // namespace L0
diff --git a/level_zero/tools/source/sysman/sysman_imp.cpp b/level_zero/tools/source/sysman/sysman_imp.cpp
index 0d6f5d518b..0da14e4d1f 100644
--- a/level_zero/tools/source/sysman/sysman_imp.cpp
+++ b/level_zero/tools/source/sysman/sysman_imp.cpp
@@ -75,9 +75,7 @@ void SysmanImp::init() {
         pPci->init();
     }
     if (pSched) {
-        if (pSched->init() != ZE_RESULT_SUCCESS) {
-            freeResource(pSched);
-        }
+        pSched->init();
     }
     if (pSysmanDevice) {
         pSysmanDevice->init();
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/mock_sysfs_scheduler.h b/level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/mock_sysfs_scheduler.h
index 63c0242617..ff3251a59c 100644
--- a/level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/mock_sysfs_scheduler.h
+++ b/level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/mock_sysfs_scheduler.h
@@ -9,21 +9,20 @@
 #include "level_zero/core/test/unit_tests/mock.h"
 
 #include "sysman/linux/fs_access.h"
+#include "sysman/linux/os_sysman_imp.h"
 #include "sysman/sysman.h"
 
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Winconsistent-missing-override"
-#endif
-
 using ::testing::_;
 
 namespace L0 {
 namespace ult {
 
 const std::string preemptTimeoutMilliSecs("engine/rcs0/preempt_timeout_ms");
+const std::string defaultPreemptTimeoutMilliSecs("engine/rcs0/.defaults/preempt_timeout_ms");
 const std::string timesliceDurationMilliSecs("engine/rcs0/timeslice_duration_ms");
+const std::string defaultTimesliceDurationMilliSecs("engine/rcs0/.defaults/timeslice_duration_ms");
 const std::string heartbeatIntervalMilliSecs("engine/rcs0/heartbeat_interval_ms");
+const std::string defaultHeartbeatIntervalMilliSecs("engine/rcs0/.defaults/heartbeat_interval_ms");
 
 class SchedulerSysfsAccess : public SysfsAccess {};
 
@@ -32,6 +31,13 @@ struct Mock<SchedulerSysfsAccess> : public SysfsAccess {
     uint64_t mockValPreemptTimeoutMilliSecs = 0;
     uint64_t mockValTimesliceDurationMilliSecs = 0;
     uint64_t mockValHeartbeatIntervalMilliSecs = 0;
+    uint64_t mockValDefaultPreemptTimeoutMilliSecs = 0;
+    uint64_t mockValDefaultTimesliceDurationMilliSecs = 0;
+    uint64_t mockValDefaultHeartbeatIntervalMilliSecs = 0;
+
+    ze_result_t getValForError(const std::string file, uint64_t &val) {
+        return ZE_RESULT_ERROR_NOT_AVAILABLE;
+    }
 
     ze_result_t getVal(const std::string file, uint64_t &val) {
         if (file.compare(preemptTimeoutMilliSecs) == 0) {
@@ -43,6 +49,15 @@ struct Mock<SchedulerSysfsAccess> : public SysfsAccess {
         if (file.compare(heartbeatIntervalMilliSecs) == 0) {
             val = mockValHeartbeatIntervalMilliSecs;
         }
+        if (file.compare(defaultPreemptTimeoutMilliSecs) == 0) {
+            val = mockValDefaultPreemptTimeoutMilliSecs;
+        }
+        if (file.compare(defaultTimesliceDurationMilliSecs) == 0) {
+            val = mockValDefaultTimesliceDurationMilliSecs;
+        }
+        if (file.compare(defaultHeartbeatIntervalMilliSecs) == 0) {
+            val = mockValDefaultHeartbeatIntervalMilliSecs;
+        }
         return ZE_RESULT_SUCCESS;
     }
     ze_result_t setVal(const std::string file, const uint64_t val) {
@@ -55,14 +70,22 @@ struct Mock<SchedulerSysfsAccess> : public SysfsAccess {
         if (file.compare(heartbeatIntervalMilliSecs) == 0) {
             mockValHeartbeatIntervalMilliSecs = val;
         }
+        if (file.compare(defaultPreemptTimeoutMilliSecs) == 0) {
+            mockValDefaultPreemptTimeoutMilliSecs = val;
+        }
+        if (file.compare(defaultTimesliceDurationMilliSecs) == 0) {
+            mockValDefaultTimesliceDurationMilliSecs = val;
+        }
+        if (file.compare(defaultHeartbeatIntervalMilliSecs) == 0) {
+            mockValDefaultHeartbeatIntervalMilliSecs = val;
+        }
         return ZE_RESULT_SUCCESS;
     }
 
-    Mock() = default;
-    ~Mock() override = default;
+    Mock<SchedulerSysfsAccess>() = default;
 
-    MOCK_METHOD2(read, ze_result_t(const std::string file, uint64_t &val));
-    MOCK_METHOD2(write, ze_result_t(const std::string file, const uint64_t val));
+    MOCK_METHOD(ze_result_t, read, (const std::string file, uint64_t &val), (override));
+    MOCK_METHOD(ze_result_t, write, (const std::string file, const uint64_t val), (override));
 };
 
 class PublicLinuxSchedulerImp : public L0::LinuxSchedulerImp {
@@ -72,7 +95,3 @@ class PublicLinuxSchedulerImp : public L0::LinuxSchedulerImp {
 
 } // namespace ult
 } // namespace L0
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/test_sysman_scheduler.cpp b/level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/test_sysman_scheduler.cpp
index c857588c8e..2ae551dd18 100644
--- a/level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/test_sysman_scheduler.cpp
+++ b/level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/test_sysman_scheduler.cpp
@@ -24,16 +24,22 @@ namespace L0 {
 namespace ult {
 
 constexpr uint64_t convertMilliToMicro = 1000u;
-constexpr uint64_t defaultTimeoutMilliSecs = 640u;
+constexpr uint64_t defaultTimeoutMilliSecs = 650u;
 constexpr uint64_t defaultTimesliceMilliSecs = 1u;
-constexpr uint64_t defaultHeartbeatMilliSecs = 2500u;
-constexpr uint64_t expectedHeartbeatTimeoutMicroSecs = defaultHeartbeatMilliSecs * convertMilliToMicro;
-constexpr uint64_t expectedTimeoutMicroSecs = defaultTimeoutMilliSecs * convertMilliToMicro;
-constexpr uint64_t expectedTimesliceMicroSecs = defaultTimesliceMilliSecs * convertMilliToMicro;
+constexpr uint64_t defaultHeartbeatMilliSecs = 3000u;
+constexpr uint64_t timeoutMilliSecs = 640u;
+constexpr uint64_t timesliceMilliSecs = 1u;
+constexpr uint64_t heartbeatMilliSecs = 2500u;
+constexpr uint64_t expectedDefaultHeartbeatTimeoutMicroSecs = defaultHeartbeatMilliSecs * convertMilliToMicro;
+constexpr uint64_t expectedDefaultTimeoutMicroSecs = defaultTimeoutMilliSecs * convertMilliToMicro;
+constexpr uint64_t expectedDefaultTimesliceMicroSecs = defaultTimesliceMilliSecs * convertMilliToMicro;
+constexpr uint64_t expectedHeartbeatTimeoutMicroSecs = heartbeatMilliSecs * convertMilliToMicro;
+constexpr uint64_t expectedTimeoutMicroSecs = timeoutMilliSecs * convertMilliToMicro;
+constexpr uint64_t expectedTimesliceMicroSecs = timesliceMilliSecs * convertMilliToMicro;
 
 class SysmanSchedulerFixture : public DeviceFixture, public ::testing::Test {
   protected:
-    SysmanImp *sysmanImp = nullptr;
+    std::unique_ptr<SysmanImp> sysmanImp;
     zet_sysman_handle_t hSysman;
 
     OsScheduler *pOsScheduler = nullptr;
@@ -44,13 +50,16 @@ class SysmanSchedulerFixture : public DeviceFixture, public ::testing::Test {
 
     void SetUp() override {
         DeviceFixture::SetUp();
-        sysmanImp = new SysmanImp(device->toHandle());
+        sysmanImp = std::make_unique<SysmanImp>(device->toHandle());
         pSysfsAccess = new NiceMock<Mock<SchedulerSysfsAccess>>;
         linuxSchedulerImp.pSysfsAccess = pSysfsAccess;
         pOsScheduler = static_cast<OsScheduler *>(&linuxSchedulerImp);
-        pSysfsAccess->setVal(preemptTimeoutMilliSecs, defaultTimeoutMilliSecs);
-        pSysfsAccess->setVal(timesliceDurationMilliSecs, defaultTimesliceMilliSecs);
-        pSysfsAccess->setVal(heartbeatIntervalMilliSecs, defaultHeartbeatMilliSecs);
+        pSysfsAccess->setVal(defaultPreemptTimeoutMilliSecs, defaultTimeoutMilliSecs);
+        pSysfsAccess->setVal(defaultTimesliceDurationMilliSecs, defaultTimesliceMilliSecs);
+        pSysfsAccess->setVal(defaultHeartbeatIntervalMilliSecs, defaultHeartbeatMilliSecs);
+        pSysfsAccess->setVal(preemptTimeoutMilliSecs, timeoutMilliSecs);
+        pSysfsAccess->setVal(timesliceDurationMilliSecs, timesliceMilliSecs);
+        pSysfsAccess->setVal(heartbeatIntervalMilliSecs, heartbeatMilliSecs);
 
         ON_CALL(*pSysfsAccess, read(_, _))
             .WillByDefault(::testing::Invoke(pSysfsAccess, &Mock<SchedulerSysfsAccess>::getVal));
@@ -73,11 +82,6 @@ class SysmanSchedulerFixture : public DeviceFixture, public ::testing::Test {
             delete pSysfsAccess;
             pSysfsAccess = nullptr;
         }
-        if (sysmanImp != nullptr) {
-            delete sysmanImp;
-            sysmanImp = nullptr;
-        }
-        DeviceFixture::TearDown();
     }
 
     zet_sched_mode_t fixtureGetCurrentMode(zet_sysman_handle_t hSysman) {
@@ -87,16 +91,16 @@ class SysmanSchedulerFixture : public DeviceFixture, public ::testing::Test {
         return mode;
     }
 
-    zet_sched_timeout_properties_t fixtureGetTimeoutModeProperties(zet_sysman_handle_t hSysman) {
+    zet_sched_timeout_properties_t fixtureGetTimeoutModeProperties(zet_sysman_handle_t hSysman, ze_bool_t getDefaults) {
         zet_sched_timeout_properties_t config;
-        ze_result_t result = zetSysmanSchedulerGetTimeoutModeProperties(hSysman, false, &config);
+        ze_result_t result = zetSysmanSchedulerGetTimeoutModeProperties(hSysman, getDefaults, &config);
         EXPECT_EQ(ZE_RESULT_SUCCESS, result);
         return config;
     }
 
-    zet_sched_timeslice_properties_t fixtureGetTimesliceModeProperties(zet_sysman_handle_t hSysman) {
+    zet_sched_timeslice_properties_t fixtureGetTimesliceModeProperties(zet_sysman_handle_t hSysman, ze_bool_t getDefaults) {
         zet_sched_timeslice_properties_t config;
-        ze_result_t result = zetSysmanSchedulerGetTimesliceModeProperties(hSysman, false, &config);
+        ze_result_t result = zetSysmanSchedulerGetTimesliceModeProperties(hSysman, getDefaults, &config);
         EXPECT_EQ(ZE_RESULT_SUCCESS, result);
         return config;
     }
@@ -108,16 +112,27 @@ TEST_F(SysmanSchedulerFixture, GivenValidSysmanHandleWhenCallingzetSysmanSchedul
 }
 
 TEST_F(SysmanSchedulerFixture, GivenValidSysmanHandleWhenCallingzetSysmanSchedulerGetTimeoutModePropertiesThenVerifyzetSysmanSchedulerGetTimeoutModePropertiesCallSucceeds) {
-    auto config = fixtureGetTimeoutModeProperties(hSysman);
+    auto config = fixtureGetTimeoutModeProperties(hSysman, false);
     EXPECT_EQ(config.watchdogTimeout, expectedHeartbeatTimeoutMicroSecs);
 }
 
+TEST_F(SysmanSchedulerFixture, GivenValidSysmanHandleWhenCallingzetSysmanSchedulerGetTimeoutModePropertiesWithDefaultsThenVerifyzetSysmanSchedulerGetTimeoutModePropertiesCallSucceeds) {
+    auto config = fixtureGetTimeoutModeProperties(hSysman, true);
+    EXPECT_EQ(config.watchdogTimeout, expectedDefaultHeartbeatTimeoutMicroSecs);
+}
+
 TEST_F(SysmanSchedulerFixture, GivenValidSysmanHandleWhenCallingzetSysmanSchedulerGetTimesliceModePropertiesThenVerifyzetSysmanSchedulerGetTimesliceModePropertiesCallSucceeds) {
-    auto config = fixtureGetTimesliceModeProperties(hSysman);
+    auto config = fixtureGetTimesliceModeProperties(hSysman, false);
     EXPECT_EQ(config.interval, expectedTimesliceMicroSecs);
     EXPECT_EQ(config.yieldTimeout, expectedTimeoutMicroSecs);
 }
 
+TEST_F(SysmanSchedulerFixture, GivenValidSysmanHandleWhenCallingzetSysmanSchedulerGetTimesliceModePropertiesWithDefaultsThenVerifyzetSysmanSchedulerGetTimesliceModePropertiesCallSucceeds) {
+    auto config = fixtureGetTimesliceModeProperties(hSysman, true);
+    EXPECT_EQ(config.interval, expectedDefaultTimesliceMicroSecs);
+    EXPECT_EQ(config.yieldTimeout, expectedDefaultTimeoutMicroSecs);
+}
+
 TEST_F(SysmanSchedulerFixture, GivenValidSysmanHandleWhenCallingzetSysmanSchedulerSetTimeoutModeThenVerifyzetSysmanSchedulerSetTimeoutModeCallSucceeds) {
     ze_bool_t needReboot;
     zet_sched_timeout_properties_t setConfig;
@@ -125,7 +140,7 @@ TEST_F(SysmanSchedulerFixture, GivenValidSysmanHandleWhenCallingzetSysmanSchedul
     ze_result_t result = zetSysmanSchedulerSetTimeoutMode(hSysman, &setConfig, &needReboot);
     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
     EXPECT_FALSE(needReboot);
-    auto getConfig = fixtureGetTimeoutModeProperties(hSysman);
+    auto getConfig = fixtureGetTimeoutModeProperties(hSysman, false);
     EXPECT_EQ(getConfig.watchdogTimeout, setConfig.watchdogTimeout);
     auto mode = fixtureGetCurrentMode(hSysman);
     EXPECT_EQ(mode, ZET_SCHED_MODE_TIMEOUT);
@@ -139,7 +154,7 @@ TEST_F(SysmanSchedulerFixture, GivenValidSysmanHandleWhenCallingzetSysmanSchedul
     ze_result_t result = zetSysmanSchedulerSetTimesliceMode(hSysman, &setConfig, &needReboot);
     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
     EXPECT_FALSE(needReboot);
-    auto getConfig = fixtureGetTimesliceModeProperties(hSysman);
+    auto getConfig = fixtureGetTimesliceModeProperties(hSysman, false);
     EXPECT_EQ(getConfig.interval, setConfig.interval);
     EXPECT_EQ(getConfig.yieldTimeout, setConfig.yieldTimeout);
     auto mode = fixtureGetCurrentMode(hSysman);
@@ -155,5 +170,29 @@ TEST_F(SysmanSchedulerFixture, GivenValidSysmanHandleWhenCallingzetSysmanSchedul
     EXPECT_EQ(mode, ZET_SCHED_MODE_EXCLUSIVE);
 }
 
+TEST_F(SysmanSchedulerFixture, GivenValidSysmanHandleWhenCallingzetSysmanSchedulerGetCurrentModeWhenSysfsNodeIsAbsentThenFailureIsReturned) {
+    ON_CALL(*pSysfsAccess, read(_, _))
+        .WillByDefault(::testing::Invoke(pSysfsAccess, &Mock<SchedulerSysfsAccess>::getValForError));
+    zet_sched_mode_t mode;
+    ze_result_t result = zetSysmanSchedulerGetCurrentMode(hSysman, &mode);
+    EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
+}
+
+TEST_F(SysmanSchedulerFixture, GivenValidSysmanHandleWhenCallingzetSysmanSchedulerGetTimeoutModePropertiesWithDefaultsWhenSysfsNodeIsAbsentThenFailureIsReturned) {
+    ON_CALL(*pSysfsAccess, read(_, _))
+        .WillByDefault(::testing::Invoke(pSysfsAccess, &Mock<SchedulerSysfsAccess>::getValForError));
+    zet_sched_timeout_properties_t config;
+    ze_result_t result = zetSysmanSchedulerGetTimeoutModeProperties(hSysman, true, &config);
+    EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
+}
+
+TEST_F(SysmanSchedulerFixture, GivenValidSysmanHandleWhenCallingzetSysmanSchedulerGetTimesliceModePropertiesWithDefaultsWhenSysfsNodeIsAbsentThenFailureIsReturned) {
+    ON_CALL(*pSysfsAccess, read(_, _))
+        .WillByDefault(::testing::Invoke(pSysfsAccess, &Mock<SchedulerSysfsAccess>::getValForError));
+    zet_sched_timeslice_properties_t config;
+    ze_result_t result = zetSysmanSchedulerGetTimesliceModeProperties(hSysman, true, &config);
+    EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
+}
+
 } // namespace ult
 } // namespace L0
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/scheduler/windows/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/sysman/scheduler/windows/CMakeLists.txt
deleted file mode 100644
index 721c6ac67e..0000000000
--- a/level_zero/tools/test/unit_tests/sources/sysman/scheduler/windows/CMakeLists.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-#
-# Copyright (C) 2020 Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-#
-
-if(WIN32)
-    target_sources(${TARGET_NAME}
-        PRIVATE
-            ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-            ${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_scheduler.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/mock_scheduler.h
-    )
-endif()
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/scheduler/windows/mock_scheduler.h b/level_zero/tools/test/unit_tests/sources/sysman/scheduler/windows/mock_scheduler.h
deleted file mode 100644
index 2c75d31666..0000000000
--- a/level_zero/tools/test/unit_tests/sources/sysman/scheduler/windows/mock_scheduler.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright (C) 2020 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#pragma once
-#include "level_zero/core/test/unit_tests/mock.h"
-
-#include "sysman/scheduler/os_scheduler.h"
-#include "sysman/scheduler/scheduler_imp.h"
-#include "sysman/sysman_imp.h"
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Winconsistent-missing-override"
-#endif
-
-namespace L0 {
-namespace ult {
-
-template <>
-struct Mock<OsScheduler> : public OsScheduler {
-    uint64_t mockTimeout;
-    uint64_t mockTimeslice;
-    uint64_t mockHeartbeat;
-
-    ze_result_t getMockTimeout(uint64_t &timeout) {
-        timeout = mockTimeout;
-        return ZE_RESULT_SUCCESS;
-    }
-    ze_result_t setMockTimeout(uint64_t timeout) {
-        mockTimeout = timeout;
-        return ZE_RESULT_SUCCESS;
-    }
-
-    ze_result_t getMockTimeslice(uint64_t &timeslice) {
-        timeslice = mockTimeslice;
-        return ZE_RESULT_SUCCESS;
-    }
-    ze_result_t setMockTimeslice(uint64_t timeslice) {
-        mockTimeslice = timeslice;
-        return ZE_RESULT_SUCCESS;
-    }
-
-    ze_result_t getMockHeartbeat(uint64_t &heartbeat) {
-        heartbeat = mockHeartbeat;
-        return ZE_RESULT_SUCCESS;
-    }
-    ze_result_t setMockHeartbeat(uint64_t heartbeat) {
-        mockHeartbeat = heartbeat;
-        return ZE_RESULT_SUCCESS;
-    }
-    Mock<OsScheduler>() = default;
-
-    MOCK_METHOD1(getPreemptTimeout, ze_result_t(uint64_t &timeout));
-    MOCK_METHOD1(getTimesliceDuration, ze_result_t(uint64_t &timeslice));
-    MOCK_METHOD1(getHeartbeatInterval, ze_result_t(uint64_t &heartbeat));
-    MOCK_METHOD1(setPreemptTimeout, ze_result_t(uint64_t timeout));
-    MOCK_METHOD1(setTimesliceDuration, ze_result_t(uint64_t timeslice));
-    MOCK_METHOD1(setHeartbeatInterval, ze_result_t(uint64_t heartbeat));
-};
-
-} // namespace ult
-} // namespace L0
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/scheduler/windows/test_sysman_scheduler.cpp b/level_zero/tools/test/unit_tests/sources/sysman/scheduler/windows/test_sysman_scheduler.cpp
deleted file mode 100644
index 06807351d1..0000000000
--- a/level_zero/tools/test/unit_tests/sources/sysman/scheduler/windows/test_sysman_scheduler.cpp
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- * Copyright (C) 2020 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "mock_scheduler.h"
-
-using ::testing::_;
-using ::testing::DoAll;
-using ::testing::InSequence;
-using ::testing::Invoke;
-using ::testing::NiceMock;
-using ::testing::Return;
-
-namespace L0 {
-namespace ult {
-
-constexpr uint64_t defaultTimeoutMilliSecs = 640u;
-constexpr uint64_t defaultTimesliceMilliSecs = 1000u;
-constexpr uint64_t defaultHeartbeatMilliSecs = 2500u;
-
-class SysmanSchedulerFixture : public DeviceFixture, public ::testing::Test {
-  protected:
-    SysmanImp *sysmanImp;
-    zet_sysman_handle_t hSysman;
-
-    Mock<OsScheduler> *pOsScheduler;
-    L0::SchedulerImp *pSchedImp;
-    L0::Scheduler *pSchedPrev;
-
-    void SetUp() override {
-        DeviceFixture::SetUp();
-        sysmanImp = new SysmanImp(device->toHandle());
-        pOsScheduler = new NiceMock<Mock<OsScheduler>>;
-        pOsScheduler->setMockTimeout(defaultTimeoutMilliSecs);
-        pOsScheduler->setMockTimeslice(defaultTimesliceMilliSecs);
-        pOsScheduler->setMockHeartbeat(defaultHeartbeatMilliSecs);
-
-        ON_CALL(*pOsScheduler, getPreemptTimeout(_))
-            .WillByDefault(Invoke(pOsScheduler, &Mock<OsScheduler>::getMockTimeout));
-        ON_CALL(*pOsScheduler, getTimesliceDuration(_))
-            .WillByDefault(Invoke(pOsScheduler, &Mock<OsScheduler>::getMockTimeslice));
-        ON_CALL(*pOsScheduler, getHeartbeatInterval(_))
-            .WillByDefault(Invoke(pOsScheduler, &Mock<OsScheduler>::getMockHeartbeat));
-        ON_CALL(*pOsScheduler, setPreemptTimeout(_))
-            .WillByDefault(Invoke(pOsScheduler, &Mock<OsScheduler>::setMockTimeout));
-        ON_CALL(*pOsScheduler, setTimesliceDuration(_))
-            .WillByDefault(Invoke(pOsScheduler, &Mock<OsScheduler>::setMockTimeslice));
-        ON_CALL(*pOsScheduler, setHeartbeatInterval(_))
-            .WillByDefault(Invoke(pOsScheduler, &Mock<OsScheduler>::setMockHeartbeat));
-
-        pSchedImp = new SchedulerImp();
-        pSchedPrev = sysmanImp->pSched;
-        sysmanImp->pSched = static_cast<Scheduler *>(pSchedImp);
-        pSchedImp->pOsScheduler = pOsScheduler;
-        pSchedImp->init();
-        hSysman = sysmanImp->toHandle();
-    }
-    void TearDown() override {
-        // restore state
-        sysmanImp->pSched = pSchedPrev;
-        // cleanup
-        if (pSchedImp != nullptr) {
-            delete pSchedImp;
-            pSchedImp = nullptr;
-        }
-        if (sysmanImp != nullptr) {
-            delete sysmanImp;
-            sysmanImp = nullptr;
-        }
-        DeviceFixture::TearDown();
-    }
-
-    zet_sched_mode_t fixtureGetCurrentMode(zet_sysman_handle_t hSysman) {
-        zet_sched_mode_t mode;
-        ze_result_t result = zetSysmanSchedulerGetCurrentMode(hSysman, &mode);
-        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-        return mode;
-    }
-
-    zet_sched_timeout_properties_t fixtureGetTimeoutModeProperties(zet_sysman_handle_t hSysman) {
-        zet_sched_timeout_properties_t config;
-        ze_result_t result = zetSysmanSchedulerGetTimeoutModeProperties(hSysman, false, &config);
-        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-        return config;
-    }
-
-    zet_sched_timeslice_properties_t fixtureGetTimesliceModeProperties(zet_sysman_handle_t hSysman) {
-        zet_sched_timeslice_properties_t config;
-        ze_result_t result = zetSysmanSchedulerGetTimesliceModeProperties(hSysman, false, &config);
-        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-        return config;
-    }
-};
-
-TEST_F(SysmanSchedulerFixture, GivenValidSysmanHandleWhenCallingzetSysmanSchedulerGetCurrentModeThenVerifyzetSysmanSchedulerGetCurrentModeCallSucceeds) {
-    auto mode = fixtureGetCurrentMode(hSysman);
-    EXPECT_EQ(mode, ZET_SCHED_MODE_TIMESLICE);
-}
-
-TEST_F(SysmanSchedulerFixture, GivenValidSysmanHandleWhenCallingzetSysmanSchedulerGetTimeoutModePropertiesThenVerifyzetSysmanSchedulerGetTimeoutModePropertiesCallSucceeds) {
-    auto config = fixtureGetTimeoutModeProperties(hSysman);
-    EXPECT_EQ(config.watchdogTimeout, defaultHeartbeatMilliSecs);
-}
-
-TEST_F(SysmanSchedulerFixture, GivenValidSysmanHandleWhenCallingzetSysmanSchedulerGetTimesliceModePropertiesThenVerifyzetSysmanSchedulerGetTimesliceModePropertiesCallSucceeds) {
-    auto config = fixtureGetTimesliceModeProperties(hSysman);
-    EXPECT_EQ(config.interval, defaultTimesliceMilliSecs);
-    EXPECT_EQ(config.yieldTimeout, defaultTimeoutMilliSecs);
-}
-
-TEST_F(SysmanSchedulerFixture, GivenValidSysmanHandleWhenCallingzetSysmanSchedulerSetTimeoutModeThenVerifyzetSysmanSchedulerSetTimeoutModeCallSucceeds) {
-    ze_bool_t needReboot;
-    zet_sched_timeout_properties_t setConfig;
-    setConfig.watchdogTimeout = 5000u;
-    ze_result_t result = zetSysmanSchedulerSetTimeoutMode(hSysman, &setConfig, &needReboot);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_FALSE(needReboot);
-    auto getConfig = fixtureGetTimeoutModeProperties(hSysman);
-    EXPECT_EQ(getConfig.watchdogTimeout, setConfig.watchdogTimeout);
-    auto mode = fixtureGetCurrentMode(hSysman);
-    EXPECT_EQ(mode, ZET_SCHED_MODE_TIMEOUT);
-}
-
-TEST_F(SysmanSchedulerFixture, GivenValidSysmanHandleWhenCallingzetSysmanSchedulerSetTimesliceModeThenVerifyzetSysmanSchedulerSetTimesliceModeCallSucceeds) {
-    ze_bool_t needReboot;
-    zet_sched_timeslice_properties_t setConfig;
-    setConfig.interval = 2000u;
-    setConfig.yieldTimeout = 1000u;
-    ze_result_t result = zetSysmanSchedulerSetTimesliceMode(hSysman, &setConfig, &needReboot);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_FALSE(needReboot);
-    auto getConfig = fixtureGetTimesliceModeProperties(hSysman);
-    EXPECT_EQ(getConfig.interval, setConfig.interval);
-    EXPECT_EQ(getConfig.yieldTimeout, setConfig.yieldTimeout);
-    auto mode = fixtureGetCurrentMode(hSysman);
-    EXPECT_EQ(mode, ZET_SCHED_MODE_TIMESLICE);
-}
-
-TEST_F(SysmanSchedulerFixture, GivenValidSysmanHandleWhenCallingzetSysmanSchedulerSetExclusiveModeThenVerifyzetSysmanSchedulerSetExclusiveModeCallSucceeds) {
-    ze_bool_t needReboot;
-    ze_result_t result = zetSysmanSchedulerSetExclusiveMode(hSysman, &needReboot);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_FALSE(needReboot);
-    auto mode = fixtureGetCurrentMode(hSysman);
-    EXPECT_EQ(mode, ZET_SCHED_MODE_EXCLUSIVE);
-}
-
-} // namespace ult
-} // namespace L0