refactor: correct naming of enum class constants n/n

Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
2025-12-20 08:53:55 +08:00 · 2023-12-19 11:02:07 +00:00
parent f5045348ad
commit bf60d77e10
28 changed files with 108 additions and 108 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -92,6 +92,8 @@ CheckOptions:
    value:           camelBack
  - key:             readability-identifier-naming.ValueTemplateParameterCase
    value:           camelBack
+  - key:             readability-identifier-naming.ScopedEnumConstantCase
+    value:           camelBack
  - key:             modernize-loop-convert.MaxCopySize
    value:           '16'
  - key:             modernize-loop-convert.MinConfidence
--- a/level_zero/sysman/source/api/ras/linux/ras_util/sysman_ras_util.cpp
+++ b/level_zero/sysman/source/api/ras/linux/ras_util/sysman_ras_util.cpp
@@ -12,9 +12,9 @@ namespace Sysman {

 std::unique_ptr<RasUtil> RasUtil::create(RasInterfaceType rasInterface, LinuxSysmanImp *pLinuxSysmanImp, zes_ras_error_type_t type, ze_bool_t onSubdevice, uint32_t subdeviceId) {
    switch (rasInterface) {
-    case RasInterfaceType::PMU:
+    case RasInterfaceType::pmu:
        return std::make_unique<PmuRasUtil>(type, pLinuxSysmanImp, onSubdevice, subdeviceId);
-    case RasInterfaceType::GSC:
+    case RasInterfaceType::gsc:
        return std::make_unique<GscRasUtil>(type, pLinuxSysmanImp, subdeviceId);
    default:
        return std::make_unique<RasUtilNone>();
--- a/level_zero/sysman/source/api/ras/linux/ras_util/sysman_ras_util.h
+++ b/level_zero/sysman/source/api/ras/linux/ras_util/sysman_ras_util.h
@@ -27,10 +27,10 @@ class SysFsAccessInterface;
 class FirmwareUtil;

 enum class RasInterfaceType {
-    PMU = 0,
-    PMT,
-    GSC,
-    NONE,
+    pmu = 0,
+    pmt,
+    gsc,
+    none,
 };

 class RasUtil : public NEO::NonCopyableOrMovableClass {
--- a/level_zero/sysman/source/api/ras/linux/sysman_os_ras_imp_gt.cpp
+++ b/level_zero/sysman/source/api/ras/linux/sysman_os_ras_imp_gt.cpp
@@ -26,7 +26,7 @@ void LinuxRasSourceGt::getSupportedRasErrorTypes(std::set<zes_ras_error_type_t>
    auto pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper();
    auto rasUtilInterface = pSysmanProductHelper->getGtRasUtilInterface();
    switch (rasUtilInterface) {
-    case RasInterfaceType::PMU:
+    case RasInterfaceType::pmu:
        PmuRasUtil::getSupportedRasErrorTypes(errorType, pLinuxSysmanImp, isSubDevice, subDeviceId);
        break;
    default:
--- a/level_zero/sysman/source/api/ras/linux/sysman_os_ras_imp_hbm.cpp
+++ b/level_zero/sysman/source/api/ras/linux/sysman_os_ras_imp_hbm.cpp
@@ -23,7 +23,7 @@ void LinuxRasSourceHbm::getSupportedRasErrorTypes(std::set<zes_ras_error_type_t>
    auto pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper();
    auto rasUtilInterface = pSysmanProductHelper->getHbmRasUtilInterface();
    switch (rasUtilInterface) {
-    case RasInterfaceType::GSC:
+    case RasInterfaceType::gsc:
        GscRasUtil::getSupportedRasErrorTypes(errorType, pLinuxSysmanImp, isSubDevice, subDeviceId);
        break;
    default:
--- a/level_zero/sysman/source/shared/linux/product_helper/gen12lp/dg1/sysman_product_helper_dg1.cpp
+++ b/level_zero/sysman/source/shared/linux/product_helper/gen12lp/dg1/sysman_product_helper_dg1.cpp
@@ -103,7 +103,7 @@ ze_result_t SysmanProductHelperHw<gfxProduct>::getGpuMaxTemperature(PlatformMoni

 template <>
 RasInterfaceType SysmanProductHelperHw<gfxProduct>::getGtRasUtilInterface() {
-    return RasInterfaceType::PMU;
+    return RasInterfaceType::pmu;
 }

 template class SysmanProductHelperHw<gfxProduct>;
--- a/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.inl
+++ b/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.inl
@@ -108,12 +108,12 @@ ze_result_t SysmanProductHelperHw<gfxProduct>::getMemoryMaxTemperature(PlatformM

 template <PRODUCT_FAMILY gfxProduct>
 RasInterfaceType SysmanProductHelperHw<gfxProduct>::getGtRasUtilInterface() {
-    return RasInterfaceType::NONE;
+    return RasInterfaceType::none;
 }

 template <PRODUCT_FAMILY gfxProduct>
 RasInterfaceType SysmanProductHelperHw<gfxProduct>::getHbmRasUtilInterface() {
-    return RasInterfaceType::NONE;
+    return RasInterfaceType::none;
 }

 } // namespace Sysman
--- a/level_zero/sysman/source/shared/linux/product_helper/xe_hpc_core/pvc/sysman_product_helper_pvc.cpp
+++ b/level_zero/sysman/source/shared/linux/product_helper/xe_hpc_core/pvc/sysman_product_helper_pvc.cpp
@@ -79,12 +79,12 @@ ze_result_t SysmanProductHelperHw<gfxProduct>::getMemoryMaxTemperature(PlatformM

 template <>
 RasInterfaceType SysmanProductHelperHw<gfxProduct>::getGtRasUtilInterface() {
-    return RasInterfaceType::PMU;
+    return RasInterfaceType::pmu;
 }

 template <>
 RasInterfaceType SysmanProductHelperHw<gfxProduct>::getHbmRasUtilInterface() {
-    return RasInterfaceType::GSC;
+    return RasInterfaceType::gsc;
 }

 template class SysmanProductHelperHw<gfxProduct>;
--- a/level_zero/sysman/source/shared/linux/product_helper/xe_hpg_core/dg2/sysman_product_helper_dg2.cpp
+++ b/level_zero/sysman/source/shared/linux/product_helper/xe_hpg_core/dg2/sysman_product_helper_dg2.cpp
@@ -15,7 +15,7 @@ constexpr static auto gfxProduct = IGFX_DG2;

 template <>
 RasInterfaceType SysmanProductHelperHw<gfxProduct>::getGtRasUtilInterface() {
-    return RasInterfaceType::PMU;
+    return RasInterfaceType::pmu;
 }

 template class SysmanProductHelperHw<gfxProduct>;
--- a/level_zero/tools/source/debug/debug_session_imp.cpp
+++ b/level_zero/tools/source/debug/debug_session_imp.cpp
@@ -502,7 +502,7 @@ bool DebugSessionImp::writeResumeCommand(const std::vector<EuThread::ThreadId> &
    } else // >= 2u
    {
        SIP::sip_command resumeCommand = {0};
-        resumeCommand.command = static_cast<uint32_t>(NEO::SipKernel::COMMAND::RESUME);
+        resumeCommand.command = static_cast<uint32_t>(NEO::SipKernel::Command::resume);

        for (auto &threadID : threadIds) {
            ze_result_t result = cmdRegisterAccessHelper(threadID, resumeCommand, true);
@@ -1441,13 +1441,13 @@ ze_result_t DebugSessionImp::waitForCmdReady(EuThread::ThreadId threadId, uint16
            return status;
        }

-        if (sipCommand.command == static_cast<uint32_t>(NEO::SipKernel::COMMAND::READY)) {
+        if (sipCommand.command == static_cast<uint32_t>(NEO::SipKernel::Command::ready)) {
            break;
        }
        NEO::sleep(std::chrono::microseconds(100));
    }

-    if (sipCommand.command != static_cast<uint32_t>(NEO::SipKernel::COMMAND::READY)) {
+    if (sipCommand.command != static_cast<uint32_t>(NEO::SipKernel::Command::ready)) {
        return ZE_RESULT_ERROR_NOT_AVAILABLE;
    }

--- a/level_zero/tools/source/debug/debug_session_imp.h
+++ b/level_zero/tools/source/debug/debug_session_imp.h
@@ -243,11 +243,11 @@ ze_result_t DebugSessionImp::slmMemoryAccess(EuThread::ThreadId threadId, const
        }

        if constexpr (write) {
-            sipCommand.command = static_cast<uint32_t>(NEO::SipKernel::COMMAND::SLM_WRITE);
+            sipCommand.command = static_cast<uint32_t>(NEO::SipKernel::Command::slmWrite);
            sipCommand.size = static_cast<uint32_t>(accessUnits);
            memcpy_s(sipCommand.buffer, accessUnits * slmSendBytesSize, tmpBuffer.get() + countReadyBytes, accessUnits * slmSendBytesSize);
        } else {
-            sipCommand.command = static_cast<uint32_t>(NEO::SipKernel::COMMAND::SLM_READ);
+            sipCommand.command = static_cast<uint32_t>(NEO::SipKernel::Command::slmRead);
            sipCommand.size = static_cast<uint32_t>(accessUnits);
        }

--- a/level_zero/tools/source/debug/eu_thread.h
+++ b/level_zero/tools/source/debug/eu_thread.h
@@ -21,9 +21,9 @@ namespace L0 {
 class EuThread {
  public:
    enum class State {
-        Running,
-        Stopped,
-        Unavailable
+        running,
+        stopped,
+        unavailable
    };

    struct ThreadId {
@@ -68,10 +68,10 @@ class EuThread {

    bool stopThread(uint64_t memHandle) {
        memoryHandle = memHandle;
-        if (state == State::Stopped) {
+        if (state == State::stopped) {
            return false;
        }
-        state = State::Stopped;
+        state = State::stopped;
        PRINT_DEBUGGER_THREAD_LOG("Stopped thread: %s", toString().c_str());
        return true;
    }
@@ -82,17 +82,17 @@ class EuThread {

        if (newCounter == systemRoutineCounter) {
            if (newCounter % 2 != 0) {
-                if (state == State::Running) {
+                if (state == State::running) {
                    PRINT_DEBUGGER_ERROR_LOG("Thread: %s state RUNNING when thread is stopped. Switching to STOPPED", toString().c_str());
                    DEBUG_BREAK_IF(true);
                }
-                state = State::Stopped;
+                state = State::stopped;
                return true;
            }
        }

        if (newCounter == (systemRoutineCounter + 2)) {
-            state = State::Stopped;
+            state = State::stopped;
            systemRoutineCounter = newCounter;
            return true;
        } else if (newCounter > systemRoutineCounter + 2) {
@@ -101,39 +101,39 @@ class EuThread {
        }

        if (newCounter % 2 == 0) {
-            if (state == State::Stopped) {
+            if (state == State::stopped) {
                PRINT_DEBUGGER_ERROR_LOG("Thread: %s state STOPPED when thread is running. Switching to RUNNING", toString().c_str());
                DEBUG_BREAK_IF(true);
            }
-            state = State::Running;
+            state = State::running;
            systemRoutineCounter = newCounter;

            return false;
        }

-        state = State::Stopped;
+        state = State::stopped;
        systemRoutineCounter = newCounter;
        return true;
    }

    bool resumeThread() {
-        if (state != State::Stopped) {
+        if (state != State::stopped) {
            PRINT_DEBUGGER_THREAD_LOG("Resuming already RUNNING thread: %s", toString().c_str());
            return false;
        }
        PRINT_DEBUGGER_THREAD_LOG("Resumed thread: %s", toString().c_str());
        reportedAsStopped = false;
-        state = State::Running;
+        state = State::running;
        memoryHandle = invalidHandle;
        return true;
    }

    bool isStopped() const {
-        return state == State::Stopped;
+        return state == State::stopped;
    }

    bool isRunning() const {
-        return state != State::Stopped;
+        return state != State::stopped;
    }

    static std::string toString(ThreadId threadId) {
@@ -160,7 +160,7 @@ class EuThread {
        reportedAsStopped = true;
    }
    bool isReportedAsStopped() {
-        DEBUG_BREAK_IF(reportedAsStopped && state != State::Stopped);
+        DEBUG_BREAK_IF(reportedAsStopped && state != State::stopped);
        return reportedAsStopped;
    }
    void setPageFault(bool value) {
@@ -176,7 +176,7 @@ class EuThread {

  protected:
    ThreadId threadId;
-    std::atomic<State> state = State::Unavailable;
+    std::atomic<State> state = State::unavailable;
    uint8_t systemRoutineCounter = 0;
    std::atomic<uint64_t> memoryHandle = invalidHandle;
    std::atomic<bool> reportedAsStopped = false;
--- a/level_zero/tools/test/unit_tests/sources/debug/debug_session_tests.cpp
+++ b/level_zero/tools/test/unit_tests/sources/debug/debug_session_tests.cpp
@@ -3023,7 +3023,7 @@ TEST(DebugSessionTest, GivenStoppedThreadWhenUnderInvalidConditionsThenSlmReadFa
    sessionMock->resumeImpResult = ZE_RESULT_SUCCESS;

    sessionMock->slmCmdRegisterAccessCount = 0;
-    sessionMock->slmCmdRegisterCmdvalue = static_cast<uint32_t>(NEO::SipKernel::COMMAND::RESUME);
+    sessionMock->slmCmdRegisterCmdvalue = static_cast<uint32_t>(NEO::SipKernel::Command::resume);

    sessionMock->forceCmdAccessFail = true;
    retVal = sessionMock->slmMemoryAccess<void *, false>(threadId, &desc, readSize, output);
@@ -3040,7 +3040,7 @@ TEST(DebugSessionTest, GivenStoppedThreadWhenUnderInvalidConditionsThenSlmReadFa
    EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, retVal);
    sessionMock->slmCmdRegisterAccessReadyCount = 2;
    sessionMock->slmCmdRegisterAccessCount = 0;
-    sessionMock->slmCmdRegisterCmdvalue = static_cast<uint32_t>(NEO::SipKernel::COMMAND::RESUME);
+    sessionMock->slmCmdRegisterCmdvalue = static_cast<uint32_t>(NEO::SipKernel::Command::resume);

    memcpy_s(sessionMock->slmMemory, strlen("FailWaiting"), "FailWaiting", strlen("FailWaiting"));
    retVal = sessionMock->slmMemoryAccess<void *, false>(threadId, &desc, readSize, output);
@@ -3200,7 +3200,7 @@ TEST(DebugSessionTest, GivenStoppedThreadWhenUnderInvalidConditionsThenSlmWriteF
    EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, retVal);

    sessionMock->slmCmdRegisterAccessCount = 0;
-    sessionMock->slmCmdRegisterCmdvalue = static_cast<uint32_t>(NEO::SipKernel::COMMAND::RESUME);
+    sessionMock->slmCmdRegisterCmdvalue = static_cast<uint32_t>(NEO::SipKernel::Command::resume);

    retVal = sessionMock->slmMemoryAccess<const void *, true>(threadId, &desc, writeSize, input);
    EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, retVal);
@@ -3210,7 +3210,7 @@ TEST(DebugSessionTest, GivenStoppedThreadWhenUnderInvalidConditionsThenSlmWriteF
    EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, retVal);
    sessionMock->slmCmdRegisterAccessReadyCount = 2;
    sessionMock->slmCmdRegisterAccessCount = 0;
-    sessionMock->slmCmdRegisterCmdvalue = static_cast<uint32_t>(NEO::SipKernel::COMMAND::RESUME);
+    sessionMock->slmCmdRegisterCmdvalue = static_cast<uint32_t>(NEO::SipKernel::Command::resume);

    desc.address = 0x10000000;
    memcpy_s(sessionMock->slmMemory, strlen("FailWaiting"), "FailWaiting", strlen("FailWaiting"));
--- a/level_zero/tools/test/unit_tests/sources/debug/mock_debug_session.h
+++ b/level_zero/tools/test/unit_tests/sources/debug/mock_debug_session.h
@@ -384,43 +384,43 @@ struct MockDebugSession : public L0::DebugSessionImp {
            uint32_t size = command.size * slmSendBytesSize;

            // initial wait for ready
-            if (!write && slmCmdRegisterCmdvalue == static_cast<uint32_t>(NEO::SipKernel::COMMAND::RESUME)) {
+            if (!write && slmCmdRegisterCmdvalue == static_cast<uint32_t>(NEO::SipKernel::Command::resume)) {
                if (!memcmp(slmMemory, "FailWaiting", strlen("FailWaiting"))) {
                    return ZE_RESULT_FORCE_UINT32;
                }
-                command.command = static_cast<uint32_t>(NEO::SipKernel::COMMAND::READY);
+                command.command = static_cast<uint32_t>(NEO::SipKernel::Command::ready);
                status = ZE_RESULT_SUCCESS;
            } else {
                if (write) { // writing to CMD register
                    if (forceCmdAccessFail) {
                        return ZE_RESULT_FORCE_UINT32;
-                    } else if (command.command == static_cast<uint32_t>(NEO::SipKernel::COMMAND::SLM_WRITE)) {
+                    } else if (command.command == static_cast<uint32_t>(NEO::SipKernel::Command::slmWrite)) {
                        memcpy_s(slmMemory + command.offset, size, command.buffer, size);
                    }
                    slmCmdRegisterCmdvalue = command.command;
                }

-                if (slmCmdRegisterCmdvalue != static_cast<uint32_t>(NEO::SipKernel::COMMAND::RESUME)) {
+                if (slmCmdRegisterCmdvalue != static_cast<uint32_t>(NEO::SipKernel::Command::resume)) {
                    slmCmdRegisterAccessCount++;
                }

                if (slmCmdRegisterAccessCount == slmCmdRegisterAccessReadyCount) { // SIP restores cmd to READY

-                    command.command = static_cast<uint32_t>(NEO::SipKernel::COMMAND::READY);
+                    command.command = static_cast<uint32_t>(NEO::SipKernel::Command::ready);

-                    if (slmCmdRegisterCmdvalue == static_cast<uint32_t>(NEO::SipKernel::COMMAND::SLM_WRITE)) {
+                    if (slmCmdRegisterCmdvalue == static_cast<uint32_t>(NEO::SipKernel::Command::slmWrite)) {
                        slmCmdRegisterAccessCount = 0;
-                        slmCmdRegisterCmdvalue = static_cast<uint32_t>(NEO::SipKernel::COMMAND::RESUME);
+                        slmCmdRegisterCmdvalue = static_cast<uint32_t>(NEO::SipKernel::Command::resume);
                    }
                } else if (slmCmdRegisterAccessCount == slmCmdRegisterAccessReadyCount + 1) { // Reading the data does an extra call to retrieve the data
                    if (!memcmp(slmMemory, "FailReadingData", strlen("FailReadingData"))) {
                        status = ZE_RESULT_FORCE_UINT32;
-                    } else if (slmCmdRegisterCmdvalue == static_cast<uint32_t>(NEO::SipKernel::COMMAND::SLM_READ)) {
+                    } else if (slmCmdRegisterCmdvalue == static_cast<uint32_t>(NEO::SipKernel::Command::slmRead)) {
                        memcpy_s(command.buffer, size, slmMemory + command.offset, size);
                    }

                    slmCmdRegisterAccessCount = 0;
-                    slmCmdRegisterCmdvalue = static_cast<uint32_t>(NEO::SipKernel::COMMAND::RESUME);
+                    slmCmdRegisterCmdvalue = static_cast<uint32_t>(NEO::SipKernel::Command::resume);
                }
            }
            return status;
@@ -540,7 +540,7 @@ struct MockDebugSession : public L0::DebugSessionImp {
    std::vector<uint32_t> cleanRootSessionDeviceIndices;

    int slmCmdRegisterAccessCount = 0;
-    uint32_t slmCmdRegisterCmdvalue = static_cast<uint32_t>(NEO::SipKernel::COMMAND::RESUME);
+    uint32_t slmCmdRegisterCmdvalue = static_cast<uint32_t>(NEO::SipKernel::Command::resume);
    bool forceCmdAccessFail = false;
    int slmCmdRegisterAccessReadyCount = 2;
    bool slmTesting = false;
--- a/opencl/source/event/event.cpp
+++ b/opencl/source/event/event.cpp
@@ -816,7 +816,7 @@ bool Event::isReadyForSubmission() {

 void Event::addCallback(Callback::ClbFuncT fn, cl_int type, void *data) {
    ECallbackTarget target = translateToCallbackTarget(type);
-    if (target == ECallbackTarget::Invalid) {
+    if (target == ECallbackTarget::invalid) {
        DEBUG_BREAK_IF(true);
        return;
    }
@@ -849,10 +849,10 @@ void Event::executeCallbacks(int32_t executionStatusIn) {
    bool terminated = isStatusCompletedByTermination(execStatus);
    ECallbackTarget target;
    if (terminated) {
-        target = ECallbackTarget::Completed;
+        target = ECallbackTarget::completed;
    } else {
        target = translateToCallbackTarget(execStatus);
-        if (target == ECallbackTarget::Invalid) {
+        if (target == ECallbackTarget::invalid) {
            DEBUG_BREAK_IF(true);
            return;
        }
--- a/opencl/source/event/event.h
+++ b/opencl/source/event/event.h
@@ -39,12 +39,12 @@ struct OpenCLObjectMapper<_cl_event> {
 class Event : public BaseObject<_cl_event>, public IDNode<Event> {
  public:
    enum class ECallbackTarget : uint32_t {
-        Queued = 0,
-        Submitted,
-        Running,
-        Completed,
-        MAX,
-        Invalid
+        queued = 0,
+        submitted,
+        running,
+        completed,
+        max,
+        invalid
    };

    struct Callback : public IFNode<Callback> {
@@ -166,7 +166,7 @@ class Event : public BaseObject<_cl_event>, public IDNode<Event> {
    }

    bool peekHasCallbacks(ECallbackTarget target) {
-        if (target >= ECallbackTarget::MAX) {
+        if (target >= ECallbackTarget::max) {
            DEBUG_BREAK_IF(true);
            return false;
        }
@@ -174,7 +174,7 @@ class Event : public BaseObject<_cl_event>, public IDNode<Event> {
    }

    bool peekHasCallbacks() {
-        for (uint32_t i = 0; i < (uint32_t)ECallbackTarget::MAX; ++i) {
+        for (uint32_t i = 0; i < (uint32_t)ECallbackTarget::max; ++i) {
            if (peekHasCallbacks((ECallbackTarget)i)) {
                return true;
            }
@@ -320,17 +320,17 @@ class Event : public BaseObject<_cl_event>, public IDNode<Event> {
        switch (execStatus) {
        default: {
            DEBUG_BREAK_IF(true);
-            return ECallbackTarget::Invalid;
+            return ECallbackTarget::invalid;
        }

        case CL_QUEUED:
-            return ECallbackTarget::Queued;
+            return ECallbackTarget::queued;
        case CL_SUBMITTED:
-            return ECallbackTarget::Submitted;
+            return ECallbackTarget::submitted;
        case CL_RUNNING:
-            return ECallbackTarget::Running;
+            return ECallbackTarget::running;
        case CL_COMPLETE:
-            return ECallbackTarget::Completed;
+            return ECallbackTarget::completed;
        }
    }

@@ -370,7 +370,7 @@ class Event : public BaseObject<_cl_event>, public IDNode<Event> {
    cl_command_type cmdType{};

    // callbacks to be executed when this event changes its execution state
-    IFList<Callback, true, true> callbacks[(uint32_t)ECallbackTarget::MAX];
+    IFList<Callback, true, true> callbacks[(uint32_t)ECallbackTarget::max];

    // can be accessed only with transitionExecutionState
    // this is to ensure state consitency event when doning lock-free multithreading
--- a/shared/source/ail/ail_configuration.h
+++ b/shared/source/ail/ail_configuration.h
@@ -35,13 +35,11 @@ extern const char legacyPlatformName[];
 struct RuntimeCapabilityTable;

 enum class AILEnumeration : uint32_t {
-    DISABLE_BLITTER,
-    DISABLE_COMPRESSION,
-    ENABLE_FP64,
-    DISABLE_HOST_PTR_TRACKING,
-    ENABLE_LEGACY_PLATFORM_NAME,
-    DISABLE_DIRECT_SUBMISSION,
-    AIL_MAX_OPTIONS_COUNT
+    disableCompression,
+    enableFp64,
+    disableHostPtrTracking,
+    enableLegacyPlatformName,
+    disableDirectSubmission,
 };

 class AILConfiguration;
--- a/shared/source/ail/ail_configuration_extra.cpp
+++ b/shared/source/ail/ail_configuration_extra.cpp
@@ -20,11 +20,11 @@ namespace NEO {
 *
 */

-std::map<std::string_view, std::vector<AILEnumeration>> applicationMap = {{"blender", {AILEnumeration::ENABLE_FP64}},
+std::map<std::string_view, std::vector<AILEnumeration>> applicationMap = {{"blender", {AILEnumeration::enableFp64}},
                                                                          // Modify reported platform name to ensure older versions of Adobe Premiere Pro are able to recognize the GPU device
-                                                                          {"Adobe Premiere Pro", {AILEnumeration::ENABLE_LEGACY_PLATFORM_NAME}}};
+                                                                          {"Adobe Premiere Pro", {AILEnumeration::enableLegacyPlatformName}}};

-std::map<std::string_view, std::vector<AILEnumeration>> applicationMapMTL = {{"svchost", {AILEnumeration::DISABLE_DIRECT_SUBMISSION}}};
+std::map<std::string_view, std::vector<AILEnumeration>> applicationMapMTL = {{"svchost", {AILEnumeration::disableDirectSubmission}}};

 const std::set<std::string_view> applicationsContextSyncFlag = {};

@@ -36,10 +36,10 @@ void AILConfiguration::apply(RuntimeCapabilityTable &runtimeCapabilityTable) {
    if (search != applicationMap.end()) {
        for (size_t i = 0; i < search->second.size(); ++i) {
            switch (search->second[i]) {
-            case AILEnumeration::ENABLE_FP64:
+            case AILEnumeration::enableFp64:
                runtimeCapabilityTable.ftrSupportsFP64 = true;
                break;
-            case AILEnumeration::ENABLE_LEGACY_PLATFORM_NAME:
+            case AILEnumeration::enableLegacyPlatformName:
                runtimeCapabilityTable.preferredPlatformName = legacyPlatformName;
                break;
            default:
--- a/shared/source/ail/gen11/ehl/ail_configuration_ehl.cpp
+++ b/shared/source/ail/gen11/ehl/ail_configuration_ehl.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
@@ -15,7 +15,7 @@ namespace NEO {
 static EnableAIL<IGFX_ELKHARTLAKE> enableAILEHL;

 std::map<std::string_view, std::vector<AILEnumeration>> applicationMapEHL = {
-    {"resolve", {AILEnumeration::DISABLE_HOST_PTR_TRACKING}} // Disable hostPtrTracking for DaVinci Resolve
+    {"resolve", {AILEnumeration::disableHostPtrTracking}} // Disable hostPtrTracking for DaVinci Resolve
 };

 template <>
@@ -24,7 +24,7 @@ inline void AILConfigurationHw<IGFX_ELKHARTLAKE>::applyExt(RuntimeCapabilityTabl
    if (search != applicationMapEHL.end()) {
        for (size_t i = 0; i < search->second.size(); ++i) {
            switch (search->second[i]) {
-            case AILEnumeration::DISABLE_HOST_PTR_TRACKING:
+            case AILEnumeration::disableHostPtrTracking:
                runtimeCapabilityTable.hostPtrTrackingEnabled = false;
                break;
            default:
--- a/shared/source/ail/gen11/icllp/ail_configuration_icllp.cpp
+++ b/shared/source/ail/gen11/icllp/ail_configuration_icllp.cpp
@@ -15,7 +15,7 @@ namespace NEO {
 static EnableAIL<IGFX_ICELAKE_LP> enableAILICLLP;

 std::map<std::string_view, std::vector<AILEnumeration>> applicationMapICLLP = {
-    {"resolve", {AILEnumeration::DISABLE_HOST_PTR_TRACKING}} // Disable hostPtrTracking for DaVinci Resolve
+    {"resolve", {AILEnumeration::disableHostPtrTracking}} // Disable hostPtrTracking for DaVinci Resolve
 };

 template <>
@@ -24,7 +24,7 @@ inline void AILConfigurationHw<IGFX_ICELAKE_LP>::applyExt(RuntimeCapabilityTable
    if (search != applicationMapICLLP.end()) {
        for (size_t i = 0; i < search->second.size(); ++i) {
            switch (search->second[i]) {
-            case AILEnumeration::DISABLE_HOST_PTR_TRACKING:
+            case AILEnumeration::disableHostPtrTracking:
                runtimeCapabilityTable.hostPtrTrackingEnabled = false;
                break;
            default:
--- a/shared/source/ail/gen11/lkf/ail_configuration_lkf.cpp
+++ b/shared/source/ail/gen11/lkf/ail_configuration_lkf.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
@@ -15,7 +15,7 @@ namespace NEO {
 static EnableAIL<IGFX_LAKEFIELD> enableAILLKF;

 std::map<std::string_view, std::vector<AILEnumeration>> applicationMapLKF = {
-    {"resolve", {AILEnumeration::DISABLE_HOST_PTR_TRACKING}} // Disable hostPtrTracking for DaVinci Resolve
+    {"resolve", {AILEnumeration::disableHostPtrTracking}} // Disable hostPtrTracking for DaVinci Resolve
 };

 template <>
@@ -24,7 +24,7 @@ inline void AILConfigurationHw<IGFX_LAKEFIELD>::applyExt(RuntimeCapabilityTable
    if (search != applicationMapLKF.end()) {
        for (size_t i = 0; i < search->second.size(); ++i) {
            switch (search->second[i]) {
-            case AILEnumeration::DISABLE_HOST_PTR_TRACKING:
+            case AILEnumeration::disableHostPtrTracking:
                runtimeCapabilityTable.hostPtrTrackingEnabled = false;
                break;
            default:
--- a/shared/source/ail/gen9/bxt/ail_configuration_bxt.cpp
+++ b/shared/source/ail/gen9/bxt/ail_configuration_bxt.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
@@ -15,7 +15,7 @@ namespace NEO {
 static EnableAIL<IGFX_BROXTON> enableAILBXT;

 std::map<std::string_view, std::vector<AILEnumeration>> applicationMapBXT = {
-    {"resolve", {AILEnumeration::DISABLE_HOST_PTR_TRACKING}} // Disable hostPtrTracking for DaVinci Resolve
+    {"resolve", {AILEnumeration::disableHostPtrTracking}} // Disable hostPtrTracking for DaVinci Resolve
 };

 template <>
@@ -24,7 +24,7 @@ inline void AILConfigurationHw<IGFX_BROXTON>::applyExt(RuntimeCapabilityTable &r
    if (search != applicationMapBXT.end()) {
        for (size_t i = 0; i < search->second.size(); ++i) {
            switch (search->second[i]) {
-            case AILEnumeration::DISABLE_HOST_PTR_TRACKING:
+            case AILEnumeration::disableHostPtrTracking:
                runtimeCapabilityTable.hostPtrTrackingEnabled = false;
                break;
            default:
--- a/shared/source/ail/gen9/cfl/ail_configuration_cfl.cpp
+++ b/shared/source/ail/gen9/cfl/ail_configuration_cfl.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
@@ -15,7 +15,7 @@ namespace NEO {
 static EnableAIL<IGFX_COFFEELAKE> enableAILCFL;

 std::map<std::string_view, std::vector<AILEnumeration>> applicationMapCFL = {
-    {"resolve", {AILEnumeration::DISABLE_HOST_PTR_TRACKING}} // Disable hostPtrTracking for DaVinci Resolve
+    {"resolve", {AILEnumeration::disableHostPtrTracking}} // Disable hostPtrTracking for DaVinci Resolve
 };

 template <>
@@ -24,7 +24,7 @@ inline void AILConfigurationHw<IGFX_COFFEELAKE>::applyExt(RuntimeCapabilityTable
    if (search != applicationMapCFL.end()) {
        for (size_t i = 0; i < search->second.size(); ++i) {
            switch (search->second[i]) {
-            case AILEnumeration::DISABLE_HOST_PTR_TRACKING:
+            case AILEnumeration::disableHostPtrTracking:
                runtimeCapabilityTable.hostPtrTrackingEnabled = false;
                break;
            default:
--- a/shared/source/ail/gen9/glk/ail_configuration_glk.cpp
+++ b/shared/source/ail/gen9/glk/ail_configuration_glk.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
@@ -15,7 +15,7 @@ namespace NEO {
 static EnableAIL<IGFX_GEMINILAKE> enableAILGLK;

 std::map<std::string_view, std::vector<AILEnumeration>> applicationMapGLK = {
-    {"resolve", {AILEnumeration::DISABLE_HOST_PTR_TRACKING}} // Disable hostPtrTracking for DaVinci Resolve
+    {"resolve", {AILEnumeration::disableHostPtrTracking}} // Disable hostPtrTracking for DaVinci Resolve
 };

 template <>
@@ -24,7 +24,7 @@ inline void AILConfigurationHw<IGFX_GEMINILAKE>::applyExt(RuntimeCapabilityTable
    if (search != applicationMapGLK.end()) {
        for (size_t i = 0; i < search->second.size(); ++i) {
            switch (search->second[i]) {
-            case AILEnumeration::DISABLE_HOST_PTR_TRACKING:
+            case AILEnumeration::disableHostPtrTracking:
                runtimeCapabilityTable.hostPtrTrackingEnabled = false;
                break;
            default:
--- a/shared/source/ail/gen9/kbl/ail_configuration_kbl.cpp
+++ b/shared/source/ail/gen9/kbl/ail_configuration_kbl.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
@@ -15,7 +15,7 @@ namespace NEO {
 static EnableAIL<IGFX_KABYLAKE> enableAILKBL;

 std::map<std::string_view, std::vector<AILEnumeration>> applicationMapKBL = {
-    {"resolve", {AILEnumeration::DISABLE_HOST_PTR_TRACKING}} // Disable hostPtrTracking for DaVinci Resolve
+    {"resolve", {AILEnumeration::disableHostPtrTracking}} // Disable hostPtrTracking for DaVinci Resolve
 };

 template <>
@@ -24,7 +24,7 @@ inline void AILConfigurationHw<IGFX_KABYLAKE>::applyExt(RuntimeCapabilityTable &
    if (search != applicationMapKBL.end()) {
        for (size_t i = 0; i < search->second.size(); ++i) {
            switch (search->second[i]) {
-            case AILEnumeration::DISABLE_HOST_PTR_TRACKING:
+            case AILEnumeration::disableHostPtrTracking:
                runtimeCapabilityTable.hostPtrTrackingEnabled = false;
                break;
            default:
--- a/shared/source/ail/gen9/skl/ail_configuration_skl.cpp
+++ b/shared/source/ail/gen9/skl/ail_configuration_skl.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
@@ -15,7 +15,7 @@ namespace NEO {
 static EnableAIL<IGFX_SKYLAKE> enableAILSKL;

 std::map<std::string_view, std::vector<AILEnumeration>> applicationMapSKL = {
-    {"resolve", {AILEnumeration::DISABLE_HOST_PTR_TRACKING}} // Disable hostPtrTracking for DaVinci Resolve
+    {"resolve", {AILEnumeration::disableHostPtrTracking}} // Disable hostPtrTracking for DaVinci Resolve
 };

 template <>
@@ -24,7 +24,7 @@ inline void AILConfigurationHw<IGFX_SKYLAKE>::applyExt(RuntimeCapabilityTable &r
    if (search != applicationMapSKL.end()) {
        for (size_t i = 0; i < search->second.size(); ++i) {
            switch (search->second[i]) {
-            case AILEnumeration::DISABLE_HOST_PTR_TRACKING:
+            case AILEnumeration::disableHostPtrTracking:
                runtimeCapabilityTable.hostPtrTrackingEnabled = false;
                break;
            default:
--- a/shared/source/ail/xe_hpg_core/mtl/ail_configuration_mtl.cpp
+++ b/shared/source/ail/xe_hpg_core/mtl/ail_configuration_mtl.cpp
@@ -29,7 +29,7 @@ void AILConfigurationHw<IGFX_METEORLAKE>::applyExt(RuntimeCapabilityTable &runti
    if (search != applicationMapMTL.end()) {
        for (size_t i = 0; i < search->second.size(); ++i) {
            switch (search->second[i]) {
-            case AILEnumeration::DISABLE_DIRECT_SUBMISSION:
+            case AILEnumeration::disableDirectSubmission:
                runtimeCapabilityTable.directSubmissionEngines.data[aub_stream::ENGINE_CCS].engineSupported = false;
            default:
                break;
--- a/shared/source/built_ins/sip.h
+++ b/shared/source/built_ins/sip.h
@@ -61,11 +61,11 @@ class SipKernel {
    static SipKernelType getSipKernelType(Device &device, bool debuggingEnable);
    static SipClassType classType;

-    enum class COMMAND : uint32_t {
-        RESUME,
-        READY,
-        SLM_READ,
-        SLM_WRITE
+    enum class Command : uint32_t {
+        resume,
+        ready,
+        slmRead,
+        slmWrite
    };

  protected: