diff --git a/level_zero/api/tools/ze_tools_loader.cpp b/level_zero/api/tools/ze_tools_loader.cpp
index 261a31f429..b07c76014f 100644
--- a/level_zero/api/tools/ze_tools_loader.cpp
+++ b/level_zero/api/tools/ze_tools_loader.cpp
@@ -552,4 +552,5 @@ zetGetDebugProcAddrTable(
     pDdiTable->pfnWriteState = (zet_pfnDebugWriteState_t)GET_FUNCTION_PTR(driver_ddiTable.driverLibrary, "zetDebugWriteState");
     return result;
 }
-};
+
+} // extern C
diff --git a/level_zero/api/tools/zet_driver.cpp b/level_zero/api/tools/zet_driver.cpp
index b3020b8b27..9ccf735f61 100644
--- a/level_zero/api/tools/zet_driver.cpp
+++ b/level_zero/api/tools/zet_driver.cpp
@@ -15,16 +15,7 @@ extern "C" {
 __zedllexport ze_result_t __zecall
 zetInit(
     ze_init_flag_t flags) {
-    try {
-        {
-        }
-        return L0::ToolsInit::get()->initTools(flags);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
-}
+    return L0::ToolsInit::get()->initTools(flags);
 }
+
+} // extern C
diff --git a/level_zero/api/tools/zet_metric.cpp b/level_zero/api/tools/zet_metric.cpp
index 12efabbddc..9535ddc79f 100644
--- a/level_zero/api/tools/zet_metric.cpp
+++ b/level_zero/api/tools/zet_metric.cpp
@@ -10,9 +10,6 @@
 #include "level_zero/tools/source/metrics/metric.h"
 #include <level_zero/zet_api.h>
 
-#include <exception>
-#include <new>
-
 extern "C" {
 
 __zedllexport ze_result_t __zecall
@@ -20,42 +17,14 @@ zetMetricGroupGet(
     zet_device_handle_t hDevice,
     uint32_t *pCount,
     zet_metric_group_handle_t *phMetricGroups) {
-    try {
-        {
-            if (nullptr == hDevice)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::metricGroupGet(hDevice, pCount, phMetricGroups);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::metricGroupGet(hDevice, pCount, phMetricGroups);
 }
 
 __zedllexport ze_result_t __zecall
 zetMetricGroupGetProperties(
     zet_metric_group_handle_t hMetricGroup,
     zet_metric_group_properties_t *pProperties) {
-    try {
-        {
-            if (nullptr == hMetricGroup)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::MetricGroup::fromHandle(hMetricGroup)->getProperties(pProperties);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::MetricGroup::fromHandle(hMetricGroup)->getProperties(pProperties);
 }
 
 __zedllexport ze_result_t __zecall
@@ -63,42 +32,14 @@ zetMetricGet(
     zet_metric_group_handle_t hMetricGroup,
     uint32_t *pCount,
     zet_metric_handle_t *phMetrics) {
-    try {
-        {
-            if (nullptr == hMetricGroup)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::metricGet(hMetricGroup, pCount, phMetrics);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::metricGet(hMetricGroup, pCount, phMetrics);
 }
 
 __zedllexport ze_result_t __zecall
 zetMetricGetProperties(
     zet_metric_handle_t hMetric,
     zet_metric_properties_t *pProperties) {
-    try {
-        {
-            if (nullptr == hMetric)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Metric::fromHandle(hMetric)->getProperties(pProperties);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Metric::fromHandle(hMetric)->getProperties(pProperties);
 }
 
 __zedllexport ze_result_t __zecall
@@ -108,23 +49,7 @@ zetMetricGroupCalculateMetricValues(
     const uint8_t *pRawData,
     uint32_t *pMetricValueCount,
     zet_typed_value_t *pMetricValues) {
-    try {
-        {
-            if (nullptr == hMetricGroup)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pRawData)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pMetricValueCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::MetricGroup::fromHandle(hMetricGroup)->calculateMetricValues(rawDataSize, pRawData, pMetricValueCount, pMetricValues);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::MetricGroup::fromHandle(hMetricGroup)->calculateMetricValues(rawDataSize, pRawData, pMetricValueCount, pMetricValues);
 }
 
 __zedllexport ze_result_t __zecall
@@ -132,19 +57,7 @@ zetDeviceActivateMetricGroups(
     zet_device_handle_t hDevice,
     uint32_t count,
     zet_metric_group_handle_t *phMetricGroups) {
-    try {
-        {
-            if (nullptr == hDevice)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Device::fromHandle(hDevice)->activateMetricGroups(count, phMetricGroups);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Device::fromHandle(hDevice)->activateMetricGroups(count, phMetricGroups);
 }
 
 __zedllexport ze_result_t __zecall
@@ -154,27 +67,7 @@ zetMetricTracerOpen(
     zet_metric_tracer_desc_t *pDesc,
     ze_event_handle_t hNotificationEvent,
     zet_metric_tracer_handle_t *phMetricTracer) {
-    try {
-        {
-            if (nullptr == hDevice)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == hMetricGroup)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pDesc)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == phMetricTracer)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (ZET_METRIC_TRACER_DESC_VERSION_CURRENT < pDesc->version)
-                return ZE_RESULT_ERROR_UNKNOWN;
-        }
-        return L0::metricTracerOpen(hDevice, hMetricGroup, pDesc, hNotificationEvent, phMetricTracer);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::metricTracerOpen(hDevice, hMetricGroup, pDesc, hNotificationEvent, phMetricTracer);
 }
 
 __zedllexport ze_result_t __zecall
@@ -182,39 +75,13 @@ zetCommandListAppendMetricTracerMarker(
     ze_command_list_handle_t hCommandList,
     zet_metric_tracer_handle_t hMetricTracer,
     uint32_t value) {
-    try {
-        {
-            if (nullptr == hCommandList)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == hMetricTracer)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::CommandList::fromHandle(hCommandList)->appendMetricTracerMarker(hMetricTracer, value);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::CommandList::fromHandle(hCommandList)->appendMetricTracerMarker(hMetricTracer, value);
 }
 
 __zedllexport ze_result_t __zecall
 zetMetricTracerClose(
     zet_metric_tracer_handle_t hMetricTracer) {
-    try {
-        {
-            if (nullptr == hMetricTracer)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::MetricTracer::fromHandle(hMetricTracer)->close();
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::MetricTracer::fromHandle(hMetricTracer)->close();
 }
 
 __zedllexport ze_result_t __zecall
@@ -223,21 +90,7 @@ zetMetricTracerReadData(
     uint32_t maxReportCount,
     size_t *pRawDataSize,
     uint8_t *pRawData) {
-    try {
-        {
-            if (nullptr == hMetricTracer)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pRawDataSize)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::MetricTracer::fromHandle(hMetricTracer)->readData(maxReportCount, pRawDataSize, pRawData);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::MetricTracer::fromHandle(hMetricTracer)->readData(maxReportCount, pRawDataSize, pRawData);
 }
 
 __zedllexport ze_result_t __zecall
@@ -246,43 +99,13 @@ zetMetricQueryPoolCreate(
     zet_metric_group_handle_t hMetricGroup,
     const zet_metric_query_pool_desc_t *desc,
     zet_metric_query_pool_handle_t *phMetricQueryPool) {
-    try {
-        {
-            if (nullptr == hDevice)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == desc)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == phMetricQueryPool)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (ZET_METRIC_QUERY_POOL_DESC_VERSION_CURRENT < desc->version)
-                return ZE_RESULT_ERROR_UNKNOWN;
-        }
-        return L0::metricQueryPoolCreate(hDevice, hMetricGroup, desc, phMetricQueryPool);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::metricQueryPoolCreate(hDevice, hMetricGroup, desc, phMetricQueryPool);
 }
 
 __zedllexport ze_result_t __zecall
 zetMetricQueryPoolDestroy(
     zet_metric_query_pool_handle_t hMetricQueryPool) {
-    try {
-        {
-            if (nullptr == hMetricQueryPool)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::metricQueryPoolDestroy(hMetricQueryPool);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::metricQueryPoolDestroy(hMetricQueryPool);
 }
 
 __zedllexport ze_result_t __zecall
@@ -290,78 +113,26 @@ zetMetricQueryCreate(
     zet_metric_query_pool_handle_t hMetricQueryPool,
     uint32_t index,
     zet_metric_query_handle_t *phMetricQuery) {
-    try {
-        {
-            if (nullptr == hMetricQueryPool)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == phMetricQuery)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::MetricQueryPool::fromHandle(hMetricQueryPool)->createMetricQuery(index, phMetricQuery);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::MetricQueryPool::fromHandle(hMetricQueryPool)->createMetricQuery(index, phMetricQuery);
 }
 
 __zedllexport ze_result_t __zecall
 zetMetricQueryDestroy(
     zet_metric_query_handle_t hMetricQuery) {
-    try {
-        {
-            if (nullptr == hMetricQuery)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::MetricQuery::fromHandle(hMetricQuery)->destroy();
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::MetricQuery::fromHandle(hMetricQuery)->destroy();
 }
 
 __zedllexport ze_result_t __zecall
 zetMetricQueryReset(
     zet_metric_query_handle_t hMetricQuery) {
-    try {
-        {
-            if (nullptr == hMetricQuery)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::MetricQuery::fromHandle(hMetricQuery)->reset();
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::MetricQuery::fromHandle(hMetricQuery)->reset();
 }
 
 __zedllexport ze_result_t __zecall
 zetCommandListAppendMetricQueryBegin(
     zet_command_list_handle_t hCommandList,
     zet_metric_query_handle_t hMetricQuery) {
-    try {
-        {
-            if (nullptr == hCommandList)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == hMetricQuery)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::CommandList::fromHandle(hCommandList)->appendMetricQueryBegin(hMetricQuery);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::CommandList::fromHandle(hCommandList)->appendMetricQueryBegin(hMetricQuery);
 }
 
 __zedllexport ze_result_t __zecall
@@ -369,39 +140,13 @@ zetCommandListAppendMetricQueryEnd(
     zet_command_list_handle_t hCommandList,
     zet_metric_query_handle_t hMetricQuery,
     ze_event_handle_t hCompletionEvent) {
-    try {
-        {
-            if (nullptr == hCommandList)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == hMetricQuery)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::CommandList::fromHandle(hCommandList)->appendMetricQueryEnd(hMetricQuery, hCompletionEvent);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::CommandList::fromHandle(hCommandList)->appendMetricQueryEnd(hMetricQuery, hCompletionEvent);
 }
 
 __zedllexport ze_result_t __zecall
 zetCommandListAppendMetricMemoryBarrier(
     zet_command_list_handle_t hCommandList) {
-    try {
-        {
-            if (nullptr == hCommandList)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::CommandList::fromHandle(hCommandList)->appendMetricMemoryBarrier();
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::CommandList::fromHandle(hCommandList)->appendMetricMemoryBarrier();
 }
 
 __zedllexport ze_result_t __zecall
@@ -409,20 +154,7 @@ zetMetricQueryGetData(
     zet_metric_query_handle_t hMetricQuery,
     size_t *pRawDataSize,
     uint8_t *pRawData) {
-    try {
-        {
-            if (nullptr == hMetricQuery)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pRawDataSize)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::MetricQuery::fromHandle(hMetricQuery)->getData(pRawDataSize, pRawData);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
-}
+    return L0::MetricQuery::fromHandle(hMetricQuery)->getData(pRawDataSize, pRawData);
 }
+
+} // extern C
diff --git a/level_zero/api/tools/zet_module.cpp b/level_zero/api/tools/zet_module.cpp
index 2bce25b480..e6687f4c72 100644
--- a/level_zero/api/tools/zet_module.cpp
+++ b/level_zero/api/tools/zet_module.cpp
@@ -8,9 +8,6 @@
 #include "level_zero/core/source/module.h"
 #include <level_zero/zet_api.h>
 
-#include <exception>
-#include <new>
-
 extern "C" {
 
 __zedllexport ze_result_t __zecall
@@ -19,14 +16,7 @@ zetModuleGetDebugInfo(
     zet_module_debug_info_format_t format,
     size_t *pSize,
     uint8_t *pDebugInfo) {
-    {
-        if (nullptr == hModule)
-            return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        if (nullptr == pSize)
-            return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        if (format != ZET_MODULE_DEBUG_INFO_FORMAT_ELF_DWARF)
-            return ZE_RESULT_ERROR_UNKNOWN;
-    }
     return L0::Module::fromHandle(hModule)->getDebugInfo(pSize, pDebugInfo);
 }
-}
\ No newline at end of file
+
+} // extern C
\ No newline at end of file
diff --git a/level_zero/api/tools/zet_sysman.cpp b/level_zero/api/tools/zet_sysman.cpp
index 3ea6950602..57bfec2872 100644
--- a/level_zero/api/tools/zet_sysman.cpp
+++ b/level_zero/api/tools/zet_sysman.cpp
@@ -16,15 +16,6 @@ zetSysmanGet(
     zet_device_handle_t hDevice,
     zet_sysman_version_t version,
     zet_sysman_handle_t *phSysman) {
-    if (nullptr == hDevice) {
-        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-    if (nullptr == phSysman) {
-        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-    if (ZET_SYSMAN_VERSION_CURRENT < version) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
     return L0::SysmanHandleContext::sysmanGet(hDevice, phSysman);
 }
 
@@ -32,42 +23,14 @@ __zedllexport ze_result_t __zecall
 zetSysmanDeviceGetProperties(
     zet_sysman_handle_t hSysman,
     zet_sysman_properties_t *pProperties) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->deviceGetProperties(pProperties);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->deviceGetProperties(pProperties);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanSchedulerGetCurrentMode(
     zet_sysman_handle_t hSysman,
     zet_sched_mode_t *pMode) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pMode)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->schedulerGetCurrentMode(pMode);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->schedulerGetCurrentMode(pMode);
 }
 
 __zedllexport ze_result_t __zecall
@@ -75,21 +38,7 @@ zetSysmanSchedulerGetTimeoutModeProperties(
     zet_sysman_handle_t hSysman,
     ze_bool_t getDefaults,
     zet_sched_timeout_properties_t *pConfig) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pConfig)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->schedulerGetTimeoutModeProperties(getDefaults, pConfig);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->schedulerGetTimeoutModeProperties(getDefaults, pConfig);
 }
 
 __zedllexport ze_result_t __zecall
@@ -97,21 +46,7 @@ zetSysmanSchedulerGetTimesliceModeProperties(
     zet_sysman_handle_t hSysman,
     ze_bool_t getDefaults,
     zet_sched_timeslice_properties_t *pConfig) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pConfig)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->schedulerGetTimesliceModeProperties(getDefaults, pConfig);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->schedulerGetTimesliceModeProperties(getDefaults, pConfig);
 }
 
 __zedllexport ze_result_t __zecall
@@ -119,23 +54,7 @@ zetSysmanSchedulerSetTimeoutMode(
     zet_sysman_handle_t hSysman,
     zet_sched_timeout_properties_t *pProperties,
     ze_bool_t *pNeedReboot) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pNeedReboot)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->schedulerSetTimeoutMode(pProperties, pNeedReboot);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->schedulerSetTimeoutMode(pProperties, pNeedReboot);
 }
 
 __zedllexport ze_result_t __zecall
@@ -143,65 +62,21 @@ zetSysmanSchedulerSetTimesliceMode(
     zet_sysman_handle_t hSysman,
     zet_sched_timeslice_properties_t *pProperties,
     ze_bool_t *pNeedReboot) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pNeedReboot)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->schedulerSetTimesliceMode(pProperties, pNeedReboot);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->schedulerSetTimesliceMode(pProperties, pNeedReboot);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanSchedulerSetExclusiveMode(
     zet_sysman_handle_t hSysman,
     ze_bool_t *pNeedReboot) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pNeedReboot)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->schedulerSetExclusiveMode(pNeedReboot);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->schedulerSetExclusiveMode(pNeedReboot);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanSchedulerSetComputeUnitDebugMode(
     zet_sysman_handle_t hSysman,
     ze_bool_t *pNeedReboot) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pNeedReboot)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->schedulerSetComputeUnitDebugMode(pNeedReboot);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->schedulerSetComputeUnitDebugMode(pNeedReboot);
 }
 
 __zedllexport ze_result_t __zecall
@@ -209,102 +84,34 @@ zetSysmanProcessesGetState(
     zet_sysman_handle_t hSysman,
     uint32_t *pCount,
     zet_process_state_t *pProcesses) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->processesGetState(pCount, pProcesses);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->processesGetState(pCount, pProcesses);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanDeviceReset(
     zet_sysman_handle_t hSysman) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->deviceReset();
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->deviceReset();
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanDeviceGetRepairStatus(
     zet_sysman_handle_t hSysman,
     zet_repair_status_t *pRepairStatus) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pRepairStatus)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->deviceGetRepairStatus(pRepairStatus);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->deviceGetRepairStatus(pRepairStatus);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanPciGetProperties(
     zet_sysman_handle_t hSysman,
     zet_pci_properties_t *pProperties) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->pciGetProperties(pProperties);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->pciGetProperties(pProperties);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanPciGetState(
     zet_sysman_handle_t hSysman,
     zet_pci_state_t *pState) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pState)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->pciGetState(pState);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->pciGetState(pState);
 }
 
 __zedllexport ze_result_t __zecall
@@ -312,42 +119,14 @@ zetSysmanPciGetBars(
     zet_sysman_handle_t hSysman,
     uint32_t *pCount,
     zet_pci_bar_properties_t *pProperties) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->pciGetBars(pCount, pProperties);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->pciGetBars(pCount, pProperties);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanPciGetStats(
     zet_sysman_handle_t hSysman,
     zet_pci_stats_t *pStats) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pStats)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->pciGetStats(pStats);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->pciGetStats(pStats);
 }
 
 __zedllexport ze_result_t __zecall
@@ -355,63 +134,21 @@ zetSysmanPowerGet(
     zet_sysman_handle_t hSysman,
     uint32_t *pCount,
     zet_sysman_pwr_handle_t *phPower) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->powerGet(pCount, phPower);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->powerGet(pCount, phPower);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanPowerGetProperties(
     zet_sysman_pwr_handle_t hPower,
     zet_power_properties_t *pProperties) {
-    try {
-        {
-            if (nullptr == hPower)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanPowerGetEnergyCounter(
     zet_sysman_pwr_handle_t hPower,
     zet_power_energy_counter_t *pEnergy) {
-    try {
-        {
-            if (nullptr == hPower)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pEnergy)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -420,19 +157,7 @@ zetSysmanPowerGetLimits(
     zet_power_sustained_limit_t *pSustained,
     zet_power_burst_limit_t *pBurst,
     zet_power_peak_limit_t *pPeak) {
-    try {
-        {
-            if (nullptr == hPower)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -441,59 +166,21 @@ zetSysmanPowerSetLimits(
     const zet_power_sustained_limit_t *pSustained,
     const zet_power_burst_limit_t *pBurst,
     const zet_power_peak_limit_t *pPeak) {
-    try {
-        {
-            if (nullptr == hPower)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanPowerGetEnergyThreshold(
     zet_sysman_pwr_handle_t hPower,
     zet_energy_threshold_t *pThreshold) {
-    try {
-        {
-            if (nullptr == hPower)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pThreshold)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanPowerSetEnergyThreshold(
     zet_sysman_pwr_handle_t hPower,
     double threshold) {
-    try {
-        {
-            if (nullptr == hPower)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -501,42 +188,14 @@ zetSysmanFrequencyGet(
     zet_sysman_handle_t hSysman,
     uint32_t *pCount,
     zet_sysman_freq_handle_t *phFrequency) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->frequencyGet(pCount, phFrequency);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->frequencyGet(pCount, phFrequency);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFrequencyGetProperties(
     zet_sysman_freq_handle_t hFrequency,
     zet_freq_properties_t *pProperties) {
-    try {
-        {
-            if (nullptr == hFrequency)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Frequency::fromHandle(hFrequency)->frequencyGetProperties(pProperties);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Frequency::fromHandle(hFrequency)->frequencyGetProperties(pProperties);
 }
 
 __zedllexport ze_result_t __zecall
@@ -544,147 +203,49 @@ zetSysmanFrequencyGetAvailableClocks(
     zet_sysman_freq_handle_t hFrequency,
     uint32_t *pCount,
     double *phFrequency) {
-    try {
-        {
-            if (nullptr == hFrequency)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFrequencyGetRange(
     zet_sysman_freq_handle_t hFrequency,
     zet_freq_range_t *pLimits) {
-    try {
-        {
-            if (nullptr == hFrequency)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pLimits)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Frequency::fromHandle(hFrequency)->frequencyGetRange(pLimits);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Frequency::fromHandle(hFrequency)->frequencyGetRange(pLimits);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFrequencySetRange(
     zet_sysman_freq_handle_t hFrequency,
     const zet_freq_range_t *pLimits) {
-    try {
-        {
-            if (nullptr == hFrequency)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pLimits)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Frequency::fromHandle(hFrequency)->frequencySetRange(pLimits);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Frequency::fromHandle(hFrequency)->frequencySetRange(pLimits);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFrequencyGetState(
     zet_sysman_freq_handle_t hFrequency,
     zet_freq_state_t *pState) {
-    try {
-        {
-            if (nullptr == hFrequency)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pState)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Frequency::fromHandle(hFrequency)->frequencyGetState(pState);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Frequency::fromHandle(hFrequency)->frequencyGetState(pState);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFrequencyGetThrottleTime(
     zet_sysman_freq_handle_t hFrequency,
     zet_freq_throttle_time_t *pThrottleTime) {
-    try {
-        {
-            if (nullptr == hFrequency)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pThrottleTime)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFrequencyOcGetCapabilities(
     zet_sysman_freq_handle_t hFrequency,
     zet_oc_capabilities_t *pOcCapabilities) {
-    try {
-        {
-            if (nullptr == hFrequency)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pOcCapabilities)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFrequencyOcGetConfig(
     zet_sysman_freq_handle_t hFrequency,
     zet_oc_config_t *pOcConfiguration) {
-    try {
-        {
-            if (nullptr == hFrequency)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pOcConfiguration)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -692,101 +253,35 @@ zetSysmanFrequencyOcSetConfig(
     zet_sysman_freq_handle_t hFrequency,
     zet_oc_config_t *pOcConfiguration,
     ze_bool_t *pDeviceRestart) {
-    try {
-        {
-            if (nullptr == hFrequency)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pOcConfiguration)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFrequencyOcGetIccMax(
     zet_sysman_freq_handle_t hFrequency,
     double *pOcIccMax) {
-    try {
-        {
-            if (nullptr == hFrequency)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pOcIccMax)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFrequencyOcSetIccMax(
     zet_sysman_freq_handle_t hFrequency,
     double ocIccMax) {
-    try {
-        {
-            if (nullptr == hFrequency)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFrequencyOcGetTjMax(
     zet_sysman_freq_handle_t hFrequency,
     double *pOcTjMax) {
-    try {
-        {
-            if (nullptr == hFrequency)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pOcTjMax)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFrequencyOcSetTjMax(
     zet_sysman_freq_handle_t hFrequency,
     double ocTjMax) {
-    try {
-        {
-            if (nullptr == hFrequency)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -794,63 +289,21 @@ zetSysmanEngineGet(
     zet_sysman_handle_t hSysman,
     uint32_t *pCount,
     zet_sysman_engine_handle_t *phEngine) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->engineGet(pCount, phEngine);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->engineGet(pCount, phEngine);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanEngineGetProperties(
     zet_sysman_engine_handle_t hEngine,
     zet_engine_properties_t *pProperties) {
-    try {
-        {
-            if (nullptr == hEngine)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanEngineGetActivity(
     zet_sysman_engine_handle_t hEngine,
     zet_engine_stats_t *pStats) {
-    try {
-        {
-            if (nullptr == hEngine)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pStats)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -858,84 +311,28 @@ zetSysmanStandbyGet(
     zet_sysman_handle_t hSysman,
     uint32_t *pCount,
     zet_sysman_standby_handle_t *phStandby) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->standbyGet(pCount, phStandby);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->standbyGet(pCount, phStandby);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanStandbyGetProperties(
     zet_sysman_standby_handle_t hStandby,
     zet_standby_properties_t *pProperties) {
-    try {
-        {
-            if (nullptr == hStandby)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Standby::fromHandle(hStandby)->standbyGetProperties(pProperties);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Standby::fromHandle(hStandby)->standbyGetProperties(pProperties);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanStandbyGetMode(
     zet_sysman_standby_handle_t hStandby,
     zet_standby_promo_mode_t *pMode) {
-    try {
-        {
-            if (nullptr == hStandby)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pMode)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Standby::fromHandle(hStandby)->standbyGetMode(pMode);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Standby::fromHandle(hStandby)->standbyGetMode(pMode);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanStandbySetMode(
     zet_sysman_standby_handle_t hStandby,
     zet_standby_promo_mode_t mode) {
-    try {
-        {
-            if (nullptr == hStandby)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (ZET_STANDBY_PROMO_MODE_DEFAULT != mode && ZET_STANDBY_PROMO_MODE_NEVER != mode)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Standby::fromHandle(hStandby)->standbySetMode(mode);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Standby::fromHandle(hStandby)->standbySetMode(mode);
 }
 
 __zedllexport ze_result_t __zecall
@@ -943,63 +340,21 @@ zetSysmanFirmwareGet(
     zet_sysman_handle_t hSysman,
     uint32_t *pCount,
     zet_sysman_firmware_handle_t *phFirmware) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->firmwareGet(pCount, phFirmware);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->firmwareGet(pCount, phFirmware);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFirmwareGetProperties(
     zet_sysman_firmware_handle_t hFirmware,
     zet_firmware_properties_t *pProperties) {
-    try {
-        {
-            if (nullptr == hFirmware)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFirmwareGetChecksum(
     zet_sysman_firmware_handle_t hFirmware,
     uint32_t *pChecksum) {
-    try {
-        {
-            if (nullptr == hFirmware)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pChecksum)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -1007,21 +362,7 @@ zetSysmanFirmwareFlash(
     zet_sysman_firmware_handle_t hFirmware,
     void *pImage,
     uint32_t size) {
-    try {
-        {
-            if (nullptr == hFirmware)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pImage)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -1029,84 +370,28 @@ zetSysmanMemoryGet(
     zet_sysman_handle_t hSysman,
     uint32_t *pCount,
     zet_sysman_mem_handle_t *phMemory) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->memoryGet(pCount, phMemory);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->memoryGet(pCount, phMemory);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanMemoryGetProperties(
     zet_sysman_mem_handle_t hMemory,
     zet_mem_properties_t *pProperties) {
-    try {
-        {
-            if (nullptr == hMemory)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanMemoryGetState(
     zet_sysman_mem_handle_t hMemory,
     zet_mem_state_t *pState) {
-    try {
-        {
-            if (nullptr == hMemory)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pState)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanMemoryGetBandwidth(
     zet_sysman_mem_handle_t hMemory,
     zet_mem_bandwidth_t *pBandwidth) {
-    try {
-        {
-            if (nullptr == hMemory)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pBandwidth)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -1114,42 +399,14 @@ zetSysmanFabricPortGet(
     zet_sysman_handle_t hSysman,
     uint32_t *pCount,
     zet_sysman_fabric_port_handle_t *phPort) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->fabricPortGet(pCount, phPort);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->fabricPortGet(pCount, phPort);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFabricPortGetProperties(
     zet_sysman_fabric_port_handle_t hPort,
     zet_fabric_port_properties_t *pProperties) {
-    try {
-        {
-            if (nullptr == hPort)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -1157,105 +414,35 @@ zetSysmanFabricPortGetLinkType(
     zet_sysman_fabric_port_handle_t hPort,
     ze_bool_t verbose,
     zet_fabric_link_type_t *pLinkType) {
-    try {
-        {
-            if (nullptr == hPort)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pLinkType)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFabricPortGetConfig(
     zet_sysman_fabric_port_handle_t hPort,
     zet_fabric_port_config_t *pConfig) {
-    try {
-        {
-            if (nullptr == hPort)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pConfig)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFabricPortSetConfig(
     zet_sysman_fabric_port_handle_t hPort,
     const zet_fabric_port_config_t *pConfig) {
-    try {
-        {
-            if (nullptr == hPort)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pConfig)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFabricPortGetState(
     zet_sysman_fabric_port_handle_t hPort,
     zet_fabric_port_state_t *pState) {
-    try {
-        {
-            if (nullptr == hPort)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pState)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFabricPortGetThroughput(
     zet_sysman_fabric_port_handle_t hPort,
     zet_fabric_port_throughput_t *pThroughput) {
-    try {
-        {
-            if (nullptr == hPort)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pThroughput)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -1263,105 +450,35 @@ zetSysmanTemperatureGet(
     zet_sysman_handle_t hSysman,
     uint32_t *pCount,
     zet_sysman_temp_handle_t *phTemperature) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->temperatureGet(pCount, phTemperature);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->temperatureGet(pCount, phTemperature);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanTemperatureGetProperties(
     zet_sysman_temp_handle_t hTemperature,
     zet_temp_properties_t *pProperties) {
-    try {
-        {
-            if (nullptr == hTemperature)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanTemperatureGetConfig(
     zet_sysman_temp_handle_t hTemperature,
     zet_temp_config_t *pConfig) {
-    try {
-        {
-            if (nullptr == hTemperature)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pConfig)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanTemperatureSetConfig(
     zet_sysman_temp_handle_t hTemperature,
     const zet_temp_config_t *pConfig) {
-    try {
-        {
-            if (nullptr == hTemperature)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pConfig)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanTemperatureGetState(
     zet_sysman_temp_handle_t hTemperature,
     double *pTemperature) {
-    try {
-        {
-            if (nullptr == hTemperature)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pTemperature)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -1369,63 +486,21 @@ zetSysmanPsuGet(
     zet_sysman_handle_t hSysman,
     uint32_t *pCount,
     zet_sysman_psu_handle_t *phPsu) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->psuGet(pCount, phPsu);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->psuGet(pCount, phPsu);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanPsuGetProperties(
     zet_sysman_psu_handle_t hPsu,
     zet_psu_properties_t *pProperties) {
-    try {
-        {
-            if (nullptr == hPsu)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanPsuGetState(
     zet_sysman_psu_handle_t hPsu,
     zet_psu_state_t *pState) {
-    try {
-        {
-            if (nullptr == hPsu)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pState)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -1433,84 +508,28 @@ zetSysmanFanGet(
     zet_sysman_handle_t hSysman,
     uint32_t *pCount,
     zet_sysman_fan_handle_t *phFan) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->fanGet(pCount, phFan);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->fanGet(pCount, phFan);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFanGetProperties(
     zet_sysman_fan_handle_t hFan,
     zet_fan_properties_t *pProperties) {
-    try {
-        {
-            if (nullptr == hFan)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFanGetConfig(
     zet_sysman_fan_handle_t hFan,
     zet_fan_config_t *pConfig) {
-    try {
-        {
-            if (nullptr == hFan)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pConfig)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanFanSetConfig(
     zet_sysman_fan_handle_t hFan,
     const zet_fan_config_t *pConfig) {
-    try {
-        {
-            if (nullptr == hFan)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pConfig)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -1518,21 +537,7 @@ zetSysmanFanGetState(
     zet_sysman_fan_handle_t hFan,
     zet_fan_speed_units_t units,
     uint32_t *pSpeed) {
-    try {
-        {
-            if (nullptr == hFan)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pSpeed)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -1540,84 +545,28 @@ zetSysmanLedGet(
     zet_sysman_handle_t hSysman,
     uint32_t *pCount,
     zet_sysman_led_handle_t *phLed) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->ledGet(pCount, phLed);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->ledGet(pCount, phLed);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanLedGetProperties(
     zet_sysman_led_handle_t hLed,
     zet_led_properties_t *pProperties) {
-    try {
-        {
-            if (nullptr == hLed)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanLedGetState(
     zet_sysman_led_handle_t hLed,
     zet_led_state_t *pState) {
-    try {
-        {
-            if (nullptr == hLed)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pState)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanLedSetState(
     zet_sysman_led_handle_t hLed,
     const zet_led_state_t *pState) {
-    try {
-        {
-            if (nullptr == hLed)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pState)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -1625,84 +574,28 @@ zetSysmanRasGet(
     zet_sysman_handle_t hSysman,
     uint32_t *pCount,
     zet_sysman_ras_handle_t *phRas) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->rasGet(pCount, phRas);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->rasGet(pCount, phRas);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanRasGetProperties(
     zet_sysman_ras_handle_t hRas,
     zet_ras_properties_t *pProperties) {
-    try {
-        {
-            if (nullptr == hRas)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanRasGetConfig(
     zet_sysman_ras_handle_t hRas,
     zet_ras_config_t *pConfig) {
-    try {
-        {
-            if (nullptr == hRas)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pConfig)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanRasSetConfig(
     zet_sysman_ras_handle_t hRas,
     const zet_ras_config_t *pConfig) {
-    try {
-        {
-            if (nullptr == hRas)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pConfig)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -1711,84 +604,28 @@ zetSysmanRasGetState(
     ze_bool_t clear,
     uint64_t *pTotalErrors,
     zet_ras_details_t *pDetails) {
-    try {
-        {
-            if (nullptr == hRas)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pTotalErrors)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanEventGet(
     zet_sysman_handle_t hSysman,
     zet_sysman_event_handle_t *phEvent) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == phEvent)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->eventGet(phEvent);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->eventGet(phEvent);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanEventGetConfig(
     zet_sysman_event_handle_t hEvent,
     zet_event_config_t *pConfig) {
-    try {
-        {
-            if (nullptr == hEvent)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pConfig)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanEventSetConfig(
     zet_sysman_event_handle_t hEvent,
     const zet_event_config_t *pConfig) {
-    try {
-        {
-            if (nullptr == hEvent)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pConfig)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -1796,21 +633,7 @@ zetSysmanEventGetState(
     zet_sysman_event_handle_t hEvent,
     ze_bool_t clear,
     uint32_t *pEvents) {
-    try {
-        {
-            if (nullptr == hEvent)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pEvents)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -1820,24 +643,7 @@ zetSysmanEventListen(
     uint32_t count,
     zet_sysman_event_handle_t *phEvents,
     uint32_t *pEvents) {
-    try {
-        {
-            if (nullptr == hDriver)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == phEvents)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == phEvents)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
-    return ZE_RESULT_ERROR_UNKNOWN;
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -1845,42 +651,14 @@ zetSysmanDiagnosticsGet(
     zet_sysman_handle_t hSysman,
     uint32_t *pCount,
     zet_sysman_diag_handle_t *phDiagnostics) {
-    try {
-        {
-            if (nullptr == hSysman)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return L0::Sysman::fromHandle(hSysman)->diagnosticsGet(pCount, phDiagnostics);
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return L0::Sysman::fromHandle(hSysman)->diagnosticsGet(pCount, phDiagnostics);
 }
 
 __zedllexport ze_result_t __zecall
 zetSysmanDiagnosticsGetProperties(
     zet_sysman_diag_handle_t hDiagnostics,
     zet_diag_properties_t *pProperties) {
-    try {
-        {
-            if (nullptr == hDiagnostics)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pProperties)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -1888,21 +666,7 @@ zetSysmanDiagnosticsGetTests(
     zet_sysman_diag_handle_t hDiagnostics,
     uint32_t *pCount,
     zet_diag_test_t *pTests) {
-    try {
-        {
-            if (nullptr == hDiagnostics)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pCount)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 __zedllexport ze_result_t __zecall
@@ -1911,20 +675,7 @@ zetSysmanDiagnosticsRunTests(
     uint32_t start,
     uint32_t end,
     zet_diag_result_t *pResult) {
-    try {
-        {
-            if (nullptr == hDiagnostics)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-            if (nullptr == pResult)
-                return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        return ZE_RESULT_ERROR_UNKNOWN;
-    } catch (ze_result_t &result) {
-        return result;
-    } catch (std::bad_alloc &) {
-        return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
-    } catch (std::exception &) {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
-}
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
+
+} // extern C
diff --git a/level_zero/api/tools/zet_tracing.cpp b/level_zero/api/tools/zet_tracing.cpp
index 290d75f06f..7f7a3514c5 100644
--- a/level_zero/api/tools/zet_tracing.cpp
+++ b/level_zero/api/tools/zet_tracing.cpp
@@ -15,22 +15,12 @@ zetTracerCreate(
     zet_driver_handle_t hDriver,
     const zet_tracer_desc_t *desc,
     zet_tracer_handle_t *phTracer) {
-    {
-        if (ZET_TRACER_DESC_VERSION_CURRENT > desc->version) {
-            return ZE_RESULT_ERROR_UNKNOWN;
-        }
-    }
     return L0::createAPITracer(hDriver, desc, phTracer);
 }
 
 __zedllexport ze_result_t __zecall
 zetTracerDestroy(
     zet_tracer_handle_t hTracer) {
-    {
-        if (nullptr == hTracer) {
-            return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-    }
     return L0::APITracer::fromHandle(hTracer)->destroyTracer(hTracer);
 }
 
@@ -38,14 +28,6 @@ __zedllexport ze_result_t __zecall
 zetTracerSetPrologues(
     zet_tracer_handle_t hTracer,
     zet_core_callbacks_t *pCoreCbs) {
-    {
-        if (nullptr == hTracer) {
-            return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        if (nullptr == pCoreCbs) {
-            return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-    }
     return L0::APITracer::fromHandle(hTracer)->setPrologues(pCoreCbs);
 }
 
@@ -53,14 +35,6 @@ __zedllexport ze_result_t __zecall
 zetTracerSetEpilogues(
     zet_tracer_handle_t hTracer,
     zet_core_callbacks_t *pCoreCbs) {
-    {
-        if (nullptr == hTracer) {
-            return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-        if (nullptr == pCoreCbs) {
-            return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-    }
     return L0::APITracer::fromHandle(hTracer)->setEpilogues(pCoreCbs);
 }
 
@@ -68,13 +42,7 @@ __zedllexport ze_result_t __zecall
 zetTracerSetEnabled(
     zet_tracer_handle_t hTracer,
     ze_bool_t enable) {
-    ze_result_t result;
-    {
-        if (nullptr == hTracer) {
-            return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-        }
-    }
-    result = L0::APITracer::fromHandle(hTracer)->enableTracer(enable);
-    return result;
-}
+    return L0::APITracer::fromHandle(hTracer)->enableTracer(enable);
 }
+
+} // extern C